Changes in src/gnutls_hooks.c [fd82e59:e391197] in mod_gnutls


Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/gnutls_hooks.c

    rfd82e59 re391197  
    44 *  Copyright 2011 Dash Shendy
    55 *  Copyright 2013-2014 Daniel Kahn Gillmor
     6 *  Copyright 2015 Thomas Klute
    67 *
    78 *  Licensed under the Apache License, Version 2.0 (the "License");
     
    4041#endif
    4142
     43#define IS_PROXY_STR(c) \
     44    ((c->is_proxy == GNUTLS_ENABLED_TRUE) ? "proxy " : "")
     45
    4246static gnutls_datum_t session_ticket_key = {NULL, 0};
    4347
     
    5054static const char* mgs_x509_construct_uid(request_rec * pool, gnutls_x509_crt_t cert);
    5155#endif
     56static int load_proxy_x509_credentials(server_rec *s);
    5257
    5358/* Pool Cleanup Function */
     
    147152    gnutls_certificate_server_set_request(session, ctxt->sc->client_verify_mode);
    148153
     154    /* Set x509 credentials */
     155    gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, ctxt->sc->certs);
    149156    /* Set Anon credentials */
    150     gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, ctxt->sc->certs);
    151         /* Set x509 credentials */
    152157    gnutls_credentials_set(session, GNUTLS_CRD_ANON, ctxt->sc->anon_creds);
    153158
     
    171176
    172177static int cert_retrieve_fn(gnutls_session_t session,
    173                                                         const gnutls_datum_t * req_ca_rdn __attribute__((unused)), int nreqs __attribute__((unused)),
    174                                                         const gnutls_pk_algorithm_t * pk_algos __attribute__((unused)), int pk_algos_length __attribute__((unused)),
    175                                                         gnutls_retr2_st *ret) {
    176 
    177 
    178         _gnutls_log(debug_log_fp, "%s: %d\n", __func__, __LINE__);
    179 
    180         mgs_handle_t *ctxt;
     178                            const gnutls_datum_t * req_ca_rdn __attribute__((unused)),
     179                            int nreqs __attribute__((unused)),
     180                            const gnutls_pk_algorithm_t * pk_algos __attribute__((unused)),
     181                            int pk_algos_length __attribute__((unused)),
     182                            gnutls_pcert_st **pcerts,
     183                            unsigned int *pcert_length,
     184                            gnutls_privkey_t *privkey)
     185{
     186    _gnutls_log(debug_log_fp, "%s: %d\n", __func__, __LINE__);
     187
     188    mgs_handle_t *ctxt;
    181189
    182190    if (session == NULL) {
    183191                // ERROR INVALID SESSION
    184                 ret->ncerts = 0;
    185                 ret->deinit_all = 1;
    186192        return -1;
    187         }
     193    }
     194
    188195    ctxt = gnutls_transport_get_ptr(session);
    189196
    190197    if (gnutls_certificate_type_get(session) == GNUTLS_CRT_X509) {
    191198                // X509 CERTIFICATE
    192                 ret->cert_type = GNUTLS_CRT_X509;
    193                 ret->key_type = GNUTLS_PRIVKEY_X509;
    194         ret->ncerts = ctxt->sc->certs_x509_chain_num;
    195         ret->deinit_all = 0;
    196         ret->cert.x509 = ctxt->sc->certs_x509_chain;
    197         ret->key.x509 = ctxt->sc->privkey_x509;
     199        *pcerts = ctxt->sc->certs_x509_chain;
     200        *pcert_length = ctxt->sc->certs_x509_chain_num;
     201        *privkey = ctxt->sc->privkey_x509;
    198202        return 0;
    199203    } else if (gnutls_certificate_type_get(session) == GNUTLS_CRT_OPENPGP) {
    200204                // OPENPGP CERTIFICATE
    201                 ret->cert_type = GNUTLS_CRT_OPENPGP;
    202                 ret->key_type = GNUTLS_PRIVKEY_OPENPGP;
    203         ret->ncerts = 1;
    204         ret->deinit_all = 0;
    205         ret->cert.pgp = ctxt->sc->cert_pgp;
    206         ret->key.pgp = ctxt->sc->privkey_pgp;
     205        *pcerts = ctxt->sc->cert_pgp;
     206        *pcert_length = 1;
     207        *privkey = ctxt->sc->privkey_pgp;
    207208        return 0;
    208209    } else {
    209210                // UNKNOWN CERTIFICATE
    210                 ret->ncerts = 0;
    211                 ret->deinit_all = 1;
    212211            return -1;
    213212        }
    214213}
    215 
    216 /* 2048-bit group parameters from SRP specification */
    217 const char static_dh_params[] = "-----BEGIN DH PARAMETERS-----\n"
    218         "MIIBBwKCAQCsa9tBMkqam/Fm3l4TiVgvr3K2ZRmH7gf8MZKUPbVgUKNzKcu0oJnt\n"
    219         "gZPgdXdnoT3VIxKrSwMxDc1/SKnaBP1Q6Ag5ae23Z7DPYJUXmhY6s2YaBfvV+qro\n"
    220         "KRipli8Lk7hV+XmT7Jde6qgNdArb9P90c1nQQdXDPqcdKB5EaxR3O8qXtDoj+4AW\n"
    221         "dr0gekNsZIHx0rkHhxdGGludMuaI+HdIVEUjtSSw1X1ep3onddLs+gMs+9v1L7N4\n"
    222         "YWAnkATleuavh05zA85TKZzMBBx7wwjYKlaY86jQw4JxrjX46dv7tpS1yAPYn3rk\n"
    223         "Nd4jbVJfVHWbZeNy/NaO8g+nER+eSv9zAgEC\n"
    224         "-----END DH PARAMETERS-----\n";
    225214
    226215/* Read the common name or the alternative name of the certificate.
     
    322311    }
    323312
    324 
    325313    s = base_server;
    326314    sc_base = (mgs_srvconf_rec *) ap_get_module_config(s->module_config, &gnutls_module);
    327315
    328     gnutls_dh_params_init(&dh_params);
    329 
    330     if (sc_base->dh_params == NULL) {
    331         gnutls_datum_t pdata = {
    332             (void *) static_dh_params,
    333             sizeof(static_dh_params)
    334         };
    335         rv = gnutls_dh_params_import_pkcs3(dh_params, &pdata, GNUTLS_X509_FMT_PEM);
    336         /* Generate DH Params
    337         int dh_bits = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH,
    338                 GNUTLS_SEC_PARAM_NORMAL);
    339         ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    340             "GnuTLS: Generating DH Params of %i bits.  "
    341             "To avoid this use GnuTLSDHFile to specify DH Params for this host",
    342             dh_bits);
    343 #if MOD_GNUTLS_DEBUG
    344             ap_log_error(APLOG_MARK, APLOG_INFO, 0, s,
    345                     "GnuTLS: Generated DH Params of %i bits",dh_bits);
    346 #endif
    347         rv = gnutls_dh_params_generate2 (dh_params,dh_bits);
    348         */
    349         if (rv < 0) {
    350             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    351                     "GnuTLS: Unable to generate or load DH Params: (%d) %s",
    352                     rv, gnutls_strerror(rv));
    353             exit(rv);
    354         }
    355     } else {
    356         dh_params = sc_base->dh_params;
    357     }
    358316
    359317    rv = mgs_cache_post_config(p, s, sc_base);
     
    365323    }
    366324
     325    /* Load additional PKCS #11 module, if requested */
     326    if (sc_base->p11_module != NULL)
     327    {
     328        rv = gnutls_pkcs11_add_provider(sc_base->p11_module, NULL);
     329        if (rv != GNUTLS_E_SUCCESS)
     330            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     331                         "GnuTLS: Loading PKCS #11 provider module %s "
     332                         "failed: %s (%d).",
     333                         sc_base->p11_module, gnutls_strerror(rv), rv);
     334    }
     335
    367336    for (s = base_server; s; s = s->next) {
    368337        sc = (mgs_srvconf_rec *) ap_get_module_config(s->module_config, &gnutls_module);
     
    370339        sc->cache_config = sc_base->cache_config;
    371340        sc->cache_timeout = sc_base->cache_timeout;
     341
     342        rv = mgs_load_files(p, s);
     343        if (rv != 0) {
     344            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     345                "GnuTLS: Loading required files failed."
     346                " Shutting Down.");
     347            exit(-1);
     348        }
    372349
    373350        /* defaults for unset values: */
     
    383360            sc->client_verify_method = mgs_cvm_cartel;
    384361
    385 
    386362        /* Check if the priorities have been set */
    387363        if (sc->priorities == NULL && sc->enabled == GNUTLS_ENABLED_TRUE) {
     
    401377        }
    402378
    403         gnutls_certificate_set_retrieve_function(sc->certs, cert_retrieve_fn);
    404 
    405 #ifdef ENABLE_SRP
    406         if (sc->srp_tpasswd_conf_file != NULL
    407                 && sc->srp_tpasswd_file != NULL) {
    408             rv = gnutls_srp_set_server_credentials_file
    409                     (sc->srp_creds, sc->srp_tpasswd_file,
    410                     sc->srp_tpasswd_conf_file);
    411 
    412             if (rv < 0 && sc->enabled == GNUTLS_ENABLED_TRUE) {
    413                 ap_log_error(APLOG_MARK, APLOG_STARTUP, 0,
    414                         s,
    415                         "[GnuTLS] - Host '%s:%d' is missing a "
    416                         "SRP password or conf File!",
    417                         s->server_hostname, s->port);
    418                 exit(-1);
    419             }
    420         }
     379        /* The call after this comment is a workaround for bug in
     380         * gnutls_certificate_set_retrieve_function2 that ignores
     381         * supported certificate types. Should be fixed in GnuTLS
     382         * 3.3.12.
     383         *
     384         * Details:
     385         * https://lists.gnupg.org/pipermail/gnutls-devel/2015-January/007377.html
     386         * Workaround from:
     387         * https://github.com/vanrein/tlspool/commit/4938102d3d1b086491d147e6c8e4e2a02825fc12 */
     388#if GNUTLS_VERSION_NUMBER < 0x030312
     389        gnutls_certificate_set_retrieve_function(sc->certs, (void *) exit);
    421390#endif
     391
     392        gnutls_certificate_set_retrieve_function2(sc->certs, cert_retrieve_fn);
    422393
    423394        if ((sc->certs_x509_chain == NULL || sc->certs_x509_chain_num < 1) &&
    424395            sc->cert_pgp == NULL && sc->enabled == GNUTLS_ENABLED_TRUE) {
    425396                        ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    426                                                 "[GnuTLS] - Host '%s:%d' is missing a Certificate File!",
     397                                                "GnuTLS: Host '%s:%d' is missing a Certificate File!",
    427398                                                s->server_hostname, s->port);
    428399            exit(-1);
    429400        }
    430 
    431401        if (sc->enabled == GNUTLS_ENABLED_TRUE &&
    432             ((sc->certs_x509_chain != NULL && sc->certs_x509_chain_num > 0 && sc->privkey_x509 == NULL) ||
    433              (sc->cert_pgp != NULL && sc->privkey_pgp == NULL))) {
     402            ((sc->certs_x509_chain_num > 0 && sc->privkey_x509 == NULL) ||
     403             (sc->cert_crt_pgp[0] != NULL && sc->privkey_pgp == NULL))) {
    434404                        ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    435                                                 "[GnuTLS] - Host '%s:%d' is missing a Private Key File!",
     405                                                "GnuTLS: Host '%s:%d' is missing a Private Key File!",
    436406                                                s->server_hostname, s->port);
    437407            exit(-1);
     
    441411            rv = -1;
    442412            if (sc->certs_x509_chain_num > 0) {
    443                 rv = read_crt_cn(s, p, sc->certs_x509_chain[0], &sc->cert_cn);
     413                rv = read_crt_cn(s, p, sc->certs_x509_crt_chain[0], &sc->cert_cn);
    444414            }
    445415            if (rv < 0 && sc->cert_pgp != NULL) {
    446                 rv = read_pgpcrt_cn(s, p, sc->cert_pgp, &sc->cert_cn);
     416                rv = read_pgpcrt_cn(s, p, sc->cert_crt_pgp[0], &sc->cert_cn);
    447417                        }
    448418
    449419            if (rv < 0) {
    450420                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    451                                                         "[GnuTLS] - Cannot find a certificate for host '%s:%d'!",
     421                                                        "GnuTLS: Cannot find a certificate for host '%s:%d'!",
    452422                                                        s->server_hostname, s->port);
    453423                sc->cert_cn = NULL;
    454424                continue;
    455425            }
     426        }
     427
     428        if (sc->enabled == GNUTLS_ENABLED_TRUE
     429            && sc->proxy_enabled == GNUTLS_ENABLED_TRUE
     430            && load_proxy_x509_credentials(s) != APR_SUCCESS)
     431        {
     432            ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     433                         "%s: loading proxy credentials for host "
     434                         "'%s:%d' failed, exiting!",
     435                         __func__, s->server_hostname, s->port);
     436            exit(-1);
    456437        }
    457438    }
     
    474455}
    475456
    476 void mgs_hook_child_init(apr_pool_t * p, server_rec * s) {
     457void mgs_hook_child_init(apr_pool_t * p, server_rec *s) {
    477458    apr_status_t rv = APR_SUCCESS;
    478     mgs_srvconf_rec *sc = ap_get_module_config(s->module_config,
    479             &gnutls_module);
     459    mgs_srvconf_rec *sc =
     460        (mgs_srvconf_rec *) ap_get_module_config(s->module_config, &gnutls_module);
    480461
    481462    _gnutls_log(debug_log_fp, "%s: %d\n", __func__, __LINE__);
     463    /* if we use PKCS #11 reinitialize it */
     464
     465    if (mgs_pkcs11_reinit(s) < 0) {
     466            ap_log_error(APLOG_MARK, APLOG_EMERG, 0, s,
     467                    "GnuTLS: Failed to reinitialize PKCS #11");
     468            exit(-1);
     469    }
     470
    482471    if (sc->cache_type != mgs_cache_none) {
    483472        rv = mgs_cache_child_init(p, s, sc);
    484473        if (rv != APR_SUCCESS) {
    485474            ap_log_error(APLOG_MARK, APLOG_EMERG, rv, s,
    486                     "[GnuTLS] - Failed to run Cache Init");
     475                    "GnuTLS: Failed to run Cache Init");
    487476        }
    488477    }
     
    605594
    606595    if (tsc->certs_x509_chain_num > 0) {
    607         /* why are we doing this check? */
    608         ret = gnutls_x509_crt_check_hostname(tsc->certs_x509_chain[0], s->server_hostname);
     596        /* this check is there to warn administrator of any missing hostname
     597         * in the certificate. */
     598        ret = gnutls_x509_crt_check_hostname(tsc->certs_x509_crt_chain[0], s->server_hostname);
    609599        if (0 == ret)
    610             ap_log_error(APLOG_MARK, APLOG_INFO, 0, s,
    611                          "GnuTLS: Error checking certificate for hostname "
     600            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s,
     601                         "GnuTLS: the certificate doesn't match requested hostname "
    612602                         "'%s'", s->server_hostname);
    613603    } else {
     
    620610#endif
    621611
    622 mgs_srvconf_rec *mgs_find_sni_server(gnutls_session_t session) {
     612mgs_srvconf_rec *mgs_find_sni_server(gnutls_session_t session)
     613{
    623614    int rv;
    624615    unsigned int sni_type;
     
    671662
    672663        tsc = (mgs_srvconf_rec *) ap_get_module_config(s->module_config,
    673                 &gnutls_module);
     664                                                       &gnutls_module);
    674665
    675666        if (tsc->enabled != GNUTLS_ENABLED_TRUE) { continue; }
    676667
    677                                 if(check_server_aliases(x, s, tsc)) {
    678                                         return tsc;
    679                                 }
     668        if(check_server_aliases(x, s, tsc)) {
     669            return tsc;
     670        }
     671    }
    680672#endif
    681673    return NULL;
    682674}
    683675
    684 static void create_gnutls_handle(conn_rec * c) {
    685     mgs_handle_t *ctxt;
    686     /* Get mod_gnutls Configuration Record */
    687     mgs_srvconf_rec *sc =(mgs_srvconf_rec *)
    688             ap_get_module_config(c->base_server->module_config,&gnutls_module);
     676/*
     677 * This function is intended as a cleanup handler for connections
     678 * using GnuTLS.
     679 *
     680 * @param data must point to the mgs_handle_t associated with the
     681 * connection
     682 */
     683static apr_status_t cleanup_gnutls_session(void *data)
     684{
     685    /* nothing to do */
     686    if (data == NULL)
     687        return APR_SUCCESS;
     688
     689    /* check if session needs closing */
     690    mgs_handle_t *ctxt = (mgs_handle_t *) data;
     691    if (ctxt->session != NULL)
     692    {
     693        int ret;
     694        /* Try A Clean Shutdown */
     695        do
     696            ret = gnutls_bye(ctxt->session, GNUTLS_SHUT_WR);
     697        while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN);
     698        if (ret != GNUTLS_E_SUCCESS)
     699            ap_log_cerror(APLOG_MARK, APLOG_INFO, ret, ctxt->c,
     700                          "%s: error while closing TLS %sconnection: %s (%d)",
     701                          __func__, IS_PROXY_STR(ctxt),
     702                          gnutls_strerror(ret), ret);
     703        else
     704            ap_log_cerror(APLOG_MARK, APLOG_DEBUG, ret, ctxt->c,
     705                          "%s: TLS %sconnection closed.",
     706                          __func__, IS_PROXY_STR(ctxt));
     707        /* De-Initialize Session */
     708        gnutls_deinit(ctxt->session);
     709        ctxt->session = NULL;
     710    }
     711    return APR_SUCCESS;
     712}
     713
     714static void create_gnutls_handle(conn_rec * c)
     715{
     716    /* Get mod_gnutls server configuration */
     717    mgs_srvconf_rec *sc = (mgs_srvconf_rec *)
     718            ap_get_module_config(c->base_server->module_config, &gnutls_module);
    689719
    690720    _gnutls_log(debug_log_fp, "%s: %d\n", __func__, __LINE__);
    691     ctxt = apr_pcalloc(c->pool, sizeof (*ctxt));
     721
     722    /* Get connection specific configuration */
     723    mgs_handle_t *ctxt = (mgs_handle_t *) ap_get_module_config(c->conn_config, &gnutls_module);
     724    if (ctxt == NULL)
     725    {
     726        ctxt = apr_pcalloc(c->pool, sizeof (*ctxt));
     727        ap_set_module_config(c->conn_config, &gnutls_module, ctxt);
     728        ctxt->is_proxy = GNUTLS_ENABLED_FALSE;
     729    }
     730    ctxt->enabled = GNUTLS_ENABLED_TRUE;
    692731    ctxt->c = c;
    693732    ctxt->sc = sc;
     
    700739    ctxt->output_blen = 0;
    701740    ctxt->output_length = 0;
     741
    702742    /* Initialize GnuTLS Library */
    703     gnutls_init(&ctxt->session, GNUTLS_SERVER);
    704     /* Initialize Session Tickets */
    705     if (session_ticket_key.data != NULL && ctxt->sc->tickets != 0) {
    706         gnutls_session_ticket_enable_server(ctxt->session,&session_ticket_key);
     743    int err = 0;
     744    if (ctxt->is_proxy == GNUTLS_ENABLED_TRUE)
     745    {
     746        /* this is an outgoing proxy connection, client mode */
     747        err = gnutls_init(&ctxt->session, GNUTLS_CLIENT);
     748        if (err != GNUTLS_E_SUCCESS)
     749            ap_log_cerror(APLOG_MARK, APLOG_ERR, err, c,
     750                          "gnutls_init for proxy connection failed: %s (%d)",
     751                          gnutls_strerror(err), err);
     752        err = gnutls_session_ticket_enable_client(ctxt->session);
     753        if (err != GNUTLS_E_SUCCESS)
     754            ap_log_cerror(APLOG_MARK, APLOG_ERR, err, c,
     755                          "gnutls_session_ticket_enable_client failed: %s (%d)",
     756                          gnutls_strerror(err), err);
     757        /* Try to close and deinit the session when the connection
     758         * pool is cleared. Note that mod_proxy might not close
     759         * connections immediately, if you need that, look at the
     760         * "proxy-nokeepalive" environment variable for
     761         * mod_proxy_http. */
     762        apr_pool_pre_cleanup_register(c->pool, ctxt, cleanup_gnutls_session);
     763    }
     764    else
     765    {
     766        /* incoming connection, server mode */
     767        err = gnutls_init(&ctxt->session, GNUTLS_SERVER);
     768        if (err != GNUTLS_E_SUCCESS)
     769            ap_log_cerror(APLOG_MARK, APLOG_ERR, err, c,
     770                          "gnutls_init for server side failed: %s (%d)",
     771                          gnutls_strerror(err), err);
     772        /* Initialize Session Tickets */
     773        if (session_ticket_key.data != NULL && ctxt->sc->tickets != 0)
     774        {
     775            err = gnutls_session_ticket_enable_server(ctxt->session, &session_ticket_key);
     776            if (err != GNUTLS_E_SUCCESS)
     777                ap_log_cerror(APLOG_MARK, APLOG_ERR, err, c,
     778                              "gnutls_session_ticket_enable_server failed: %s (%d)",
     779                              gnutls_strerror(err), err);
     780        }
    707781    }
    708782
    709783    /* Set Default Priority */
    710         gnutls_priority_set_direct (ctxt->session, "NORMAL", NULL);
     784        err = gnutls_priority_set_direct(ctxt->session, "NORMAL", NULL);
     785    if (err != GNUTLS_E_SUCCESS)
     786        ap_log_cerror(APLOG_MARK, APLOG_ERR, err, c, "gnutls_priority_set_direct failed!");
    711787    /* Set Handshake function */
    712788    gnutls_handshake_set_post_client_hello_function(ctxt->session,
    713789            mgs_select_virtual_server_cb);
     790
     791    /* Set GnuTLS user pointer, so we can access the module session
     792     * context in GnuTLS callbacks */
     793    gnutls_session_set_ptr(ctxt->session, ctxt);
     794
     795    /* If mod_gnutls is the TLS server, mgs_select_virtual_server_cb
     796     * will load appropriate credentials during handshake. However,
     797     * when handling a proxy backend connection, mod_gnutls acts as
     798     * TLS client and credentials must be loaded here. */
     799    if (ctxt->is_proxy == GNUTLS_ENABLED_TRUE)
     800    {
     801        /* Set anonymous client credentials for proxy connections */
     802        gnutls_credentials_set(ctxt->session, GNUTLS_CRD_ANON,
     803                               ctxt->sc->anon_client_creds);
     804        /* Set x509 credentials */
     805        gnutls_credentials_set(ctxt->session, GNUTLS_CRD_CERTIFICATE,
     806                               ctxt->sc->proxy_x509_creds);
     807        /* Load priorities from the server configuration */
     808        err = gnutls_priority_set(ctxt->session, ctxt->sc->proxy_priorities);
     809        if (err != GNUTLS_E_SUCCESS)
     810            ap_log_cerror(APLOG_MARK, APLOG_ERR, err, c,
     811                          "%s: setting priorities for proxy connection "
     812                          "failed: %s (%d)",
     813                          __func__, gnutls_strerror(err), err);
     814    }
     815
    714816    /* Initialize Session Cache */
    715817    mgs_cache_session_init(ctxt);
    716818
    717     /* Set this config for this connection */
    718     ap_set_module_config(c->conn_config, &gnutls_module, ctxt);
    719819    /* Set pull, push & ptr functions */
    720820    gnutls_transport_set_pull_function(ctxt->session,
     
    730830}
    731831
    732 int mgs_hook_pre_connection(conn_rec * c, void *csd __attribute__((unused))) {
    733     mgs_srvconf_rec *sc;
    734 
     832int mgs_hook_pre_connection(conn_rec * c, void *csd __attribute__((unused)))
     833{
    735834    _gnutls_log(debug_log_fp, "%s: %d\n", __func__, __LINE__);
    736835
    737     sc = (mgs_srvconf_rec *) ap_get_module_config(c->base_server->module_config,
    738             &gnutls_module);
    739 
    740     if (sc && (!sc->enabled || sc->proxy_enabled == GNUTLS_ENABLED_TRUE)) {
     836    mgs_srvconf_rec *sc = (mgs_srvconf_rec *)
     837        ap_get_module_config(c->base_server->module_config, &gnutls_module);
     838    mgs_handle_t *ctxt = (mgs_handle_t *)
     839        ap_get_module_config(c->conn_config, &gnutls_module);
     840
     841    if ((sc && (!sc->enabled)) || (ctxt && ctxt->enabled == GNUTLS_ENABLED_FALSE))
     842    {
     843        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, c, "%s declined connection",
     844                      __func__);
    741845        return DECLINED;
    742846    }
     
    760864    apr_table_t *env = r->subprocess_env;
    761865
    762     ctxt =
    763             ap_get_module_config(r->connection->conn_config,
    764             &gnutls_module);
    765 
    766     if (!ctxt || ctxt->session == NULL) {
     866    ctxt = ap_get_module_config(r->connection->conn_config,
     867                                &gnutls_module);
     868
     869    if (!ctxt || ctxt->enabled != GNUTLS_ENABLED_TRUE || ctxt->session == NULL)
     870    {
     871        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "request declined in %s", __func__);
    767872        return DECLINED;
    768873    }
     
    821926
    822927    if (gnutls_certificate_type_get(ctxt->session) == GNUTLS_CRT_X509) {
    823                 mgs_add_common_cert_vars(r, ctxt->sc->certs_x509_chain[0], 0, ctxt->sc->export_certificates_size);
    824         } else if (gnutls_certificate_type_get(ctxt->session) == GNUTLS_CRT_OPENPGP) {
    825         mgs_add_common_pgpcert_vars(r, ctxt->sc->cert_pgp, 0, ctxt->sc->export_certificates_size);
    826         }
     928        mgs_add_common_cert_vars(r, ctxt->sc->certs_x509_crt_chain[0], 0, ctxt->sc->export_certificates_size);
     929    } else if (gnutls_certificate_type_get(ctxt->session) == GNUTLS_CRT_OPENPGP) {
     930        mgs_add_common_pgpcert_vars(r, ctxt->sc->cert_crt_pgp[0], 0, ctxt->sc->export_certificates_size);
     931    }
    827932
    828933    return rv;
     
    879984        }
    880985        rv = mgs_cert_verify(r, ctxt);
    881         if (rv != DECLINED &&
    882                 (rv != HTTP_FORBIDDEN ||
    883                 dc->client_verify_mode == GNUTLS_CERT_REQUIRE)) {
     986        if (rv != DECLINED
     987            && (rv != HTTP_FORBIDDEN
     988                || dc->client_verify_mode == GNUTLS_CERT_REQUIRE
     989                || (dc->client_verify_mode == -1
     990                    && ctxt->sc->client_verify_mode == GNUTLS_CERT_REQUIRE)))
     991        {
    884992            return rv;
    885993        }
     
    15531661}
    15541662
     1663
     1664
     1665/*
     1666 * Callback to check the server certificate for proxy HTTPS
     1667 * connections, to be used with
     1668 * gnutls_certificate_set_verify_function.
     1669
     1670 * Returns: 0 if certificate check was successful (certificate
     1671 * trusted), non-zero otherwise (error during check or untrusted
     1672 * certificate).
     1673 */
     1674static int gtls_check_server_cert(gnutls_session_t session)
     1675{
     1676    mgs_handle_t *ctxt = (mgs_handle_t *) gnutls_session_get_ptr(session);
     1677    unsigned int status;
     1678
     1679    /* Get peer hostname from a note left by mod_proxy */
     1680    const char *peer_hostname =
     1681        apr_table_get(ctxt->c->notes, "proxy-request-hostname");
     1682    if (peer_hostname == NULL)
     1683        ap_log_cerror(APLOG_MARK, APLOG_WARNING, 0, ctxt->c,
     1684                      "%s: proxy-request-hostname is NULL, cannot check "
     1685                      "peer's hostname", __func__);
     1686
     1687    /* Verify certificate, including hostname match. Should
     1688     * peer_hostname be NULL for some reason, the name is not
     1689     * checked. */
     1690    int err = gnutls_certificate_verify_peers3(session, peer_hostname,
     1691                                               &status);
     1692    if (err != GNUTLS_E_SUCCESS)
     1693    {
     1694        ap_log_cerror(APLOG_MARK, APLOG_INFO, 0, ctxt->c,
     1695                      "%s: server certificate check failed: %s (%d)",
     1696                      __func__, gnutls_strerror(err), err);
     1697        return err;
     1698    }
     1699
     1700    gnutls_datum_t * out = gnutls_malloc(sizeof(gnutls_datum_t));
     1701    /* GNUTLS_CRT_X509: ATM, only X509 is supported for proxy certs
     1702     * 0: according to function API, the last argument should be 0 */
     1703    err = gnutls_certificate_verification_status_print(status, GNUTLS_CRT_X509,
     1704                                                       out, 0);
     1705    if (err != GNUTLS_E_SUCCESS)
     1706        ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, ctxt->c,
     1707                      "%s: server verify print failed: %s (%d)",
     1708                      __func__, gnutls_strerror(err), err);
     1709    else
     1710    {
     1711        /* If the certificate is trusted, logging the result is just
     1712         * nice for debugging. But if the back end server provided an
     1713         * untrusted certificate, warn! */
     1714        int level = (status == 0 ? APLOG_DEBUG : APLOG_WARNING);
     1715        ap_log_cerror(APLOG_MARK, level, 0, ctxt->c,
     1716                      "%s: server certificate verify result: %s",
     1717                      __func__, out->data);
     1718    }
     1719
     1720    gnutls_free(out);
     1721    return status;
     1722}
     1723
     1724
     1725
     1726static apr_status_t load_proxy_x509_credentials(server_rec *s)
     1727{
     1728    mgs_srvconf_rec *sc = (mgs_srvconf_rec *)
     1729        ap_get_module_config(s->module_config, &gnutls_module);
     1730
     1731    if (sc == NULL)
     1732        return APR_EGENERAL;
     1733
     1734    apr_status_t ret = APR_SUCCESS;
     1735    int err = GNUTLS_E_SUCCESS;
     1736
     1737    /* Function pool, gets destroyed before exit. */
     1738    apr_pool_t *pool;
     1739    ret = apr_pool_create(&pool, s->process->pool);
     1740    if (ret != APR_SUCCESS)
     1741    {
     1742        ap_log_error(APLOG_MARK, APLOG_ERR, ret, s,
     1743                     "%s: failed to allocate function memory pool.", __func__);
     1744        return ret;
     1745    }
     1746
     1747    /* allocate credentials structures */
     1748    err = gnutls_certificate_allocate_credentials(&sc->proxy_x509_creds);
     1749    if (err != GNUTLS_E_SUCCESS)
     1750    {
     1751        ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,
     1752                     "%s: Failed to initialize proxy credentials: (%d) %s",
     1753                     __func__, err, gnutls_strerror(err));
     1754        return APR_EGENERAL;
     1755    }
     1756    err = gnutls_anon_allocate_client_credentials(&sc->anon_client_creds);
     1757    if (err != GNUTLS_E_SUCCESS)
     1758    {
     1759        ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,
     1760                     "%s: Failed to initialize anon credentials for proxy: "
     1761                     "(%d) %s", __func__, err, gnutls_strerror(err));
     1762        return APR_EGENERAL;
     1763    }
     1764
     1765    /* Check if the proxy priorities have been set, fail immediately
     1766     * if not */
     1767    if (sc->proxy_priorities_str == NULL)
     1768    {
     1769        ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     1770                     "Host '%s:%d' is missing the GnuTLSProxyPriorities "
     1771                     "directive!",
     1772                     s->server_hostname, s->port);
     1773        return APR_EGENERAL;
     1774    }
     1775    /* parse proxy priorities */
     1776    const char *err_pos = NULL;
     1777    err = gnutls_priority_init(&sc->proxy_priorities,
     1778                               sc->proxy_priorities_str, &err_pos);
     1779    if (err != GNUTLS_E_SUCCESS)
     1780    {
     1781        if (ret == GNUTLS_E_INVALID_REQUEST)
     1782            ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,
     1783                         "%s: Syntax error parsing proxy priorities "
     1784                         "string at: %s",
     1785                         __func__, err_pos);
     1786        else
     1787            ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,
     1788                         "Error setting proxy priorities: %s (%d)",
     1789                         gnutls_strerror(err), err);
     1790        ret = APR_EGENERAL;
     1791    }
     1792
     1793    /* load certificate and key for client auth, if configured */
     1794    if (sc->proxy_x509_key_file && sc->proxy_x509_cert_file)
     1795    {
     1796        char* cert_file = ap_server_root_relative(pool,
     1797                                                  sc->proxy_x509_cert_file);
     1798        char* key_file = ap_server_root_relative(pool,
     1799                                                 sc->proxy_x509_key_file);
     1800        err = gnutls_certificate_set_x509_key_file(sc->proxy_x509_creds,
     1801                                                   cert_file,
     1802                                                   key_file,
     1803                                                   GNUTLS_X509_FMT_PEM);
     1804        if (err != GNUTLS_E_SUCCESS)
     1805        {
     1806            ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,
     1807                         "%s: loading proxy client credentials failed: %s (%d)",
     1808                         __func__, gnutls_strerror(err), err);
     1809            ret = APR_EGENERAL;
     1810        }
     1811    }
     1812    else if (!sc->proxy_x509_key_file && sc->proxy_x509_cert_file)
     1813    {
     1814        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
     1815                     "%s: proxy key file not set!", __func__);
     1816        ret = APR_EGENERAL;
     1817    }
     1818    else if (!sc->proxy_x509_cert_file && sc->proxy_x509_key_file)
     1819    {
     1820        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
     1821                     "%s: proxy certificate file not set!", __func__);
     1822        ret = APR_EGENERAL;
     1823    }
     1824    else
     1825        /* if both key and cert are NULL, client auth is not used */
     1826        ap_log_error(APLOG_MARK, APLOG_INFO, 0, s,
     1827                     "%s: no client credentials for proxy", __func__);
     1828
     1829    /* must be set if the server certificate is to be checked */
     1830    if (sc->proxy_x509_ca_file)
     1831    {
     1832        /* initialize the trust list */
     1833        err = gnutls_x509_trust_list_init(&sc->proxy_x509_tl, 0);
     1834        if (err != GNUTLS_E_SUCCESS)
     1835        {
     1836            ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,
     1837                         "%s: gnutls_x509_trust_list_init failed: %s (%d)",
     1838                         __func__, gnutls_strerror(err), err);
     1839            ret = APR_EGENERAL;
     1840        }
     1841
     1842        char* ca_file = ap_server_root_relative(pool,
     1843                                                sc->proxy_x509_ca_file);
     1844        /* if no CRL is used, sc->proxy_x509_crl_file is NULL */
     1845        char* crl_file = NULL;
     1846        if (sc->proxy_x509_crl_file)
     1847            crl_file = ap_server_root_relative(pool,
     1848                                               sc->proxy_x509_crl_file);
     1849
     1850        /* returns number of loaded elements */
     1851        err = gnutls_x509_trust_list_add_trust_file(sc->proxy_x509_tl,
     1852                                                    ca_file,
     1853                                                    crl_file,
     1854                                                    GNUTLS_X509_FMT_PEM,
     1855                                                    0 /* tl_flags */,
     1856                                                    0 /* tl_vflags */);
     1857        if (err > 0)
     1858            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s,
     1859                         "%s: proxy CA trust list: %d structures loaded",
     1860                         __func__, err);
     1861        else if (err == 0)
     1862            ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
     1863                         "%s: proxy CA trust list is empty (%d)",
     1864                         __func__, err);
     1865        else /* err < 0 */
     1866        {
     1867            ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,
     1868                         "%s: error loading proxy CA trust list: %s (%d)",
     1869                         __func__, gnutls_strerror(err), err);
     1870            ret = APR_EGENERAL;
     1871        }
     1872
     1873        /* attach trust list to credentials */
     1874        gnutls_certificate_set_trust_list(sc->proxy_x509_creds,
     1875                                          sc->proxy_x509_tl, 0);
     1876    }
     1877    else
     1878        ap_log_error(APLOG_MARK, APLOG_WARNING, 0, s,
     1879                     "%s: no CA trust list for proxy connections, "
     1880                     "TLS connections will fail!", __func__);
     1881
     1882    gnutls_certificate_set_verify_function(sc->proxy_x509_creds,
     1883                                           gtls_check_server_cert);
     1884    apr_pool_destroy(pool);
     1885    return ret;
     1886}
Note: See TracChangeset for help on using the changeset viewer.