TLS client连接百度（www.baidu.com）

原创 已于 2022-02-07 09:47:48 修改 · 1.8k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#百度 #mariadb #linux

于 2019-07-13 17:43:16 首次发布
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <openssl/ssl.h>
#include <openssl/err.h>
#include <openssl/ssl_log.h>

#include <config.h>

#define CLIENT_CA   "ClientCAcert.pem"
#define CLIENT_KEY  "ClientPrivkey.pem"
#define CA          "ca.crt"

enum {
    LOG_ERR = 1,
    LOG_WAR = 2,
    LOG_NOT = 3,
    LOG_DEB = 4,
    LOG_VEB = 5,
};

static void openssl_log_vsprintf(int level, const char *file, int line, const char *format, ...)
{
    char *log_buffer = NULL;
    char *file_name = NULL;
    char *level_str = NULL;
    struct timeval tv_now;
    time_t tt;
    struct tm *t = NULL;

    va_list ap;
    va_start(ap, format);
    int ret = vasprintf(&log_buffer, format, ap);
    va_end(ap);

    if (file) {
        file_name = strrchr(file, '/');
    }

    switch (level) {
    case LOG_ERR:
        level_str = "\033[31;1m  ERROR\33[0m";
        break;
    case LOG_WAR:
        level_str = "\033[32;31;1mWARRING\33[0m";
        break;
    case LOG_NOT:
        level_str = "\033[33;1m NOTICE\33[0m";
        break;
    case LOG_DEB:
        level_str = "\033[32;1m  DEBUG\33[0m";
        break;
    case LOG_VEB:
        level_str = "\033[32mVERBOSE\33[0m";
        break;
    default:
        level_str = "\033[32;1m  DEBUG\33[0m";
        break;
    }

    tt = time(NULL);
    t = localtime(&tt);
    gettimeofday(&tv_now, NULL);

    fprintf(stderr, "[%4d-%02d-%02d %02d:%02d:%02d:%03ld] %s [%05ld] -- %s:%d %s\n",
        t->tm_year+1900, t->tm_mon+1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, tv_now.tv_usec,
        level_str, syscall(SYS_gettid), file_name ? ++file_name : file, line, log_buffer);

    if (log_buffer) {
        free(log_buffer);
    }
}

#define openssl_log(level, ...) do {                                    \
    if (level) {                                                        \
        openssl_log_vsprintf(level, __FILE__, __LINE__, __VA_ARGS__);   \
    }                                                                   \
} while (0)

static void openssl_log_format(int level, const char *file, int line, const char *msg)
{
    int openssl_level = 0;

    switch (level) {
    case SSL_LOG_ERR:
        openssl_level = LOG_ERR;
        break;
    case SSL_LOG_WAR:
        openssl_level = LOG_WAR;
        break;
    case SSL_LOG_NOT:
        openssl_level = LOG_NOT;
        break;
    case SSL_LOG_DEB:
        openssl_level = LOG_DEB;
        break;
    case SSL_LOG_VEB:
        openssl_level = LOG_VEB;
        break;
    default:
        openssl_level = LOG_DEB;
        break;
    }

    openssl_log(openssl_level, "[%6s:%04d] %s\n", file, line, msg);
}

