关闭

nginx openssl 的集成代码流程

444人阅读 评论(0) 收藏 举报
分类:
说明:
一、这里个人测试完全和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. #ifndef SOURCE_H_
  8. #define SOURCE_H_

  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <stdint.h>
  12. #include <unistd.h>
  13. #include <sys/types.h>
  14. #include <sys/epoll.h>

  15. #include <sys/stat.h>
  16. #include <fcntl.h>
  17. #include <unistd.h>
  18. #include <sys/socket.h>
  19. #include <netinet/in.h>
  20. #include <arpa/inet.h>
  21. #include <sys/ioctl.h>
  22. #include <openssl/ssl.h>
  23. #include <openssl/err.h>
  24. #include <openssl/conf.h>
  25. #include <openssl/engine.h>
  26. #include <openssl/evp.h>

  27. //错误码的定义
  28. #define NGX_OK 0
  29. #define NGX_ERROR -1
  30. #define NGX_AGAIN -2
  31. #define NGX_BUSY -3
  32. #define NGX_DONE -4
  33. #define NGX_DECLINED -5
  34. #define NGX_ABORT -6
  35. #if (NGX_HAVE_ACCEPT4)
  36.     static ngx_uint_t use_accept4 = 1;
  37. #endif
  38. typedef int ngx_socket_t;

  39. int ngx_ssl_connection_index;
  40. int ngx_ssl_server_conf_index;
  41. int ngx_ssl_session_cache_index;

  42. #define NGX_SSL_SSLv2 0x0002
  43. #define NGX_SSL_SSLv3 0x0004
  44. #define NGX_SSL_TLSv1 0x0008
  45. #define NGX_SSL_TLSv1_1 0x0010
  46. #define NGX_SSL_TLSv1_2 0x0020

  47. #define ngx_ssl_get_connection(ssl_conn) 
  48.     SSL_get_ex_data(ssl_conn, ngx_ssl_connection_index)

  49. #define ngx_ssl_conn_t SSL

  50. #define ngx_close_socket close
  51. #define ngx_socket socket

  52. //错误吗的定义
  53. #define NGX_OK 0
  54. #define NGX_ERROR -1
  55. #define NGX_AGAIN -2
  56. #define NGX_BUSY -3
  57. #define NGX_DONE -4
  58. #define NGX_DECLINED -5
  59. #define NGX_ABORT -6

  60. typedef intptr_t ngx_int_t; //long int 定义
  61. typedef uintptr_t ngx_uint_t; //unsigned long int定义
  62. typedef intptr_t ngx_flag_t;

  63. typedef struct {
  64.     SSL_CTX *ctx;
  65. } ngx_ssl_t;

  66. RSA * ngx_ssl_rsa512_key_callback(SSL *ssl, int is_export, int key_length);
  67. int ngx_nonblocking(ngx_socket_t s);
  68. void ngx_http_ssl_handshake(int fd,ngx_ssl_conn_t *connection);
  69. ngx_int_t ngx_ssl_handshake(ngx_ssl_conn_t *connection);
  70. ngx_int_t ngx_ssl_shutdown(ngx_ssl_conn_t *connection);
  71. void ngx_ssl_clear_error();

  72. #endif /* SOURCE_H_ */
source.c

