nginx openssl 的集成代码流程

说明：
一、这里个人测试完全和nginx处理流程和返回的数据完全一致
二、这里做了只是做了简要抽取，如果作为服务器，能实现这些步骤整体ssl处理应该没有任何问题。
三、这里包含三个文件：NGXSSL.c 为主文件，source.h为头文件，source.c为部分代码文件。

source.h

---

点击(此处)折叠或打开

1. /*
   
2.  * source.h
   
3.  *
   
4.  * Created on: 2013-3-3
   
5.  * Author: root
   
6.  */
   
7. 
   
8. #ifndef SOURCE_H_
   
9. #define SOURCE_H_
   
10. 
    
11. #include <stdio.h>
    
12. #include <stdlib.h>
    
13. #include <stdint.h>
    
14. #include <unistd.h>
    
15. #include <sys/types.h>
    
16. #include <sys/epoll.h>
    
17. 
    
18. #include <sys/stat.h>
    
19. #include <fcntl.h>
    
20. #include <unistd.h>
    
21. #include <sys/socket.h>
    
22. #include <netinet/in.h>
    
23. #include <arpa/inet.h>
    
24. #include <sys/ioctl.h>
    
25. #include <openssl/ssl.h>
    
26. #include <openssl/err.h>
    
27. #include <openssl/conf.h>
    
28. #include <openssl/engine.h>
    
29. #include <openssl/evp.h>
    
30. 
    
31. //错误码的定义
    
32. #define NGX_OK 0
    
33. #define NGX_ERROR -1
    
34. #define NGX_AGAIN -2
    
35. #define NGX_BUSY -3
    
36. #define NGX_DONE -4
    
37. #define NGX_DECLINED -5
    
38. #define NGX_ABORT -6
    
39. #if (NGX_HAVE_ACCEPT4)
    
40.     static ngx_uint_t use_accept4 = 1;
    
41. #endif
    
42. typedef int ngx_socket_t;
    
43. 
    
44. int ngx_ssl_connection_index;
    
45. int ngx_ssl_server_conf_index;
    
46. int ngx_ssl_session_cache_index;
    
47. 
    
48. #define NGX_SSL_SSLv2 0x0002
    
49. #define NGX_SSL_SSLv3 0x0004
    
50. #define NGX_SSL_TLSv1 0x0008
    
51. #define NGX_SSL_TLSv1_1 0x0010
    
52. #define NGX_SSL_TLSv1_2 0x0020
    
53. 
    
54. #define ngx_ssl_get_connection(ssl_conn) 
    
55.     SSL_get_ex_data(ssl_conn, ngx_ssl_connection_index)
    
56. 
    
57. #define ngx_ssl_conn_t SSL
    
58. 
    
59. #define ngx_close_socket close
    
60. #define ngx_socket socket
    
61. 
    
62. //错误吗的定义
    
63. #define NGX_OK 0
    
64. #define NGX_ERROR -1
    
65. #define NGX_AGAIN -2
    
66. #define NGX_BUSY -3
    
67. #define NGX_DONE -4
    
68. #define NGX_DECLINED -5
    
69. #define NGX_ABORT -6
    
70. 
    
71. typedef intptr_t ngx_int_t; //long int 定义
    
72. typedef uintptr_t ngx_uint_t; //unsigned long int定义
    
73. typedef intptr_t ngx_flag_t;
    
74. 
    
75. typedef struct {
    
76.     SSL_CTX *ctx;
    
77. } ngx_ssl_t;
    
78. 
    
79. RSA * ngx_ssl_rsa512_key_callback(SSL *ssl, int is_export, int key_length);
    
80. int ngx_nonblocking(ngx_socket_t s);
    
81. void ngx_http_ssl_handshake(int fd,ngx_ssl_conn_t *connection);
    
82. ngx_int_t ngx_ssl_handshake(ngx_ssl_conn_t *connection);
    
83. ngx_int_t ngx_ssl_shutdown(ngx_ssl_conn_t *connection);
    
84. void ngx_ssl_clear_error();
    
85. 
    
86. #endif /* SOURCE_H_ */

source.c

---

点击(此处)折叠或打开

1. /*
   
2.  * source.c
   
3.  *
   
4.  * Created on: 2013-3-3
   
5.  * Author: root
   
6.  */
   
7. 
   
8. #include "source.h"
   
9. 
   
10. //设置一个临时的RSA，在出口算法中，有规定需要这么做的
    
11. RSA * ngx_ssl_rsa512_key_callback(SSL *ssl, int is_export, int key_length) {
    
12.     static RSA *key;
    
13. 
    
14.     if (key_length == 512) {
    
15.         if (key == NULL) {
    
16.             key = RSA_generate_key(512, RSA_F4, NULL, NULL);
    
17.         }
    
18.     }
    
19. 
    
20.     return key;
    
21. }
    
22. 
    
23. //
    
24. int ngx_nonblocking(ngx_socket_t s) {
    
25.     int nb;
    
26. 
    
27.     nb = 1;
    
28. 
    
29.     return ioctl(s, FIONBIO, &nb);
    
30. }
    
31. 
    
32. void ngx_http_ssl_handshake(int fd,ngx_ssl_conn_t *connection) {
    
33.     u_char buf[1];
    
34.     ssize_t n;
    
35.     ngx_int_t rc;
    
36. 
    
37.     //如果在recv的时候，flag字段设置了MSG_PEEK，则读取数据包的时候，不会把该数据包从缓存队列中删除；下次读取时还是这个数据包
    
38.     n = recv(fd, (char *) buf, 1, MSG_PEEK);
    
39. 
    
40.     if (n == 1) {
    
41.         if (buf[0] & 0x80 /* SSLv2 */|| buf[0] == 0x16 /* SSLv3/TLSv1 */) { //对不同加密协议进行判断
    
42.             rc = ngx_ssl_handshake(connection); //处理握手和单向认证
    
43.             if (rc == NGX_AGAIN) {
    
44.                 return;
    
45.             }
    
46.             return;
    
47.         }else
    
48.         {
    
49.             //http 平台的请求，如果是http平台的请求，就走一般流程返回错我信息
    
50.             return;
    
51.         }
    
52.     }
    
53.     return;
    
54. }
    