static void openssl_msg_cb(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg)
{
    const char *str_write_p, *str_version, *str_content_type =
        "", *str_details1 = "", *str_details2 = "";

    char msg_buffer[65535] = {0};
    int msg_len = 0;

    str_write_p = write_p ? "[Write]" : "[Read]";

    switch (version) {
    case SSL2_VERSION:
        str_version = "SSL 2.0";
        break;
    case SSL3_VERSION:
        str_version = "SSL 3.0 ";
        break;
    case TLS1_VERSION:
        str_version = "TLS 1.0 ";
        break;
    case TLS1_1_VERSION:
        str_version = "TLS 1.1 ";
        break;
    case TLS1_2_VERSION:
        str_version = "TLS 1.2 ";
        break;
    case DTLS1_VERSION:
        str_version = "DTLS 1.0 ";
        break;
    case DTLS1_2_VERSION:
        str_version = "DTLS 1.2 ";
        break;
    case DTLS1_BAD_VER:
        str_version = "DTLS 1.0 (bad) ";
        break;
    default:
        str_version = "???";
    }

    if (version == SSL2_VERSION) {
        str_details1 = "???";

        if (len > 0) {
            switch (((const unsigned char *)buf)[0]) {
            case 0:
                str_details1 = ", ERROR:";
                str_details2 = " ???";
                if (len >= 3) {
                    unsigned err =
                        (((const unsigned char *)buf)[1] << 8) +
                        ((const unsigned char *)buf)[2];

                    switch (err) {
                    case 0x0001:
                        str_details2 = " NO-CIPHER-ERROR";
                        break;
                    case 0x0002:
                        str_details2 = " NO-CERTIFICATE-ERROR";
                        break;
                    case 0x0004:
                        str_details2 = " BAD-CERTIFICATE-ERROR";
                        break;
                    case 0x0006:
                        str_details2 = " UNSUPPORTED-CERTIFICATE-TYPE-ERROR";
                        break;
                    }
                }

                break;
            case 1:
                str_details1 = ", CLIENT-HELLO";
                break;
            case 2:
                str_details1 = ", CLIENT-MASTER-KEY";
                break;
            case 3:
                str_details1 = ", CLIENT-FINISHED";
                break;
            case 4:
                str_details1 = ", SERVER-HELLO";
                break;
            case 5:
                str_details1 = ", SERVER-VERIFY";
                break;
            case 6:
                str_details1 = ", SERVER-FINISHED";
                break;
            case 7:
                str_details1 = ", REQUEST-CERTIFICATE";
                break;
            case 8:
                str_details1 = ", CLIENT-CERTIFICATE";
                break;
            }
        }
    }

    if (version == SSL3_VERSION ||
        version == TLS1_VERSION ||
        version == TLS1_1_VERSION ||
        version == TLS1_2_VERSION ||
        version == DTLS1_VERSION ||
        version == DTLS1_2_VERSION ||
        version == DTLS1_BAD_VER) {
        switch (content_type) {
        case 20:
            str_content_type = "ChangeCipherSpec";
            break;
        case 21:
            str_content_type = "Alert";
            break;
        case 22:
            str_content_type = "Handshake";
            break;
        }

        if (content_type == 21) { /* Alert */
            str_details1 = ", ???";

            if (len == 2) {
                switch (((const unsigned char *)buf)[0]) {
                case 1:
                    str_details1 = ", warning";
                    break;
                case 2:
                    str_details1 = ", fatal";
                    break;
                }

                str_details2 = " ???";
                switch (((const unsigned char *)buf)[1]) {
                case 0:
                    str_details2 = " close_notify";
                    break;
                case 10:
                    str_details2 = " unexpected_message";
                    break;
                case 20:
                    str_details2 = " bad_record_mac";
                    break;
                case 21:
                    str_details2 = " decryption_failed";
                    break;
                case 22:
                    str_details2 = " record_overflow";
                    break;
                case 30:
                    str_details2 = " decompression_failure";
                    break;
                case 40:
                    str_details2 = " handshake_failure";
                    break;
                case 42:
                    str_details2 = " bad_certificate";
                    break;
                case 43:
                    str_details2 = " unsupported_certificate";
                    break;
                case 44:
                    str_details2 = " certificate_revoked";
                    break;
                case 45:
                    str_details2 = " certificate_expired";
                    break;
                case 46:
                    str_details2 = " certificate_unknown";
                    break;
                case 47:
                    str_details2 = " illegal_parameter";
                    break;
                case 48:
                    str_details2 = " unknown_ca";
                    break;
                case 49:
                    str_details2 = " access_denied";
                    break;
                case 50:
                    str_details2 = " decode_error";
                    break;
                case 51:
                    str_details2 = " decrypt_error";
                    break;
                case 60:
                    str_details2 = " export_restriction";
                    break;
                case 70:
                    str_details2 = " protocol_version";
                    break;
                case 71:
                    str_details2 = " insufficient_security";
                    break;
                case 80:
                    str_details2 = " internal_error";
                    break;
                case 90:
                    str_details2 = " user_canceled";
                    break;
                case 100:
                    str_details2 = " no_renegotiation";
                    break;
                case 110:
                    str_details2 = " unsupported_extension";
                    break;
                case 111:
                    str_details2 = " certificate_unobtainable";
                    break;
                case 112:
                    str_details2 = " unrecognized_name";
                    break;
                case 113:
                    str_details2 = " bad_certificate_status_response";
                    break;
                case 114:
                    str_details2 = " bad_certificate_hash_value";
                    break;
                case 115:
                    str_details2 = " unknown_psk_identity";
                    break;
                }
            }
        }

        if (content_type == 22) { /* Handshake */
            str_details1 = "???";

            if (len > 0) {
                switch (((const unsigned char *)buf)[0]) {
                case 0:
                    str_details1 = ", HelloRequest";
                    break;
                case 1:
                    str_details1 = ", ClientHello";
                    break;
                case 2:
                    str_details1 = ", ServerHello";
                    break;
                case 3:
                    str_details1 = ", HelloVerifyRequest";
                    break;
                case 11:
                    str_details1 = ", Certificate";
                    break;
                case 12:
                    str_details1 = ", ServerKeyExchange";
                    break;
                case 13:
                    str_details1 = ", CertificateRequest";
                    break;
                case 14:
                    str_details1 = ", ServerHelloDone";
                    break;
                case 15:
                    str_details1 = ", CertificateVerify";
                    break;
                case 16:
                    str_details1 = ", ClientKeyExchange";
                    break;
                case 20:
                    str_details1 = ", Finished";
                    break;
                }
            }
        }

#ifndef OPENSSL_NO_HEARTBEATS
        if (content_type == 24) { /* Heartbeat */
            str_details1 = ", Heartbeat";

            if (len > 0) {
                switch (((const unsigned char *)buf)[0]) {
                case 1:
                    str_details1 = ", HeartbeatRequest";
                    break;
                case 2:
                    str_details1 = ", HeartbeatResponse";
                    break;
                }
            }
        }
#endif
    }

    msg_len += snprintf(msg_buffer + msg_len, sizeof(msg_buffer) - msg_len - 1,
        "%s %s%s [length %04lx]%s%s\n", str_write_p, str_version,
        str_content_type, (unsigned long)len, str_details1, str_details2);

    if (len > 0) {
        size_t num, i;
        msg_len += snprintf(msg_buffer + msg_len, sizeof(msg_buffer) - msg_len - 1, "%s", "   ");
        num = len;

        for (i = 0; i < num; i++) {
            if (i % 32 == 0 && i > 0) {
                msg_len += snprintf(msg_buffer + msg_len, sizeof(msg_buffer) - msg_len - 1, "%s", "\n   ");
            }
            msg_len += snprintf(msg_buffer + msg_len, sizeof(msg_buffer) - msg_len - 1, " %02x", ((const unsigned char *)buf)[i]);
        }

        if (i < len) {

            msg_len += snprintf(msg_buffer + msg_len, sizeof(msg_buffer) - msg_len - 1, "%s", " ...");
        }

        msg_len += snprintf(msg_buffer + msg_len, sizeof(msg_buffer) - msg_len - 1, "%s", "\n");
    }

    openssl_log(LOG_DEB, "\n%s", msg_buffer);
}