点击(此处)折叠或打开

  1. /*
  2.  * source.c
  3.  *
  4.  * Created on: 2013-3-3
  5.  * Author: root
  6.  */

  7. #include "source.h"

  8. //设置一个临时的RSA,在出口算法中,有规定需要这么做的
  9. RSA * ngx_ssl_rsa512_key_callback(SSL *ssl, int is_export, int key_length) {
  10.     static RSA *key;

  11.     if (key_length == 512) {
  12.         if (key == NULL) {
  13.             key = RSA_generate_key(512, RSA_F4, NULL, NULL);
  14.         }
  15.     }

  16.     return key;
  17. }

  18. //
  19. int ngx_nonblocking(ngx_socket_t s) {
  20.     int nb;

  21.     nb = 1;

  22.     return ioctl(s, FIONBIO, &nb);
  23. }

  24. void ngx_http_ssl_handshake(int fd,ngx_ssl_conn_t *connection) {
  25.     u_char buf[1];
  26.     ssize_t n;
  27.     ngx_int_t rc;

  28.     //如果在recv的时候,flag字段设置了MSG_PEEK,则读取数据包的时候,不会把该数据包从缓存队列中删除;下次读取时还是这个数据包
  29.     n = recv(fd, (char *) buf, 1, MSG_PEEK);

  30.     if (== 1) {
  31.         if (buf[0] & 0x80 /* SSLv2 */|| buf[0] == 0x16 /* SSLv3/TLSv1 */) { //对不同加密协议进行判断
  32.             rc = ngx_ssl_handshake(connection); //处理握手和单向认证
  33.             if (rc == NGX_AGAIN) {
  34.                 return;
  35.             }
  36.             return;
  37.         }else
  38.         {
  39.             //http 平台的请求,如果是http平台的请求,就走一般流程返回错我信息
  40.             return;
  41.         }
  42.     }
  43.     return;
  44. }

  45. ngx_int_t ngx_ssl_handshake(ngx_ssl_conn_t *connection) {
  46.     int n, sslerr;
  47.     n = SSL_do_handshake(connection); //这里会试着握手,由于上次recv之后,会有数据正在写入,返回-1
  48.     if (== 1) {
  49.         /* initial handshake done, disable renegotiation (CVE-2009-3555) */
  50.         if (connection->s3) {
  51.             connection->s3->flags |= SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS;
  52.         }
  53.         return NGX_OK;
  54.     }
  55.     sslerr = SSL_get_error(connection, n);

  56.     //这里应该再重新接收一次和NGINX一样,等待下一次循环(epoll)再进行,同时设置读写句柄,以便下次读取的时候直接进行握手
  57.      if (sslerr == SSL_ERROR_WANT_READ) {
  58.          n = SSL_do_handshake(connection);
  59.              if (== 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.      }

  67.     return NGX_AGAIN;
  68. }

  69. //ret->quiet_shutdown=1;默认的是ret->quiet_shutdown=0;他相当于SSL_set_shutdown函数将参数设置为SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN
  70. // 当设置为1时,假如关闭后,不通知对方,这样不适合TLS标准
  71. ngx_int_t ngx_ssl_shutdown(ngx_ssl_conn_t *connection) {

  72.     //这里是对认证正确的处理方式简要地关闭处理
  73.     int n, sslerr, mode;
  74. //    ngx_err_t err;

  75. //    if (c->timedout) { //超时,可能是读取或写入超时导致
  76.     if(0){
  77.         mode = SSL_RECEIVED_SHUTDOWN|SSL_SENT_SHUTDOWN;
  78.         SSL_set_quiet_shutdown(connection, 1); //设置为1时,假如关闭后,不通知对方

  79.     } else {
  80.         mode = SSL_get_shutdown(connection);

  81. //        if (c->ssl->no_wait_shutdown) {
  82.             mode |= SSL_RECEIVED_SHUTDOWN;
  83. //        }

  84. //        if (c->ssl->no_send_shutdown) {
  85.             mode |= SSL_SENT_SHUTDOWN;
  86. //        }

  87. //        if (c->ssl->no_wait_shutdown && c->ssl->no_send_shutdown) {
  88.             SSL_set_quiet_shutdown(connection, 1);
  89. //        }
  90.     }

  91.     SSL_set_shutdown(connection, mode);

  92.     ngx_ssl_clear_error();

  93.     n = SSL_shutdown(connection);//关闭SSL套接字


  94.     sslerr = 0;

  95. //    /* SSL_shutdown() never returns -1, on error it returns 0 */
  96. //    if (== 1 || sslerr == 0 || sslerr == SSL_ERROR_ZERO_RETURN) {
  97.         SSL_free(connection); //释放SSL套接字
  98. //        c->ssl = NULL;

  99.         return NGX_OK; //到这里结束了
  100. //    }
  101. //
  102. // return NGX_OK;
  103. }

  104. void ngx_ssl_clear_error() { //对错误信息的清理工作
  105.     while (ERR_peek_error()) {
  106.     }

  107.     ERR_clear_error();
  108. }


  109. //
  110. //ngx_int_t ngx_ssl_init(void) {
  111. //    OPENSSL_config(NULL);
  112. //
  113. //    SSL_library_init();
  114. //    SSL_load_error_strings();
  115. //
  116. //    OpenSSL_add_all_algorithms();
  117. //
  118. //    ngx_ssl_connection_index = SSL_get_ex_new_index(0, NULL, NULL, NULL, NULL);
  119. //
  120. //    if (ngx_ssl_connection_index == -1) {
  121. //        printf("SSL_get_ex_new_index() failed");
  122. //        return NGX_ERROR;
  123. //    }
  124. //
  125. //    ngx_ssl_server_conf_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,
  126. //            NULL);
  127. //    if (ngx_ssl_server_conf_index == -1) {
  128. //        printf("SSL_CTX_get_ex_new_index() failed");
  129. //        return NGX_ERROR;
  130. //    }
  131. //
  132. //    ngx_ssl_session_cache_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,
  133. //            NULL);
  134. //    if (ngx_ssl_session_cache_index == -1) {
  135. //        printf("SSL_CTX_get_ex_new_index() failed");
  136. //        return NGX_ERROR;
  137. //    }
  138. //
  139. //    return NGX_OK;
  140. //}
  141. //
  142. ////static void *
  143. ////ngx_openssl_create_conf(ngx_cycle_t *cycle)
  144. ////{
  145. //// ngx_openssl_conf_t *oscf;
  146. ////
  147. //// oscf = ngx_pcalloc(cycle->pool, sizeof(ngx_openssl_conf_t));
  148. //// if (oscf == NULL) {
  149. //// return NULL;
  150. //// }
  151. ////
  152. //// /*
  153. //// * set by ngx_pcalloc():
  154. //// *
  155. //// * oscf->engine = 0;
  156. //// */
  157. ////
  158. //// return oscf;
  159. ////}
  160. ////
  161. ////static void *
  162. ////ngx_http_ssl_create_srv_conf(ngx_conf_t *cf)
  163. ////{
  164. //// ngx_http_ssl_srv_conf_t *sscf;
  165. ////
  166. //// sscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_ssl_srv_conf_t));
  167. //// if (sscf == NULL) {
  168. //// return NULL;
  169. //// }
  170. ////
  171. //// /*
  172. //// * set by ngx_pcalloc():
  173. //// *
  174. //// * sscf->protocols = 0;
  175. //// * sscf->certificate = { 0, NULL };
  176. //// * sscf->certificate_key = { 0, NULL };
  177. //// * sscf->dhparam = { 0, NULL };
  178. //// * sscf->ecdh_curve = { 0, NULL };
  179. //// * sscf->client_certificate = { 0, NULL };
  180. //// * sscf->crl = { 0, NULL };
  181. //// * sscf->ciphers = { 0, NULL };
  182. //// * sscf->shm_zone = NULL;
  183. //// */
  184. ////
  185. //// sscf->enable = NGX_CONF_UNSET;
  186. //// sscf->prefer_server_ciphers = NGX_CONF_UNSET;
  187. //// sscf->verify = NGX_CONF_UNSET_UINT;
  188. //// sscf->verify_depth = NGX_CONF_UNSET_UINT;
  189. //// sscf->builtin_session_cache = NGX_CONF_UNSET;
  190. //// sscf->session_timeout = NGX_CONF_UNSET;
  191. ////
  192. //// return sscf;
  193. ////}
  194. ////
  195. ////static ngx_int_t
  196. ////ngx_http_ssl_add_variables(ngx_conf_t *cf)
  197. ////{
  198. //// ngx_http_variable_t *var, *v;
  199. ////
  200. //// for (= ngx_http_ssl_vars; v->name.len; v++) {
  201. //// var = ngx_http_add_variable(cf, &v->name, v->flags);
  202. //// if (var == NULL) {
  203. //// return NGX_ERROR;
  204. //// }
  205. ////
  206. //// var->get_handler = v->get_handler;
  207. //// var->data = v->data;
  208. //// }
  209. ////
  210. //// return NGX_OK;
  211. ////}
  212. ////
  213. ////static void *
  214. ////ngx_http_ssl_create_srv_conf(ngx_conf_t *cf)
  215. ////{
  216. //// ngx_http_ssl_srv_conf_t *sscf;
  217. ////
  218. //// sscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_ssl_srv_conf_t));
  219. //// if (sscf == NULL) {
  220. //// return NULL;
  221. //// }
  222. ////
  223. //// /*
  224. //// * set by ngx_pcalloc():
  225. //// *
  226. //// * sscf->protocols = 0;
  227. //// * sscf->certificate = { 0, NULL };
  228. //// * sscf->certificate_key = { 0, NULL };
  229. //// * sscf->dhparam = { 0, NULL };
  230. //// * sscf->ecdh_curve = { 0, NULL };
  231. //// * sscf->client_certificate = { 0, NULL };
  232. //// * sscf->crl = { 0, NULL };
  233. //// * sscf->ciphers = { 0, NULL };
  234. //// * sscf->shm_zone = NULL;
  235. //// */
  236. ////
  237. //// sscf->enable = NGX_CONF_UNSET;
  238. //// sscf->prefer_server_ciphers = NGX_CONF_UNSET;
  239. //// sscf->verify = NGX_CONF_UNSET_UINT;
  240. //// sscf->verify_depth = NGX_CONF_UNSET_UINT;
  241. //// sscf->builtin_session_cache = NGX_CONF_UNSET;
  242. //// sscf->session_timeout = NGX_CONF_UNSET;
  243. ////
  244. //// return sscf;
  245. ////}
  246. ////
  247. ////
  248. //ngx_int_t ngx_ssl_create(ngx_ssl_t *ssl, ngx_uint_t protocols, void *data) {
  249. //    ssl->ctx = SSL_CTX_new(SSLv23_method());
  250. //
  251. //    if (ssl->ctx == NULL) {
  252. //        printf("SSL_CTX_new() failed");
  253. //        return NGX_ERROR;
  254. //    }
  255. //
  256. //    if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_server_conf_index, data) == 0) {
  257. //        printf("SSL_CTX_set_ex_data() failed");
  258. //        return NGX_ERROR;
  259. //    }
  260. //
  261. //    /* client side options */
  262. //
  263. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_MICROSOFT_SESS_ID_BUG);
  264. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_NETSCAPE_CHALLENGE_BUG);
  265. //
  266. //    /* server side options */
  267. //
  268. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG);
  269. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER);
  270. //
  271. //    /* this option allow a potential SSL 2.0 rollback (CAN-2005-2969) */
  272. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_MSIE_SSLV2_RSA_PADDING);
  273. //
  274. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_SSLEAY_080_CLIENT_DH_BUG);
  275. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_D5_BUG);
  276. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_TLS_BLOCK_PADDING_BUG);
  277. //
  278. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
  279. //
  280. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_SINGLE_DH_USE);
  281. //
  282. //    if (!(protocols & NGX_SSL_SSLv2)) {
  283. //        SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_SSLv2);
  284. //    }
  285. //    if (!(protocols & NGX_SSL_SSLv3)) {
  286. //        SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_SSLv3);
  287. //    }
  288. //    if (!(protocols & NGX_SSL_TLSv1)) {
  289. //        SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_TLSv1);
  290. //    }
  291. //
  292. //#ifdef SSL_OP_NO_COMPRESSION
  293. //    SSL_CTX_set_options(ssl->ctx, SSL_OP_NO_COMPRESSION);
  294. //#endif
  295. //
  296. //#ifdef SSL_MODE_RELEASE_BUFFERS
  297. //    SSL_CTX_set_mode(ssl->ctx, SSL_MODE_RELEASE_BUFFERS);
  298. //#endif
  299. //
  300. //    SSL_CTX_set_read_ahead(ssl->ctx, 1);
  301. //
  302. //    SSL_CTX_set_info_callback(ssl->ctx, ngx_ssl_info_callback);
  303. //
  304. //    return NGX_OK;
  305. //}
  306. //
  307. //void ngx_ssl_info_callback(const ngx_ssl_conn_t *ssl_conn, int where, int ret) {
  308. //    //    void *c;
  309. //    //
  310. //    // if (where & SSL_CB_HANDSHAKE_START) {
  311. //    // c = ngx_ssl_get_connection((ngx_ssl_conn_t *) ssl_conn);
  312. //    //
  313. //    // if (c) {
  314. //    // printf("SSL renegotiation");
  315. //    // }
  316. //    // }
  317. //
  318. //    printf("SSL renegotiation");
  319. //}
  320. //
  321. //int ngx_http_ssl_servername(ngx_ssl_conn_t *ssl_conn, int *ad, void *arg) {
  322. //    const char *servername;
  323. //
  324. //    servername = SSL_get_servername(ssl_conn, TLSEXT_NAMETYPE_host_name);
  325. //
  326. //    if (servername == NULL) {
  327. //        return SSL_TLSEXT_ERR_NOACK;
  328. //    }
  329. //
  330. //    c = ngx_ssl_get_connection(ssl_conn);
  331. //
  332. //    printf("SSL server name: "%s"", servername);
  333. //
  334. //    return SSL_TLSEXT_ERR_OK;
  335. //}
  336. //
  337. //ngx_int_t ngx_ssl_certificate(ngx_ssl_t *ssl, const char *cert, const char *key) {
  338. //    if (SSL_CTX_use_certificate_chain_file(ssl->ctx, (char *) cert) == 0) {
  339. //        printf("SSL_CTX_use_certificate_chain_file("%s") failed", cert);
  340. //        return NGX_ERROR;
  341. //    }
  342. //
  343. //    if (SSL_CTX_use_PrivateKey_file(ssl->ctx, (char *) key, SSL_FILETYPE_PEM)
  344. //            == 0) {
  345. //        printf("SSL_CTX_use_PrivateKey_file("%s") failed", key);
  346. //        return NGX_ERROR;
  347. //    }
  348. //
  349. //    return NGX_OK;
  350. //}
  351. //

  352. //
  353. //ngx_ssl_conn_t * ngx_ssl_create_connection(ngx_ssl_t *ssl, int socketid) {
  354. //    c = malloc(1024);
  355. //    ngx_ssl_conn_t *connection;
  356. //
  357. //    connection = SSL_new(ssl->ctx);
  358. //
  359. //    if (connection == NULL) {
  360. //        return NULL;
  361. //    }
  362. //
  363. //    if (SSL_set_fd(connection, socketid) == 0) {
  364. //        return NULL;
  365. //    }
  366. //    SSL_set_accept_state(connection);
  367. //    if (SSL_set_ex_data(connection, ngx_ssl_connection_index, c) == 0) {
  368. //        return NULL;
  369. //    }
  370. //
  371. //    return connection;
  372. //}
  373. //
  374. //
  375. //ngx_int_t ngx_ssl_dhparam(ngx_ssl_t *ssl, const char *file) {
  376. //    DH *dh;
  377. //    BIO *bio;
  378. //
  379. //    /*
  380. //     * -----BEGIN DH PARAMETERS-----
  381. //     * MIGHAoGBALu8LcrYRnSQfEP89YDpz9vZWKP1aLQtSwju1OsPs1BMbAMCducQgAxc
  382. //     * y7qokiYUxb7spWWl/fHSh6K8BJvmd4Bg6RqSp1fjBI9osHb302zI8pul34HcLKcl
  383. //     * 7OZicMyaUDXYzs7vnqAnSmOrHlj6/UmI0PZdFGdX2gcd8EXP4WubAgEC
  384. //     * -----END DH PARAMETERS-----
  385. //     */
  386. //
  387. //    static unsigned char dh1024_p[] = { 0xBB, 0xBC, 0x2D, 0xCA, 0xD8, 0x46,
  388. //            0x74, 0x90, 0x7C, 0x43, 0xFC, 0xF5, 0x80, 0xE9, 0xCF, 0xDB, 0xD9,
  389. //            0x58, 0xA3, 0xF5, 0x68, 0xB4, 0x2D, 0x4B, 0x08, 0xEE, 0xD4, 0xEB,
  390. //            0x0F, 0xB3, 0x50, 0x4C, 0x6C, 0x03, 0x02, 0x76, 0xE7, 0x10, 0x80,
  391. //            0x0C, 0x5C, 0xCB, 0xBA, 0xA8, 0x92, 0x26, 0x14, 0xC5, 0xBE, 0xEC,
  392. //            0xA5, 0x65, 0xA5, 0xFD, 0xF1, 0xD2, 0x87, 0xA2, 0xBC, 0x04, 0x9B,
  393. //            0xE6, 0x77, 0x80, 0x60, 0xE9, 0x1A, 0x92, 0xA7, 0x57, 0xE3, 0x04,
  394. //            0x8F, 0x68, 0xB0, 0x76, 0xF7, 0xD3, 0x6C, 0xC8, 0xF2, 0x9B, 0xA5,
  395. //            0xDF, 0x81, 0xDC, 0x2C, 0xA7, 0x25, 0xEC, 0xE6, 0x62, 0x70, 0xCC,
  396. //            0x9A, 0x50, 0x35, 0xD8, 0xCE, 0xCE, 0xEF, 0x9E, 0xA0, 0x27, 0x4A,
  397. //            0x63, 0xAB, 0x1E, 0x58, 0xFA, 0xFD, 0x49, 0x88, 0xD0, 0xF6, 0x5D,
  398. //            0x14, 0x67, 0x57, 0xDA, 0x07, 0x1D, 0xF0, 0x45, 0xCF, 0xE1, 0x6B,
  399. //            0x9B };
  400. //
  401. //    static unsigned char dh1024_g[] = { 0x02 };
  402. //
  403. //    if (!file) {
  404. //
  405. //        dh = DH_new();
  406. //        if (dh == NULL) {
  407. //            return NGX_ERROR;
  408. //        }
  409. //
  410. //        dh->= BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
  411. //        dh->= BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);
  412. //
  413. //        if (dh->== NULL || dh->== NULL) {
  414. //            DH_free(dh);
  415. //            return NGX_ERROR;
  416. //        }
  417. //
  418. //        SSL_CTX_set_tmp_dh(ssl->ctx, dh);
  419. //
  420. //        DH_free(dh);
  421. //
  422. //        return NGX_OK;
  423. //    }
  424. //
  425. //    bio = BIO_new_file((char *) file, "r");
  426. //    if (bio == NULL) {
  427. //        return NGX_ERROR;
  428. //    }
  429. //
  430. //    dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
  431. //    if (dh == NULL) {
  432. //        BIO_free(bio);
  433. //        return NGX_ERROR;
  434. //    }
  435. //
  436. //    SSL_CTX_set_tmp_dh(ssl->ctx, dh);
  437. //
  438. //    DH_free(dh);
  439. //    BIO_free(bio);
  440. //
  441. //    return NGX_OK;
  442. //}
  443. //
  444. //ngx_int_t ngx_ssl_session_cache(ngx_ssl_t *ssl, const char *sess_ctx,
  445. //        ssize_t builtin_session_cache, time_t timeout) {
  446. //    SSL_CTX_set_session_id_context(ssl->ctx, (const unsigned char *) sess_ctx,strlen(sess_ctx));
  447. //
  448. //    SSL_CTX_set_session_cache_mode(ssl->ctx,
  449. //            SSL_SESS_CACHE_SERVER
  450. //            |SSL_SESS_CACHE_NO_AUTO_CLEAR
  451. //            |SSL_SESS_CACHE_NO_INTERNAL_STORE);
  452. //
  453. //    SSL_CTX_sess_set_cache_size(ssl->ctx, 1);
  454. //
  455. //    return NGX_OK;
  456. //
  457. //}
  458. ////
  459. //////打开监听到接口,只绑定了一个
  460. ////ngx_socket_t ngx_open_listening_sockets() {
  461. ////    int reuseaddr;
  462. ////    ngx_socket_t s;
  463. ////    reuseaddr = 1; //重用地址
  464. ////    struct sockaddr_in addr;
  465. ////
  466. ////    s = ngx_socket(AF_INET, SOCK_STREAM, 0); //创建套接口
  467. ////    if (== -1) {
  468. ////        return NGX_ERROR;
  469. ////    }
  470. ////
  471. ////    /* 填写sockaddr_in结构*/
  472. ////    bzero(&addr, sizeof(addr));
  473. ////    addr.sin_family = AF_INET;
  474. ////    addr.sin_port = htons(443);
  475. ////    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  476. ////
  477. ////    if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuseaddr,
  478. ////            sizeof(int)) == -1) {
  479. ////        if (ngx_close_socket(s) == -1) { //出错就把它关闭
  480. ////        }
  481. ////        return NGX_ERROR;
  482. ////    }
  483. ////
  484. ////    if (ngx_nonblocking(s) == -1) { //堵塞失败调用
  485. ////        if (ngx_close_socket(s) == -1) { //关闭套接字
  486. ////        }
  487. ////        return NGX_ERROR;
  488. ////    }
  489. ////
  490. ////    if (bind(s, (struct sockaddr*) &addr, sizeof(addr)) == -1) { //绑定
  491. ////        return NGX_ERROR;
  492. ////    }
  493. ////
  494. ////    if (listen(s, 5) == -1) { //监听套接口
  495. ////        if (ngx_close_socket(s) == -1) {
  496. ////        }
  497. ////        return NGX_ERROR;
  498. ////    }
  499. ////
  500. ////    return s;
  501. ////}
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. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include "source.h"

  13. int epfd;

  14. int main(void) {

  15. //    void *data = NULL;

  16.     //认证和密钥目录
  17.     const char * certificate = "/usr/local/nginx/conf/api.bz.crt";
  18.     const char * certificate_key = "/usr/local/nginx/conf/api.bz_nopass.key";

  19.     //这里模拟nginx初始化
  20.     //    ngx_ssl_init(); //初始化ssl
  21.     OPENSSL_config(NULL); //加载openssl的配置信息,不知道对否
  22.     SSL_library_init(); //加载ssl库函数
  23.     SSL_load_error_strings(); //格式化错误日志信息
  24.     OpenSSL_add_all_algorithms(); //load所有的SSL算法

  25. //    //这里没有必要,是做为缓存,会话和连接池处理的
  26. //    ngx_ssl_connection_index = SSL_get_ex_new_index(0, NULL, NULL, NULL, NULL);
  27. //    if (ngx_ssl_connection_index == -1) {
  28. //        printf("SSL_get_ex_new_index() failed");
  29. //        return NGX_ERROR;
  30. //    }
  31. //
  32. //    ngx_ssl_server_conf_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,NULL);
  33. //    if (ngx_ssl_server_conf_index == -1) {
  34. //        printf("SSL_CTX_get_ex_new_index() failed");
  35. //        return NGX_ERROR;
  36. //    }
  37. //
  38. //    ngx_ssl_session_cache_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL,NULL);
  39. //    if (ngx_ssl_session_cache_index == -1) {
  40. //        printf("SSL_CTX_get_ex_new_index() failed");
  41. //        return NGX_ERROR;
  42. //    }

  43.     //创建ssl
  44.     ngx_ssl_t ssl;
  45.     ngx_uint_t protocols = 61;
  46. //    ngx_ssl_create(ssl, protocols, data);
  47.     ssl.ctx = SSL_CTX_new(SSLv23_method()); //通过SSL所用方法新建SSL_CTX上下文信息
  48.     if (ssl.ctx == NULL) {
  49.         printf("SSL_CTX_new() failed");
  50.         return NGX_ERROR;
  51.     }

  52. //    //设置上下文信息的数据,保存扩展数据(应该不是很需要)
  53. //    if (SSL_CTX_set_ex_data(ssl.ctx, ngx_ssl_server_conf_index, data) == 0) {
  54. //        printf("SSL_CTX_set_ex_data() failed");
  55. //        return NGX_ERROR;
  56. //    }

  57.     //客户端服务器选项的设定,具体查看具体参数吧,可以看一下英文
  58.     /* client side options */
  59.     SSL_CTX_set_options(ssl.ctx, SSL_OP_MICROSOFT_SESS_ID_BUG);
  60.     SSL_CTX_set_options(ssl.ctx, SSL_OP_NETSCAPE_CHALLENGE_BUG);

  61.     /* server side options */
  62.     SSL_CTX_set_options(ssl.ctx, SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG);
  63.     SSL_CTX_set_options(ssl.ctx, SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER);

  64.     /* this option allow a potential SSL 2.0 rollback (CAN-2005-2969) */
  65.     SSL_CTX_set_options(ssl.ctx, SSL_OP_MSIE_SSLV2_RSA_PADDING);
  66.     SSL_CTX_set_options(ssl.ctx, SSL_OP_SSLEAY_080_CLIENT_DH_BUG);
  67.     SSL_CTX_set_options(ssl.ctx, SSL_OP_TLS_D5_BUG);
  68.     SSL_CTX_set_options(ssl.ctx, SSL_OP_TLS_BLOCK_PADDING_BUG);
  69.     SSL_CTX_set_options(ssl.ctx, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
  70.     SSL_CTX_set_options(ssl.ctx, SSL_OP_SINGLE_DH_USE);

  71.     if (!(protocols & NGX_SSL_SSLv2)) {
  72.         SSL_CTX_set_options(ssl.ctx, SSL_OP_NO_SSLv2);
  73.     }
  74.     if (!(protocols & NGX_SSL_SSLv3)) {
  75.         SSL_CTX_set_options(ssl.ctx, SSL_OP_NO_SSLv3);
  76.     }
  77.     if (!(protocols & NGX_SSL_TLSv1)) {
  78.         SSL_CTX_set_options(ssl.ctx, SSL_OP_NO_TLSv1);
  79.     }

  80. #ifdef SSL_OP_NO_COMPRESSION
  81.     SSL_CTX_set_options(ssl.ctx, SSL_OP_NO_COMPRESSION);
  82. #endif

  83. #ifdef SSL_MODE_RELEASE_BUFFERS
  84.     SSL_CTX_set_mode(ssl.ctx, SSL_MODE_RELEASE_BUFFERS);
  85. #endif

  86.     //这里一定需要,设置读取头一个字节,作为判断协议,如果不设定那么将使得n = SSL_read(connection, buffer, 512);少读前一个字节,因为读取第一个字节作为判断字节
  87.     SSL_CTX_set_read_ahead(ssl.ctx, 1);

  88.     //下面也不是必要的
  89. //    SSL_CTX_set_info_callback(ssl.ctx, ngx_ssl_info_callback);
  90. //    SSL_CTX_set_tlsext_servername_callback(ssl.ctx,ngx_http_ssl_servername);

  91. //    ngx_ssl_certificate(ssl, certificate, certificate_key);

  92. //     SSL_CTX_load_verify_locations用于加载受信任的CA证书,CAfile如果不为NULL,则他指向的文件包含PEM编码格式的一个或多个证书,可以用e.g.来简要介绍证书内容
  93. //      CApath如果不为NULL,则它指向一个包含PEM格式的CA证书的目录,目录中每个文件包含一份CA证书,文件名是证书中CA名的HASH值
  94. //      可以用c-rehash来建立该目录,如cd /some/where/certs(包含了很多可信任的CA证书) c_rehash .。返回一成功,0 失败。SSL_CTX_set_default_verify_paths找寻默认的验证路径,在这里肯定找不到的。
  95. //      这里主要set cert_store
  96. //      char *CAfile=NULL,*CApath=NULL;
  97. //      SSL_CTX_load_verify_locations(ctx,CAfile,CApath);
  98. //      当需要客户端验证的时候,服务器把CAfile里面的可信任CA证书发往客户端。
  99. //      if(CAfile !=NULL )SSL_CTX_set_client_CA_list(ctx,SSL_load_client_CA_file(CAfile));
  100. //      设置最大的验证用户证书的上级数。
  101. //      SSL_CTX_set_verify_depth(ctx,10);

  102.     //设置加载服务器的证书和私钥
  103.     if (SSL_CTX_use_certificate_chain_file(ssl.ctx, (char *) certificate) == 0) {
  104.         printf("SSL_CTX_use_certificate_chain_file("%s") failed", certificate);
  105.     }
  106.     if (SSL_CTX_use_PrivateKey_file(ssl.ctx, (char *) certificate_key, SSL_FILETYPE_PEM)== 0) { //类型测试好像无所谓,应该是SSL_FILETYPE_ASN1?
  107.         printf("SSL_CTX_use_PrivateKey_file("%s") failed", certificate_key);
  108.     }

  109.     SSL_CTX_set_cipher_list(ssl.ctx, "HIGH:!aNULL:!MD5"); //设置密码链表,具体看密码    ciphers(1)指令吧
  110.     SSL_CTX_set_tmp_rsa_callback(ssl.ctx, ngx_ssl_rsa512_key_callback); //设置键改变时调用,握手时的处理

  111.     //如果是双向认证还得做下面这几件事情
  112. //     SSL_CTX_set_verify(ssl->ctx, SSL_VERIFY_PEER, ngx_http_ssl_verify_callback);
  113. // SSL_CTX_set_verify_depth(ssl->ctx, depth);
  114. //     SSL_CTX_load_verify_locations(ssl->ctx, (char *) cert->data, NULL);
  115. //     SSL_load_client_CA_file((char *) cert->data);
  116. //     ERR_clear_error();
  117. //     SSL_CTX_set_client_CA_list(ssl->ctx, list);
  118. //     SSL_CTX_get_cert_store(ssl->ctx);
  119. // X509_STORE_add_lookup(store, X509_LOOKUP_file();
  120. // X509_LOOKUP_load_file(lookup, (char *) crl->data, X509_FILETYPE_PEM);
  121. // X509_STORE_set_flags(store,X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);

  122.     //ngx_ssl_dhparam(ssl, "");
  123. //    当使用RSA算法鉴别的时候,会有一个临时的DH密钥磋商发生。这样会话数据将用这个临时的密钥加密,而证书中的密钥中做为签名。
  124. //    所以这样增强了安全性,临时密钥是在会话结束消失的,所以就是获取了全部信息也无法把通信内容给解密出来。

  125. //    实现 openssl 提供的默认的 DH_METHOD,实现了根据密钥参数生成 DH 公私钥,以及根据 DH 公钥(一方)以及 DH 私钥(另一方)来生成一个共享密钥,用于密钥交换。
  126.     //DH密钥磋商设置
  127.     DH *dh;
  128.     static unsigned char dh1024_p[] = { 0xBB, 0xBC, 0x2D, 0xCA, 0xD8, 0x46,
  129.             0x74, 0x90, 0x7C, 0x43, 0xFC, 0xF5, 0x80, 0xE9, 0xCF, 0xDB, 0xD9,
  130.             0x58, 0xA3, 0xF5, 0x68, 0xB4, 0x2D, 0x4B, 0x08, 0xEE, 0xD4, 0xEB,
  131.             0x0F, 0xB3, 0x50, 0x4C, 0x6C, 0x03, 0x02, 0x76, 0xE7, 0x10, 0x80,
  132.             0x0C, 0x5C, 0xCB, 0xBA, 0xA8, 0x92, 0x26, 0x14, 0xC5, 0xBE, 0xEC,
  133.             0xA5, 0x65, 0xA5, 0xFD, 0xF1, 0xD2, 0x87, 0xA2, 0xBC, 0x04, 0x9B,
  134.             0xE6, 0x77, 0x80, 0x60, 0xE9, 0x1A, 0x92, 0xA7, 0x57, 0xE3, 0x04,
  135.             0x8F, 0x68, 0xB0, 0x76, 0xF7, 0xD3, 0x6C, 0xC8, 0xF2, 0x9B, 0xA5,
  136.             0xDF, 0x81, 0xDC, 0x2C, 0xA7, 0x25, 0xEC, 0xE6, 0x62, 0x70, 0xCC,
  137.             0x9A, 0x50, 0x35, 0xD8, 0xCE, 0xCE, 0xEF, 0x9E, 0xA0, 0x27, 0x4A,
  138.             0x63, 0xAB, 0x1E, 0x58, 0xFA, 0xFD, 0x49, 0x88, 0xD0, 0xF6, 0x5D,
  139.             0x14, 0x67, 0x57, 0xDA, 0x07, 0x1D, 0xF0, 0x45, 0xCF, 0xE1, 0x6B,
  140.             0x9B };

  141.     static unsigned char dh1024_g[] = { 0x02 };
  142.     dh = DH_new();
  143.     if (dh == NULL) {
  144.     }

  145.     dh->= BN_bin2bn(dh1024_p, sizeof(dh1024_p), NULL);
  146.     dh->= BN_bin2bn(dh1024_g, sizeof(dh1024_g), NULL);

  147.     if (dh->== NULL || dh->== NULL) {
  148.         DH_free(dh);
  149.     }
  150.     SSL_CTX_set_tmp_dh(ssl.ctx, dh);
  151.     DH_free(dh);

  152. //    ngx_ssl_session_cache(ssl, "HTTP", 0, 0);
  153.     //下面只是会话的设置
  154.     SSL_CTX_set_session_id_context(ssl.ctx, (const unsigned char *) "HTTP",strlen("HTTP"));
  155.     SSL_CTX_set_session_cache_mode(ssl.ctx,
  156.             SSL_SESS_CACHE_SERVER
  157.             |SSL_SESS_CACHE_NO_AUTO_CLEAR
  158.             |SSL_SESS_CACHE_NO_INTERNAL_STORE);

  159. //    设置cache的大小,默认的为1024*20=20000,这个也就是可以存多少个session_id,一般都不需要更改的。假如为0的话将是无限
  160.     SSL_CTX_sess_set_cache_size(ssl.ctx, 1);

  161.     //下面是网络模块
  162.     socklen_t sin_len = sizeof(struct sockaddr_in);
  163.     int fd, opt = 1;
  164.     struct epoll_event ev;
  165.     struct sockaddr_in sin, cin;

  166.     epfd = epoll_create(1024);
  167.     if ((fd = socket(AF_INET, SOCK_STREAM, 0)) <= 0) {
  168.         fprintf(stderr, "socket failed/n");
  169.         return -1;
  170.     }
  171.     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const void*) &opt, sizeof(opt));

  172.     memset(&sin, 0, sizeof(struct sockaddr_in));
  173.     sin.sin_family = AF_INET;
  174.     sin.sin_port = htons((short) (443));
  175.     sin.sin_addr.s_addr = INADDR_ANY;
  176.     if (bind(fd, (struct sockaddr *) &sin, sizeof(sin)) != 0) {
  177.         fprintf(stderr, "bind failed/n");
  178.         return -1;
  179.     }
  180.     if (listen(fd, 32) != 0) {
  181.         fprintf(stderr, "listen failed/n");
  182.         return -1;
  183.     }

  184.     int i, cfd, n, nfds;

  185.     struct epoll_event events[1024];
  186.     char buffer[512];

  187.     ev.data.fd = fd;
  188.     ev.events = EPOLLIN | EPOLLET; //设置要处理的事件类型
  189.     epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);

  190.     while (1) {
  191.         nfds = epoll_wait(epfd, events, 1024, -1);
  192.         printf("nfds ........... %d/n", nfds);
  193.         for (= 0; i < nfds; i++) {
  194.             if (events[i].data.fd == fd) {
  195.                 cfd = accept(fd, (struct sockaddr *) &cin, &sin_len);
  196.                 ngx_nonblocking(cfd); //把客户端的socket设置为非阻塞方式
  197.                 ev.data.fd = cfd;
  198.                 ev.events = EPOLLIN | EPOLLET;
  199.                 epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
  200.             } else {
  201.                 if (events[i].events & EPOLLIN) {
  202.                     cfd = events[i].data.fd;

  203.                     //这里模拟nginx接收
  204. //                    ngx_ssl_create_connection(ssl, cfd);
  205.                     ngx_ssl_conn_t *connection = SSL_new(ssl.ctx); //根据上下文,建立ssl套接口或链接
  206.                     if (connection == NULL) {
  207.                     }

  208.                     if (SSL_set_fd(connection, cfd) == 0) { //设置处理的id进入上下文里面
  209.                     }
  210.                     SSL_set_accept_state(connection); //设置接收状态

  211. //                    if (SSL_set_ex_data(connection, ngx_ssl_connection_index, c) == 0) {
  212. //                    }

  213.                     //进行握手处理
  214.                     ngx_http_ssl_handshake(cfd,connection);

  215.                     //正确处理
  216.                     for (;;) {
  217.                         n = SSL_read(connection, buffer, 512); //会读取好几次把之前读取的第一个字节也读取回来
  218.                         if (> 0) {
  219.                         } else {
  220.                             break;
  221.                         }
  222.                         continue;
  223.                     }

  224.                     //这里是,对请求的相关处理,省略掉了

  225.                     //ngx_http_process_request_headers(rev);

  226.                     //给客户端发送数据
  227.                     const char *data = "HTTP/1.1 200 OKrnServer: nginx/1.0.12rnDate: Sun, 03 Mar 2013 12:38:48 GMTrnContent- ...";
  228.                     n = SSL_write(connection, data, sizeof(data));

  229.                     //关闭请求链接;如果验证通过是不会走这里的(而等到超时的时候才处理);对于验证不通过或http请求则直接调用关闭链接。
  230.                     ngx_ssl_shutdown(connection);
  231.                     SSL_CTX_free(ssl.ctx);//释放SSL环境
  232.                     close(fd);

  233.                     //                    ret = recv(cfd, buffer, sizeof(buffer), 0);
  234.                     //                    printf("read ret..........= %d/n", ret);
  235.                     //
  236.                     //                    ev.data.fd = cfd;
  237.                     //                    ev.events = EPOLLOUT | EPOLLET;
  238.                     //                    epoll_ctl(epfd, EPOLL_CTL_MOD, cfd, &ev);
  239.                 } else if (events[i].events & EPOLLOUT) {
  240.                     cfd = events[i].data.fd;

  241.                     ev.data.fd = cfd;
  242.                     epoll_ctl(epfd, EPOLL_CTL_DEL, cfd, &ev);
  243.                     close(cfd);

  244.                 }
  245.             }
  246.         }
  247.     }

  248.     if (fd > 0)
  249.         close(fd);
  250.     return 0;
  251. }




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自带的接收和链接函数
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:226193次
    • 积分:3189
    • 等级:
    • 排名:第10747名
    • 原创:73篇
    • 转载:154篇
    • 译文:0篇
    • 评论:34条
    博客专栏
    最新评论