55. 
    
56. ngx_int_t ngx_ssl_handshake(ngx_ssl_conn_t *connection) {
    
57.     int n, sslerr;
    
58.     n = SSL_do_handshake(connection); //这里会试着握手，由于上次recv之后，会有数据正在写入，返回-1
    
59.     if (n == 1) {
    
60.         /* initial handshake done, disable renegotiation (CVE-2009-3555) */
    
61.         if (connection->s3) {
    
62.             connection->s3->flags |= SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS;
    
63.         }
    
64.         return NGX_OK;
    
65.     }
    
66.     sslerr = SSL_get_error(connection, n);
    
67. 
    
68.     //这里应该再重新接收一次和NGINX一样,等待下一次循环（epoll）再进行，同时设置读写句柄，以便下次读取的时候直接进行握手
    
69.      if (sslerr == SSL_ERROR_WANT_READ) {
    
70.          n = SSL_do_handshake(connection);
    
71.              if (n == 1) {
    
72.                  /* initial handshake done, disable renegotiation (CVE-2009-3555) */
    
73.                  if (connection->s3) {
    
74.                      connection->s3->flags |= SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS;
    
75.                  }
    
76.                  return NGX_OK;//握手成功，就可以读取了
    
77.              }
    
78.      }
    
79. 
    
80.     return NGX_AGAIN;
    
81. }
    
82. 
    
83. //ret->quiet_shutdown=1;默认的是ret->quiet_shutdown=0;他相当于SSL_set_shutdown函数将参数设置为SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN
    
84. //　当设置为1时，假如关闭后，不通知对方，这样不适合TLS标准
    
85. ngx_int_t ngx_ssl_shutdown(ngx_ssl_conn_t *connection) {
    
86. 
    
87.     //这里是对认证正确的处理方式简要地关闭处理
    
88.     int n, sslerr, mode;
    
89. //    ngx_err_t err;
    
90. 
    
91. //    if (c->timedout) { //超时，可能是读取或写入超时导致
    
92.     if(0){
    
93.         mode = SSL_RECEIVED_SHUTDOWN|SSL_SENT_SHUTDOWN;
    
94.         SSL_set_quiet_shutdown(connection, 1); //设置为1时，假如关闭后，不通知对方
    
95. 
    
96.     } else {
    
97.         mode = SSL_get_shutdown(connection);
    
98. 
    
99. //        if (c->ssl->no_wait_shutdown) {
    
100.             mode |= SSL_RECEIVED_SHUTDOWN;
     
101. //        }
     
102. 
     
103. //        if (c->ssl->no_send_shutdown) {
     
104.             mode |= SSL_SENT_SHUTDOWN;
     
105. //        }
     
106. 
     
107. //        if (c->ssl->no_wait_shutdown && c->ssl->no_send_shutdown) {
     
108.             SSL_set_quiet_shutdown(connection, 1);
     
109. //        }
     
110.     }
     
111. 
     
112.     SSL_set_shutdown(connection, mode);
     
113. 
     
114.     ngx_ssl_clear_error();
     
115. 
     
116.     n = SSL_shutdown(connection);//关闭SSL套接字
     
117. 
     
118. 
     
119.     sslerr = 0;
     
120. 
     
121. //    /* SSL_shutdown() never returns -1, on error it returns 0 */
     
122. //    if (n == 1 || sslerr == 0 || sslerr == SSL_ERROR_ZERO_RETURN) {
     
123.         SSL_free(connection); //释放SSL套接字
     
124. //        c->ssl = NULL;
     
125. 
     
126.         return NGX_OK; //到这里结束了
     
127. //    }
     
128. //
     
129. // return NGX_OK;
     
130. }
     
131. 
     
132. void ngx_ssl_clear_error() { //对错误信息的清理工作
     
133.     while (ERR_peek_error()) {
     
134.     }
     
135. 
     
136.     ERR_clear_error();
     
137. }
     
138. 
     
139. 
     
140. //
     
141. //ngx_int_t ngx_ssl_init(void) {
     
142. //    OPENSSL_config(NULL);
     
143. //
     
144. //    SSL_library_init();
     
145. //    SSL_load_error_strings();
     
146. //
     
147. //    OpenSSL_add_all_algorithms();
     
148. //
     
149. //    ngx_ssl_connection_index = SSL_get_ex_new_index(0, NULL, NULL, NULL, NULL);
     
150. //
     
151. //    if (ngx_ssl_connection_index == -1) {
     
152. //        printf("SSL_get_ex_new_index() failed");
     
153. //        return NGX_ERROR;
     
154. //    }
     
155. //
     
156. //    ngx_ssl_server_conf_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,
     
157. //            NULL);
     
158. //    if (ngx_ssl_server_conf_index == -1) {
     
159. //        printf("SSL_CTX_get_ex_new_index() failed");
     
160. //        return NGX_ERROR;
     
161. //    }
     
162. //
     
163. //    ngx_ssl_session_cache_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,
     
164. //            NULL);
     
165. //    if (ngx_ssl_session_cache_index == -1) {
     
166. //        printf("SSL_CTX_get_ex_new_index() failed");
     
167. //        return NGX_ERROR;
     
168. //    }
     
169. //
     
170. //    return NGX_OK;
     
171. //}
     
172. //
     
173. static void *
     
174. ngx_openssl_create_conf(ngx_cycle_t *cycle)
     
175. {
     
176. ngx_openssl_conf_t *oscf;
     
177. 
     
178. oscf = ngx_pcalloc(cycle->pool, sizeof(ngx_openssl_conf_t));
     
179.  if (oscf == NULL) {
     
180. return NULL;
     
181. }
     
182. 
     
183. /*
     
184.  * set by ngx_pcalloc():
     
185.  *
     
186.  * oscf->engine = 0;
     
187.  */
     
188. 
     
189. return oscf;
     
190. }
     