static int connect_to_baidu(int sockfd, struct sockaddr *sockaddr, size_t len)
{
    SSL_CTX *ctx = NULL;
    SSL *ssl = NULL;

    if (connect(sockfd, sockaddr, len)) {
        openssl_log(LOG_ERR, "%s\n", strerror(errno));
        return -1;
    }

    SSL_library_init();
    OpenSSL_add_all_algorithms();
    SSL_load_error_strings();

    ctx = SSL_CTX_new(SSLv23_method());
    if (!ctx) {
        openssl_log(LOG_ERR, "%s\n", strerror(errno));
        goto error;
    }

    if (SSL_CTX_use_certificate_file(ctx, OPENSSL_CLIENT_CA_PATH "/" CLIENT_CA, SSL_FILETYPE_PEM) <= 0) {
        openssl_log(LOG_ERR, "%s\n", strerror(errno));
        goto error;
    }

    if (SSL_CTX_use_PrivateKey_file(ctx, OPENSSL_CLIENT_CA_PATH "/" CLIENT_KEY, SSL_FILETYPE_PEM) <= 0) {
        openssl_log(LOG_ERR, "%s\n", strerror(errno));
        goto error;
    }

    
    if (!SSL_CTX_check_private_key(ctx)) {
        openssl_log(LOG_ERR, "%s\n", strerror(errno));
        goto error;
    }

    if (!SSL_CTX_load_verify_locations(ctx, OPENSSL_CA_PATH "/" CA, NULL)) {
        openssl_log(LOG_ERR, "%s\n", strerror(errno));
        goto error;
    }
    SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);

    if (!SSL_CTX_set_default_verify_paths(ctx)) {
        openssl_log(LOG_ERR, "%s\n", strerror(errno));
        goto error;
    }

    ssl = SSL_new(ctx);
    if (!ssl) {
        openssl_log(LOG_ERR, "%s\n", strerror(errno));
        goto error;
    }
    SSL_set_fd(ssl, sockfd);
    SSL_set_msg_callback(ssl, openssl_msg_cb);

    if (-1 == SSL_connect(ssl)) {
        openssl_log(LOG_ERR, "error in %s\n", SSL_state_string_long(ssl));
        goto error;
    } else {
        openssl_log(LOG_DEB, "SSL connection using %s\n", SSL_get_cipher (ssl));
    }

    if (ctx) {
        SSL_CTX_free(ctx);
    }

    return 0;

