基于openssl的单向和双向认证

1、前言

   最近工作涉及到https,需要修改nginx的openssl模块,引入keyless方案。关于keyless可以参考CloudFlare的官方博客:

https://blog.cloudflare.com/keyless-ssl-the-nitty-gritty-technical-details/?utm_source=tuicool&utm_medium=referral

在openssl的基础上修改私钥校验过程,因此需要对openssl的认证认证流程需要熟悉一下。SSL中涉及到很多概念,开始都不清楚,例如CA,数字签名、数字证书等,本文主要是总结SSL认证的基础知识,openssl的单向和双向认证流程,并写代码测试。

2、基础知识

  SSL:Secure Socket Layer,安全套接字层,它位于TCP层与Application层之间。提供对Application数据的加密保护(密文),完整性保护(不被篡改)等安全服务,它缺省工作在TCP 443 端口,一般对HTTP加密,即俗称的HTTPS。

  TLS:Transport Layer Secure,更关注的是提供安全的传输服务,它很灵活,如果可能,它可以工作在TCP,也可以UDP (DTLS),也可以工作在数据链路层,比如802.1x EAP-TLS。

关于SSL/TSL可以参考:http://www.ruanyifeng.com/blog/2014/02/ssl_tls.html

  公钥:大家公用的,可以通过电子邮件发布,通过网站让别人下载,公钥其用来加密和验章。

  私钥:就是自己的私有的,必须非常小心保存,最好加上 密码,私钥是用来解密和签章。

  数字签名:将报文按双方约定的HASH算法计算得到一个固定位数的报文摘要。在数学上保证:只要改动报文中任何一位,重新计算出的报文摘要值就会与原先的值不相符。这样就保证了报文的不可更改性。将该报文摘要值用发送者的私人密钥加密,然后连同原报文一起发送给接收者,而产生的报文即称数字签名。关于数字签名参考:http://www.ruanyifeng.com/blog/2011/08/what_is_a_digital_signature.htmlhttp://www.youdzone.com/signature.html

  数字证书:数字证书就是互联网通讯中标志通讯各方身份信息的一系列数据,提供了一种在Internet上验证您身份的方式,其作用类似于司机的驾驶执照或日常生活中的身份证。它是由一个由权威机构-----CA机构,又称为证书授权(Certificate Authority)中心发行的,人们可以在网上用它来识别对方的身份。数字证书是一个经证书授权中心数字签名的包含公开密钥拥有者信息以及公开密钥的文件。最简单的证书包含一个公开密钥、名称以及证书授权中心的数字签名。

参考:http://blog.csdn.net/oscar999/article/details/9364101

      CA:Certificate Authority,证书授权中心。是一个单位,来管理发放数字证书的。由它发放的证书就叫 CA 证书,以区别于个人使用工具随意生成的数字证书,查看 CA 证书,里面有两项重要内容,一个是颂发给谁,另一个是由谁颂发的。

参考:http://blog.csdn.net/mostone/article/details/22302035

SSL/TLS协议的基本思路是采用公钥加密法,也就是说,客户端先向服务器端索要公钥,然后用公钥加密信息,服务器收到密文后,用自己的私钥解密。

3、认证流程

单向认证:只需要验证SSL服务器身份,不需要验证SSL客户端身份。

 

双向认证:要求服务器和客户端双方都有证书,客户端需要校验服务端,服务端也需要校验客户端。

SSL双向认证和SSL单向认证的区别

  双向认证 SSL 协议要求服务器和用户双方都有证书。单向认证 SSL 协议不需要客户拥有CA证书,具体的过程相对于上面的步骤,只需将服务器端验证客户证书的过程去掉,以及在协商对称密码方案,对称通话密钥时,服务器发送给客户的是没有加过密的(这并不影响 SSL 过程的安全性)密码方案。这样,双方具体的通讯内容,就是加过密的数据,如果有第三方攻击,获得的只是加密的数据,第三方要获得有用的信息,就需要对加密的数据进行解密,这时候的安全就依赖于密码方案的安全。而幸运的是,目前所用的密码方案,只要通讯密钥长度足够的长,就足够的安全。这也是我们强调要求使用128位加密通讯的原因。

  一般Web应用都是采用SSL单向认证的,原因很简单,用户数目广泛,且无需在通讯层对用户身份进行验证,一般都在应用逻辑层来保证用户的合法登入。但如果是企业应用对接,情况就不一样,可能会要求对客户端(相对而言)做身份验证。这时就需要做SSL双向认证。

