SSL鏈接創建過程分析(1)

Https協議:SSL創建過程分析

web訪問的兩種方式:

http協議,咱們普通狀況下是經過它訪問web,因爲它不要求太多的安全機制,使用起來也簡單,很是多web網站也僅僅支持這樣的方式下的訪問.

https協議(Hypertext Transfer Protocol over Secure Socket Layer),對於安全性要求比較高的狀況,可以經過它訪問web,比方工商銀行https://www.icbc.com.cn/icbc/(固然也可以經過http協議訪問,僅僅是沒那麼安全了).其安全基礎是SSL協議.

SSL協議,當前版本號爲3.1(SSL3.1就是TLS1.0)。它已被普遍地用於Web瀏覽器與server之間的身份認證和加密傳輸數據.它位於TCP/IP協議與各類應用層協議之間，爲數據通信提供安全支持。SSL協議可分爲兩層： SSL記錄協議（SSL Record Protocol）：它創建在可靠的傳輸協議（如TCP）之上，爲高層協議提供數據封裝、壓縮、加密等基本功能的支持。 SSL握手協議（SSL Handshake Protocol）：它創建在SSL記錄協議之上，用於在實際的傳輸數據開始前，通信兩方進行身份認證、協商加密算法、交換加密密鑰等。

爲了瞭解具體過程,可以經過網絡抓包工具(Commview,Iris)分析https協議,SSL鏈接創建過程當中,數據包交換狀況.

數據包分析過程用到的幾個圖.

圖,SSL Protocol Stack

 

圖.SSL Record Format

 

圖.SSL Record Protocol Payload

 

圖.Handshake Protocol Action

 

 

它們來之.Cryptography and Network Security Principles and Practices, Fourth Edition-Chapter 17. Web Security-17.2. Secure Socket Layer and Transport Layer Security(password學與網絡安全 原理與實踐第四版,17章web安全,17.2節,SSL與TLS)詳細細節參考本書.

如下跟蹤握手過程(圖Handshake Protocol Action)中,數據包的交換.

覺得https方式訪問www.sun.com爲樣例,通常大型公司,銀行的web都支持https訪問,如工商銀行,sun,微軟,IBM.

在IE中輸入:https://wwww.sun.com,因爲這是https協議,因此在實際訪問web前,會創建SSL鏈接.

經過Commview抓包工具,過濾443port(普通狀況下,HTTPS使用port443，HTTP使用port80)可以獲得數據包.

數據包大體狀況和(圖Handshake Protocol Action)相應.

 

SSL鏈接創建過程分析(1)

1. 應用程序接口

1.1 SSL初始化

SSL_CTX* InitSSL(int server, char *cert, char *key, char *pw)
{
    SSL_CTX* ctx;
    SSL_METHOD *meth;
    int status;

// 算法初始化  
// 載入SSL錯誤信息
    SSL_load_error_strings();
// 加入SSL的加密/HASH算法
    SSLeay_add_ssl_algorithms();
// 服務器仍是客戶端
    If(server)
 meth = SSLv23_server_method();
    else
 meth = SSLv23_client_method();
// 創建新的SSL上下文
    ctx = SSL_CTX_new (meth);
    if(!ctx) return NULL;

// 設置證書文件的口令
    SSL_CTX_set_default_passwd_cb_userdata(ctx, pw);
//載入本地證書文件
    status=SSL_CTX_use_certificate_file(ctx, cert, SSL_FILETYPE_ASN1);
    if (status <= 0) {
        frintf(stderr, "Use cert fail, status=%d/n", status);
        goto bad;
    }
// 載入私鑰文件
    if (SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM) <= 0) {
        fprintf(stderr, "Use private key fail/n");
        goto bad;
    }
// 檢查證書和私鑰是否匹配
    if (!SSL_CTX_check_private_key(ctx)) {
        fprintf("Private key does not match the certificate public key/n");
        goto bad;
    }
    fprintf("Cert and key OK/n");
    return ctx;
bad:
    SSL_CTX_free (ctx);
    return NULL;
}

1.2 創建SSL新鏈接

server：

// 創建SSL
ssl = SSL_new (ctx);
// 將SSL與TCP socket鏈接
SSL_set_fd (ssl, sd);
//接受新SSL鏈接
err = SSL_accept (ssl);