error:
    if (ctx) {
        SSL_CTX_free(ctx);
    }
    return -1;
}

int main(int argc, char **argv)
{
    struct addrinfo hints, *result = NULL, *rp = NULL;
    struct sockaddr sockaddr;
    int sockfd = -1;
    struct sockaddr_in addr4;
    struct sockaddr_in6 addr6;

    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = 0;
    hints.ai_protocol = 0;

    if (getaddrinfo("www.baidu.com", NULL, &hints, &result)) {
        openssl_log(LOG_ERR, "%s\n", strerror(errno));
        return -1;
    }
    memset(&sockaddr, 0, sizeof(sockaddr));

    for (rp = result; rp != NULL; rp = rp->ai_next) {
        sockfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
        if (sockfd < 0) {
            openssl_log(LOG_ERR, "%s\n", strerror(errno));
            continue;
        }

        if (AF_INET == rp->ai_family) {
            memcpy(&addr4, rp->ai_addr, rp->ai_addrlen);
            addr4.sin_port = htons(443);
            openssl_log(LOG_DEB, "Get www.baidu.com ip address: %s:%d, sockfd: %d\n",
                inet_ntoa(addr4.sin_addr), ntohs(addr4.sin_port), sockfd);
            if (connect_to_baidu(sockfd, (struct sockaddr *)&addr4, sizeof(addr4))) {
                close(sockfd);
                continue;
            } else {
                break;
            }
        }
    }

    close(sockfd);
    freeaddrinfo(result);

    return 0;
}
24. 【gRPC系列学习】gRPC安全认证-TLS认证
菜鸟的博客
12-24 956
gRPC 安全认证-TLS认证
WireShark 抓包理解 TLS 建立加密连接的过程
yetugeng的专栏
09-06 9152
一、实验环境 服务端：web容器 glassfish 部署了一个可以访问的web包 keystore.jks里添加的SSL证书，可参见https://blog.csdn.net/yetugeng/article/details/81416320 客户端：一台笔记本，安装好wireshark 二、服务端的证书 在服务端keystore.jks内容如下，主...
tls协议|tls客户端|tls模拟|tls指纹|浏览器指纹|akamai
hanli_lifeiyu的博客
10-10 827
tls协议|tls客户端|tls模拟|tls指纹|浏览器指纹
探索 TLS-Client: 安全网络通信的新工具
gitblog_00060的博客
04-18 644
探索 TLS-Client: 安全网络通信的新工具 在数字化的时代，安全的网络通信变得越来越重要。今天，我们想向您介绍一个开源项目——tls-client，它是一个强大的TLS（Transport Layer Security）客户端实现，旨在帮助开发者构建更安全、更可靠的网络应用程序。 项目简介 tls-client 是一个用 Rust 编程语言编写的库，提供了与标准库 std::net 类似的...
【亲测免费】 Python-TLS-Client 使用指南
gitblog_01085的博客
08-09 2417
Python-TLS-Client 使用指南 项目介绍 Python-TLS-Client 是一个基于 requests 和自定义 tls-client 的高级HTTP库，专为Python开发者设计。它提供了类似于 requests 的简洁API，同时增加了更多HTTPS连接的定制选项，如客户端标识符模拟（例如Chrome、Firefox等浏览器版本），以及TLS扩展的随机排序功能，以增强网络请...
【免费下载】 Python-TLS-Client安装与配置完全指南
gitblog_07693的博客
09-13 1238
Python-TLS-Client安装与配置完全指南 项目基础介绍与编程语言 Python-TLS-Client 是一款专为Python开发者打造的高级HTTP库，它集成了requests库的功能，并且引入了tls-client来增强HTTPS连接的定制能力。此项目的核心在于提供类似requests的简单API，同时支持更多的HTTPS连接选项定制，比如模拟不同的浏览器客户端（如Chrome、Fi...
TLS协议
CATCH A FIRE
10-18 2072
TLS简介TLS协议基于面向连接的TCP协议，它可被看作由两个主要部分组成：TLS记录协议(TLS Record Protocol)和TLS握手协议(TLS Handshake Protocol)。它可以实现传输应用数据前的通信双方身份的认证，加密套件(对称加密算法，签名算法等)的协商，会话密钥的协商，以及握手完成后的数据加密、压缩传输、以及数据完整性的校验。TLS握手具体的过程1.TCP三次握手T
SVN Client.zip
12-17
用户通过客户端连接到版本库，进行添加、删除、修改等操作。 2. **工作副本（Working Copy）**：当用户从版本库检出代码时，会得到一个工作副本，这个副本包含了所有文件和目录的当前状态。用户可以在本地修改这些...
win64_11gR2_client.zip
08-17
5. **Instant Client**: 虽然在描述中没有特别提到，但Oracle 11gR2客户端可能包括Instant Client版本，这是一个轻量级的客户端，包含基本的连接和查询功能，不需完整安装即可使用。这对于只需要偶尔连接数据库的...
Siemens.OpcUA
01-11
1. **安全性**：OPC UA支持多种安全机制，如TLS/SSL加密、用户身份验证和数据完整性检查，确保了通信过程中的数据安全。 2. **平台无关性**：基于服务导向架构（SOA），OPC UA可以在各种操作系统和网络环境中运行，...
hello-tls:解析TLS ClientHello消息
04-30
你好 解析TLS ClientHello消息 关于 编写该解析器是为了支持基于子域（类似于apache虚拟主机）构建具有TLS功能的代理。 TLS具有名为服务器名称标识（SNI）的扩展名，以支持此类应用程序。 client_hello框架包含TLS ClientHello框架中的所有数据，并且可以使用公开可见的成员进行检索。 目前，支持TLS协议是该项目的明确目标。 但是，支持它的某些数据类型可以作为改进项目API的一部分来实现。 到目前为止，未来的工作将集中在改进API和针对预期用例的基准测试上。 例子 以下示例来自examples/sni.rs 尝试使用cargo run --example sni 。 通常，提供的字节将来自TCP套接字。 出于演示目的，它们是内联提供的。 extern crate tls_client_hello; use tls_client_hello
C# TLS程序
08-16
利用Ｃ＃实现正交整体最小二乘的编程，并实现利用正交整体最小进行噪声的剔除，采用迭代的方法实现C#程序。
baidudl-百度网盘获取资源链接-Chrome扩展程序包
02-09
baidudl-百度网盘获取资源链接-Chrome扩展程序包，将扩展包加入谷歌浏览器，启用，在浏览器打开百度网盘，获取链接，配合Internet Download Manager等下载器下载。
漏洞修复：TLS Client-initiated重协商攻击（CVE-2011-1473）
热门推荐
u012785397的博客
05-14 1万+
修复通过jsse实现的ssl/tls不安全的重协商漏洞。
客户端 tls解密_TLS客户端身份验证
danpu0978的博客
05-20 1422
客户端 tls解密 我决定为电子识别方案设计一个原型，因此我研究了如何使用Java / Spring服务器端进行TLS客户端身份验证（即使您不是Java开发人员，也可以继续阅读-大部分文章是Java -不可知）。 为什么要进行TLS客户端身份验证？ 因为这是认证拥有证书的用户（例如，在智能卡上）的最标准方法。 当然，智能卡证书并不是唯一的应用程序–组织可以向存储在其计算机上的用户颁发内部证...
HttpClient https 请求TLS client hello 报文延时10秒发送
遇到对你这么好的女孩,唯有在她一丈之内。
02-15 1061
HttpClient https 请求TLS client hello 报文延时10秒发送
openssl3.2 - 官方demo学习 - guide - tls-client-block.c
谢绝(无视)留言与私信
01-14 773
tls 客户端官方demo有问题, 无法建立客户端socket, 可以确认sSever没问题, 用tcping试过了.启动server和Client时, 都用127.0.0.1是可以建立socket的, 可以通讯.但是说IP不匹配, 以后再玩.(等自己做了靠谱的证书实验, 再继续验证这个官方demo)
用python在两台机器之间建立TLS连接，实现加密传输。
zhongbing1234的博客
12-04 8563
2.1 TLS/SSL 基本知识 SSL(Secure Sockets Layer 安全套接层)协议,及其继任者TLS（Transport Layer Security传输层安全）协议，是为网络通信提供安全及数据完整性的一种安全协议。TLS与SSL在传输层对网络连接进行加密，用于保障网络数据传输安全，利用数据加密技术，确保数据在网络传输过程中不会被截取及窃听。 要建立TSL/SSL连接则需要证书文...
Python-TLS-Client：新一代HTTP库，基于requests和tls-client的增强版
gitblog_00692的博客
08-09 854
Python-TLS-Client：新一代HTTP库，基于requests和tls-client的增强版 项目介绍 Python-TLS-Client是一个先进的HTTP库，它在requests库的基础上进行了扩展，并引入了tls-client的功能。这个库旨在提供更安全、更灵活的HTTPS请求处理方式，尤其适用于对TLS协议有特定需求的场景。 项目技术分析 Python-TLS-Client的核...
乐鑫 连接百度云iot
最新发布
05-21
if (client.connect(clientId.c_str())) { // 连接到百度云IoT Core时需提供认证参数 client.subscribe("/topic/example"); // 订阅主题 } else { Serial.print("Failed, rc="); Serial.print(client.state());...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值