191. 
     
192. static void *
     
193. ngx_http_ssl_create_srv_conf(ngx_conf_t *cf)
     
194. {
     
195. ngx_http_ssl_srv_conf_t *sscf;
     
196. 
     
197. sscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_ssl_srv_conf_t));
     
198.  if (sscf == NULL) {
     
199. return NULL;
     
200. }
     
201. 
     
202. /*
     
203.  * set by ngx_pcalloc():
     
204.  *
     
205.  * sscf->protocols = 0;
     
206.  * sscf->certificate = { 0, NULL };
     
207.  * sscf->certificate_key = { 0, NULL };
     
208.  * sscf->dhparam = { 0, NULL };
     
209.  * sscf->ecdh_curve = { 0, NULL };
     
210.  * sscf->client_certificate = { 0, NULL };
     
211.  * sscf->crl = { 0, NULL };
     
212.  * sscf->ciphers = { 0, NULL };
     
213.  * sscf->shm_zone = NULL;
     
214.  */
     
215. 
     
216. sscf->enable = NGX_CONF_UNSET;
     
217. sscf->prefer_server_ciphers = NGX_CONF_UNSET;
     
218. sscf->verify = NGX_CONF_UNSET_UINT;
     
219. sscf->verify_depth = NGX_CONF_UNSET_UINT;
     
220. sscf->builtin_session_cache = NGX_CONF_UNSET;
     
221. sscf->session_timeout = NGX_CONF_UNSET;
     
222. 
     
223. return sscf;
     
224. }
     
225. 
     
226. static ngx_int_t
     
227. ngx_http_ssl_add_variables(ngx_conf_t *cf)
     
228. {
     
229. ngx_http_variable_t *var, *v;
     
230. 
     
231.  for (v = ngx_http_ssl_vars; v->name.len; v++) {
     
232. var = ngx_http_add_variable(cf, &v->name, v->flags);
     
233.  if (var == NULL) {
     
234. return NGX_ERROR;
     
235. }
     
236. 
     
237. var->get_handler = v->get_handler;
     
238. var->data = v->data;
     
239. }
     
240. 
     
241. return NGX_OK;
     
242. }
     
243. 
     
244. static void *
     
245. ngx_http_ssl_create_srv_conf(ngx_conf_t *cf)
     
246. {
     
247. ngx_http_ssl_srv_conf_t *sscf;
     
248. 
     
249. sscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_ssl_srv_conf_t));
     
250.  if (sscf == NULL) {
     
251. return NULL;
     
252. }
     
253. 
     
254. /*
     
255.  * set by ngx_pcalloc():
     
256.  *
     
257.  * sscf->protocols = 0;
     
258.  * sscf->certificate = { 0, NULL };
     
259.  * sscf->certificate_key = { 0, NULL };
     
260.  * sscf->dhparam = { 0, NULL };
     
261.  * sscf->ecdh_curve = { 0, NULL };
     
262.  * sscf->client_certificate = { 0, NULL };
     
263.  * sscf->crl = { 0, NULL };
     
264.  * sscf->ciphers = { 0, NULL };
     
265.  * sscf->shm_zone = NULL;
     
266.  */
     
267. 
     
268. sscf->enable = NGX_CONF_UNSET;
     
269. sscf->prefer_server_ciphers = NGX_CONF_UNSET;
     
270. sscf->verify = NGX_CONF_UNSET_UINT;
     
271. sscf->verify_depth = NGX_CONF_UNSET_UINT;
     
272. sscf->builtin_session_cache = NGX_CONF_UNSET;
     
273. sscf->session_timeout = NGX_CONF_UNSET;
     
274. 
     
275. return sscf;
     
276. }
     
277. 
     
278. 
     
279. //ngx_int_t ngx_ssl_create(ngx_ssl_t *ssl, ngx_uint_t protocols, void *data) {
     
280. //    ssl->ctx = SSL_CTX_new(SSLv23_method());
     
281. //
     
282. //    if (ssl->ctx == NULL) {
     
283. //        printf("SSL_CTX_new() failed");
     
284. //        return NGX_ERROR;
     
285. //    }
     
286. //
     
287. //    if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_server_conf_index, data) == 0) {
     
288. //        printf("SSL_CTX_set_ex_data() failed");
     
289. //        return NGX_ERROR;
     
290. //    }
     
291. //
     
292. //    /* client side options */
     
293. //
     
294. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_MICROSOFT_SESS_ID_BUG);
     
295. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_NETSCAPE_CHALLENGE_BUG);
     
296. //
     
297. //    /* server side options */
     
298. //
     
299. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG);
     
300. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER);
     
301. //
     
302. //    /* this option allow a potential SSL 2.0 rollback (CAN-2005-2969) */
     
303. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_MSIE_SSLV2_RSA_PADDING);
     
304. //
     
305. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLEAY_080_CLIENT_DH_BUG);
     
306. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_D5_BUG);
     
307. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_BLOCK_PADDING_BUG);
     
308. //
     
309. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
     
310. //
     
311. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_SINGLE_DH_USE);
     
312. //
     
313. //    if (!(protocols & NGX_SSL_SSLv2)) {
     
314. //        SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_SSLv2);
     
315. //    }
     
316. //    if (!(protocols & NGX_SSL_SSLv3)) {
     
317. //        SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_SSLv3);
     
318. //    }
     
319. //    if (!(protocols & NGX_SSL_TLSv1)) {
     
320. //        SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_TLSv1);
     
321. //    }
     
322. //
     
323. //#ifdef SSL_OP_NO_COMPRESSION
     
324. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_COMPRESSION);
     
325. //#endif
     
326. //
     
327. //#ifdef SSL_MODE_RELEASE_BUFFERS
     
328. //    SSL_CTX_set_mode(ssl->ctx, SSL_MODE_RELEASE_BUFFERS);
     
329. //#endif
     
330. //
     
331. //    SSL_CTX_set_read_ahead(ssl->ctx, 1);
     
332. //
     