client：
// 創建SSL
ssl = SSL_new (ctx);
// 將SSL與TCP socket鏈接
SSL_set_fd (ssl, sd);
// SSL鏈接
err = SSL_connect (ssl);

server的SSL_accept()和client的SSL_connect()函數共同完畢SSL的握手協商過程。

 

1.3 SSL通訊

和普通的read()/write()調用同樣，用如下的函數完畢數據的SSL發送和接收，函數輸入數據是明文，SSL本身主動將數據封裝進SSL中：

讀/接收：SSL_read()
寫/發送：SSL_write()

1.4 SSL釋放

SSL釋放很是easy：

 SSL_free (ssl);

 

2. SSL實現分析

下面SSL源碼取自openssl-0.9.7b。

2.1 SSL_load_error_strings

該函數載入錯誤字符串信息：

void SSL_load_error_strings(void)
 {
#ifndef OPENSSL_NO_ERR
 ERR_load_crypto_strings();
 ERR_load_SSL_strings();
#endif
 }

最後將會進入函數：

static void err_load_strings(int lib, ERR_STRING_DATA *str)
 {
 while (str->error)
  {
  str->error|=ERR_PACK(lib,0,0);
  ERRFN(err_set_item)(str);
  str++;
  }
 }
當中：
#define ERR_PACK(l,f,r)  (((((unsigned long)l)&0xffL)*0x1000000)| /
    ((((unsigned long)f)&0xfffL)*0x1000)| /
    ((((unsigned long)r)&0xfffL)))

#define ERRFN(a) err_fns->cb_##a

ERRFN(err_set_item)(str)的實際函數實現爲：

static ERR_STRING_DATA *int_err_set_item(ERR_STRING_DATA *d)
 {
 ERR_STRING_DATA *p;
 LHASH *hash;

 err_fns_check();
 hash = ERRFN(err_get)(1);
 if (!hash)
  return NULL;

 CRYPTO_w_lock(CRYPTO_LOCK_ERR);
 p = (ERR_STRING_DATA *)lh_insert(hash, d);
 CRYPTO_w_unlock(CRYPTO_LOCK_ERR);

 return p;
 }

Lh_insert()將錯誤信息插入到一個鏈表中

如關於加密算法的錯誤信息：

/* crypto/err/err.c */
static ERR_STRING_DATA ERR_str_functs[]=
……
static ERR_STRING_DATA ERR_str_libraries[]=
……
static ERR_STRING_DATA ERR_str_reasons[]=
……

 

2.2 SSLeay_add_ssl_algorithms()

這實際是個宏：
#define OpenSSL_add_ssl_algorithms()    SSL_library_init()
#define SSLeay_add_ssl_algorithms() SSL_library_init()

實際函數爲SSL_library_init()，函數比較簡單，就是載入各類加密和HASH算法：

/* ssl/ssl_algs.c */
int SSL_library_init(void)
 {

#ifndef OPENSSL_NO_DES
 EVP_add_cipher(EVP_des_cbc());
 EVP_add_cipher(EVP_des_ede3_cbc());
#endif
#ifndef OPENSSL_NO_IDEA
 EVP_add_cipher(EVP_idea_cbc());
#endif
#ifndef OPENSSL_NO_RC4
 EVP_add_cipher(EVP_rc4());
#endif 
#ifndef OPENSSL_NO_RC2
 EVP_add_cipher(EVP_rc2_cbc());
#endif
#ifndef OPENSSL_NO_AES
 EVP_add_cipher(EVP_aes_128_cbc());
 EVP_add_cipher(EVP_aes_192_cbc());
 EVP_add_cipher(EVP_aes_256_cbc());
#endif
#ifndef OPENSSL_NO_MD2
 EVP_add_digest(EVP_md2());
#endif
#ifndef OPENSSL_NO_MD5
 EVP_add_digest(EVP_md5());
 EVP_add_digest_alias(SN_md5,"ssl2-md5");
 EVP_add_digest_alias(SN_md5,"ssl3-md5");
#endif
#ifndef OPENSSL_NO_SHA
 EVP_add_digest(EVP_sha1()); /* RSA with sha1 */
 EVP_add_digest_alias(SN_sha1,"ssl3-sha1");
 EVP_add_digest_alias(SN_sha1WithRSAEncryption,SN_sha1WithRSA);
#endif
#if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_DSA)
 EVP_add_digest(EVP_dss1()); /* DSA with sha1 */
 EVP_add_digest_alias(SN_dsaWithSHA1,SN_dsaWithSHA1_2);
 EVP_add_digest_alias(SN_dsaWithSHA1,"DSS1");
 EVP_add_digest_alias(SN_dsaWithSHA1,"dss1");
#endif
 /* If you want support for phased out ciphers, add the following */
#if 0
 EVP_add_digest(EVP_sha());
 EVP_add_digest(EVP_dss());
#endif
 return(1);
 }