参考:

http://blog.csdn.net/duanbokan/article/details/50847612

http://blog.csdn.net/it_man/article/details/24698093

4、测试代码

证书生成过程:

(1)自签CA证书

#生成根证书私钥(pem文件)                                                                                                   
openssl genrsa -out cakey.pem 2048                                                                                        
#生成根证书签发申请文件(csr文件)                                                                                           
openssl req -new -key cakey.pem -out ca.csr -subj "/C=CN/ST=myprovince/L=mycity/O=myorganization/OU=mygroup/CN=myCA"   
#自签发根证书(cer文件)                                                                                                     
openssl x509 -req -days 365 -sha1 -extensions v3_ca -signkey cakey.pem -in ca.csr -out  cacert.pem     

(2)服务端私钥和证书

#生成服务端私钥                                                                                                            
openssl genrsa -out key.pem 2048                                                                                          
#生成证书请求文件                                                                                                          
openssl req -new -key key.pem -out server.csr -subj "/C=CN/ST=myprovince/L=mycity/O=myorganization/OU=mygroup/CN=myServer"
#使用根证书签发服务端证书                                                                                                  
openssl x509 -req -days 365 -sha1 -extensions v3_req -CA ../CA/cacert.pem -CAkey ../CA/cakey.pem -CAserial ca.srl -CAcreateserial -in server.csr -out cert.pem
#使用CA证书验证server端证书                                                                                                
openssl verify -CAfile ../CA/cacert.pem  cert.pem

(3)客户端私钥和证书

#生成客户端私钥                                                                                                            
openssl genrsa  -out key.pem 2048                                                                                         
#生成证书请求文件                                                                                                          
openssl req -new -key key.pem -out client.csr -subj "/C=CN/ST=myprovince/L=mycity/O=myorganization/OU=mygroup/CN=myClient"
#使用根证书签发客户端证书                                                                                                  
openssl x509 -req -days 365 -sha1 -extensions v3_req -CA  ../CA/cacert.pem -CAkey ../CA/cakey.pem  -CAserial ../server-cert/ca.srl -in client.csr -out cert.pem
#使用CA证书验证客户端证书                                                                                                  
openssl verify -CAfile ../CA/cacert.pem  cert.pem  

验证CA证书出现错误处理:

http://stackoverflow.com/questions/19726138/openssl-error-18-at-0-depth-lookupself-signed-certificate

单向认证:

