基于boost和QT 实现客户端/服务端TCP双向证书认证与SSL加密

最新推荐文章于 2024-05-19 12:30:00 发布
最新推荐文章于 2024-05-19 12:30:00 发布
阅读量860 收藏 3
点赞数 3
分类专栏： SSL 文章标签： ssl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZhixinZhao/article/details/129899145
版权
该代码展示了如何使用Boost库中的ASIO组件创建一个SSL/TLS服务器和客户端。服务器接受连接，进行SSL握手，并在接收到数据时进行读写操作。客户端则建立SSL连接，发送请求并接收响应。代码中包含了SSL验证回调函数和证书的使用。
摘要由CSDN通过智能技术生成

服务器代码(boost实现)

#pragma warning(disable : 4996)
#include <cstdlib>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>

typedef boost::asio::ssl::stream<boost::asio::ip::tcp::socket> ssl_socket;

class session
{
public:
	session(boost::asio::io_service& io_service, boost::asio::ssl::context& context)
		: socket_(io_service, context)
	{
	}

	ssl_socket::lowest_layer_type& socket()
	{
		return socket_.lowest_layer();
	}

	void start()
	{
		socket_.async_handshake(boost::asio::ssl::stream_base::server,
			boost::bind(&session::handle_handshake, this,
				boost::asio::placeholders::error));
	}

	void handle_handshake(const boost::system::error_code& error)
	{
		if (!error)
		{
			std::cout << "handshake success" << std::endl;
			socket_.async_read_some(boost::asio::buffer(data_, max_length),
				boost::bind(&session::handle_read, this,
					boost::asio::placeholders::error,
					boost::asio::placeholders::bytes_transferred));
		}
		else
		{
			std::cout << error.message() << std::endl;
			delete this;
		}
	}

	void handle_read(const boost::system::error_code& error,
		size_t bytes_transferred)
	{
		if (!error)
		{
			std::cout << "handle_read success:"<< std::string(data_, bytes_transferred) << std::endl;
			boost::asio::async_write(socket_,
				boost::asio::buffer(data_, bytes_transferred),
				boost::bind(&session::handle_write, this,
					boost::asio::placeholders::error, _2));
		}
		else
		{
			std::cout << "handle_read error" << std::endl;
			delete this;
		}
	}

	void handle_write(const boost::system::error_code& error, size_t bytes_transferred)
	{
		if (!error)
		{
			std::cout << "handle_write success bytes_transferred:" << bytes_transferred << std::endl;
			socket_.async_read_some(boost::asio::buffer(data_, max_length),
				boost::bind(&session::handle_read, this,
					boost::asio::placeholders::error,
					boost::asio::placeholders::bytes_transferred));
		}
		else
		{
			std::cout << "handle_write error" << std::endl;
			delete this;
		}
	}

private:
	ssl_socket socket_;
	enum { max_length = 1024 };
	char data_[max_length];
};

bool verify_callback(bool preverified, boost::asio::ssl::verify_context& ctx)
{
	char subject_name[256];
	X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
	X509_NAME_oneline(X509_get_subject_name(cert), subject_name, 256);
	std::cout << "subject_name:" << subject_name << std::endl;
	return true;
}

class server
{
public:
	server(boost::asio::io_service& io_service, unsigned short port)
		: io_service_(io_service),
		acceptor_(io_service,
			boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string("192.168.1.102"), port)),
		context_(boost::asio::ssl::context::sslv23)
	{
		context_.set_options(
			boost::asio::ssl::context::default_workarounds
			| boost::asio::ssl::context::no_sslv2
			| boost::asio::ssl::context::single_dh_use);
		//context_.set_password_callback(boost::bind(&server::get_password, this, _1, _2));
		context_.use_certificate_chain_file("server.crt");
		context_.use_private_key_file("private_server.key", boost::asio::ssl::context::pem);
		context_.set_default_verify_paths();
		context_.set_verify_mode(boost::asio::ssl::verify_peer | boost::asio::ssl::verify_fail_if_no_peer_cert);
		context_.set_verify_callback(verify_callback);

		session* new_session = new session(io_service_, context_);
		acceptor_.async_accept(new_session->socket(),
			boost::bind(&server::handle_accept, this, new_session,
				boost::asio::placeholders::error));
	}

	std::string get_password(std::size_t  max_length, boost::asio::ssl::context_base::password_purpose password_purpose)
	{
		std::cout << "get_password" << std::endl;
		return "boost Server";
	}

	void handle_accept(session* new_session,
		const boost::system::error_code& error)
	{
		if (!error)
		{
			std::cout << "accept success" << std::endl;
			new_session->start();
			new_session = new session(io_service_, context_);
			acceptor_.async_accept(new_session->socket(),
				boost::bind(&server::handle_accept, this, new_session,
					boost::asio::placeholders::error));
		}
		else
		{
			std::cout << "accept error" << std::endl;
			delete new_session;
		}
	}