333. //    SSL_CTX_set_info_callback(ssl->ctx, ngx_ssl_info_callback);
     
334. //
     
335. //    return NGX_OK;
     
336. //}
     
337. //
     
338. //void ngx_ssl_info_callback(const ngx_ssl_conn_t *ssl_conn, int where, int ret) {
     
339. //    //    void *c;
     
340. //    //
     
341. //    // if (where & SSL_CB_HANDSHAKE_START) {
     
342. //    // c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn);
     
343. //    //
     
344. //    // if (c) {
     
345. //    // printf("SSL renegotiation");
     
346. //    // }
     
347. //    // }
     
348. //
     
349. //    printf("SSL renegotiation");
     
350. //}
     
351. //
     
352. //int ngx_http_ssl_servername(ngx_ssl_conn_t *ssl_conn, int *ad, void *arg) {
     
353. //    const char *servername;
     
354. //
     
355. //    servername = SSL_get_servername(ssl_conn, TLSEXT_NAMETYPE_host_name);
     
356. //
     
357. //    if (servername == NULL) {
     
358. //        return SSL_TLSEXT_ERR_NOACK;
     
359. //    }
     
360. //
     
361. //    c = ngx_ssl_get_connection(ssl_conn);
     
362. //
     
363. //    printf("SSL server name: "%s"", servername);
     
364. //
     
365. //    return SSL_TLSEXT_ERR_OK;
     
366. //}
     
367. //
     
368. //ngx_int_t ngx_ssl_certificate(ngx_ssl_t *ssl, const char *cert, const char *key) {
     
369. //    if (SSL_CTX_use_certificate_chain_file(ssl->ctx, (char *) cert) == 0) {
     
370. //        printf("SSL_CTX_use_certificate_chain_file("%s") failed", cert);
     
371. //        return NGX_ERROR;
     
372. //    }
     
373. //
     
374. //    if (SSL_CTX_use_PrivateKey_file(ssl->ctx, (char *) key, SSL_FILETYPE_PEM)
     
375. //            == 0) {
     
376. //        printf("SSL_CTX_use_PrivateKey_file("%s") failed", key);
     
377. //        return NGX_ERROR;
     
378. //    }
     
379. //
     
380. //    return NGX_OK;
     
381. //}
     
382. //
     
383. 
     
384. //
     
385. //ngx_ssl_conn_t * ngx_ssl_create_connection(ngx_ssl_t *ssl, int socketid) {
     
386. //    c = malloc(1024);
     
387. //    ngx_ssl_conn_t *connection;
     
388. //
     
389. //    connection = SSL_new(ssl->ctx);
     
390. //
     
391. //    if (connection == NULL) {
     
392. //        return NULL;
     
393. //    }
     
394. //
     
395. //    if (SSL_set_fd(connection, socketid) == 0) {
     
396. //        return NULL;
     
397. //    }
     
398. //    SSL_set_accept_state(connection);
     
399. //    if (SSL_set_ex_data(connection, ngx_ssl_connection_index, c) == 0) {
     
400. //        return NULL;
     
401. //    }
     
402. //
     
403. //    return connection;
     
404. //}
     
405. //
     
406. //
     
407. //ngx_int_t ngx_ssl_dhparam(ngx_ssl_t *ssl, const char *file) {
     
408. //    DH *dh;
     
409. //    BIO *bio;
     
410. //
     
411. //    /*
     
412. //     * -----BEGIN DH PARAMETERS-----
     
413. //     * MIGHAoGBALu8LcrYRnSQfEP89YDpz9vZWKP1aLQtSwju1OsPs1BMbAMCducQgAxc
     
414. //     * y7qokiYUxb7spWWl/fHSh6K8BJvmd4Bg6RqSp1fjBI9osHb302zI8pul34HcLKcl
     
415. //     * 7OZicMyaUDXYzs7vnqAnSmOrHlj6/UmI0PZdFGdX2gcd8EXP4WubAgEC
     
416. //     * -----END DH PARAMETERS-----
     
417. //     */
     
418. //
     
419. //    static unsigned char dh1024_p[] = { 0xBB, 0xBC, 0x2D, 0xCA, 0xD8, 0x46,
     
420. //            0x74, 0x90, 0x7C, 0x43, 0xFC, 0xF5, 0x80, 0xE9, 0xCF, 0xDB, 0xD9,
     
421. //            0x58, 0xA3, 0xF5, 0x68, 0xB4, 0x2D, 0x4B, 0x08, 0xEE, 0xD4, 0xEB,
     
422. //            0x0F, 0xB3, 0x50, 0x4C, 0x6C, 0x03, 0x02, 0x76, 0xE7, 0x10, 0x80,
     
423. //            0x0C, 0x5C, 0xCB, 0xBA, 0xA8, 0x92, 0x26, 0x14, 0xC5, 0xBE, 0xEC,
     
424. //            0xA5, 0x65, 0xA5, 0xFD, 0xF1, 0xD2, 0x87, 0xA2, 0xBC, 0x04, 0x9B,
     
425. //            0xE6, 0x77, 0x80, 0x60, 0xE9, 0x1A, 0x92, 0xA7, 0x57, 0xE3, 0x04,
     
426. //            0x8F, 0x68, 0xB0, 0x76, 0xF7, 0xD3, 0x6C, 0xC8, 0xF2, 0x9B, 0xA5,
     
427. //            0xDF, 0x81, 0xDC, 0x2C, 0xA7, 0x25, 0xEC, 0xE6, 0x62, 0x70, 0xCC,
     
428. //            0x9A, 0x50, 0x35, 0xD8, 0xCE, 0xCE, 0xEF, 0x9E, 0xA0, 0x27, 0x4A,
     
429. //            0x63, 0xAB, 0x1E, 0x58, 0xFA, 0xFD, 0x49, 0x88, 0xD0, 0xF6, 0x5D,
     
430. //            0x14, 0x67, 0x57, 0xDA, 0x07, 0x1D, 0xF0, 0x45, 0xCF, 0xE1, 0x6B,
     
431. //            0x9B };
     