客户端代码:不需要配置证书和私钥

  1 #include <stdio.h>
  2 #include <string.h>
  3 #include <errno.h>
  4 #include <sys/socket.h>
  5 #include <resolv.h>
  6 #include <stdlib.h>
  7 #include <netinet/in.h>
  8 #include <arpa/inet.h>
  9 #include <unistd.h>
 10 #include <openssl/ssl.h>
 11 #include <openssl/err.h>
 12 
 13 #define MAXBUF 1024
 14 
 15 void ShowCerts(SSL * ssl)
 16 {
 17     X509 *cert;
 18     char *line;
 19     cert = SSL_get_peer_certificate(ssl);
 20     if (cert != NULL) {
 21         printf("数字证书信息:\n");
 22         line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
 23         printf("证书: %s\n", line);
 24         free(line);
 25         line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
 26         printf("颁发者: %s\n", line);
 27         free(line);
 28         X509_free(cert);
 29     } else {
 30         printf("无证书信息!\n");
 31     }
 32 }
 33 
 34 int main(int argc, char **argv)
 35 {
 36     int sockfd, len;
 37     struct sockaddr_in dest;
 38     char buffer[MAXBUF + 1];
 39     SSL_CTX *ctx;
 40     SSL *ssl;
 41 
 42     if (argc != 3) {
 43         printf("参数格式错误!正确用法如下:\n\t\t%s IP地址 端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来从某个"
 44                 "IP 地址的服务器某个端口接收最多 %d 个字节的消息.\n", argv[0], argv[0], MAXBUF);
 45         exit(0);
 46     }
 47 
 48     /*SSL初始化*/
 49     SSL_library_init();
 50     OpenSSL_add_all_algorithms();
 51     SSL_load_error_strings();
 52     ctx = SSL_CTX_new(SSLv3_client_method());
 53 
 54     if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 55         perror("Socket");
 56         exit(errno);
 57     }
 58 
 59     bzero(&dest, sizeof(dest));
 60     dest.sin_family = AF_INET;
 61     dest.sin_port = htons(atoi(argv[2]));
 62     if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
 63         perror(argv[1]);
 64         exit(errno);
 65     }
 66 
 67     if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
 68         perror("Connect ");
 69         exit(errno);
 70     }
 71     printf("connectd server successly\n");
 72 
 73     ssl = SSL_new(ctx);
 74     SSL_set_fd(ssl, sockfd);
 75     if (SSL_connect(ssl) == -1) {
 76         ERR_print_errors_fp(stderr);
 77     } else {
 78         printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
 79         ShowCerts(ssl);
 80     }
 81 
 82     bzero(buffer, MAXBUF + 1);
 83     len = SSL_read(ssl, buffer, MAXBUF);
 84     if (len > 0) {
 85         printf("接收消息成功:'%s',共%d个字节的数据\n", buffer, len);
 86     } else {
 87         printf("消息接收失败!错误代码是%d,错误信息是'%s'\n", errno, strerror(errno));
 88         goto finish;
 89     }
 90     bzero(buffer, MAXBUF + 1);
 91     strcpy(buffer, "from client->server");
 92 
 93     len = SSL_write(ssl, buffer, strlen(buffer));
 94     if (len < 0) {
 95         printf("消息'%s'发送失败!错误代码是%d,错误信息是'%s'\n", buffer, errno, strerror(errno));
 96     } else {
 97         printf("消息'%s'发送成功,共发送了%d个字节!\n", buffer, len);
 98     }
 99 
100 finish:
101     SSL_shutdown(ssl);
102     SSL_free(ssl);
103     close(sockfd);
104     SSL_CTX_free(ctx);
105     return 0;
106 }