private:
	boost::asio::io_service& io_service_;
	boost::asio::ip::tcp::acceptor acceptor_;
	boost::asio::ssl::context context_;
};

int main(int argc, char* argv[])
{
	boost::asio::io_service io_service;
	boost::asio::io_service::work work(io_service);

	using namespace std; // For atoi.
	server s(io_service, 20000);

	io_service.run();
	return 0;
}

客户端(boost实现)

#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include <boost/bind.hpp>
#include <iostream>
using namespace boost::asio;


bool verify_callback(bool preverified, boost::asio::ssl::verify_context& ctx)
{
	char subject_name[256];
	X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
	X509_NAME_oneline(X509_get_subject_name(cert), subject_name, 256);
	std::cout << "subject_name:" << subject_name << std::endl;
	return true;
}

io_service service;

int main(int argc, char* argv[]) {
	typedef ssl::stream<ip::tcp::socket> ssl_socket;
	ssl::context ctx(ssl::context::sslv23);
	ctx.set_default_verify_paths();
	ctx.set_options(
		boost::asio::ssl::context::default_workarounds
		| boost::asio::ssl::context::no_sslv2
		| boost::asio::ssl::context::single_dh_use);
	ctx.use_certificate_chain_file("cilent.crt");
	ctx.use_private_key_file("private_cilent.key", boost::asio::ssl::context::pem);
	// 打开一个到指定主机的ssl socket
	io_service service;
	ssl_socket sock(service, ctx);
	boost::system::error_code code;
	sock.lowest_layer().connect(ip::tcp::endpoint(ip::address::from_string("192.168.1.102"), 20000), code);
	if (code)
	{
		std::cout << "connect error" << std::endl;
		return 0;
	}
	std::cout << "connect success" << std::endl;
	// ssl 握手
	sock.set_verify_mode(ssl::verify_peer | ssl::verify_fail_if_no_peer_cert);
	sock.set_verify_callback(verify_callback);
	boost::system::error_code ec;
	sock.handshake(ssl_socket::client);
	std::string req = "get /index.html http/1.0\r\nhost: 172.16.8.118\r\naccept: */*\r\nconnection: close\r\n\r\n";
	write(sock, buffer(req.c_str(), req.size()));
	char buff[512];
	while (true) {
		int bytes = read(sock, buffer(buff, 80), ec);
		if (bytes > 0)
		{
			std::cout << "bytes:" << bytes << std::string(buff, bytes);
		}
	}
	return 1;
}

客户端(QT实现)

QFile file("D:/Users/Documents/untitled111/cilent.crt");
    if(!file.open(QIODevice::ReadOnly))
        return;

    QSslCertificate cert(file.readAll());
    if(cert.isNull())
        return;

    QFile key("D:/Users/Documents/untitled111/private_cilent.key");
    if(!key.open(QIODevice::ReadOnly))
        return;

    QSslKey clientKey(key.readAll(), QSsl::Rsa);
    QSslConfiguration config;
    config.setPrivateKey(clientKey);
    config.setLocalCertificate(cert);
    config.setPeerVerifyMode(QSslSocket::VerifyPeer);
//    config.setCiphers(QList<QSslCipher>()<<QSslCipher("PSK-AES128-CBC-SHA256"));

    QList<QSslCipher> ls = config.supportedCiphers();
//    for(int i=0;i<ls.count();i++)
//    {
//        qDebug()<<"****"<<ls.at(i).name();
//    }

    m_sslSocket.setSslConfiguration(config);
    m_sslSocket.setProtocol(QSsl::SecureProtocols);
//    connect(&m_sslSocket, &QSslSocket::preSharedKeyAuthenticationRequired, [=](QSslPreSharedKeyAuthenticator *authenticator)
//    {
//        authenticator->setIdentity("QT user");
//        authenticator->setPreSharedKey("1111111222222222222223333333333333333");
//        qDebug()<<"---------------------------------------";
//    });
    connect(&m_sslSocket, &QSslSocket::peerVerifyError, [=](const QSslError &error){
        QSslCertificate c = error.certificate();
        qDebug()<< "cert:" << c.issuerDisplayName() << " error:" << error.errorString();
        m_sslSocket.ignoreSslErrors();
    });
    connect(&m_sslSocket, &QSslSocket::encrypted, [=]()
    {
        m_sslSocket.write("get /index.html http/1.0\r\nhost: 172.16.8.118\r\naccept: */*\r\nconnection: close\r\n\r\n");
    });
    connect(&m_sslSocket, &QSslSocket::readyRead, [=]()
    {
        qDebug()<<"======";
        qDebug()<<m_sslSocket.readAll();
    });
    m_sslSocket.connectToHostEncrypted("192.168.1.102", 20000);