432. //
     
433. //    static unsigned char dh1024_g[] = { 0x02 };
     
434. //
     
435. //    if (!file) {
     
436. //
     
437. //        dh = DH_new();
     
438. //        if (dh == NULL) {
     
439. //            return NGX_ERROR;
     
440. //        }
     
441. //
     
442. //        dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
     
443. //        dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
     
444. //
     
445. //        if (dh->p == NULL || dh->g == NULL) {
     
446. //            DH_free(dh);
     
447. //            return NGX_ERROR;
     
448. //        }
     
449. //
     
450. //        SSL_CTX_set_tmp_dh(ssl->ctx, dh);
     
451. //
     
452. //        DH_free(dh);
     
453. //
     
454. //        return NGX_OK;
     
455. //    }
     
456. //
     
457. //    bio = BIO_new_file((char *) file, "r");
     
458. //    if (bio == NULL) {
     
459. //        return NGX_ERROR;
     
460. //    }
     
461. //
     
462. //    dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
     
463. //    if (dh == NULL) {
     
464. //        BIO_free(bio);
     
465. //        return NGX_ERROR;
     
466. //    }
     
467. //
     
468. //    SSL_CTX_set_tmp_dh(ssl->ctx, dh);
     
469. //
     
470. //    DH_free(dh);
     
471. //    BIO_free(bio);
     
472. //
     
473. //    return NGX_OK;
     
474. //}
     
475. //
     
476. //ngx_int_t ngx_ssl_session_cache(ngx_ssl_t *ssl, const char *sess_ctx,
     
477. //        ssize_t builtin_session_cache, time_t timeout) {
     
478. //    SSL_CTX_set_session_id_context(ssl->ctx, (const unsigned char *) sess_ctx,strlen(sess_ctx));
     
479. //
     
480. //    SSL_CTX_set_session_cache_mode(ssl->ctx,
     
481. //            SSL_SESS_CACHE_SERVER
     
482. //            |SSL_SESS_CACHE_NO_AUTO_CLEAR
     
483. //            |SSL_SESS_CACHE_NO_INTERNAL_STORE);
     
484. //
     
485. //    SSL_CTX_sess_set_cache_size(ssl->ctx, 1);
     
486. //
     
487. //    return NGX_OK;
     
488. //
     
489. //}
     
490. 
     
491. //打开监听到接口,只绑定了一个
     
492. ngx_socket_t ngx_open_listening_sockets() {
     
493.     int reuseaddr;
     
494.     ngx_socket_t s;
     
495.     reuseaddr = 1; //重用地址
     
496.     struct sockaddr_in addr;
     
497. 
     
498.     s = ngx_socket(AF_INET, SOCK_STREAM, 0); //创建套接口
     
499.     if (s == -1) {
     
500.         return NGX_ERROR;
     
501.     }
     
502. 
     
503.     /* 填写sockaddr_in结构*/
     
504.     bzero(&addr, sizeof(addr));
     
505.     addr.sin_family = AF_INET;
     
506.     addr.sin_port = htons(443);
     
507.     addr.sin_addr.s_addr = inet_addr("127.0.0.1");
     
508. 
     
509.     if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuseaddr,
     
510.             sizeof(int)) == -1) {
     
511.         if (ngx_close_socket(s) == -1) { //出错就把它关闭
     
512.         }
     
513.         return NGX_ERROR;
     
514.     }
     
515. 
     
516.     if (ngx_nonblocking(s) == -1) { //堵塞失败调用
     
517.         if (ngx_close_socket(s) == -1) { //关闭套接字
     
518.         }
     
519.         return NGX_ERROR;
     
520.     }
     
521. 
     
522.     if (bind(s, (struct sockaddr*) &addr, sizeof(addr)) == -1) { //绑定
     
523.         return NGX_ERROR;
     
524.     }
     
525. 
     
526.     if (listen(s, 5) == -1) { //监听套接口
     
527.         if (ngx_close_socket(s) == -1) {
     
528.         }
     
529.         return NGX_ERROR;
     
530.     }
     
531. 
     
532.     return s;
     
533. }

NGXSSL.c

---

点击(此处)折叠或打开

1. /*
   
2.  ============================================================================
   
3.  Name : NGXSSL.c
   
4.  Author : xiangrongcheng
   
5.  Version :
   
6.  Copyright : Your copyright notice
   
7.  Description :  Ansi-style
   
8.  ============================================================================
   
9.  */
   
10. 
    
11. #include <stdio.h>
    
12. #include <stdlib.h>
    
13. #include "source.h"
    
14. 
    
15. int epfd;
    
16. 
    