服务端代码:

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <errno.h>
  4 #include <string.h>
  5 #include <sys/types.h>
  6 #include <netinet/in.h>
  7 #include <sys/socket.h>
  8 #include <sys/wait.h>
  9 #include <unistd.h>
 10 #include <arpa/inet.h>
 11 #include <openssl/ssl.h>
 12 #include <openssl/err.h>
 13 
 14 #define MAXBUF 1024
 15 #define SERVER_CERT     "/home/waf/test/cert/server-cert/cert.pem"
 16 #define SERVER_KEY      "/home/waf/test/cert/server-cert/key.pem"
 17 
 18 int main(int argc, char **argv)
 19 {
 20     int sockfd, new_fd;
 21     int reuse = 0;
 22     socklen_t len;
 23     struct sockaddr_in my_addr, their_addr;
 24     unsigned int myport, lisnum;
 25     char buf[MAXBUF + 1];
 26     SSL_CTX *ctx;
 27 
 28     if (argv[1]) {
 29         myport = atoi(argv[1]);
 30     } else {
 31         myport = 7838;
 32     }
 33 
 34     if (argv[2]) {
 35         lisnum = atoi(argv[2]);
 36     } else {
 37         lisnum = 2;
 38     }
 39 
 40     SSL_library_init();
 41     OpenSSL_add_all_algorithms();
 42     SSL_load_error_strings();
 43     ctx = SSL_CTX_new(SSLv3_server_method());
 44     if (ctx == NULL) {
 45         ERR_print_errors_fp(stdout);
 46         exit(1);
 47     }
 48 
 49     /*加载公钥证书*/
 50     if (SSL_CTX_use_certificate_file(ctx, SERVER_CERT, SSL_FILETYPE_PEM) <= 0) {
 51         ERR_print_errors_fp(stdout);
 52         exit(1);
 53     }
 54 
 55     /*设置私钥*/
 56     if (SSL_CTX_use_PrivateKey_file(ctx, SERVER_KEY, SSL_FILETYPE_PEM) <= 0) {
 57         printf("use private key fail.\n");
 58         ERR_print_errors_fp(stdout);
 59         exit(1);
 60     }
 61 
 62     if (!SSL_CTX_check_private_key(ctx)) {
 63         ERR_print_errors_fp(stdout);
 64         exit(1);
 65     }
 66     if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
 67         perror("socket");
 68         exit(1);
 69     } 
 70     if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0){
 71         printf("setsockopet error\n");
 72         return -1;
 73     }
 74     bzero(&my_addr, sizeof(my_addr));
 75     my_addr.sin_family = PF_INET;
 76     my_addr.sin_port = htons(myport);
 77     my_addr.sin_addr.s_addr = INADDR_ANY;
 78 
 79     if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1) {
 80         perror("bind");
 81         exit(1);
 82     } else {
 83         printf("binded\n");
 84     }
 85 
 86     if (listen(sockfd, lisnum) == -1) {
 87         perror("listen");
 88         exit(1);
 89     } else {
 90         printf("begin listen\n");
 91     }
 92 
 93     while (1) {
 94         SSL *ssl;
 95         len = sizeof(struct sockaddr);
 96 
 97         if ((new_fd = accept(sockfd, (struct sockaddr *) &their_addr, &len)) == -1) {
 98             perror("accept");
 99             exit(errno);
100         } 
101         printf("server: got connection from %s, port %d, socket %d\n",inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port), new_fd);
102 
103         ssl = SSL_new(ctx);
104         SSL_set_fd(ssl, new_fd);
105         if (SSL_accept(ssl) == -1) {
106             perror("accept");
107             close(new_fd);
108             break;
109         }
110 
111         bzero(buf, MAXBUF + 1);
112         strcpy(buf, "server->client");
113         len = SSL_write(ssl, buf, strlen(buf));
114         if (len <= 0) {
115             printf("消息'%s'发送失败!错误代码是%d,错误信息是'%s'\n", buf, errno, strerror(errno));
116             goto finish;
117         } 
118         printf("消息'%s'发送成功,共发送了%d个字节!\n", buf, len);
119 
120         bzero(buf, MAXBUF + 1);
121         len = SSL_read(ssl, buf, MAXBUF);
122         if (len > 0) {
123             printf("接收消息成功:'%s',共%d个字节的数据\n", buf, len);
124         } else {
125             printf("消息接收失败!错误代码是%d,错误信息是'%s'\n", errno, strerror(errno));
126         }
127 finish:
128         SSL_shutdown(ssl);
129         SSL_free(ssl);
130         close(new_fd);
131     }
132 
133     close(sockfd);
134     SSL_CTX_free(ctx);
135     return 0;
136 }

测试结果:

双向认证:

客户端代码:需要设置CA证书,客户端证书和私钥,校验服务器。