证书与私钥

服务端和客户端各持有证书和私钥，其中证书是由自建CA机构颁发。
利用openssl生成证书和私钥
生成CA自签名根证书和颁发证书

TLS链路协商加密协议方式

1、由客户端发起Client Hello请求，其中带有支持的SSL协议以及支持的加密算法；
在这里插入图片描述
同时交换本地生成的随机数和a*G
在这里插入图片描述
2、服务端根据客户端支持的加密算法和SSL版本，选择后发送Server Hello和b*G，以及数据等
在这里插入图片描述
3、进行加密数据传输（交互）
在这里插入图片描述

气氛组小弟
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【Qt】详解 C++ 实现 HTTP/HTTPS 服务器和客户端
Fanjufei的博客
01-26 342
由于cpp-httplib使用阻塞套接字I/O，因此它适用于需要快速开发和部署的小型HTTP服务器和客户端。但是，在高并发环境下，由于阻塞I/O的限制，可能会导致性能瓶颈和资源浪费。cpp-httplib是一个基于C++11的HTTP客户端/服务器库，用于轻松实现HTTP服务器和客户端。函数，该函数接受一个char指针和一个整数作为参数，用于设置响应内容。函数，将std::string对象的data()指针和size()大小作为参数传递进去，从而避免了复制字符串的开销。的结构体，代表HTTP请求。
Qt实现的SSL通信客户端和服务器
10-25
Qt实现的SSL通信客户端和服务器 使用QSslSocket实现加密通信
QTcpSocket SLL加密Demo（包含客户端和服务端，QTCreator项目）.rar
06-27
QTcpSocket 添加 SLL 加密的 Demo，支持单向认证和双向认证，支持windows和linux双平台。
c++使用OpenSSL基于socket实现tcp双向认证ssl(使用TSL协议)代码实现
热门推荐
dream_caoyun的博客
02-23 1万+
相信各位对OpenSSL库已经不陌生了，目前笔者使用这个库实现了RSA、AES加解密和tcp的双向认证功能，下面来看tcp的双向认证。 1、什么是双向认证 简单说双向认证就是：客户端认证服务端是否合法，服务端认证客户端是否合法。 可以借助于HTTPS来说明，http网络传输协议是超文本的明文协议，也就是说经过网卡传输的字节序列都是明文，那么HTTPS上的s就是双向认证的操作（ssl），实际上就是在http的逻辑上再套一层ssl握手，进程想要发送的字节序列数据经过http传输时再加上一层ssl来让c和s两端先
Netty+OpenSSL TCP双向认证证书配置
Brethless_breath的博客
11-04 2688
百度加自研终于成功配置了netty+TLS双向认证，做个笔记。 TCP双向认证证书配置 1.linux下OpenSSL安装 1.1 openSSL下载 OpenSSL*下载地址：https://oomake.com/download/openssl 1.2 openSSL安装 # tar -xzf openssl-1.0.2f.tar.gz # cd openssl-1.0.2f # mkdir /usr/local/openssl # ./config --prefix=/usr/local/opens
基于boost asio TCP/SSL 网络库
08-25
在标题中提到的“基于boost asio TCP/SSL网络库”是一个利用Boost.Asio实现的，具备TCP和SSL功能的网络库。这个库为开发者提供了构建高效、可靠的网络应用程序的基础。 **TCP（Transmission Control Protocol）** ...
基于boost asio历TCP开发的客户端和服务端程序
06-22
利用boost的asio基于TCP开发的客户端和服务端程序，此程序在两端同时读取文件到内存，然后通过TCP发送数据，并且收到的数据保存到文件,收和发均用了内存池，在客户端发送数据而服务端接收数据的时候在本机可以达到40...
C++实现客户端与服务器TCP连接，上传，下载，执行指定exe文件，获取目录等功能Client_Server.rar
04-06
在本项目中，"C++实现客户端与服务器TCP连接，上传，下载，执行指定exe文件，获取目录等功能Client_Server.rar" 提供了一个基于C++的网络编程实例，它涵盖了多种核心概念和技术，主要包括： 1. **TCP连接**：TCP...
基于C++&Qt实现的在线点餐系统（客户端+服务端——.zip
09-12
《基于C++&Qt实现的在线点餐系统详解》 在信息技术日新月异的今天，餐饮行业的数字化转型已经成为一种趋势。本项目“基于C++&Qt实现的在线点餐系统”正是顺应这一潮流，利用先进的编程语言和图形用户界面库，为用户...
ROS环境下TCP/IP客户端和服务器端C++程序
10-08
在ROS(机器人操作系统)环境中，TCP/IP通信是实现机器人组件间或者机器人与远程计算机之间通信的一种常见方式。本文将深入探讨如何使用C++在ROS环境下编写TCP/IP客户端和服务器端程序，确保其“绝对可用”。 首先，...
boost.asio.ssl示例的证书
08-21
boost.asio.ssl示例的证书
QT中Socket加密算法
08-08
QT sokcet加密算法 使用SSL进行的QT SOCKET加密算法
boost asio tcp服务器的实现
04-24
boost::asio tcp服务器的实现 封装socket, 监听socket, C++11智能指针， 要求： vs2012或以上版本
Nginx - 四层代理TCP配置SSL加密访问
最新发布
小工匠
05-19 1999
``nginxstream {# 定义 upstream，指向 Redis 服务# 日志配置# SSL代理本地服务器server {# 监听 8100 端口，并开启 SSL# 访问日志路径# SSL 证书路径# SSL 证书私钥路径# 设置 SSL 协议版本# 启用 SSL 会话重用MD5;# SSL 加密算法# SSL 会话缓存# SSL 会话超时时间# 代理到 Redis 服务# 模拟客户端解密,对外暴露server {# 监听 8104 端口# 访问日志路径。
基于C++和QT的文件传输系统（含客户端和服务端）
学习中
12-22 569
毕业设计——基于C++和QT的文件传输系统（含客户端和服务端）
QT中使用C++ socket通信（了解socket通信、socket的三次握手和四次挥手、socket函数说明、客户端与服务端的代码实例）
m0_67254672的博客
05-13 4861
了解socket通信、socket的三次握手和四次挥手、socket函数说明、客户端与服务端的代码实例
QT篇——SSL配置
2401_84403918的博客
04-30 487
创建一个QSslSocket对象，并连接它的信号和槽。我们可以使用QSslSocket的error信号和sslErrors信号来处理任何错误或SSL证书问题。如果服务器使用自签名的证书，需要通过调用QSslSocket的addCaCertificates。通过使用QSslSocket类，我们可以建立一个加密的SSL / TLS连接来发送和接收加密的HTTP请求和响应。默认情况下，验证是禁用的，我们可以根据需要进行启用。使用QSslSocket的disconnectFromHost函数断开与服务器的连接。
TCP/IP协议二十一：HTTPS/SSL协议详解（1）加密原理
哈尼的博客
06-21 1756
TCP/IP协议二十一：HTTPS/SSL协议详解（1）加密原理
基于boost实现的linux c++ http服务端
07-28
你可以使用Boost库来实现一个基于C++的Linux HTTP服务器。以下是一个简单的示例代码： ```cpp #include <iostream> #include <boost/asio.hpp> #include <boost/bind.hpp> class HttpServer { public: HttpServer(boost::asio::io_service& ioService, short port) : acceptor_(ioService, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)) { startAccept(); } private: void startAccept() { boost::asio::ip::tcp::socket socket(acceptor_.get_io_service()); acceptor_.async_accept(socket, boost::bind(&HttpServer::handleAccept, this, socket, boost::asio::placeholders::error)); } void handleAccept(boost::asio::ip::tcp::socket& socket, const boost::system::error_code& error) { if (!error) { std::cout << "Accepted connection from: " << socket.remote_endpoint().address().to_string() << std::endl; startAccept(); } } boost::asio::ip::tcp::acceptor acceptor_; }; int main() { boost::asio::io_service ioService; HttpServer server(ioService, 8080); ioService.run(); return 0; } ``` 这个简单的HTTP服务器使用Boost库中的`asio`模块来处理网络通信。它监听8080端口，并在有新连接时打印客户端的IP地址。你可以根据需要扩展这个示例，添加HTTP请求处理逻辑。 请注意，这只是一个基本的示例，实际的HTTP服务器可能需要更多的功能和复杂性。你可能需要处理HTTP请求、路由、静态文件服务、动态内容生成等。但是，这个示例应该可以帮助你入门并了解如何使用Boost库构建一个简单的Linux C++ HTTP服务器。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值