17. int main(void) {
    
18. 
    
19. //    void *data = NULL;
    
20. 
    
21.     //认证和密钥目录
    
22.     const char * certificate = "/usr/local/nginx/conf/api.bz.crt";
    
23.     const char * certificate_key = "/usr/local/nginx/conf/api.bz_nopass.key";
    
24. 
    
25.     //这里模拟nginx初始化
    
26.     //    ngx_ssl_init(); //初始化ssl
    
27.     OPENSSL_config(NULL); //加载openssl的配置信息，不知道对否
    
28.     SSL_library_init(); //加载ssl库函数
    
29.     SSL_load_error_strings(); //格式化错误日志信息
    
30.     OpenSSL_add_all_algorithms(); //load所有的SSL算法
    
31. 
    
32. //    //这里没有必要，是做为缓存，会话和连接池处理的
    
33. //    ngx_ssl_connection_index = SSL_get_ex_new_index(0, NULL, NULL, NULL, NULL);
    
34. //    if (ngx_ssl_connection_index == -1) {
    
35. //        printf("SSL_get_ex_new_index() failed");
    
36. //        return NGX_ERROR;
    
37. //    }
    
38. //
    
39. //    ngx_ssl_server_conf_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,NULL);
    
40. //    if (ngx_ssl_server_conf_index == -1) {
    
41. //        printf("SSL_CTX_get_ex_new_index() failed");
    
42. //        return NGX_ERROR;
    
43. //    }
    
44. //
    
45. //    ngx_ssl_session_cache_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,NULL);
    
46. //    if (ngx_ssl_session_cache_index == -1) {
    
47. //        printf("SSL_CTX_get_ex_new_index() failed");
    
48. //        return NGX_ERROR;
    
49. //    }
    
50. 
    
51.     //创建ssl
    
52.     ngx_ssl_t ssl;
    
53.     ngx_uint_t protocols = 61;
    
54. //    ngx_ssl_create(ssl, protocols, data);
    
55.     ssl.ctx = SSL_CTX_new(SSLv23_method()); //通过SSL所用方法新建SSL_CTX上下文信息
    
56.     if (ssl.ctx == NULL) {
    
57.         printf("SSL_CTX_new() failed");
    
58.         return NGX_ERROR;
    
59.     }
    
60. 
    
61. //    //设置上下文信息的数据，保存扩展数据（应该不是很需要）
    
62. //    if (SSL_CTX_set_ex_data(ssl.ctx, ngx_ssl_server_conf_index, data) == 0) {
    
63. //        printf("SSL_CTX_set_ex_data() failed");
    
64. //        return NGX_ERROR;
    
65. //    }
    
66. 
    
67.     //客户端服务器选项的设定，具体查看具体参数吧，可以看一下英文
    
68.     /* client side options */
    
69.     SSL_CTX_set_options(ssl.ctx, SSL_OP_MICROSOFT_SESS_ID_BUG);
    
70.     SSL_CTX_set_options(ssl.ctx, SSL_OP_NETSCAPE_CHALLENGE_BUG);
    
71. 
    
72.     /* server side options */
    
73.     SSL_CTX_set_options(ssl.ctx, SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG);
    
74.     SSL_CTX_set_options(ssl.ctx, SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER);
    
75. 
    
76.     /* this option allow a potential SSL 2.0 rollback (CAN-2005-2969) */
    
77.     SSL_CTX_set_options(ssl.ctx, SSL_OP_MSIE_SSLV2_RSA_PADDING);
    
78.     SSL_CTX_set_options(ssl.ctx, SSL_OP_SSLEAY_080_CLIENT_DH_BUG);
    
79.     SSL_CTX_set_options(ssl.ctx, SSL_OP_TLS_D5_BUG);
    
80.     SSL_CTX_set_options(ssl.ctx, SSL_OP_TLS_BLOCK_PADDING_BUG);
    
81.     SSL_CTX_set_options(ssl.ctx, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
    
82.     SSL_CTX_set_options(ssl.ctx, SSL_OP_SINGLE_DH_USE);
    
83. 
    
84.     if (!(protocols & NGX_SSL_SSLv2)) {
    
85.         SSL_CTX_set_options(ssl.ctx, SSL_OP_NO_SSLv2);
    
86.     }
    
87.     if (!(protocols & NGX_SSL_SSLv3)) {
    
88.         SSL_CTX_set_options(ssl.ctx, SSL_OP_NO_SSLv3);
    
89.     }
    
90.     if (!(protocols & NGX_SSL_TLSv1)) {
    
91.         SSL_CTX_set_options(ssl.ctx, SSL_OP_NO_TLSv1);
    
92.     }
    
93. 
    
94. #ifdef SSL_OP_NO_COMPRESSION
    
95.     SSL_CTX_set_options(ssl.ctx, SSL_OP_NO_COMPRESSION);
    
96. #endif
    
97. 
    
98. #ifdef SSL_MODE_RELEASE_BUFFERS
    
99.     SSL_CTX_set_mode(ssl.ctx, SSL_MODE_RELEASE_BUFFERS);
    
100. #endif
     
101. 
     
102.     //这里一定需要，设置读取头一个字节，作为判断协议，如果不设定那么将使得n = SSL_read(connection, buffer, 512);少读前一个字节，因为读取第一个字节作为判断字节
     
103.     SSL_CTX_set_read_ahead(ssl.ctx, 1);
     
104. 
     
105.     //下面也不是必要的
     
106. //    SSL_CTX_set_info_callback(ssl.ctx, ngx_ssl_info_callback);
     
107. //    SSL_CTX_set_tlsext_servername_callback(ssl.ctx,ngx_http_ssl_servername);
     
108. 
     
109. //    ngx_ssl_certificate(ssl, certificate, certificate_key);
     
110. 
     
111. //     SSL_CTX_load_verify_locations用于加载受信任的CA证书，CAfile如果不为NULL，则他指向的文件包含PEM编码格式的一个或多个证书，可以用e.g.来简要介绍证书内容
     
112. //    　　CApath如果不为NULL，则它指向一个包含PEM格式的CA证书的目录，目录中每个文件包含一份CA证书，文件名是证书中CA名的HASH值
     
113. //    　　可以用c-rehash来建立该目录，如cd /some/where/certs（包含了很多可信任的CA证书） c_rehash .。返回一成功，0 失败。SSL_CTX_set_default_verify_paths找寻默认的验证路径，在这里肯定找不到的。
     
114. //    　　这里主要set cert_store
     
115. //    　　char *CAfile=NULL,*CApath=NULL;
     
116. //    　　SSL_CTX_load_verify_locations(ctx,CAfile,CApath);
     
117. //    　　当需要客户端验证的时候，服务器把CAfile里面的可信任CA证书发往客户端。
     
118. //    　　if(CAfile !=NULL )SSL_CTX_set_client_CA_list(ctx,SSL_load_client_CA_file(CAfile));
     
119. //    　　设置最大的验证用户证书的上级数。
     
120. //    　　SSL_CTX_set_verify_depth(ctx,10);
     
121. 
     
122.     //设置加载服务器的证书和私钥
     
123.     if (SSL_CTX_use_certificate_chain_file(ssl.ctx, (char *) certificate) == 0) {
     
124.         printf("SSL_CTX_use_certificate_chain_file("%s") failed", certificate);
     
125.     }
     
126.     if (SSL_CTX_use_PrivateKey_file(ssl.ctx, (char *) certificate_key, SSL_FILETYPE_PEM)== 0) { //类型测试好像无所谓，应该是SSL_FILETYPE_ASN1？
     
127.         printf("SSL_CTX_use_PrivateKey_file("%s") failed", certificate_key);
     
128.     }
     
129. 
     
130.     SSL_CTX_set_cipher_list(ssl.ctx, "HIGH:!aNULL:!MD5"); //设置密码链表，具体看密码    ciphers(1)指令吧
     
131.     SSL_CTX_set_tmp_rsa_callback(ssl.ctx, ngx_ssl_rsa512_key_callback); //设置键改变时调用，握手时的处理
     
132. 
     
133.     //如果是双向认证还得做下面这几件事情
     
134. //     SSL_CTX_set_verify(ssl->ctx, SSL_VERIFY_PEER, ngx_http_ssl_verify_callback);
     
135. // SSL_CTX_set_verify_depth(ssl->ctx, depth);
     
136. //     SSL_CTX_load_verify_locations(ssl->ctx, (char *) cert->data, NULL);
     
137. //     SSL_load_client_CA_file((char *) cert->data);
     
138. //     ERR_clear_error();
     
139. //     SSL_CTX_set_client_CA_list(ssl->ctx, list);
     
140. //     SSL_CTX_get_cert_store(ssl->ctx);
     
141. // X509_STORE_add_lookup(store, X509_LOOKUP_file();
     
142. // X509_LOOKUP_load_file(lookup, (char *) crl->data, X509_FILETYPE_PEM);
     
143. // X509_STORE_set_flags(store,X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
     
144. 
     
145.     //ngx_ssl_dhparam(ssl, "");
     
146. //    当使用RSA算法鉴别的时候，会有一个临时的DH密钥磋商发生。这样会话数据将用这个临时的密钥加密，而证书中的密钥中做为签名。
     
147. //    所以这样增强了安全性，临时密钥是在会话结束消失的，所以就是获取了全部信息也无法把通信内容给解密出来。
     
148. 
     
149. //    实现 openssl 提供的默认的 DH_METHOD,实现了根据密钥参数生成 DH 公私钥,以及根据 DH 公钥(一方)以及 DH 私钥(另一方)来生成一个共享密钥,用于密钥交换。
     
150.     //DH密钥磋商设置
     
151.     DH *dh;
     
152.     static unsigned char dh1024_p[] = { 0xBB, 0xBC, 0x2D, 0xCA, 0xD8, 0x46,
     
153.             0x74, 0x90, 0x7C, 0x43, 0xFC, 0xF5, 0x80, 0xE9, 0xCF, 0xDB, 0xD9,
     
154.             0x58, 0xA3, 0xF5, 0x68, 0xB4, 0x2D, 0x4B, 0x08, 0xEE, 0xD4, 0xEB,
     
155.             0x0F, 0xB3, 0x50, 0x4C, 0x6C, 0x03, 0x02, 0x76, 0xE7, 0x10, 0x80,
     
156.             0x0C, 0x5C, 0xCB, 0xBA, 0xA8, 0x92, 0x26, 0x14, 0xC5, 0xBE, 0xEC,
     
157.             0xA5, 0x65, 0xA5, 0xFD, 0xF1, 0xD2, 0x87, 0xA2, 0xBC, 0x04, 0x9B,
     
158.             0xE6, 0x77, 0x80, 0x60, 0xE9, 0x1A, 0x92, 0xA7, 0x57, 0xE3, 0x04,
     
159.             0x8F, 0x68, 0xB0, 0x76, 0xF7, 0xD3, 0x6C, 0xC8, 0xF2, 0x9B, 0xA5,
     
160.             0xDF, 0x81, 0xDC, 0x2C, 0xA7, 0x25, 0xEC, 0xE6, 0x62, 0x70, 0xCC,
     
161.             0x9A, 0x50, 0x35, 0xD8, 0xCE, 0xCE, 0xEF, 0x9E, 0xA0, 0x27, 0x4A,
     
162.             0x63, 0xAB, 0x1E, 0x58, 0xFA, 0xFD, 0x49, 0x88, 0xD0, 0xF6, 0x5D,
     
163.             0x14, 0x67, 0x57, 0xDA, 0x07, 0x1D, 0xF0, 0x45, 0xCF, 0xE1, 0x6B,
     
164.             0x9B };
     
165. 
     
166.     static unsigned char dh1024_g[] = { 0x02 };
     
167.     dh = DH_new();
     
168.     if (dh == NULL) {
     
169.     }
     
170. 
     
171.     dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
     
172.     dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
     
173. 
     
174.     if (dh->p == NULL || dh->g == NULL) {
     
175.         DH_free(dh);
     
176.     }
     
177.     SSL_CTX_set_tmp_dh(ssl.ctx, dh);
     
178.     DH_free(dh);
     
179. 
     
180. //    ngx_ssl_session_cache(ssl, "HTTP", 0, 0);
     
181.     //下面只是会话的设置
     
182.     SSL_CTX_set_session_id_context(ssl.ctx, (const unsigned char *) "HTTP",strlen("HTTP"));
     
183.     SSL_CTX_set_session_cache_mode(ssl.ctx,
     
184.             SSL_SESS_CACHE_SERVER
     
185.             |SSL_SESS_CACHE_NO_AUTO_CLEAR
     
186.             |SSL_SESS_CACHE_NO_INTERNAL_STORE);
     
187. 
     
188. //    设置cache的大小，默认的为1024*20=20000，这个也就是可以存多少个session_id，一般都不需要更改的。假如为0的话将是无限
     
189.     SSL_CTX_sess_set_cache_size(ssl.ctx, 1);
     
190. 
     
191.     //下面是网络模块
     
192.     socklen_t sin_len = sizeof(struct sockaddr_in);
     
193.     int fd, opt = 1;
     
194.     struct epoll_event ev;
     
195.     struct sockaddr_in sin, cin;
     
196. 
     
197.     epfd = epoll_create(1024);
     
198.     if ((fd = socket(AF_INET, SOCK_STREAM, 0)) <= 0) {
     
199.         fprintf(stderr, "socket failed/n");
     
200.         return -1;
     
201.     }
     
202.     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const void*) &opt, sizeof(opt));
     
