• openssl实现双向认证教程（服务端代码+客户端代码+证书生成）

    参考链接

    注意事项

    •  openssl版本差异很可能导致程序编译与运行出现问题
    • 本程序在OpenSSL 1.1.1  11 Sep 2018 版本下执行编译没有问题

    创建目录

    • 目录结构如下所示
    • 创建目录使用命令mkdir
    • 创建文件使用命令touch

    路径说明

    • client路径：/home/chy-cpabe/ssl_server_client/client/pem
    • server路径：/home/chy-cpabe/ssl_server_client/server/pem
    • ca路径：/home/chy-cpabe/ssl_server_client/ca 

    生成证书

    生成ca证书

    1. # CA证书及密钥生成方法一----直接生成CA密钥及其自签名证书
    2. openssl req -newkey rsa:2048 -passout pass:123456 -keyout ca_rsa_private.pem -x509 -days 365 -out ca.crt -subj "/C=CN/ST=GD/L=SZ/O=COM/OU=NSP/CN=CA/emailAddress=ca_email@qq.com"

    Server 

     生成server证书

    1. # 服务器证书及密钥生成方法一----直接生成服务器密钥及待签名证书
    2. openssl req -newkey rsa:2048 -passout pass:server -keyout server_rsa_private.pem  -out server.csr -subj "/C=CN/ST=GD/L=SZ/O=COM/OU=NSP/CN=SERVER/emailAddress=server_email@qq.com"

    对server证书进行签名

    1. # 使用CA证书及密钥对服务器证书进行签名：
    2. openssl x509 -req -days 365 -in server.csr -CA /home/chy-cpabe/ssl_server_client/ca/ca.crt -CAkey /home/chy-cpabe/ssl_server_client/ca/ca_rsa_private.pem -passin pass:123456 -CAcreateserial -out server.crt

     生成未加密的server的密钥

    1. # 将加密的RSA密钥转成未加密的RSA密钥，避免每次读取都要求输入解密密码
    2. # 密码就是生成私钥文件时设置的passout、读取私钥文件时要输入的passin，比如这里要输入“server”
    3. openssl rsa -in server_rsa_private.pem -out server_rsa_private.pem.unsecure

     Client

    生成client证书

    1. # 客户端证书及密钥生成方法一----直接生成客户端密钥及待签名证书
    2. openssl req -newkey rsa:2048 -passout pass:client -keyout client_rsa_private.pem -out client.csr -subj "/C=CN/ST=GD/L=SZ/O=COM/OU=NSP/CN=CLIENT/emailAddress=client_email@qq.com"

    对client证书进行签名 

    1. # 使用CA证书及密钥对客户端证书进行签名：
    2. openssl x509 -req -days 365 -in client.csr -CA /home/chy-cpabe/ssl_server_client/ca/ca.crt -CAkey /home/chy-cpabe/ssl_server_client/ca/ca_rsa_private.pem -passin pass:123456 -CAcreateserial -out client.crt

      生成未加密的client的密钥

    1. # 将加密的RSA密钥转成未加密的RSA密钥，避免每次读取都要求输入解密密码
    2. # 密码就是生成私钥文件时设置的passout、读取私钥文件时要输入的passin，比如这里要输入“client”
    3. openssl rsa -in client_rsa_private.pem -out client_rsa_private.pem.unsecure

    程序

    • 注意事项：ca的证书需要程序内部指定，server和client的证书通过形参进行传递

    server端程序

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13.  
    14. #define MAXBUF 1024
    15.  
    16. void ShowCerts(SSL * ssl)
    17. {
    18.     X509 *cert;
    19.     char *line;
    20.  
    21.     cert = SSL_get_peer_certificate(ssl);
    22.     // SSL_get_verify_result()是重点，SSL_CTX_set_verify()只是配置启不启用并没有执行认证，调用该函数才会真证进行证书认证
    23.     // 如果验证不通过，那么程序抛出异常中止连接
    24.     if(SSL_get_verify_result(ssl) == X509_V_OK){
    25.         printf("证书验证通过\n");
    26.     }
    27.     if (cert != NULL) {
    28.         printf("数字证书信息:\n");
    29.         line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
    30.         printf("证书: %s\n", line);
    31.         free(line);
    32.         line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
    33.         printf("颁发者: %s\n", line);
    34.         free(line);
    35.         X509_free(cert);
    36.     } else
    37.         printf("无证书信息！\n");
    38. }
    39.  
    40. int main(int argc, char **argv) {
    41.     int sockfd, new_fd;
    42.     socklen_t len;
    43.     struct sockaddr_in my_addr, their_addr;
    44.     unsigned int myport, lisnum;
    45.     char buf[MAXBUF + 1];
    46.     SSL_CTX *ctx;
    47.  
    48.     if (argv[1])
    49.         myport = atoi(argv[1]);
    50.     else
    51.         myport = 7838;
    52.  
    53.     if (argv[2])
    54.         lisnum = atoi(argv[2]);
    55.     else
    56.         lisnum = 2;
    57.  
    58.     /* SSL 库初始化 */
    59.     SSL_library_init();
    60.     /* 载入所有 SSL 算法 */
    61.     OpenSSL_add_all_algorithms();
    62.     /* 载入所有 SSL 错误消息 */
    63.     SSL_load_error_strings();
    64.     /* 以 SSL V2 和 V3 标准兼容方式产生一个 SSL_CTX ，即 SSL Content Text */
    65.     ctx = SSL_CTX_new(SSLv23_server_method());
    66.     /* 也可以用 SSLv2_server_method() 或 SSLv3_server_method() 单独表示 V2 或 V3标准 */
    67.     if (ctx == NULL) {
    68.         ERR_print_errors_fp(stdout);
    69.         exit(1);
    70.     }
    71.  
    72.     // 双向验证
    73.     // SSL_VERIFY_PEER---要求对证书进行认证，没有证书也会放行
    74.     // SSL_VERIFY_FAIL_IF_NO_PEER_CERT---要求客户端需要提供证书，但验证发现单独使用没有证书也会放行
    75.     SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);
    76.     // 设置信任根证书
    77.     if (SSL_CTX_load_verify_locations(ctx, "/home/chy-cpabe/ssl_server_client/ca/ca.crt",NULL)<=0){
    78.         ERR_print_errors_fp(stdout);
    79.         exit(1);
    80.     }
    81.  
    82.     /* 载入用户的数字证书， 此证书用来发送给客户端。 证书里包含有公钥 */
    83.     if (SSL_CTX_use_certificate_file(ctx, argv[3], SSL_FILETYPE_PEM) <= 0) {
    84.         ERR_print_errors_fp(stdout);
    85.         exit(1);
    86.     }
    87.     /* 载入用户私钥 */
    88.     if (SSL_CTX_use_PrivateKey_file(ctx, argv[4], SSL_FILETYPE_PEM) <= 0) {
    89.         ERR_print_errors_fp(stdout);
    90.         exit(1);
    91.     }
    92.     /* 检查用户私钥是否正确 */
    93.     if (!SSL_CTX_check_private_key(ctx)) {
    94.         ERR_print_errors_fp(stdout);
    95.         exit(1);
    96.     }
    97.  
    98.     /* 开启一个 socket 监听 */
    99.     if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
    100.         perror("socket");
    101.         exit(1);
    102.     } else
    103.         printf("socket created\n");
    104.  
    105.     bzero(&my_addr, sizeof(my_addr));
    106.     my_addr.sin_family = PF_INET;
    107.     my_addr.sin_port = htons(myport);
    108.     my_addr.sin_addr.s_addr = INADDR_ANY;
    109.  
    110.     if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr))
    111.             == -1) {
    112.         perror("bind");
    113.         exit(1);
    114.     } else
    115.         printf("binded\n");
    116.  
    117.     if (listen(sockfd, lisnum) == -1) {
    118.         perror("listen");
    119.         exit(1);
    120.     } else
    121.         printf("begin listen\n");
    122.  
    123.     while (1) {
    124.         SSL *ssl;
    125.         len = sizeof(struct sockaddr);
    126.         /* 等待客户端连上来 */
    127.         if ((new_fd = accept(sockfd, (struct sockaddr *) &their_addr, &len))
    128.                 == -1) {
    129.             perror("accept");
    130.             exit(errno);
    131.         } else
    132.             printf("server: got connection from %s, port %d, socket %d\n",
    133.                     inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port),
    134.                     new_fd);
    135.  
    136.         /* 基于 ctx 产生一个新的 SSL */
    137.         ssl = SSL_new(ctx);
    138.         /* 将连接用户的 socket 加入到 SSL */
    139.         SSL_set_fd(ssl, new_fd);
    140.         /* 建立 SSL 连接 */
    141.         if (SSL_accept(ssl) == -1) {
    142.             perror("accept");
    143.             close(new_fd);
    144.             break;
    145.         }
    146.         ShowCerts(ssl);
    147.  
    148.         /* 开始处理每个新连接上的数据收发 */
    149.         bzero(buf, MAXBUF + 1);
    150.         strcpy(buf, "server->client");
    151.         /* 发消息给客户端 */
    152.         len = SSL_write(ssl, buf, strlen(buf));
    153.  
    154.         if (len <= 0) {
    155.             printf("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n", buf, errno,
    156.                     strerror(errno));
    157.             goto finish;
    158.         } else
    159.             printf("消息'%s'发送成功，共发送了%d个字节！\n", buf, len);
    160.  
    161.         bzero(buf, MAXBUF + 1);
    162.         /* 接收客户端的消息 */
    163.         len = SSL_read(ssl, buf, MAXBUF);
    164.         if (len > 0)
    165.             printf("接收消息成功:'%s'，共%d个字节的数据\n", buf, len);
    166.         else
    167.             printf("消息接收失败！错误代码是%d，错误信息是'%s'\n",
    168.             errno, strerror(errno));
    169.         /* 处理每个新连接上的数据收发结束 */
    170.         finish:
    171.         /* 关闭 SSL 连接 */
    172.         SSL_shutdown(ssl);
    173.         /* 释放 SSL */
    174.         SSL_free(ssl);
    175.         /* 关闭 socket */
    176.         close(new_fd);
    177.     }
    178.     /* 关闭监听的 socket */
    179.     close(sockfd);
    180.     /* 释放 CTX */
    181.     SSL_CTX_free(ctx);
    182.     return 0;
    183. }

    client程序

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. #define MAXBUF 1024
    14.  
    15. void ShowCerts(SSL * ssl)
    16. {
    17.     X509 *cert;
    18.     char *line;
    19.  
    20.     cert = SSL_get_peer_certificate(ssl);
    21.     // SSL_get_verify_result()是重点，SSL_CTX_set_verify()只是配置启不启用并没有执行认证，调用该函数才会真证进行证书认证
    22.     // 如果验证不通过，那么程序抛出异常中止连接
    23.     if(SSL_get_verify_result(ssl) == X509_V_OK){
    24.         printf("证书验证通过\n");
    25.     }
    26.     if (cert != NULL) {
    27.         printf("数字证书信息:\n");
    28.         line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
    29.         printf("证书: %s\n", line);
    30.         free(line);
    31.         line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
    32.         printf("颁发者: %s\n", line);
    33.         free(line);
    34.         X509_free(cert);
    35.     } else
    36.         printf("无证书信息！\n");
    37. }
    38.  
    39. int main(int argc, char **argv)
    40. {
    41.     int sockfd, len;
    42.     struct sockaddr_in dest;
    43.     char buffer[MAXBUF + 1];
    44.     SSL_CTX *ctx;
    45.     SSL *ssl;
    46.  
    47.     if (argc != 5) {
    48.         printf("参数格式错误！正确用法如下：\n\t\t%s IP地址 端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来从某个"
    49.              "IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息",
    50.              argv[0], argv[0]);
    51.         exit(0);
    52.     }
    53.  
    54.     /* SSL 库初始化，参看 ssl-server.c 代码 */
    55.     SSL_library_init();
    56.     OpenSSL_add_all_algorithms();
    57.     SSL_load_error_strings();
    58.     ctx = SSL_CTX_new(SSLv23_client_method());
    59.     if (ctx == NULL) {
    60.         ERR_print_errors_fp(stdout);
    61.         exit(1);
    62.     }
    63.  
    64.     // 双向验证
    65.     // SSL_VERIFY_PEER---要求对证书进行认证，没有证书也会放行
    66.     // SSL_VERIFY_FAIL_IF_NO_PEER_CERT---要求客户端需要提供证书，但验证发现单独使用没有证书也会放行
    67.     SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);
    68.     // 设置信任根证书
    69.     if (SSL_CTX_load_verify_locations(ctx, "/home/chy-cpabe/ssl_server_client/ca/ca.crt",NULL)<=0){
    70.         ERR_print_errors_fp(stdout);
    71.         exit(1);
    72.     }
    73.  
    74.     /* 载入用户的数字证书， 此证书用来发送给客户端。 证书里包含有公钥 */
    75.     if (SSL_CTX_use_certificate_file(ctx, argv[3], SSL_FILETYPE_PEM) <= 0) {
    76.         ERR_print_errors_fp(stdout);
    77.         exit(1);
    78.     }
    79.     /* 载入用户私钥 */
    80.     if (SSL_CTX_use_PrivateKey_file(ctx, argv[4], SSL_FILETYPE_PEM) <= 0) {
    81.         ERR_print_errors_fp(stdout);
    82.         exit(1);
    83.     }
    84.     /* 检查用户私钥是否正确 */
    85.     if (!SSL_CTX_check_private_key(ctx)) {
    86.         ERR_print_errors_fp(stdout);
    87.         exit(1);
    88.     }
    89.  
    90.     /* 创建一个 socket 用于 tcp 通信 */
    91.     if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
    92.         perror("Socket");
    93.         exit(errno);
    94.     }
    95.     printf("socket created\n");
    96.  
    97.     /* 初始化服务器端（对方）的地址和端口信息 */
    98.     bzero(&dest, sizeof(dest));
    99.     dest.sin_family = AF_INET;
    100.     dest.sin_port = htons(atoi(argv[2]));
    101.     if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
    102.         perror(argv[1]);
    103.         exit(errno);
    104.     }
    105.     printf("address created\n");
    106.  
    107.     /* 连接服务器 */
    108.     if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
    109.         perror("Connect ");
    110.         exit(errno);
    111.     }
    112.     printf("server connected\n");
    113.  
    114.     /* 基于 ctx 产生一个新的 SSL */
    115.     ssl = SSL_new(ctx);
    116.     SSL_set_fd(ssl, sockfd);
    117.     /* 建立 SSL 连接 */
    118.     if (SSL_connect(ssl) == -1)
    119.         ERR_print_errors_fp(stderr);
    120.     else {
    121.         printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
    122.         ShowCerts(ssl);
    123.     }
    124.  
    125.     /* 接收对方发过来的消息，最多接收 MAXBUF 个字节 */
    126.     bzero(buffer, MAXBUF + 1);
    127.     /* 接收服务器来的消息 */
    128.     len = SSL_read(ssl, buffer, MAXBUF);
    129.     if (len > 0)
    130.         printf("接收消息成功:'%s'，共%d个字节的数据\n",
    131.                buffer, len);
    132.     else {
    133.         printf
    134.             ("消息接收失败！错误代码是%d，错误信息是'%s'\n",
    135.              errno, strerror(errno));
    136.         goto finish;
    137.     }
    138.     bzero(buffer, MAXBUF + 1);
    139.     strcpy(buffer, "from client->server");
    140.     /* 发消息给服务器 */
    141.     len = SSL_write(ssl, buffer, strlen(buffer));
    142.     if (len < 0)
    143.         printf
    144.             ("消息'%s'发送失败！错误代码是%d，错误信息是'%s'\n",
    145.              buffer, errno, strerror(errno));
    146.     else
    147.         printf("消息'%s'发送成功，共发送了%d个字节！\n",
    148.                buffer, len);
    149.  
    150.   finish:
    151.     /* 关闭连接 */
    152.     SSL_shutdown(ssl);
    153.     SSL_free(ssl);
    154.     close(sockfd);
    155.     SSL_CTX_free(ctx);
    156.     return 0;
    157. }

     编译程序

    • server端
    • sudo gcc ssl_server.c -o server -lssl -lcrypto -ldl
    • client端
    • sudo gcc ssl_client.c -o client -lssl -lcrypto -ldl

    运行程序

    •  server端
    • sudo ./server 7838 1 /home/chy-cpabe/ssl_server_client/server/pem/server.crt /home/chy-cpabe/ssl_server_client/server/pem/server_rsa_private.pem.unsecure
    • client端
    • sudo ./client 127.0.0.1 7838 /home/chy-cpabe/ssl_server_client/client/pem/client.crt /home/chy-cpabe/ssl_server_client/client/pem/client_rsa_private.pem.unsecure

    运行截图

     server端

    client端

    补充知识

    1. # CA证书及密钥生成方法一----直接生成CA密钥及其自签名证书
    2. # 如果想以后读取私钥文件ca_rsa_private.pem时不需要输入密码，亦即不对私钥进行加密存储，那么将-passout pass:123456替换成-nodes
    3. openssl req -newkey rsa:2048 -passout pass:123456 -keyout ca_rsa_private.pem -x509 -days 365 -out ca.crt -subj "/C=CN/ST=GD/L=SZ/O=COM/OU=NSP/CN=CA/emailAddress=youremail@qq.com"
    4. # CA证书及密钥生成方法二----分步生成CA密钥及其自签名证书：
    5. # openssl genrsa -aes256 -passout pass:123456 -out ca_rsa_private.pem 2048
    6. # openssl req -new -x509 -days 365 -key ca_rsa_private.pem -passin pass:123456 -out ca.crt -subj "/C=CN/ST=GD/L=SZ/O=COM/OU=NSP/CN=CA/emailAddress=youremail@qq.com"
    7.  
    8. # 服务器证书及密钥生成方法一----直接生成服务器密钥及待签名证书
    9. # 如果想以后读取私钥文件server_rsa_private.pem时不需要输入密码，亦即不对私钥进行加密存储，那么将-passout pass:server替换成-nodes
    10. openssl req -newkey rsa:2048 -passout pass:server -keyout server_rsa_private.pem  -out server.csr -subj "/C=CN/ST=GD/L=SZ/O=COM/OU=NSP/CN=SERVER/emailAddress=youremail@qq.com"
    11. # 服务器证书及密钥生成方法二----分步生成服务器密钥及待签名证书
    12. # openssl genrsa -aes256 -passout pass:server -out server_rsa_private.pem 2048
    13. # openssl req -new -key server_rsa_private.pem -passin pass:server -out server.csr -subj "/C=CN/ST=GD/L=SZ/O=COM/OU=NSP/CN=SERVER/emailAddress=youremail@qq.com"
    14. # 使用CA证书及密钥对服务器证书进行签名：
    15. openssl x509 -req -days 365 -in server.csr -CA ca.crt -CAkey ca_rsa_private.pem -passin pass:123456 -CAcreateserial -out server.crt
    16. # 将加密的RSA密钥转成未加密的RSA密钥，避免每次读取都要求输入解密密码
    17. # 密码就是生成私钥文件时设置的passout、读取私钥文件时要输入的passin，比如这里要输入“server”
    18. openssl rsa -in server_rsa_private.pem -out server_rsa_private.pem.unsecure
    19.  
    20. # 客户端证书及密钥生成方法一----直接生成客户端密钥及待签名证书
    21. # 如果想以后读取私钥文件client_rsa_private.pem时不需要输入密码，亦即不对私钥进行加密存储，那么将-passout pass:client替换成-nodes
    22. openssl req -newkey rsa:2048 -passout pass:client -keyout client_rsa_private.pem -out client.csr -subj "/C=CN/ST=GD/L=SZ/O=COM/OU=NSP/CN=CLIENT/emailAddress=youremail@qq.com"
    23. # 客户端证书及密钥生成方法二----分步生成客户端密钥及待签名证书：
    24. # openssl genrsa -aes256 -passout pass:client -out client_rsa_private.pem 2048
    25. # openssl req -new -key client_rsa_private.pem -passin pass:client -out client.csr -subj "/C=CN/ST=GD/L=SZ/O=COM/OU=NSP/CN=CLIENT/emailAddress=youremail@qq.com"
    26. # 使用CA证书及密钥对客户端证书进行签名：
    27. openssl x509 -req -days 365 -in client.csr -CA ca.crt -CAkey ca_rsa_private.pem -passin pass:123456 -CAcreateserial -out client.crt
    28. # 将加密的RSA密钥转成未加密的RSA密钥，避免每次读取都要求输入解密密码
    29. # 密码就是生成私钥文件时设置的passout、读取私钥文件时要输入的passin，比如这里要输入“client”
    30. openssl rsa -in client_rsa_private.pem -out client_rsa_private.pem.unsecure

     

  • 相关阅读:
    每日更新SQL练习题之第一天
    学习记忆——数学篇——案例——代数——方程——一元二次方程
    使用 Amazon Bedrock 和 Amazon SageMaker，开启全新的生成式 AI “工作年”！
    子网的划分
    暑期JAVA学习（37）定时器
    一般过去式练习题
    Unity URP14.0 自定义后处理框架
    HbuilderX uniapp项目转cli项目全过程记录
    4、Netty 线程模型
    【C++】STL——stack&queue模拟实现
  • 原文地址：https://blog.csdn.net/CHYabc123456hh/article/details/125880756