本文主要介紹使用libevhtp搭建一個HTTPS SERVER的方法，非加密的HTTP SERVER搭建方法，請點選此處 （本文的構建環境繼承自該部落格）。

本文將針對“單向驗證身份”場景，介紹HTTPS SERVER的搭建方法。“雙向驗證身份”的場景，請點選此處。

1. 單向驗證身份

一般的HTTPS服務都是隻需要客戶端驗證伺服器的身份就可以了。

例如我們想訪問銀行的網站，我們首先需要確認要訪問的這個網站確實是真實的銀行網站，而不是一個介面類似的、用來誘騙我們輸入銀行賬號和密碼的釣魚網站，這就是我們作為客戶端對銀行進行身份驗證的過程；而銀行網站並不需要通過SSL/TLS來驗證我們的身份，因為我們會通過在網頁裡輸入銀行賬號和密碼向伺服器展示我們的身份。

我們可以通過以下步驟搭建單向驗證身份的HTTPS SERVER。

1.1 生成伺服器的證書檔案

要搭建HTTPS伺服器，需要使用HTTPS伺服器的祕鑰檔案和證書檔案。

生成HTTPS伺服器的祕鑰檔案和證書檔案的步驟如下：

1. 生成祕鑰對（RSA）檔案：

openssl genrsa -out server-key.pem 2048

2. 生成身份證申請（CSR）檔案：

openssl req -new -key server-key.pem -out server-csr.pem -subj "/CN=192.168.213.133"

3. 簽署身份證（CRT）檔案：

openssl x509 -req -sha256 -days 365 -in server-csr.pem -signkey server-key.pem -out server-crt.pem
 

經過上面的3步，我們得到了HTTPS伺服器的祕鑰檔案server-key.pem和證書檔案server-crt.pem。

說明：

• 在上面的例子中，用來簽署CSR檔案的私鑰和CSR裡的公鑰是一對兒，也就是說這是一個自簽名（self-sign）的例子。通常情況下，我們會用一個CA的私鑰來簽署一個CSR，在雙向驗證身份的博文中會有相關介紹。
  
• 上述步驟中的引數需要根據實際情況進行調整，如HTTPS伺服器的訪問域名“/CN=192.168.213.133”。

1.2 呼叫libevhtp介面，構建HTTPS伺服器

呼叫libevhtp介面，編寫HTTPS伺服器，程式碼（https_server.cpp）如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <getopt.h>

#include "../log.h"
#include "internal.h"
#include "evhtp/evhtp.h"

#ifndef EVHTP_DISABLE_SSL
// 回撥方法的具體實現
static void http__callback_(evhtp_request_t* req, void* arg)
{
    evbuffer_add_reference(req->buffer_out, "foobar\n", 7, NULL, NULL);
    return evhtp_send_reply(req, EVHTP_RES_OK);
}

// 認證客戶端的相關資訊
static int ssl__x509_verify_(int ok, X509_STORE_CTX* store)
{
    char                 buf[256];
    X509               * err_cert;
    int                  err;
    int                  depth;
    SSL                * ssl;
    evhtp_connection_t * connection;
    evhtp_ssl_cfg_t    * ssl_cfg;

    err_cert   = X509_STORE_CTX_get_current_cert(store);
    err        = X509_STORE_CTX_get_error(store);
    depth      = X509_STORE_CTX_get_error_depth(store);
    ssl        = (SSL*)X509_STORE_CTX_get_ex_data(store, SSL_get_ex_data_X509_STORE_CTX_idx());

    X509_NAME_oneline(X509_get_subject_name(err_cert), buf, 256);

    connection = (evhtp_connection_t*)SSL_get_app_data(ssl);
    ssl_cfg    = connection->htp->ssl_cfg;

    if (depth > ssl_cfg->verify_depth)
    {
        ok  = 0;
        err = X509_V_ERR_CERT_CHAIN_TOO_LONG;

        X509_STORE_CTX_set_error(store, err);
    }

    if (!ok)
    {
        log_error("SSL: verify error:num=%d:%s:depth=%d:%s", err, X509_verify_cert_error_string(err), depth, buf);
    }

    return ok;
}

// https server引數列舉值
enum {
    OPTARG_CERT = 1000,
    OPTARG_KEY,
    OPTARG_CA,
    OPTARG_CAPATH,
    OPTARG_CIPHERS,
    OPTARG_VERIFY_PEER,
    OPTARG_ENFORCE_PEER_CERT,
    OPTARG_VERIFY_DEPTH,
    OPTARG_ENABLE_CACHE,
    OPTARG_CACHE_TIMEOUT,
    OPTARG_CACHE_SIZE,
    OPTARG_CTX_TIMEOUT,
    OPTARG_ENABLE_PROTOCOL,
    OPTARG_DISABLE_PROTOCOL
};