服务端代码:

  1 #include <stdio.h>
  2 #include <string.h>
  3 #include <errno.h>
  4 #include <sys/socket.h>
  5 #include <resolv.h>
  6 #include <stdlib.h>
  7 #include <netinet/in.h>
  8 #include <arpa/inet.h>
  9 #include <unistd.h>
 10 #include <openssl/ssl.h>
 11 #include <openssl/err.h>
 12 
 13 #define MAXBUF 1024
 14 
 15 #define CA_FILE                "/home/waf/keyless/test/cert/CA/cacert.pem"
 16 #define CLIENT_KEY            "/home/waf/keyless/test/cert/client-cert/key.pem"
 17 #define CLIENT_CERT         "/home/waf/keyless/test/cert/client-cert/cert.pem"
 18 
 19 void ShowCerts(SSL * ssl)
 20 {
 21     X509 *cert;
 22     char *line;
 23     cert = SSL_get_peer_certificate(ssl);
 24     if (cert != NULL) {
 25         printf("数字证书信息:\n");
 26         line = X509_NAME_oneline(X509_get_subject_name(cert), 0, 0);
 27         printf("证书: %s\n", line);
 28         free(line);
 29         line = X509_NAME_oneline(X509_get_issuer_name(cert), 0, 0);
 30         printf("颁发者: %s\n", line);
 31         free(line);
 32         X509_free(cert);
 33     } else {
 34         printf("无证书信息!\n");
 35     }
 36 }
 37 
 38 int main(int argc, char **argv)
 39 {
 40     int sockfd, len;
 41     struct sockaddr_in dest;
 42     char buffer[MAXBUF + 1];
 43     SSL_CTX *ctx;
 44     SSL *ssl;
 45     const SSL_METHOD *method;
 46 
 47     if (argc != 3) {
 48         printf("参数格式错误!正确用法如下:\n\t\t%s IP地址 端口\n\t比如:\t%s 127.0.0.1 80\n此程序用来从某个"
 49                 "IP 地址的服务器某个端口接收最多 MAXBUF 个字节的消息", argv[0], argv[0]);
 50         exit(0);
 51     }
 52 
 53     SSL_library_init();
 54     SSL_load_error_strings();
 55     OpenSSL_add_all_algorithms();  
 56     method = TLSv1_2_client_method();
 57     ctx = SSL_CTX_new(method);
 58 
 59     if (!ctx) {
 60         printf("create ctx is failed.\n");
 61     }
 62 
 63 #if 0
 64     const char * cipher_list = "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-SHA256:AES128-GCM-SHA256:RC4:HIGH:!MD5:!aNULL:!EDH";
 65     if (SSL_CTX_set_cipher_list(ctx, cipher_list) == 0) {
 66         SSL_CTX_free(ctx);
 67         printf("Failed to set cipher list: %s", cipher_list);
 68     }
 69 #endif
 70 
 71     /*设置会话的握手方式*/ 
 72     SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, 0);
 73 
 74     /*加载CA FILE*/
 75     if (SSL_CTX_load_verify_locations(ctx, CA_FILE, 0) != 1) {
 76         SSL_CTX_free(ctx);
 77         printf("Failed to load CA file %s", CA_FILE);
 78     }
 79     if (SSL_CTX_set_default_verify_paths(ctx) != 1) {
 80         SSL_CTX_free(ctx);
 81         printf("Call to SSL_CTX_set_default_verify_paths failed");
 82     }
 83     /*加载客户端证书*/
 84     if (SSL_CTX_use_certificate_file(ctx, CLIENT_CERT, SSL_FILETYPE_PEM) != 1) {
 85         SSL_CTX_free(ctx);
 86         printf("Failed to load client certificate from %s", CLIENT_KEY);
 87     }
 88     /*加载客户端私钥*/
 89     if (SSL_CTX_use_PrivateKey_file(ctx, CLIENT_KEY, SSL_FILETYPE_PEM) != 1) {
 90         SSL_CTX_free(ctx);
 91         printf("Failed to load client private key from %s", CLIENT_KEY);
 92     }
 93     /*验证私钥*/
 94     if (SSL_CTX_check_private_key(ctx) != 1) {
 95         SSL_CTX_free(ctx);
 96         printf("SSL_CTX_check_private_key failed");
 97     }
 98     /*处理握手多次*/  
 99     SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY); 