203. 
     
204.     memset(&sin, 0, sizeof(struct sockaddr_in));
     
205.     sin.sin_family = AF_INET;
     
206.     sin.sin_port = htons((short) (443));
     
207.     sin.sin_addr.s_addr = INADDR_ANY;
     
208.     if (bind(fd, (struct sockaddr *) &sin, sizeof(sin)) != 0) {
     
209.         fprintf(stderr, "bind failed/n");
     
210.         return -1;
     
211.     }
     
212.     if (listen(fd, 32) != 0) {
     
213.         fprintf(stderr, "listen failed/n");
     
214.         return -1;
     
215.     }
     
216. 
     
217.     int i, cfd, n, nfds;
     
218. 
     
219.     struct epoll_event events[1024];
     
220.     char buffer[512];
     
221. 
     
222.     ev.data.fd = fd;
     
223.     ev.events = EPOLLIN | EPOLLET; //设置要处理的事件类型
     
224.     epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
     
225. 
     
226.     while (1) {
     
227.         nfds = epoll_wait(epfd, events, 1024, -1);
     
228.         printf("nfds ........... %d/n", nfds);
     
229.         for (i = 0; i < nfds; i++) {
     
230.             if (events[i].data.fd == fd) {
     
231.                 cfd = accept(fd, (struct sockaddr *) &cin, &sin_len);
     
232.                 ngx_nonblocking(cfd); //把客户端的socket设置为非阻塞方式
     
233.                 ev.data.fd = cfd;
     
234.                 ev.events = EPOLLIN | EPOLLET;
     
235.                 epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
     
236.             } else {
     
237.                 if (events[i].events & EPOLLIN) {
     
238.                     cfd = events[i].data.fd;
     
239. 
     
240.                     //这里模拟nginx接收
     
241. //                    ngx_ssl_create_connection(ssl, cfd);
     
242.                     ngx_ssl_conn_t *connection = SSL_new(ssl.ctx); //根据上下文，建立ssl套接口或链接
     
243.                     if (connection == NULL) {
     
244.                     }
     
245. 
     
246.                     if (SSL_set_fd(connection, cfd) == 0) { //设置处理的id进入上下文里面
     
247.                     }
     
248.                     SSL_set_accept_state(connection); //设置接收状态
     
249. 
     
250. //                    if (SSL_set_ex_data(connection, ngx_ssl_connection_index, c) == 0) {
     
251. //                    }
     
252. 
     
253.                     //进行握手处理
     
254.                     ngx_http_ssl_handshake(cfd,connection);
     
255. 
     
256.                     //正确处理
     
257.                     for (;;) {
     
258.                         n = SSL_read(connection, buffer, 512); //会读取好几次把之前读取的第一个字节也读取回来
     
259.                         if (n > 0) {
     
260.                         } else {
     
261.                             break;
     
262.                         }
     
263.                         continue;
     
264.                     }
     
265. 
     
266.                     //这里是，对请求的相关处理，省略掉了
     
267. 
     
268.                     //ngx_http_process_request_headers(rev);
     
269. 
     
270.                     //给客户端发送数据
     
271.                     const char *data = "HTTP/1.1 200 OKrnServer: nginx/1.0.12rnDate: Sun, 03 Mar 2013 12:38:48 GMTrnContent- ...";
     
272.                     n = SSL_write(connection, data, sizeof(data));
     
273. 
     
274.                     //关闭请求链接；如果验证通过是不会走这里的（而等到超时的时候才处理）；对于验证不通过或http请求则直接调用关闭链接。
     
275.                     ngx_ssl_shutdown(connection);
     
276.                     SSL_CTX_free(ssl.ctx);//释放SSL环境
     
277.                     close(fd);
     
278. 
     
279.                     //                    ret = recv(cfd, buffer, sizeof(buffer), 0);
     
280.                     //                    printf("read ret..........= %d/n", ret);
     
281.                     //
     
282.                     //                    ev.data.fd = cfd;
     
283.                     //                    ev.events = EPOLLOUT | EPOLLET;
     
284.                     //                    epoll_ctl(epfd, EPOLL_CTL_MOD, cfd, &ev);
     
285.                 } else if (events[i].events & EPOLLOUT) {
     
286.                     cfd = events[i].data.fd;
     
287. 
     
288.                     ev.data.fd = cfd;
     
289.                     epoll_ctl(epfd, EPOLL_CTL_DEL, cfd, &ev);
     
290.                     close(cfd);
     
291. 
     
292.                 }
     
293.             }
     
294.         }
     
295.     }
     