// https server幫助資訊
static const char* help =
    "Usage %s [opts] <host>:<port>\n"
    "  -cert          <file> : Server PEM-encoded X.509 Certificate file\n"
    "  -key           <file> : Server PEM-encoded Private Key file\n"
    "  -ca            <file> : File of PEM-encoded Server CA Certificates\n"
    "  -capath        <path> : Directory of PEM-encoded CA Certificates for Client Auth\n"
    "  -ciphers        <str> : Accepted SSL Ciphers\n"
    "  -verify-peer          : Enable SSL client verification\n"
    "  -enforce-peer-cert    : Reject clients without a cert\n"
    "  -verify-depth     <n> : Maximum depth of CA Certificates in Client Certificate verification\n"
    "  -enable-protocol  <p> : Enable one of the following protocols: SSLv2, SSLv3, TLSv1, or ALL\n"
    "  -disable-protocol <p> : Disable one of the following protocols: SSLv2, SSLv3, TLSv1, or ALL\n"
    "  -ctx-timeout      <n> : SSL Session Timeout (SSL >= 1.0)\n";

// 獲取並解析使用者輸入的https server引數，配置evhtp的ssl資訊
evhtp_ssl_cfg_t *parse__ssl_opts_(int argc, char** argv)
{
    int opt = 0;
    int long_index = 0;
    int ssl_verify_mode = 0;
    struct stat f_stat;
    evhtp_ssl_cfg_t* ssl_config = (evhtp_ssl_cfg_t*)calloc(1, sizeof(evhtp_ssl_cfg_t));

    ssl_config->ssl_opts = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1;

    static struct option long_options[] = {
        { "cert",              required_argument, 0, OPTARG_CERT              },
        { "key",               required_argument, 0, OPTARG_KEY               },
        { "ca",                required_argument, 0, OPTARG_CA                },
        { "capath",            required_argument, 0, OPTARG_CAPATH            },
        { "ciphers",           required_argument, 0, OPTARG_CIPHERS           },
        { "verify-peer",       no_argument,       0, OPTARG_VERIFY_PEER       },
        { "enforce-peer-cert", no_argument,       0, OPTARG_ENFORCE_PEER_CERT },
        { "verify-depth",      required_argument, 0, OPTARG_VERIFY_DEPTH      },
        { "enable-cache",      no_argument,       0, OPTARG_ENABLE_CACHE      },
        { "cache-timeout",     required_argument, 0, OPTARG_CACHE_TIMEOUT     },
        { "cache-size",        required_argument, 0, OPTARG_CACHE_SIZE        },
        { "enable-protocol",   required_argument, 0, OPTARG_ENABLE_PROTOCOL   },
        { "disable-protocol",  required_argument, 0, OPTARG_DISABLE_PROTOCOL  },
        { "ctx-timeout",       required_argument, 0, OPTARG_CTX_TIMEOUT       },
        { "help",              no_argument,       0, 'h'                      },
        { NULL,                0,                 0, 0                        }
    };

    // 獲取使用者輸入的https server引數
    while ((opt = getopt_long_only(argc, argv, "", long_options, &long_index)) != -1) {
        switch (opt) {
            case 'h':
                printf(help, argv[0]);
                exit(EXIT_FAILURE);
            // 服務端證書檔案
            case OPTARG_CERT:
                ssl_config->pemfile         = strdup(optarg);
                break;
            // 服務端祕鑰檔案
            case OPTARG_KEY:
                ssl_config->privfile        = strdup(optarg);
                break;
            // 簽署伺服器證書檔案的CA證書檔案
            case OPTARG_CA:
                ssl_config->cafile          = strdup(optarg);
                break;
            case OPTARG_CAPATH:
                ssl_config->capath          = strdup(optarg);
                break;
            case OPTARG_CIPHERS:
                ssl_config->ciphers         = strdup(optarg);
                break;
            // 簽署客戶端證書檔案的CA證書檔案的最大深度
            case OPTARG_VERIFY_DEPTH:
                ssl_config->verify_depth = atoi(optarg);
                break;
            // 啟用對於客戶端的SSL認證
            case OPTARG_VERIFY_PEER:
                ssl_verify_mode            |= SSL_VERIFY_PEER;
                break;
            // 拒絕沒有證書檔案的客戶端的連線
            case OPTARG_ENFORCE_PEER_CERT:
                ssl_verify_mode            |= SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
                break;
            case OPTARG_ENABLE_CACHE:
                ssl_config->scache_type     = evhtp_ssl_scache_type_internal;
                break;
            case OPTARG_CACHE_TIMEOUT:
                ssl_config->scache_timeout  = atoi(optarg);
                break;
            case OPTARG_CACHE_SIZE:
                ssl_config->scache_size     = atoi(optarg);
                break;
            case OPTARG_CTX_TIMEOUT:
                ssl_config->ssl_ctx_timeout = atoi(optarg);
                break;
            case OPTARG_ENABLE_PROTOCOL:
                if (!strcasecmp(optarg, "SSLv2"))
                {
                    ssl_config->ssl_opts &= ~SSL_OP_NO_SSLv2;
                }
                else if (!strcasecmp(optarg, "SSLv3"))
                {
                    ssl_config->ssl_opts &= ~SSL_OP_NO_SSLv3;
                }
                else if (!strcasecmp(optarg, "TLSv1"))
                {
                    ssl_config->ssl_opts &= ~SSL_OP_NO_TLSv1;
                }
                else if (!strcasecmp(optarg, "ALL"))
                {
                    ssl_config->ssl_opts = 0;
                }

                break;
            case OPTARG_DISABLE_PROTOCOL:
                if (!strcasecmp(optarg, "SSLv2"))
                {
                    ssl_config->ssl_opts |= SSL_OP_NO_SSLv2;
                }
                else if (!strcasecmp(optarg, "SSLv3"))
                {
                    ssl_config->ssl_opts |= SSL_OP_NO_SSLv3;
                }
                else if (!strcasecmp(optarg, "TLSv1"))
                {
                    ssl_config->ssl_opts |= SSL_OP_NO_TLSv1;
                }
                else if (!strcasecmp(optarg, "ALL"))
                {
                    ssl_config->ssl_opts = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1;
                }
                break;

            default:
                break;
        } /* switch */
    }

    // 需要對客戶端進行認證的情況
    if (ssl_verify_mode != 0)
    {
        ssl_config->verify_peer    = ssl_verify_mode;
        ssl_config->x509_verify_cb = ssl__x509_verify_;
    }

    // 檢查服務端證書檔案
    if (ssl_config->pemfile)
    {
        if (stat(ssl_config->pemfile, &f_stat) != 0)
        {
            log_error("Cannot load SSL cert '%s' (%s)", ssl_config->pemfile, strerror(errno));
            exit(EXIT_FAILURE);
        }
    }

    // 檢查服務端祕鑰檔案
    if (ssl_config->privfile)
    {
        if (stat(ssl_config->privfile, &f_stat) != 0)
        {
            log_error("Cannot load SSL key '%s' (%s)", ssl_config->privfile, strerror(errno));
            exit(EXIT_FAILURE);
        }
    }

    // 檢查簽署伺服器證書檔案的CA證書檔案
    if (ssl_config->cafile)
    {
        if (stat(ssl_config->cafile, &f_stat) != 0)
        {
            log_error("Cannot find SSL CA File '%s' (%s)", ssl_config->cafile, strerror(errno));
            exit(EXIT_FAILURE);
        }
    }

    if (ssl_config->capath) {
        if (stat(ssl_config->capath, &f_stat) != 0) {
            log_error("Cannot find SSL CA PATH '%s' (%s)", ssl_config->capath, strerror(errno));
            exit(EXIT_FAILURE);
        }
    }

    return ssl_config;
}
#endif

