Changeset 19e80a5 in mod_gnutls for src/gnutls_config.c


Ignore:
Timestamp:
Jan 28, 2019, 2:50:38 PM (21 months ago)
Author:
Fiona Klute <fiona.klute@…>
Branches:
debian/master
Children:
102aa67
Parents:
0931b35 (diff), ea9c699 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Update upstream source from tag 'upstream/0.9.0'

Update to upstream version '0.9.0'
with Debian dir 619b546038886b240d2c8e61ee1a1b13ce0867d7

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/gnutls_config.c

    r0931b35 r19e80a5  
    33 *  Copyright 2008, 2014 Nikos Mavrogiannopoulos
    44 *  Copyright 2011 Dash Shendy
    5  *  Copyright 2015-2016 Fiona Klute
     5 *  Copyright 2015-2018 Fiona Klute
    66 *
    77 *  Licensed under the Apache License, Version 2.0 (the "License");
     
    1818 */
    1919
     20#include "gnutls_cache.h"
    2021#include "gnutls_config.h"
    2122#include "mod_gnutls.h"
    2223#include "gnutls_ocsp.h"
     24
    2325#include "apr_lib.h"
     26#include <apr_strings.h>
    2427#include <gnutls/abstract.h>
    2528
     
    142145    }
    143146
    144     if (sc->cert_pgp)
    145     {
    146         gnutls_pcert_deinit(&sc->cert_pgp[0]);
    147         sc->cert_pgp = NULL;
    148         gnutls_openpgp_crt_deinit(sc->cert_crt_pgp[0]);
    149         sc->cert_crt_pgp = NULL;
    150     }
    151 
    152     if (sc->privkey_pgp)
    153     {
    154         gnutls_privkey_deinit(sc->privkey_pgp);
    155         sc->privkey_pgp = NULL;
    156 #if GNUTLS_VERSION_NUMBER < 0x030312
    157         gnutls_openpgp_privkey_deinit(sc->privkey_pgp_internal);
    158         sc->privkey_pgp_internal = NULL;
    159 #endif
    160     }
    161 
    162     if (sc->pgp_list)
    163     {
    164         gnutls_openpgp_keyring_deinit(sc->pgp_list);
    165         sc->pgp_list = NULL;
    166     }
    167 
    168     if (sc->priorities)
     147    /* Deinit server priorities only if set from
     148     * sc->priorities_str. Otherwise the server is using the default
     149     * global priority cache, which must not be deinitialized here. */
     150    if (sc->priorities_str && sc->priorities)
    169151    {
    170152        gnutls_priority_deinit(sc->priorities);
     
    453435    }
    454436
    455     if (sc->pgp_cert_file && sc->cert_pgp == NULL)
    456     {
    457         sc->cert_pgp = apr_pcalloc(pconf, sizeof(sc->cert_pgp[0]));
    458         sc->cert_crt_pgp = apr_pcalloc(pconf, sizeof(sc->cert_crt_pgp[0]));
    459 
    460         if (load_datum_from_file(spool, sc->pgp_cert_file, &data) != 0) {
    461             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    462                          "GnuTLS: Error Reading " "Certificate '%s'",
    463                          sc->pgp_cert_file);
    464             ret = -1;
    465             goto cleanup;
    466         }
    467 
    468         ret = gnutls_openpgp_crt_init(&sc->cert_crt_pgp[0]);
    469         if (ret < 0) {
    470             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    471                          "GnuTLS: Failed to Init "
    472                          "PGP Certificate: (%d) %s", ret,
    473                          gnutls_strerror(ret));
    474             ret = -1;
    475             goto cleanup;
    476         }
    477 
    478         ret = gnutls_openpgp_crt_import(sc->cert_crt_pgp[0], &data,
    479                                         GNUTLS_OPENPGP_FMT_BASE64);
    480         if (ret < 0) {
    481             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    482                          "GnuTLS: Failed to Import "
    483                          "PGP Certificate: (%d) %s", ret,
    484                          gnutls_strerror(ret));
    485             ret = -1;
    486             goto cleanup;
    487         }
    488 
    489         ret = gnutls_pcert_import_openpgp(sc->cert_pgp,
    490                                           sc->cert_crt_pgp[0], 0);
    491         if (ret < 0) {
    492             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    493                          "GnuTLS: Failed to Import "
    494                          "PGP pCertificate: (%d) %s", ret,
    495                          gnutls_strerror(ret));
    496             ret = -1;
    497             goto cleanup;
    498         }
    499     }
    500 
    501     /* Load the PGP key file */
    502     if (sc->pgp_key_file && sc->privkey_pgp == NULL)
    503     {
    504         if (load_datum_from_file(spool, sc->pgp_key_file, &data) != 0) {
    505             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    506                          "GnuTLS: Error Reading " "Private Key '%s'",
    507                          sc->pgp_key_file);
    508             ret = -1;
    509             goto cleanup;
    510         }
    511 
    512         ret = gnutls_privkey_init(&sc->privkey_pgp);
    513         if (ret < 0) {
    514             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    515                          "GnuTLS: Failed to initialize"
    516                          ": (%d) %s", ret, gnutls_strerror(ret));
    517             ret = -1;
    518             goto cleanup;
    519         }
    520 
    521 #if GNUTLS_VERSION_NUMBER < 0x030312
    522         /* GnuTLS versions before 3.3.12 contain a bug in
    523          * gnutls_privkey_import_openpgp_raw which frees data that is
    524          * accessed when the key is used, leading to segfault. Loading
    525          * the key into a gnutls_openpgp_privkey_t and then assigning
    526          * it to the gnutls_privkey_t works around the bug, hence this
    527          * chain of gnutls_openpgp_privkey_init,
    528          * gnutls_openpgp_privkey_import and
    529          * gnutls_privkey_import_openpgp. */
    530         ret = gnutls_openpgp_privkey_init(&sc->privkey_pgp_internal);
    531         if (ret != 0) {
    532             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    533                          "GnuTLS: Failed to initialize "
    534                          "PGP Private Key '%s': (%d) %s",
    535                          sc->pgp_key_file, ret, gnutls_strerror(ret));
    536             ret = -1;
    537             goto cleanup;
    538         }
    539 
    540         ret = gnutls_openpgp_privkey_import(sc->privkey_pgp_internal, &data,
    541                                             GNUTLS_OPENPGP_FMT_BASE64, NULL, 0);
    542         if (ret != 0) {
    543             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    544                          "GnuTLS: Failed to Import "
    545                          "PGP Private Key '%s': (%d) %s",
    546                          sc->pgp_key_file, ret, gnutls_strerror(ret));
    547             ret = -1;
    548             goto cleanup;
    549         }
    550 
    551         ret = gnutls_privkey_import_openpgp(sc->privkey_pgp,
    552                                             sc->privkey_pgp_internal, 0);
    553         if (ret != 0)
    554         {
    555             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    556                          "GnuTLS: Failed to assign PGP Private Key '%s' "
    557                          "to gnutls_privkey_t structure: (%d) %s",
    558                          sc->pgp_key_file, ret, gnutls_strerror(ret));
    559             ret = -1;
    560             goto cleanup;
    561         }
    562 #else
    563         ret = gnutls_privkey_import_openpgp_raw(sc->privkey_pgp, &data,
    564                                                 GNUTLS_OPENPGP_FMT_BASE64,
    565                                                 NULL, NULL);
    566         if (ret != 0)
    567         {
    568             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    569                          "GnuTLS: Failed to Import "
    570                          "PGP Private Key '%s': (%d) %s",
    571                          sc->pgp_key_file, ret, gnutls_strerror(ret));
    572             ret = -1;
    573             goto cleanup;
    574         }
    575 #endif
    576     }
    577 
    578     /* Load the keyring file */
    579     if (sc->pgp_ring_file && sc->pgp_list == NULL)
    580     {
    581         if (load_datum_from_file(spool, sc->pgp_ring_file, &data) != 0) {
    582             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    583                          "GnuTLS: Error Reading " "Keyring File '%s'",
    584                          sc->pgp_ring_file);
    585             ret = -1;
    586             goto cleanup;
    587         }
    588 
    589         ret = gnutls_openpgp_keyring_init(&sc->pgp_list);
    590         if (ret < 0) {
    591             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    592                          "GnuTLS: Failed to initialize"
    593                          "keyring: (%d) %s", ret, gnutls_strerror(ret));
    594             ret = -1;
    595             goto cleanup;
    596         }
    597 
    598         ret = gnutls_openpgp_keyring_import(sc->pgp_list, &data,
    599                                             GNUTLS_OPENPGP_FMT_BASE64);
    600         if (ret < 0) {
    601             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    602                          "GnuTLS: Failed to load "
    603                          "Keyring File '%s': (%d) %s", sc->pgp_ring_file,
    604                          ret, gnutls_strerror(ret));
    605             ret = -1;
    606             goto cleanup;
    607         }
    608     }
    609 
    610437    if (sc->priorities_str && sc->priorities == NULL)
    611438    {
     
    715542}
    716543
    717 const char *mgs_set_pgpcert_file(cmd_parms * parms, void *dummy __attribute__((unused)),
    718         const char *arg)
    719 {
    720     mgs_srvconf_rec *sc =
    721         (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    722                                                  module_config,
    723                                                  &gnutls_module);
    724 
    725     sc->pgp_cert_file = ap_server_root_relative(parms->pool, arg);
    726 
    727     return NULL;
    728 }
    729 
    730 const char *mgs_set_pgpkey_file(cmd_parms * parms, void *dummy __attribute__((unused)),
    731         const char *arg) {
    732     mgs_srvconf_rec *sc =
    733         (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    734                                                  module_config,
    735                                                  &gnutls_module);
    736 
    737     sc->pgp_key_file = ap_server_root_relative(parms->pool, arg);
    738 
    739     return NULL;
    740 }
    741 
    742544const char *mgs_set_tickets(cmd_parms *parms,
    743545                            void *dummy __attribute__((unused)),
     
    784586#endif
    785587
    786 const char *mgs_set_cache(cmd_parms * parms, void *dummy __attribute__((unused)),
    787         const char *type, const char *arg) {
     588const char *mgs_set_cache(cmd_parms * parms,
     589                          void *dummy __attribute__((unused)),
     590                          const char *type, const char *arg)
     591{
    788592    const char *err;
    789593    mgs_srvconf_rec *sc =
    790         ap_get_module_config(parms->server->module_config,
    791                              &gnutls_module);
    792     if ((err = ap_check_cmd_context(parms, GLOBAL_ONLY))) {
    793         return err;
    794     }
    795 
    796     if (strcasecmp("none", type) == 0) {
    797         sc->cache_type = mgs_cache_none;
    798         sc->cache_config = NULL;
    799         return NULL;
    800     } else if (strcasecmp("dbm", type) == 0) {
    801         sc->cache_type = mgs_cache_dbm;
    802     } else if (strcasecmp("gdbm", type) == 0) {
    803         sc->cache_type = mgs_cache_gdbm;
    804     }
    805 #if HAVE_APR_MEMCACHE
    806     else if (strcasecmp("memcache", type) == 0) {
    807         sc->cache_type = mgs_cache_memcache;
    808     }
    809 #endif
    810     else {
    811         return "Invalid Type for GnuTLSCache!";
    812     }
    813 
    814     if (arg == NULL)
    815         return "Invalid argument 2 for GnuTLSCache!";
    816 
    817     if (sc->cache_type == mgs_cache_dbm
    818         || sc->cache_type == mgs_cache_gdbm) {
    819         sc->cache_config = ap_server_root_relative(parms->pool, arg);
    820     } else {
    821         sc->cache_config = apr_pstrdup(parms->pool, arg);
    822     }
    823 
    824     return NULL;
     594        ap_get_module_config(parms->server->module_config,
     595                             &gnutls_module);
     596    if ((err = ap_check_cmd_context(parms, GLOBAL_ONLY)))
     597        return err;
     598
     599    unsigned char enable = GNUTLS_ENABLED_TRUE;
     600    /* none: disable cache */
     601    if (strcasecmp("none", type) == 0)
     602        enable = GNUTLS_ENABLED_FALSE;
     603
     604    /* Try to split socache "type:config" style configuration */
     605    const char* sep = ap_strchr_c(type, ':');
     606    if (sep)
     607    {
     608        type = apr_pstrmemdup(parms->temp_pool, type, sep - type);
     609        if (arg != NULL)
     610        {
     611            /* No mixing of socache style and legacy config! */
     612            return "GnuTLSCache appears to have a mod_socache style "
     613                "type:config value, but there is a second parameter!";
     614        }
     615        arg = ++sep;
     616    }
     617
     618    mgs_cache_t *cache = NULL;
     619    /* parms->directive->directive contains the directive string */
     620    if (!strcasecmp(parms->directive->directive, "GnuTLSCache"))
     621    {
     622        if (enable == GNUTLS_ENABLED_FALSE)
     623        {
     624            sc->cache_enable = GNUTLS_ENABLED_FALSE;
     625            return NULL;
     626        }
     627        sc->cache_enable = GNUTLS_ENABLED_TRUE;
     628        cache = &sc->cache;
     629    }
     630    else if (!strcasecmp(parms->directive->directive, "GnuTLSOCSPCache"))
     631    {
     632        if (enable == GNUTLS_ENABLED_FALSE)
     633            return "\"GnuTLSOCSPCache none\" is invalid, use "
     634                "\"GnuTLSOCSPStapling off\" if you want to disable "
     635                "OCSP stapling.";
     636        cache = &sc->ocsp_cache;
     637    }
     638    else
     639        return apr_psprintf(parms->temp_pool, "Internal Error: %s "
     640                            "called for unknown directive %s",
     641                            __func__, parms->directive->directive);
     642
     643    return mgs_cache_inst_config(cache, parms->server,
     644                                 type, arg,
     645                                 parms->pool, parms->temp_pool);
    825646}
    826647
     
    838659        ap_get_module_config(parms->server->module_config, &gnutls_module);
    839660
    840     if (!apr_strnatcasecmp(parms->directive->directive, "GnuTLSCacheTimeout"))
    841     {
    842         const char *err;
    843         if ((err = ap_check_cmd_context(parms, GLOBAL_ONLY)))
    844             return err;
     661    if (!strcasecmp(parms->directive->directive, "GnuTLSCacheTimeout"))
    845662        sc->cache_timeout = apr_time_from_sec(argint);
    846     }
    847     else if (!apr_strnatcasecmp(parms->directive->directive,
    848                                 "GnuTLSOCSPCacheTimeout"))
     663    else if (!strcasecmp(parms->directive->directive,
     664                         "GnuTLSOCSPCacheTimeout"))
    849665        sc->ocsp_cache_time = apr_time_from_sec(argint);
    850     else if (!apr_strnatcasecmp(parms->directive->directive,
    851                                 "GnuTLSOCSPFailureTimeout"))
     666    else if (!strcasecmp(parms->directive->directive,
     667                         "GnuTLSOCSPFailureTimeout"))
    852668        sc->ocsp_failure_timeout = apr_time_from_sec(argint);
    853     else if (!apr_strnatcasecmp(parms->directive->directive,
    854                                 "GnuTLSOCSPSocketTimeout"))
     669    else if (!strcasecmp(parms->directive->directive,
     670                         "GnuTLSOCSPFuzzTime"))
     671        sc->ocsp_fuzz_time = apr_time_from_sec(argint);
     672    else if (!strcasecmp(parms->directive->directive,
     673                         "GnuTLSOCSPSocketTimeout"))
    855674        sc->ocsp_socket_timeout = apr_time_from_sec(argint);
    856675    else
     
    920739
    921740    sc->x509_ca_file = ap_server_root_relative(parms->pool, arg);
    922 
    923     return NULL;
    924 }
    925 
    926 const char *mgs_set_keyring_file(cmd_parms * parms, void *dummy __attribute__((unused)),
    927         const char *arg) {
    928     mgs_srvconf_rec *sc =
    929         (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    930                                                  module_config,
    931                                                  &gnutls_module);
    932 
    933     sc->pgp_ring_file = ap_server_root_relative(parms->pool, arg);
    934741
    935742    return NULL;
     
    1071878    sc->pin = NULL;
    1072879
    1073     sc->cert_pgp = NULL;
    1074     sc->cert_crt_pgp = NULL;
    1075     sc->privkey_pgp = NULL;
    1076 #if GNUTLS_VERSION_NUMBER < 0x030312
    1077     sc->privkey_pgp_internal = NULL;
    1078 #endif
    1079     sc->pgp_list = NULL;
    1080 
    1081880    sc->priorities_str = NULL;
    1082881    sc->cache_timeout = MGS_TIMEOUT_UNSET;
    1083     sc->cache_type = mgs_cache_unset;
    1084     sc->cache_config = NULL;
     882    sc->cache_enable = GNUTLS_ENABLED_UNSET;
    1085883    sc->cache = NULL;
    1086884    sc->tickets = GNUTLS_ENABLED_UNSET;
     
    1105903
    1106904    sc->ocsp_staple = GNUTLS_ENABLED_UNSET;
     905    sc->ocsp_auto_refresh = GNUTLS_ENABLED_UNSET;
    1107906    sc->ocsp_check_nonce = GNUTLS_ENABLED_UNSET;
    1108907    sc->ocsp_response_file = NULL;
    1109908    sc->ocsp_mutex = NULL;
     909    sc->ocsp_cache = NULL;
    1110910    sc->ocsp_cache_time = MGS_TIMEOUT_UNSET;
    1111911    sc->ocsp_failure_timeout = MGS_TIMEOUT_UNSET;
     912    sc->ocsp_fuzz_time = MGS_TIMEOUT_UNSET;
    1112913    sc->ocsp_socket_timeout = MGS_TIMEOUT_UNSET;
     914
     915    sc->singleton_wd = NULL;
    1113916
    1114917/* this relies on GnuTLS never changing the gnutls_certificate_request_t enum to define -1 */
     
    1133936void *mgs_config_server_merge(apr_pool_t * p, void *BASE, void *ADD)
    1134937{
    1135     int i;
    1136938    char *err = NULL;
    1137939    mgs_srvconf_rec *base = (mgs_srvconf_rec *) BASE;
     
    1155957    gnutls_srvconf_merge(p11_modules, NULL);
    1156958    gnutls_srvconf_merge(pin, NULL);
    1157     gnutls_srvconf_merge(pgp_cert_file, NULL);
    1158     gnutls_srvconf_merge(pgp_key_file, NULL);
    1159     gnutls_srvconf_merge(pgp_ring_file, NULL);
    1160959    gnutls_srvconf_merge(dh_file, NULL);
    1161960    gnutls_srvconf_merge(priorities_str, NULL);
     961    gnutls_srvconf_merge(cache_timeout, MGS_TIMEOUT_UNSET);
    1162962
    1163963    gnutls_srvconf_merge(proxy_x509_key_file, NULL);
     
    1169969
    1170970    gnutls_srvconf_merge(ocsp_staple, GNUTLS_ENABLED_UNSET);
     971    gnutls_srvconf_merge(ocsp_auto_refresh, GNUTLS_ENABLED_UNSET);
    1171972    gnutls_srvconf_merge(ocsp_check_nonce, GNUTLS_ENABLED_UNSET);
    1172973    gnutls_srvconf_assign(ocsp_response_file);
    1173974    gnutls_srvconf_merge(ocsp_cache_time, MGS_TIMEOUT_UNSET);
    1174975    gnutls_srvconf_merge(ocsp_failure_timeout, MGS_TIMEOUT_UNSET);
     976    gnutls_srvconf_merge(ocsp_fuzz_time, MGS_TIMEOUT_UNSET);
    1175977    gnutls_srvconf_merge(ocsp_socket_timeout, MGS_TIMEOUT_UNSET);
    1176978
    1177979    gnutls_srvconf_assign(ca_list);
    1178980    gnutls_srvconf_assign(ca_list_size);
    1179     gnutls_srvconf_assign(cert_pgp);
    1180     gnutls_srvconf_assign(cert_crt_pgp);
    1181     gnutls_srvconf_assign(pgp_list);
    1182981    gnutls_srvconf_assign(certs);
    1183982    gnutls_srvconf_assign(anon_creds);
     
    1186985    gnutls_srvconf_assign(certs_x509_crt_chain);
    1187986    gnutls_srvconf_assign(certs_x509_chain_num);
    1188 
    1189     /* how do these get transferred cleanly before the data from ADD
    1190      * goes away? */
    1191     gnutls_srvconf_assign(cert_cn);
    1192     for (i = 0; i < MAX_CERT_SAN; i++)
    1193         gnutls_srvconf_assign(cert_san[i]);
    1194987
    1195988    return sc;
Note: See TracChangeset for help on using the changeset viewer.