100 
101     if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
102         perror("Socket");
103         exit(errno);
104     }
105 
106     bzero(&dest, sizeof(dest));
107     dest.sin_family = AF_INET;
108     dest.sin_port = htons(atoi(argv[2]));
109     if (inet_aton(argv[1], (struct in_addr *) &dest.sin_addr.s_addr) == 0) {
110         perror(argv[1]);
111         exit(errno);
112     }
113 
114     if (connect(sockfd, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
115         perror("Connect ");
116         exit(errno);
117     }
118 
119     /*创建SSL*/
120     ssl = SSL_new(ctx);
121     if (ssl == NULL) {
122         printf("SSL_new error.\n");
123     }
124     /*将fd添加到ssl层*/
125     SSL_set_fd(ssl, sockfd);
126     if (SSL_connect(ssl) == -1) {
127         printf("SSL_connect fail.\n");
128         ERR_print_errors_fp(stderr);
129     } else {
130         printf("Connected with %s encryption\n", SSL_get_cipher(ssl));
131         ShowCerts(ssl);
132     }
133 
134     bzero(buffer, MAXBUF + 1);
135     len = SSL_read(ssl, buffer, MAXBUF);
136     if (len > 0) {
137         printf("接收消息成功:'%s',共%d个字节的数据\n", buffer, len);
138     } else {
139         printf("消息接收失败!错误代码是%d,错误信息是'%s'\n", errno, strerror(errno));
140         goto finish;
141     }
142     bzero(buffer, MAXBUF + 1);
143     strcpy(buffer, "from client->server");
144 
145     len = SSL_write(ssl, buffer, strlen(buffer));
146     if (len < 0) {
147         printf("消息'%s'发送失败!错误代码是%d,错误信息是'%s'\n", buffer, errno, strerror(errno));
148     } else {
149         printf("消息'%s'发送成功,共发送了%d个字节!\n", buffer, len);
150     }
151 
152 finish:
153 
154     SSL_shutdown(ssl);
155     SSL_free(ssl);
156     close(sockfd);
157     SSL_CTX_free(ctx);
158     return 0;
159 }

服务端代码:

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <errno.h>
  4 #include <string.h>
  5 #include <sys/types.h>
  6 #include <netinet/in.h>
  7 #include <sys/socket.h>
  8 #include <sys/wait.h>
  9 #include <unistd.h>
 10 #include <arpa/inet.h>
 11 #include <openssl/ssl.h>
 12 #include <openssl/err.h>
 13 
 14 #define MAXBUF 1024
 15 
 16 #define CA_FILE                "/home/waf/keyless/test/cert/CA/cacert.pem"
 17 #define SERVER_KEY             "/home/waf/keyless/test/cert/server-cert/key.pem"
 18 #define SERVER_CERT            "/home/waf/keyless/test/cert/server-cert/cert.pem"
 19 
 20 int main(int argc, char **argv)
 21 {
 22     int sockfd, new_fd;
 23     int reuse = 0;
 24     socklen_t len;
 25     struct sockaddr_in my_addr, their_addr;
 26     unsigned int myport, lisnum;
 27     char buf[MAXBUF + 1];
 28     SSL_CTX *ctx;
 29     const SSL_METHOD *method;
 30 
 31     if (argv[1]) {
 32         myport = atoi(argv[1]);
 33     } else {
 34         myport = 7838;
 35     }
 36 
 37     if (argv[2]) {
 38         lisnum = atoi(argv[2]);
 39     } else {
 40         lisnum = 2;
 41     }
 42 
 43     SSL_library_init();
 44     OpenSSL_add_all_algorithms();
 45     SSL_load_error_strings();
 46 
 47     method = TLSv1_2_server_method();
 48     ctx = SSL_CTX_new(method);
 49     if (ctx == NULL) {
 50         ERR_print_errors_fp(stdout);
 51         exit(1);
 52     }
 53 
 54 #if 0
 55     const char *cipher_list = "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384";
 56     if (SSL_CTX_set_cipher_list(ctx, cipher_list) == 0) {
 57         SSL_CTX_free(ctx);
 58         printf("Failed to set cipher list %s", cipher_list);
 59     }
 60 #endif
 61 
 62     SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, 0);
 63     /*加载CA FILE*/
 64     if (SSL_CTX_load_verify_locations(ctx, CA_FILE, 0) != 1) {
 65         SSL_CTX_free(ctx);
 66         printf("Failed to load CA file %s", CA_FILE);
 67     }
 68     /*加载服务端证书*/
 69     if (SSL_CTX_use_certificate_file(ctx, SERVER_CERT, SSL_FILETYPE_PEM) <= 0) {
 70         ERR_print_errors_fp(stdout);
 71         exit(1);
 72     }
 73     /*加载服务端私钥*/
 74     if (SSL_CTX_use_PrivateKey_file(ctx, SERVER_KEY, SSL_FILETYPE_PEM) <= 0) {
 75         printf("use private key fail.\n");
 76         ERR_print_errors_fp(stdout);
 77         exit(1);
 78     }
 79     /*验证私钥*/
 80     if (!SSL_CTX_check_private_key(ctx)) {
 81         ERR_print_errors_fp(stdout);
 82         exit(1);
 83     }
 84     //处理握手多次  
 85     SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY); 
 86 
 87     if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
 88         perror("socket");
 89         exit(1);
 90     } else {
 91         printf("socket created\n");
 92     }
 93 
 94     if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0){
 95         printf("setsockopet error\n");
 96         return -1;
 97     }
 98 
 99     bzero(&my_addr, sizeof(my_addr));