2.3 SSL23_server_method()

創建服務器端的方法庫，這是個通用函數，可動態選擇SSL協議。假設想固定協議，可以僅僅用SSLv2_server_method(), SSLv3_server_method() 等函數來初始化，該函數返回一個SSL_METHOD結構：

/* ssl/ssl.h */
/* Used to hold functions for SSLv2 or SSLv3/TLSv1 functions */
typedef struct ssl_method_st
 {
 int version; // 版本號號
 int (*ssl_new)(SSL *s); // 創建新SSL
 void (*ssl_clear)(SSL *s); // 清除SSL
 void (*ssl_free)(SSL *s);  // 釋放SSL
 int (*ssl_accept)(SSL *s); // server接受SSL鏈接
 int (*ssl_connect)(SSL *s); // client的SSL鏈接
 int (*ssl_read)(SSL *s,void *buf,int len); // SSL讀
 int (*ssl_peek)(SSL *s,void *buf,int len); // SSL查看數據
 int (*ssl_write)(SSL *s,const void *buf,int len); // SSL寫
 int (*ssl_shutdown)(SSL *s); // SSL半關閉
 int (*ssl_renegotiate)(SSL *s); // SSL重協商
 int (*ssl_renegotiate_check)(SSL *s); // SSL重協商檢查
 long (*ssl_ctrl)(SSL *s,int cmd,long larg,void *parg); // SSL控制
 long (*ssl_ctx_ctrl)(SSL_CTX *ctx,int cmd,long larg,void *parg); //SSL上下文控制
 SSL_CIPHER *(*get_cipher_by_char)(const unsigned char *ptr); // 經過名稱獲取SSL的算法
 int (*put_cipher_by_char)(const SSL_CIPHER *cipher,unsigned char *ptr);
 int (*ssl_pending)(SSL *s);
 int (*num_ciphers)(void); // 算法數
 SSL_CIPHER *(*get_cipher)(unsigned ncipher); // 獲取算法
 struct ssl_method_st *(*get_ssl_method)(int version);
 long (*get_timeout)(void); // 超時
 struct ssl3_enc_method *ssl3_enc; /* Extra SSLv3/TLS stuff */ // SSL3加密
 int (*ssl_version)(); // SSL版本號
 long (*ssl_callback_ctrl)(SSL *s, int cb_id, void (*fp)()); // SSL控制回調函數
 long (*ssl_ctx_callback_ctrl)(SSL_CTX *s, int cb_id, void (*fp)()); //SSL上下文控制回調函數
 } SSL_METHOD;

/* ssl/s23_srvr.c */

SSL_METHOD *SSLv23_server_method(void)
 {
 static int init=1;
// 靜態量，每個進程僅僅初始化一次
 static SSL_METHOD SSLv23_server_data;

 if (init)
  {
  CRYPTO_w_lock(CRYPTO_LOCK_SSL_METHOD);

  if (init)
   {
// ssl23的基本方法結構
   memcpy((char *)&SSLv23_server_data,
    (char *)sslv23_base_method(),sizeof(SSL_METHOD));
// 服務器,因此要定義accept方法
   SSLv23_server_data.ssl_accept=ssl23_accept;
// 依據SSL的版本號設置SSL的詳細方法函數
   SSLv23_server_data.get_ssl_method=ssl23_get_server_method;
   init=0;
   }

  CRYPTO_w_unlock(CRYPTO_LOCK_SSL_METHOD);
  }
 return(&SSLv23_server_data);
 }

static SSL_METHOD *ssl23_get_server_method(int ver)
 {
#ifndef OPENSSL_NO_SSL2
 if (ver == SSL2_VERSION)
  return(SSLv2_server_method());
#endif
 if (ver == SSL3_VERSION)
  return(SSLv3_server_method());
 else if (ver == TLS1_VERSION)
  return(TLSv1_server_method());
// 隨着TLS1.1(RFC4346)的推出，預計不久將出現TLSv1_1_server_method()
 else
  return(NULL);
 }