int main(int argc, char **argv)
{
#ifndef EVHTP_DISABLE_SSL
    struct event_base *evbase = event_base_new();
    evhtp_alloc_assert(evbase);
    evhtp_t *htp    = evhtp_new(evbase, NULL);
    evhtp_alloc_assert(htp);

    // 根據使用者輸入的https server引數，初始化evhtp的ssl相關配置
    evhtp_ssl_init(htp, parse__ssl_opts_(argc, argv));
    // 設定回撥函式
    evhtp_set_gencb(htp, http__callback_, NULL);
    // 監聽本機IP"192.168.213.133"的4443埠, backlog為128
    evhtp_bind_socket(htp, "192.168.213.133", 4443, 128);
    log_info("[https server info] https://192.168.213.133:4443/");

    /* 進入迴圈、監聽連線，http server開始工作 */
    event_base_loop(evbase, 0);
    return 0;
#else
    log_error("Not compiled with SSL support, go away");
    return EXIT_FAILURE;
#endif
}
 

編譯生成HTTPS伺服器程式，命令如下：

g++ -o https_server https_server.cpp -I/opt/liitdar/libevhtp/libevhtp-1.2.15/include/ -L/opt/liitdar/libevhtp/libevhtp-1.2.15/build/  -levhtp -levent -lpthread -levent_openssl -lssl -lcrypto

說明：

• 需要根據實際情況設定標頭檔案路徑，並在標頭檔案路徑中新增需要的標頭檔案；
  
• 需要根據實際情況設定靜態庫 libevhtp.a 的地址；
  
• 因為libevhtp的靜態庫 libevhtp.a 中包含了一些ssl的內容，所以在我們使用該靜態庫時，也需要連線一下ssl的相關庫。

1.3 測試HTTPS伺服器

開啟一個終端，執行剛剛生成的HTTPS伺服器程式，如下：

./https_server -cert ssl/server-crt.pem -key ssl/server-key.pem

在客戶端機器上，開啟一個終端，使用curl命令測試HTTPS伺服器，如下：

curl https://192.168.213.133:4443/ --cacert ssl/server-crt.pem

說明：上述命令使用的HTTPS伺服器的證書和祕鑰是在本文前面生成的。

上面的curl命令的執行結果如下：

如果客戶端的終端中出現上述資訊，說明單向身份驗證的HTTPS伺服器部署成功了。