100     my_addr.sin_family = PF_INET;
101     my_addr.sin_port = htons(myport);
102     my_addr.sin_addr.s_addr = INADDR_ANY;
103 
104     if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1) {
105         perror("bind");
106         exit(1);
107     } 
108     printf("Server bind success.\n");
109 
110     if (listen(sockfd, lisnum) == -1) {
111         perror("listen");
112         exit(1);
113     } 
114     printf("Server begin to listen\n");
115 
116     while (1) {
117         SSL *ssl;
118         len = sizeof(struct sockaddr);
119 
120         if ((new_fd = accept(sockfd, (struct sockaddr *) &their_addr, &len)) == -1) {
121             perror("accept");
122             exit(errno);
123         } 
124 
125         printf("Server: receive a connection from %s, port %d, socket %d\n", inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port), new_fd);
126 
127         ssl = SSL_new(ctx);
128         if (ssl == NULL) {
129             printf("SSL_new error.\n");
130         }
131 
132         SSL_set_fd(ssl, new_fd);
133 
134         if (SSL_accept(ssl) == -1) {
135             perror("accept");
136             ERR_print_errors_fp(stderr);  
137             close(new_fd);
138             break;
139         }
140         printf("Server with %s encryption\n", SSL_get_cipher(ssl));
141 
142         bzero(buf, MAXBUF + 1);
143         strcpy(buf, "server->client");
144         len = SSL_write(ssl, buf, strlen(buf));
145         if (len <= 0) {
146             printf("消息'%s'发送失败!错误代码是%d,错误信息是'%s'\n", buf, errno, strerror(errno));
147             goto finish;
148         } else {
149             printf("消息'%s'发送成功,共发送了%d个字节!\n", buf, len);
150         }
151 
152         bzero(buf, MAXBUF + 1);
153         len = SSL_read(ssl, buf, MAXBUF);
154         if (len > 0) {
155             printf("接收消息成功:'%s',共%d个字节的数据\n", buf, len);
156         } else {
157             printf("消息接收失败!错误代码是%d,错误信息是'%s'\n", errno, strerror(errno));
158         }
159 finish:
160         SSL_shutdown(ssl);
161         SSL_free(ssl);
162         close(new_fd);
163     }
164 
165     close(sockfd);
166     SSL_CTX_free(ctx);
167     return 0;
168 }

测试结果:

 

posted @ 2016-11-01 00:31 Rabbit_Dale 阅读(...) 评论(...) 编辑 收藏