// SSL23的方法基本數據定義
/* ssl/s23_lib.c */
SSL_METHOD *sslv23_base_method(void)
 {
 return(&SSLv23_data);
 }

static SSL_METHOD SSLv23_data= {
 TLS1_VERSION,
 tls1_new,
 tls1_clear,
 tls1_free,
 ssl_undefined_function,
 ssl_undefined_function,
 ssl23_read,
 ssl23_peek,
 ssl23_write,
 ssl_undefined_function,
 ssl_undefined_function,
 ssl_ok,
 ssl3_ctrl,
 ssl3_ctx_ctrl,
 ssl23_get_cipher_by_char,
 ssl23_put_cipher_by_char,
 ssl_undefined_function,
 ssl23_num_ciphers,
 ssl23_get_cipher,
 ssl_bad_method,
 ssl23_default_timeout,
 &ssl3_undef_enc_method,
 ssl_undefined_function,
 ssl3_callback_ctrl,
 ssl3_ctx_callback_ctrl,
 };

以SSL3的server方法函數爲例，其它方法類似：

/* ssl/s3_srvr.c */

SSL_METHOD *SSLv3_server_method(void)
 {
 static int init=1;
 static SSL_METHOD SSLv3_server_data;

// 僅僅初始化一次
 if (init)
  {
  CRYPTO_w_lock(CRYPTO_LOCK_SSL_METHOD);

  if (init)
   {
// ssl3的基本方法結構
   memcpy((char *)&SSLv3_server_data,(char *)sslv3_base_method(),
    sizeof(SSL_METHOD));
// ssl3的接受方法
   SSLv3_server_data.ssl_accept=ssl3_accept;
// ssl3獲取服務器的方法函數
   SSLv3_server_data.get_ssl_method=ssl3_get_server_method;
   init=0;
   }
   
  CRYPTO_w_unlock(CRYPTO_LOCK_SSL_METHOD);
  }
 return(&SSLv3_server_data);
 }

// SSL3的方法基本數據定義
/* ssl/s3_lib.c */
static SSL_METHOD SSLv3_data= {
 SSL3_VERSION,
 ssl3_new,
 ssl3_clear,
 ssl3_free,
 ssl_undefined_function,
 ssl_undefined_function,
 ssl3_read,
 ssl3_peek,
 ssl3_write,
 ssl3_shutdown,
 ssl3_renegotiate,
 ssl3_renegotiate_check,
 ssl3_ctrl,
 ssl3_ctx_ctrl,
 ssl3_get_cipher_by_char,
 ssl3_put_cipher_by_char,
 ssl3_pending,
 ssl3_num_ciphers,
 ssl3_get_cipher,
 ssl_bad_method,
 ssl3_default_timeout,
 &SSLv3_enc_data,
 ssl_undefined_function,
 ssl3_callback_ctrl,
 ssl3_ctx_callback_ctrl,
 };

 

2.4 SSL23_client_method()

和server端的事實上是一樣的，僅僅是不定義結構中的ssl_accept而是定義ssl_connnect：

SSL_METHOD *SSLv23_client_method(void)
 {
 static int init=1;
 static SSL_METHOD SSLv23_client_data;

 if (init)
  {
  CRYPTO_w_lock(CRYPTO_LOCK_SSL_METHOD);

  if (init)
   {
   memcpy((char *)&SSLv23_client_data,
    (char *)sslv23_base_method(),sizeof(SSL_METHOD));
   SSLv23_client_data.ssl_connect=ssl23_connect;
   SSLv23_client_data.get_ssl_method=ssl23_get_client_method;
   init=0;
   }

  CRYPTO_w_unlock(CRYPTO_LOCK_SSL_METHOD);
  }
 return(&SSLv23_client_data);
 }

 

2.5 SSL_CTX_new ()

該函數依據SSL方法獲取一個SSL上下文結構，該結構定義爲：