296. 
     
297.     if (fd > 0)
     
298.         close(fd);
     
299.     return 0;
     
300. }
     
301. 
     

---

openssl nginx 处理流程总结：

一、初始化工作
1、通过SSL所用方法新建SSL_CTX上下文信息
2、客户端服务器选项的ssl上下文设定
3、设置读取第一个字节读取设定
4、设置服务器的CA证书和私钥
5、DH密钥磋商设定，加强数据安全性
6、如果是双向认证还得做一些事情
7、设置密码链表
8、设置键改变时调用，握手时的处理
9、网络模块的建立

二、当请求到来时
1、通过ssl的上下文建立ssl链接
2、设置链接状态和描述符
3、进行握手处理
4、读取一个字节，进行协议判断，如果协议不正确做退出等操作
5、协议正确，会进行握手操作（SSL_do_handshake），握手里面做了三件事：加密算法保持一致，确认所使用的算法中的加密密钥，对客户端进行认证。
6、握手成功后SSL_read 在“记录层”进行数据读取
7、数据处理
8、对客户端进行写入操作，也在“记录层”进行处理。
9、最后进行数据的关闭等操作

SSL_read 和 SSL_write 都是根据记录层，进行数据加密/解密传输所得的正确数据
当然实现还可有使用 SSL自带的接收和链接函数