huanglinhuan/TLS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
huanglinhuan
2025-10-09 10:05:40 +08:00
commit 63273630b3
12 changed files with 1395 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

970
tls_client.c Normal file
View File

@@ -0,0 +1,970 @@
/**
* @file tls_client.c
* @brief TLS 1.2/1.3 客户端实现
* @author Assistant
* @date 2024
* @version 1.0.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <openssl/x509.h>
#include <openssl/x509_vfy.h>
#include <time.h>
#define MAX_BUFFER_SIZE 4096
#define TEST_DATA_SIZE 1024
#define MAX_RETRIES 3
#define CONNECT_TIMEOUT 10
// 全局SSL上下文
SSL_CTX *ssl_ctx = NULL;
/**
* @brief 格式化时间戳为易读格式
*/
void print_timestamp(time_t timestamp) {
struct tm *tm_info;
char time_str[32];
tm_info = gmtime(&timestamp);
strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S UTC", tm_info);
printf("[%s]", time_str);
}
/**
* @brief SSL信息回调函数
*/
void ssl_info_callback(const SSL *ssl, int type, int val) {
const char *str;
static time_t last_time = 0;
time_t current_time;
// 检查SSL对象是否有效
if (!ssl) {
printf("SSL回调: SSL对象为空\n");
return;
}
current_time = time(NULL);
switch (type) {
case SSL_CB_LOOP:
str = SSL_state_string_long(ssl);
if (str) {
// 计算与上次状态的时间差
if (last_time > 0) {
double time_diff = difftime(current_time, last_time);
if (time_diff > 0.5) { // 只显示超过0.5秒的延迟
print_timestamp(current_time);
printf(" SSL状态: %s (延迟: %.1f秒)\n", str, time_diff);
} else {
print_timestamp(current_time);
printf(" SSL状态: %s\n", str);
}
} else {
print_timestamp(current_time);
printf(" SSL状态: %s\n", str);
}
last_time = current_time;
}
break;
case SSL_CB_ALERT:
str = SSL_alert_type_string_long(val);
if (str) {
print_timestamp(current_time);
printf(" SSL警告: %s\n", str);
}
break;
case SSL_CB_EXIT:
if (val == 0) {
str = SSL_state_string_long(ssl);
if (str) {
print_timestamp(current_time);
printf(" SSL退出: %s\n", str);
}
} else if (val < 0) {
str = SSL_state_string_long(ssl);
if (str) {
print_timestamp(current_time);
printf(" SSL错误: %s\n", str);
}
}
break;
case SSL_CB_HANDSHAKE_START:
print_timestamp(current_time);
printf(" SSL握手开始\n");
last_time = current_time;
break;
case SSL_CB_HANDSHAKE_DONE:
print_timestamp(current_time);
printf(" SSL握手完成\n");
break;
default:
// 过滤掉重复的4097类型回调
if (type != 4097) {
print_timestamp(current_time);
printf(" SSL回调: 类型=%d, 值=%d\n", type, val);
}
break;
}
}
/**
* @brief SSL消息回调函数
*/
void ssl_msg_callback(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg) {
const char *direction = write_p ? "发送" : "接收";
const char *content_name = "";
time_t current_time;
// 检查参数有效性
if (!buf || len == 0) {
return;
}
current_time = time(NULL);
switch (content_type) {
case SSL3_RT_CHANGE_CIPHER_SPEC:
content_name = "ChangeCipherSpec";
break;
case SSL3_RT_ALERT:
content_name = "Alert";
break;
case SSL3_RT_HANDSHAKE:
content_name = "Handshake";
break;
case SSL3_RT_APPLICATION_DATA:
content_name = "ApplicationData";
break;
default:
content_name = "Unknown";
break;
}
// 只显示重要的握手消息，过滤掉重复的Unknown消息
if (content_type == SSL3_RT_HANDSHAKE || content_type == SSL3_RT_CHANGE_CIPHER_SPEC) {
print_timestamp(current_time);
printf(" SSL消息: %s %s (版本: %d, 长度: %zu)\n", direction, content_name, version, len);
}
}
/**
* @brief 初始化OpenSSL库
* @param debug_level 调试级别 (0=无调试, 1=基本, 2=详细, 3=完整)
*/
void init_openssl(int debug_level) {
SSL_library_init();
SSL_load_error_strings();
OpenSSL_add_all_algorithms();
if (debug_level > 0) {
// 启用OpenSSL调试
if (debug_level >= 1) {
printf("启用OpenSSL基本调试\n");
}
if (debug_level >= 2) {
printf("启用OpenSSL详细调试\n");
}
if (debug_level >= 3) {
printf("启用OpenSSL完整调试\n");
}
}
}
/**
* @brief 清理OpenSSL资源
*/
void cleanup_openssl() {
if (ssl_ctx) {
SSL_CTX_free(ssl_ctx);
}
EVP_cleanup();
ERR_free_strings();
}
/**
* @brief 创建SSL上下文
* @param cert_file 客户端证书文件路径
* @param key_file 客户端私钥文件路径
* @param ca_file CA证书文件路径
* @param verify_peer 是否验证服务器证书
* @param tls_version TLS版本 (1=TLS1.2, 2=TLS1.3, 0=自动)
* @return SSL_CTX* SSL上下文指针，失败返回NULL
*/
SSL_CTX* create_ssl_context(const char* cert_file, const char* key_file, const char* ca_file, int verify_peer, int tls_version, int debug_level) {
SSL_CTX *ctx;
// 创建SSL上下文，支持TLS 1.2和1.3
ctx = SSL_CTX_new(TLS_client_method());
if (!ctx) {
fprintf(stderr, "无法创建SSL上下文\n");
return NULL;
}
// 设置调试回调（如果启用调试）
if (debug_level >= 2) {
SSL_CTX_set_info_callback(ctx, ssl_info_callback);
}
if (debug_level >= 3) {
SSL_CTX_set_msg_callback(ctx, ssl_msg_callback);
}
// 根据指定版本设置TLS版本
if (tls_version == 1) {
// 只使用TLS 1.2
if (SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION) != 1 ||
SSL_CTX_set_max_proto_version(ctx, TLS1_2_VERSION) != 1) {
fprintf(stderr, "设置TLS 1.2版本失败\n");
SSL_CTX_free(ctx);
return NULL;
}
printf("配置为TLS 1.2模式\n");
} else if (tls_version == 2) {
// 只使用TLS 1.3
if (SSL_CTX_set_min_proto_version(ctx, TLS1_3_VERSION) != 1 ||
SSL_CTX_set_max_proto_version(ctx, TLS1_3_VERSION) != 1) {
fprintf(stderr, "设置TLS 1.3版本失败\n");
SSL_CTX_free(ctx);
return NULL;
}
printf("配置为TLS 1.3模式\n");
} else {
// 自动模式：支持TLS 1.2和1.3
if (SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION) != 1) {
fprintf(stderr, "设置最小TLS版本失败\n");
SSL_CTX_free(ctx);
return NULL;
}
if (SSL_CTX_set_max_proto_version(ctx, TLS1_3_VERSION) != 1) {
fprintf(stderr, "设置最大TLS版本失败\n");
SSL_CTX_free(ctx);
return NULL;
}
printf("配置为TLS 1.2/1.3自动模式\n");
}
// 加载客户端证书
printf("加载客户端证书: %s\n", cert_file);
if (SSL_CTX_use_certificate_file(ctx, cert_file, SSL_FILETYPE_PEM) != 1) {
fprintf(stderr, "加载客户端证书失败: %s\n", cert_file);
ERR_print_errors_fp(stderr);
SSL_CTX_free(ctx);
return NULL;
}
printf("客户端证书加载成功\n");
// 加载客户端私钥
printf("加载客户端私钥: %s\n", key_file);
if (SSL_CTX_use_PrivateKey_file(ctx, key_file, SSL_FILETYPE_PEM) != 1) {
fprintf(stderr, "加载客户端私钥失败: %s\n", key_file);
ERR_print_errors_fp(stderr);
SSL_CTX_free(ctx);
return NULL;
}
printf("客户端私钥加载成功\n");
// 验证私钥与证书匹配
printf("验证私钥与证书匹配...\n");
if (SSL_CTX_check_private_key(ctx) != 1) {
fprintf(stderr, "私钥与证书不匹配\n");
ERR_print_errors_fp(stderr);
SSL_CTX_free(ctx);
return NULL;
}
printf("私钥与证书匹配验证成功\n");
// 加载CA证书用于验证服务器证书
if (ca_file && SSL_CTX_load_verify_locations(ctx, ca_file, NULL) != 1) {
fprintf(stderr, "加载CA证书失败: %s\n", ca_file);
SSL_CTX_free(ctx);
return NULL;
}
// 设置验证模式
if (verify_peer) {
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
} else {
SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
printf("警告: 已禁用服务器证书验证\n");
}
// 设置验证深度
SSL_CTX_set_verify_depth(ctx, 4);
return ctx;
}
/**
* @brief 创建TCP连接
* @param hostname 服务器主机名
* @param port 服务器端口
* @return int 套接字文件描述符，失败返回-1
*/
int create_tcp_connection(const char* hostname, int port) {
int sockfd;
struct sockaddr_in server_addr;
int opt = 1;
// 创建套接字
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("创建套接字失败");
return -1;
}
// 设置套接字选项，避免RST包问题
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
perror("设置SO_REUSEADDR失败");
close(sockfd);
return -1;
}
// 设置TCP_NODELAY选项，减少延迟
if (setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)) < 0) {
perror("设置TCP_NODELAY失败");
close(sockfd);
return -1;
}
// 设置服务器地址
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
// 解析主机名
if (inet_pton(AF_INET, hostname, &server_addr.sin_addr) <= 0) {
fprintf(stderr, "无效的IP地址: %s\n", hostname);
close(sockfd);
return -1;
}
// 连接到服务器
if (connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
perror("连接服务器失败");
close(sockfd);
return -1;
}
printf("成功连接到服务器 %s:%d\n", hostname, port);
return sockfd;
}
/**
* @brief 执行TLS握手
* @param ssl SSL连接对象
* @return int 成功返回1，失败返回0
*/
int perform_tls_handshake(SSL* ssl) {
int ret;
time_t start_time, end_time, step_time;
double handshake_time, step_duration;
printf("开始TLS握手...\n");
start_time = time(NULL);
step_time = start_time;
// 设置握手超时
int sockfd = SSL_get_fd(ssl);
if (sockfd > 0) {
struct timeval timeout;
timeout.tv_sec = 30; // 30秒超时
timeout.tv_usec = 0;
setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
printf("设置握手超时: 30秒\n");
}
// 执行SSL握手
printf("正在执行SSL_connect()...\n");
ret = SSL_connect(ssl);
end_time = time(NULL);
handshake_time = difftime(end_time, start_time);
step_duration = difftime(end_time, step_time);
printf("SSL_connect() 耗时: %.2f 秒\n", step_duration);
if (ret != 1) {
int err = SSL_get_error(ssl, ret);
fprintf(stderr, "TLS握手失败，错误代码: %d\n", err);
// 详细的错误诊断
switch (err) {
case SSL_ERROR_SSL:
fprintf(stderr, "SSL协议错误，可能是证书验证失败\n");
break;
case SSL_ERROR_SYSCALL:
fprintf(stderr, "系统调用错误\n");
break;
case SSL_ERROR_WANT_READ:
case SSL_ERROR_WANT_WRITE:
fprintf(stderr, "需要更多数据\n");
break;
default:
fprintf(stderr, "未知SSL错误\n");
break;
}
ERR_print_errors_fp(stderr);
// 提供解决建议
fprintf(stderr, "\n解决建议:\n");
fprintf(stderr, "1. 使用 --no-verify 选项禁用证书验证\n");
fprintf(stderr, "2. 检查服务器证书是否有效\n");
fprintf(stderr, "3. 确保CA证书文件正确\n");
fprintf(stderr, "4. 检查系统时间是否正确\n");
return 0;
}
// 获取连接信息
printf("TLS握手成功！\n");
printf("握手耗时: %.2f 秒\n", handshake_time);
printf("协议版本: %s\n", SSL_get_version(ssl));
printf("密码套件: %s\n", SSL_get_cipher(ssl));
// 验证服务器证书
X509* cert = SSL_get_peer_certificate(ssl);
if (cert) {
printf("服务器证书验证成功\n");
X509_free(cert);
} else {
printf("警告: 无法获取服务器证书\n");
}
return 1;
}
/**
* @brief 发送测试数据
* @param ssl SSL连接对象
* @return int 成功返回1，失败返回0
*/
int send_test_data(SSL* ssl) {
char test_data[TEST_DATA_SIZE];
int bytes_sent;
time_t start_time, end_time;
double send_time;
// 生成1KB测试数据
for (int i = 0; i < TEST_DATA_SIZE; i++) {
test_data[i] = 'A' + (i % 26);
}
printf("发送 %d 字节测试数据...\n", TEST_DATA_SIZE);
start_time = time(NULL);
// 发送数据
bytes_sent = SSL_write(ssl, test_data, TEST_DATA_SIZE);
end_time = time(NULL);
send_time = difftime(end_time, start_time);
printf("SSL_write() 耗时: %.2f 秒\n", send_time);
if (bytes_sent <= 0) {
int err = SSL_get_error(ssl, bytes_sent);
fprintf(stderr, "发送数据失败，错误代码: %d\n", err);
return 0;
}
printf("成功发送 %d 字节数据\n", bytes_sent);
return 1;
}
/**
* @brief 接收服务器响应
* @param ssl SSL连接对象
* @return int 成功返回1，失败返回0
*/
int receive_response(SSL* ssl) {
char buffer[MAX_BUFFER_SIZE];
int bytes_received;
time_t start_time, end_time;
double receive_time;
int timeout_seconds = 30; // 30秒超时
printf("等待服务器响应（超时: %d秒）...\n", timeout_seconds);
start_time = time(NULL);
// 设置socket超时
int sockfd = SSL_get_fd(ssl);
if (sockfd > 0) {
struct timeval timeout;
timeout.tv_sec = timeout_seconds;
timeout.tv_usec = 0;
setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
}
// 接收数据
bytes_received = SSL_read(ssl, buffer, MAX_BUFFER_SIZE - 1);
end_time = time(NULL);
receive_time = difftime(end_time, start_time);
printf("SSL_read() 耗时: %.2f 秒\n", receive_time);
// 检查是否超时
if (receive_time >= timeout_seconds) {
printf("⚠ 警告: 服务器响应超时（%.2f秒）\n", receive_time);
}
if (bytes_received <= 0) {
int err = SSL_get_error(ssl, bytes_received);
fprintf(stderr, "接收数据失败，错误代码: %d\n", err);
return 0;
}
buffer[bytes_received] = '\0';
printf("接收到 %d 字节响应:\n", bytes_received);
printf("--- 响应内容 ---\n");
printf("%s\n", buffer);
printf("--- 响应结束 ---\n");
// 检查是否收到预期的HTTP响应
if (strstr(buffer, "HTTP/1.1 200 OK") && strstr(buffer, "Hello from TLS server!")) {
printf("✓ 收到预期的HTTP响应\n");
} else {
printf("⚠ 响应内容与预期不符\n");
}
return 1;
}
/**
* @brief 执行单次TLS测试
* @param hostname 服务器主机名
* @param port 服务器端口
* @param cert_file 客户端证书文件
* @param key_file 客户端私钥文件
* @param ca_file CA证书文件
* @return int 成功返回1，失败返回0
*/
int perform_tls_test(const char* hostname, int port, const char* cert_file,
const char* key_file, const char* ca_file, int verify_peer, int tls_version, int debug_level) {
int sockfd;
SSL* ssl;
SSL_CTX* local_ctx = NULL;
int success = 0;
// 创建TCP连接
sockfd = create_tcp_connection(hostname, port);
if (sockfd < 0) {
return 0;
}
// 创建本地SSL上下文（如果提供了tls_version参数）
if (tls_version > 0) {
printf("为TLS版本 %d 创建SSL上下文...\n", tls_version);
local_ctx = create_ssl_context(cert_file, key_file, ca_file, verify_peer, tls_version, debug_level);
if (!local_ctx) {
fprintf(stderr, "创建SSL上下文失败\n");
close(sockfd);
return 0;
}
printf("SSL上下文创建成功\n");
}
// 创建SSL连接
ssl = SSL_new(local_ctx ? local_ctx : ssl_ctx);
if (!ssl) {
fprintf(stderr, "创建SSL连接失败\n");
if (local_ctx) {
SSL_CTX_free(local_ctx);
}
close(sockfd);
return 0;
}
// 将套接字绑定到SSL连接
SSL_set_fd(ssl, sockfd);
// 执行TLS握手
if (perform_tls_handshake(ssl)) {
// 发送测试数据
if (send_test_data(ssl)) {
// 接收响应
if (receive_response(ssl)) {
success = 1;
}
}
}
// 安全关闭SSL连接和套接字
if (ssl) {
// 检查SSL连接状态
int shutdown_state = SSL_get_shutdown(ssl);
printf("SSL关闭前状态: %d\n", shutdown_state);
if (shutdown_state == 0) {
// 连接仍然活跃，需要优雅关闭
printf("开始优雅关闭SSL连接...\n");
// 设置SSL关闭模式为双向关闭
SSL_set_shutdown(ssl, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
// 尝试优雅关闭SSL连接
int ret = SSL_shutdown(ssl);
printf("第一次SSL_shutdown返回: %d\n", ret);
if (ret == 0) {
// 需要再次调用SSL_shutdown完成双向关闭
printf("执行第二次SSL关闭...\n");
ret = SSL_shutdown(ssl);
printf("第二次SSL_shutdown返回: %d\n", ret);
}
// 等待一段时间确保关闭完成
usleep(100000); // 等待100ms
}
// 释放SSL对象
SSL_free(ssl);
}
// 关闭套接字
if (sockfd > 0) {
// 检查套接字状态
int error = 0;
socklen_t len = sizeof(error);
if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) == 0) {
if (error != 0) {
printf("套接字错误: %d\n", error);
}
}
// 设置套接字选项，避免TIME_WAIT状态
int opt = 1;
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
perror("设置SO_REUSEADDR失败");
}
// 设置LINGER选项，确保数据发送完成
struct linger linger_opt;
linger_opt.l_onoff = 1;
linger_opt.l_linger = 5; // 等待5秒
if (setsockopt(sockfd, SOL_SOCKET, SO_LINGER, &linger_opt, sizeof(linger_opt)) < 0) {
perror("设置SO_LINGER失败");
}
// 关闭套接字
close(sockfd);
}
if (local_ctx) {
SSL_CTX_free(local_ctx);
}
return success;
}
/**
* @brief 执行TLS版本循环测试
* @param hostname 服务器主机名
* @param port 服务器端口
* @param cert_file 客户端证书文件
* @param key_file 客户端私钥文件
* @param ca_file CA证书文件
* @param verify_peer 是否验证服务器证书
* @param test_count 测试次数 (-1表示无限循环)
* @param interval 测试间隔
* @return int 成功返回1，失败返回0
*/
int perform_tls_version_test(const char* hostname, int port, const char* cert_file,
const char* key_file, const char* ca_file, int verify_peer,
int test_count, int interval, int continue_on_failure, int debug_level) {
int test_num = 0;
int success_count = 0;
int total_tests = 0;
time_t start_time, end_time;
printf("=== TLS版本循环测试开始 ===\n");
printf("服务器: %s:%d\n", hostname, port);
printf("测试模式: TLS 1.2 -> TLS 1.3 -> 重复\n");
printf("测试次数: %s\n", test_count == -1 ? "无限循环" : "有限次数");
printf("测试间隔: %d 秒\n", interval);
printf("========================\n\n");
start_time = time(NULL);
while (test_count == -1 || test_num < test_count) {
test_num++;
total_tests++;
// 测试TLS 1.2
printf("\n--- 第 %d 次测试 - TLS 1.2 ---\n", test_num);
if (perform_tls_test(hostname, port, cert_file, key_file, ca_file, verify_peer, 1, debug_level)) {
printf("✓ TLS 1.2 测试成功\n");
success_count++;
} else {
printf("✗ TLS 1.2 测试失败\n");
if (!continue_on_failure) {
printf("TLS 1.2 测试失败，退出测试循环\n");
break; // 失败时退出循环
} else {
printf("TLS 1.2 测试失败，继续测试\n");
}
}
// 等待间隔
if (interval > 0) {
sleep(interval);
}
// 测试TLS 1.3
printf("\n--- 第 %d 次测试 - TLS 1.3 ---\n", test_num);
if (perform_tls_test(hostname, port, cert_file, key_file, ca_file, verify_peer, 2, debug_level)) {
printf("✓ TLS 1.3 测试成功\n");
success_count++;
} else {
printf("✗ TLS 1.3 测试失败\n");
if (!continue_on_failure) {
printf("TLS 1.3 测试失败，退出测试循环\n");
break; // 失败时退出循环
} else {
printf("TLS 1.3 测试失败，继续测试\n");
}
}
// 如果不是最后一次测试，等待指定间隔
if (test_count == -1 || test_num < test_count) {
if (interval > 0) {
printf("等待 %d 秒后进行下次测试...\n", interval);
sleep(interval);
}
}
}
end_time = time(NULL);
// 打印测试统计
printf("\n=== 测试统计 ===\n");
printf("总测试次数: %d (TLS 1.2: %d次, TLS 1.3: %d次)\n", total_tests * 2, total_tests, total_tests);
printf("成功次数: %d\n", success_count);
printf("失败次数: %d\n", total_tests * 2 - success_count);
printf("成功率: %.2f%%\n", total_tests > 0 ? (double)success_count / (total_tests * 2) * 100 : 0);
printf("总耗时: %ld 秒\n", end_time - start_time);
printf("===============\n");
return success_count > 0 ? 1 : 0;
}
/**
* @brief 打印使用说明
*/
void print_usage(const char* program_name) {
printf("用法: %s [选项]\n", program_name);
printf("选项:\n");
printf(" -h <hostname> 服务器主机名或IP地址 (默认: 127.0.0.1)\n");
printf(" -p <port> 服务器端口 (默认: 443)\n");
printf(" -c <cert_file> 客户端证书文件 (必需)\n");
printf(" -k <key_file> 客户端私钥文件 (必需)\n");
printf(" -a <ca_file> CA证书文件 (可选)\n");
printf(" -n <count> 测试次数 (默认: 无限循环)\n");
printf(" -i <interval> 测试间隔秒数 (默认: 1)\n");
printf(" -v 详细输出\n");
printf(" -x 禁用服务器证书验证\n");
printf(" -t <version> TLS版本 (1=TLS1.2, 2=TLS1.3, 3=循环测试1.2和1.3)\n");
printf(" -f 失败时继续测试（默认：失败时退出）\n");
printf(" -d <level> OpenSSL调试级别 (0=无, 1=基本, 2=详细, 3=完整)\n");
printf(" --no-verify 禁用服务器证书验证\n");
printf(" --help 显示此帮助信息\n");
printf("\n示例:\n");
printf(" %s -h 192.168.1.100 -p 8443 -c client.crt -k client.key\n", program_name);
printf(" %s -h example.com -p 443 -c client.crt -k client.key -a ca.crt -n 10\n", program_name);
}
int main(int argc, char *argv[]) {
char hostname[256] = "127.0.0.1";
int port = 443;
char cert_file[256] = "";
char key_file[256] = "";
char ca_file[256] = "";
int test_count = -1; // -1表示无限循环
int interval = 1;
int verbose = 0;
int no_verify = 0; // 是否禁用服务器证书验证
int tls_version = 3; // 默认循环测试TLS 1.2和1.3
int continue_on_failure = 0; // 失败时是否继续测试
int debug_level = 0; // OpenSSL调试级别
int opt;
int test_num = 0;
int success_count = 0;
int total_tests = 0;
time_t start_time, end_time;
// 预处理长选项，将它们转换为短选项
for (int i = 1; i < argc; i++) {
if (strcmp(argv[i], "--no-verify") == 0) {
no_verify = 1;
// 移除这个参数，避免getopt处理
for (int j = i; j < argc - 1; j++) {
argv[j] = argv[j + 1];
}
argc--;
i--;
} else if (strcmp(argv[i], "--help") == 0) {
print_usage(argv[0]);
return 0;
}
}
// 解析命令行参数
while ((opt = getopt(argc, argv, "h:p:c:k:a:n:i:vxt:fd:")) != -1) {
switch (opt) {
case 'h':
strncpy(hostname, optarg, sizeof(hostname) - 1);
break;
case 'p':
port = atoi(optarg);
break;
case 'c':
strncpy(cert_file, optarg, sizeof(cert_file) - 1);
break;
case 'k':
strncpy(key_file, optarg, sizeof(key_file) - 1);
break;
case 'a':
strncpy(ca_file, optarg, sizeof(ca_file) - 1);
break;
case 'n':
test_count = atoi(optarg);
break;
case 'i':
interval = atoi(optarg);
break;
case 'v':
verbose = 1;
break;
case 'x':
no_verify = 1;
break;
case 't':
tls_version = atoi(optarg);
if (tls_version < 1 || tls_version > 3) {
fprintf(stderr, "错误: TLS版本必须是1、2或3\n");
print_usage(argv[0]);
return 1;
}
break;
case 'f':
continue_on_failure = 1;
break;
case 'd':
debug_level = atoi(optarg);
if (debug_level < 0 || debug_level > 3) {
fprintf(stderr, "错误: 调试级别必须是0-3\n");
print_usage(argv[0]);
return 1;
}
break;
default:
print_usage(argv[0]);
return 1;
}
}
// 检查必需参数
if (strlen(cert_file) == 0 || strlen(key_file) == 0) {
fprintf(stderr, "错误: 必须指定客户端证书和私钥文件\n");
print_usage(argv[0]);
return 1;
}
// 初始化OpenSSL
init_openssl(debug_level);
// 根据TLS版本选择测试模式
if (tls_version == 3) {
// 循环测试TLS 1.2和1.3
return perform_tls_version_test(hostname, port, cert_file, key_file,
ca_file[0] ? ca_file : NULL, !no_verify,
test_count, interval, continue_on_failure, debug_level);
} else {
// 单版本测试
// 创建SSL上下文
ssl_ctx = create_ssl_context(cert_file, key_file, ca_file[0] ? ca_file : NULL, !no_verify, tls_version, debug_level);
if (!ssl_ctx) {
fprintf(stderr, "创建SSL上下文失败\n");
cleanup_openssl();
return 1;
}
}
printf("=== TLS客户端测试程序 ===\n");
printf("服务器: %s:%d\n", hostname, port);
printf("客户端证书: %s\n", cert_file);
printf("客户端私钥: %s\n", key_file);
if (strlen(ca_file) > 0) {
printf("CA证书: %s\n", ca_file);
}
printf("测试次数: %s\n", test_count == -1 ? "无限循环" : "有限次数");
if (test_count != -1) {
printf("计划测试: %d 次\n", test_count);
}
printf("测试间隔: %d 秒\n", interval);
printf("========================\n\n");
start_time = time(NULL);
// 开始测试循环
while (test_count == -1 || test_num < test_count) {
test_num++;
total_tests++;
printf("\n--- 第 %d 次测试 ---\n", test_num);
if (verbose) {
printf("开始时间: %s", ctime(&start_time));
}
// 执行TLS测试
if (perform_tls_test(hostname, port, cert_file, key_file, ca_file, !no_verify, tls_version, debug_level)) {
printf("✓ 第 %d 次测试成功\n", test_num);
success_count++;
} else {
printf("✗ 第 %d 次测试失败\n", test_num);
if (!continue_on_failure) {
printf("测试失败，退出测试循环\n");
break; // 失败时退出循环
} else {
printf("测试失败，继续测试\n");
}
}
// 如果不是最后一次测试，等待指定间隔
if (test_count == -1 || test_num < test_count) {
if (interval > 0) {
printf("等待 %d 秒后进行下次测试...\n", interval);
sleep(interval);
}
}
}
end_time = time(NULL);
// 打印测试统计
printf("\n=== 测试统计 ===\n");
printf("总测试次数: %d\n", total_tests);
printf("成功次数: %d\n", success_count);
printf("失败次数: %d\n", total_tests - success_count);
printf("成功率: %.2f%%\n", total_tests > 0 ? (double)success_count / total_tests * 100 : 0);
printf("总耗时: %ld 秒\n", end_time - start_time);
printf("===============\n");
// 清理资源
cleanup_openssl();
return 0;
}