/* ssl/ssl.h */
struct ssl_ctx_st
 {
 SSL_METHOD *method;

 STACK_OF(SSL_CIPHER) *cipher_list;
 /* same as above but sorted for lookup */
 STACK_OF(SSL_CIPHER) *cipher_list_by_id;

 struct x509_store_st /* X509_STORE */ *cert_store;
 struct lhash_st /* LHASH */ *sessions; /* a set of SSL_SESSIONs */
 /* Most session-ids that will be cached, default is
  * SSL_SESSION_CACHE_MAX_SIZE_DEFAULT. 0 is unlimited. */
 unsigned long session_cache_size;
 struct ssl_session_st *session_cache_head;
 struct ssl_session_st *session_cache_tail;

 /* This can have one of 2 values, ored together,
  * SSL_SESS_CACHE_CLIENT,
  * SSL_SESS_CACHE_SERVER,
  * Default is SSL_SESSION_CACHE_SERVER, which means only
  * SSL_accept which cache SSL_SESSIONS. */
 int session_cache_mode;

 /* If timeout is not 0, it is the default timeout value set
  * when SSL_new() is called.  This has been put in to make
  * life easier to set things up */
 long session_timeout;

 /* If this callback is not null, it will be called each
  * time a session id is added to the cache.  If this function
  * returns 1, it means that the callback will do a
  * SSL_SESSION_free() when it has finished using it.  Otherwise,
  * on 0, it means the callback has finished with it.
  * If remove_session_cb is not null, it will be called when
  * a session-id is removed from the cache.  After the call,
  * OpenSSL will SSL_SESSION_free() it. */
 int (*new_session_cb)(struct ssl_st *ssl,SSL_SESSION *sess);
 void (*remove_session_cb)(struct ssl_ctx_st *ctx,SSL_SESSION *sess);
 SSL_SESSION *(*get_session_cb)(struct ssl_st *ssl,
  unsigned char *data,int len,int *copy);

 struct
  {
  int sess_connect; /* SSL new conn - started */
  int sess_connect_renegotiate;/* SSL reneg - requested */
  int sess_connect_good; /* SSL new conne/reneg - finished */
  int sess_accept; /* SSL new accept - started */
  int sess_accept_renegotiate;/* SSL reneg - requested */
  int sess_accept_good; /* SSL accept/reneg - finished */
  int sess_miss;  /* session lookup misses  */
  int sess_timeout; /* reuse attempt on timeouted session */
  int sess_cache_full; /* session removed due to full cache */
  int sess_hit;  /* session reuse actually done */
  int sess_cb_hit; /* session-id that was not
      * in the cache was
      * passed back via the callback.  This
      * indicates that the application is
      * supplying session-id's from other
      * processes - spooky :-) */
  } stats;

 int references;

 /* if defined, these override the X509_verify_cert() calls */
 int (*app_verify_callback)(X509_STORE_CTX *, void *);
 void *app_verify_arg;
 /* before OpenSSL 0.9.7, 'app_verify_arg' was ignored
  * ('app_verify_callback' was called with just one argument) */

 /* Default password callback. */
 pem_password_cb *default_passwd_callback;

 /* Default password callback user data. */
 void *default_passwd_callback_userdata;

 /* get client cert callback */
 int (*client_cert_cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey);

 CRYPTO_EX_DATA ex_data;

 const EVP_MD *rsa_md5;/* For SSLv2 - name is 'ssl2-md5' */
 const EVP_MD *md5; /* For SSLv3/TLSv1 'ssl3-md5' */
 const EVP_MD *sha1;   /* For SSLv3/TLSv1 'ssl3->sha1' */

 STACK_OF(X509) *extra_certs;
 STACK_OF(SSL_COMP) *comp_methods; /* stack of SSL_COMP, SSLv3/TLSv1 */

 /* Default values used when no per-SSL value is defined follow */

 void (*info_callback)(const SSL *ssl,int type,int val); /* used if SSL's info_callback is NULL */

 /* what we put in client cert requests */
 STACK_OF(X509_NAME) *client_CA;

 /* Default values to use in SSL structures follow (these are copied by SSL_new) */

 unsigned long options;
 unsigned long mode;
 long max_cert_list;

 struct cert_st /* CERT */ *cert;
 int read_ahead;

 /* callback that allows applications to peek at protocol messages */
 void (*msg_callback)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg);
 void *msg_callback_arg;

 int verify_mode;
 int verify_depth;
 unsigned int sid_ctx_length;
 unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];
 int (*default_verify_callback)(int ok,X509_STORE_CTX *ctx); /* called 'verify_callback' in the SSL */

 /* Default generate session ID callback. */
 GEN_SESSION_CB generate_session_id;

 int purpose;  /* Purpose setting */
 int trust;  /* Trust setting */

 int quiet_shutdown;
 };

typedef struct ssl_ctx_st SSL_CTX;

/* ssl/ssl_lib.h */
SSL_CTX *SSL_CTX_new(SSL_METHOD *meth)
 {
 SSL_CTX *ret=NULL;
 
 if (meth == NULL)
  {
  SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_NULL_SSL_METHOD_PASSED);
  return(NULL);
  }

 if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0)
  {
  SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
  goto err;
  }
// 分配上下文的內存空間
 ret=(SSL_CTX *)OPENSSL_malloc(sizeof(SSL_CTX));
 if (ret == NULL)
  goto err;

 memset(ret,0,sizeof(SSL_CTX));

 

// 初始化上下文的結構參數
 ret->method=meth;

 ret->cert_store=NULL;
 ret->session_cache_mode=SSL_SESS_CACHE_SERVER;
 ret->session_cache_size=SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
 ret->session_cache_head=NULL;
 ret->session_cache_tail=NULL;

 /* We take the system default */
 ret->session_timeout=meth->get_timeout();

 ret->new_session_cb=0;
 ret->remove_session_cb=0;
 ret->get_session_cb=0;
 ret->generate_session_id=0;

 memset((char *)&ret->stats,0,sizeof(ret->stats));

 ret->references=1;
 ret->quiet_shutdown=0;

/* ret->cipher=NULL;*/
/* ret->s2->challenge=NULL;
 ret->master_key=NULL;
 ret->key_arg=NULL;
 ret->s2->conn_id=NULL; */

 ret->info_callback=NULL;

 ret->app_verify_callback=0;
 ret->app_verify_arg=NULL;

 ret->max_cert_list=SSL_MAX_CERT_LIST_DEFAULT;
 ret->read_ahead=0;
 ret->msg_callback=0;
 ret->msg_callback_arg=NULL;
 ret->verify_mode=SSL_VERIFY_NONE;
 ret->verify_depth=-1; /* Don't impose a limit (but x509_lu.c does) */
 ret->sid_ctx_length=0;
 ret->default_verify_callback=NULL;
 if ((ret->cert=ssl_cert_new()) == NULL)
  goto err;

 ret->default_passwd_callback=0;
 ret->default_passwd_callback_userdata=NULL;
 ret->client_cert_cb=0;

 ret->sessions=lh_new(LHASH_HASH_FN(SSL_SESSION_hash),
   LHASH_COMP_FN(SSL_SESSION_cmp));
 if (ret->sessions == NULL) goto err;
 ret->cert_store=X509_STORE_new();
 if (ret->cert_store == NULL) goto err;

 

// 創建加密算法鏈表
 ssl_create_cipher_list(ret->method,
  &ret->cipher_list,&ret->cipher_list_by_id,
  SSL_DEFAULT_CIPHER_LIST);
 if (ret->cipher_list == NULL
     || sk_SSL_CIPHER_num(ret->cipher_list) <= 0)
  {
  SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_LIBRARY_HAS_NO_CIPHERS);
  goto err2;
  }

 

// 定義上下文結構中HASH算法
 if ((ret->rsa_md5=EVP_get_digestbyname("ssl2-md5")) == NULL)
  {
  SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES);
  goto err2;
  }
 if ((ret->md5=EVP_get_digestbyname("ssl3-md5")) == NULL)
  {
  SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES);
  goto err2;
  }
 if ((ret->sha1=EVP_get_digestbyname("ssl3-sha1")) == NULL)
  {
  SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES);
  goto err2;
  }

 if ((ret->client_CA=sk_X509_NAME_new_null()) == NULL)
  goto err;

 

 CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data);

 ret->extra_certs=NULL;

// 壓縮算法

 ret->comp_methods=SSL_COMP_get_compression_methods();

 return(ret);

err:
 SSLerr(SSL_F_SSL_CTX_NEW,ERR_R_MALLOC_FAILURE);
err2:
 if (ret != NULL) SSL_CTX_free(ret);
 return(NULL);
 }

...待續...