Changeset 3b4c0d0 in mod_gnutls


Ignore:
Timestamp:
Dec 20, 2012, 11:29:16 PM (7 years ago)
Author:
Dash Shendy <neuromancer@…>
Branches:
debian/master, debian/stretch-backports, jessie-backports, master, msva, upstream
Children:
8780e34
Parents:
8c03808
Message:
  • Added Comments to Header Structures
  • Refactored the following:

mod_gnutls.h.in:

  • struct mgs_srvconf_rec{}

gnutls_config.c:

  • mgs_set_cert_file()
  • mgs_set_key_file()
  • mgs_set_priorities()
  • mgs_config_server_create()

gnutls_hooks.c

  • mgs_hook_pre_config()
  • mgs_select_virtual_server_cb()
  • cert_retrieve_fn()
  • read_crt_cn()
  • mgs_hook_post_config()
  • mgs_find_sni_server()
  • mgs_add_common_cert_vars()
  • mgs_add_common_pgpcert_vars()

Signed-off-by: Dash Shendy <neuromancer@…>

Files:
3 edited

Legend:

Unmodified
Added
Removed
  • include/mod_gnutls.h.in

    r8c03808 r3b4c0d0  
    1616 */
    1717
     18/* Apache Runtime Headers */
    1819#include "httpd.h"
    1920#include "http_config.h"
     
    2829#include "ap_release.h"
    2930#include "apr_fnmatch.h"
    30 
     31/* GnuTLS Library Headers */
    3132#include <gnutls/gnutls.h>
    3233#include <gnutls/extra.h>
     
    4142extern module AP_MODULE_DECLARE_DATA gnutls_module;
    4243
     44/* IO Filter names */
    4345#define GNUTLS_OUTPUT_FILTER_NAME "gnutls_output_filter"
    4446#define GNUTLS_INPUT_FILTER_NAME "gnutls_input_filter"
    45 
     47/* GnuTLS Constants */
    4648#define GNUTLS_ENABLED_FALSE 0
    4749#define GNUTLS_ENABLED_TRUE  1
    48 
    49 #define MOD_GNUTLS_VERSION "@MOD_GNUTLS_VERSION@"
    50 
    51 #define MOD_GNUTLS_DEBUG @OOO_MAINTAIN@
    52 
    53 /* Recent Versions of 2.1 renamed several hooks. This allows us to
    54    compile on 2.0.xx  */
     50/* Current module version */
     51#define MOD_GNUTLS_VERSION "0.5.10"
     52/* Module Debug Mode */
     53#define MOD_GNUTLS_DEBUG 1
     54
     55/*
     56 * Recent Versions of 2.1 renamed several hooks.
     57 * This allows us to compile on 2.0.xx 
     58 */
    5559#if AP_SERVER_MINORVERSION_NUMBER >= 2 || (AP_SERVER_MINORVERSION_NUMBER == 1 && AP_SERVER_PATCHLEVEL_NUMBER >= 3)
    56 #define USING_2_1_RECENT 1
     60        #define USING_2_1_RECENT 1
    5761#else
    58 #define USING_2_1_RECENT 0
     62        #define USING_2_1_RECENT 0
    5963#endif
    6064
    61 typedef enum
    62 {
     65/* mod_gnutls Cache Types */
     66typedef enum {
     67        /* No Cache */
    6368    mgs_cache_none,
     69        /* Use Old Berkley DB */
    6470    mgs_cache_dbm,
     71        /* Use Gnu's version of Berkley DB */
    6572    mgs_cache_gdbm,
    6673#if HAVE_APR_MEMCACHE
     74        /* Use Memcache */
    6775    mgs_cache_memcache
    6876#endif
    6977} mgs_cache_e;
    7078
    71 typedef struct
    72 {
     79/* Directory Configuration Record */
     80typedef struct {
    7381    int client_verify_mode;
    7482    const char* lua_bytecode;
     
    7785
    7886
    79 /* The maximum number of certificates to send in a chain
    80  */
     87/* The maximum number of certificates to send in a chain */
    8188#define MAX_CHAIN_SIZE 8
    82 
    83 typedef struct
    84 {
    85     gnutls_certificate_credentials_t certs;
     89/* The maximum number of SANs to read from a x509 certificate */
     90#define MAX_CERT_SAN 5
     91
     92/* Server Configuration Record */
     93typedef struct {
     94        /* x509 Certificate Structure */
     95    gnutls_certificate_credentials_t certs;
     96        /* SRP Certificate Structure*/
    8697    gnutls_srp_server_credentials_t srp_creds;
     98        /* Annonymous Certificate Structure */
    8799    gnutls_anon_server_credentials_t anon_creds;
     100        /* Current x509 Certificate CN [Common Name] */
    88101    char* cert_cn;
    89     gnutls_x509_crt_t certs_x509[MAX_CHAIN_SIZE]; /* A certificate chain */
    90     unsigned int certs_x509_num;
     102        /* Current x509 Certificate SAN [Subject Alternate Name]s*/
     103        char* cert_san[MAX_CERT_SAN];
     104        /* A x509 Certificate Chain */
     105    gnutls_x509_crt_t *certs_x509_chain;
     106        /* Current x509 Certificate Private Key */
    91107    gnutls_x509_privkey_t privkey_x509;
    92     gnutls_openpgp_crt_t cert_pgp; /* A certificate chain */
     108        /* OpenPGP Certificate */
     109    gnutls_openpgp_crt_t cert_pgp;
     110        /* OpenPGP Certificate Private Key */
    93111    gnutls_openpgp_privkey_t privkey_pgp;
     112        /* Number of Certificates in Chain */
     113    unsigned int certs_x509_chain_num;
     114        /* Is the module enabled? */
    94115    int enabled;
    95     /* whether to send the PEM encoded certificates
    96      * to CGIs
    97      */
    98     int export_certificates_enabled;
     116        /* GnuTLS Priorities */
    99117    gnutls_priority_t priorities;
     118        /* GnuTLS RSA Parameters [Obselete] */
    100119    gnutls_rsa_params_t rsa_params;
     120        /* GnuTLS DH Parameters */
    101121    gnutls_dh_params_t dh_params;
     122        /* Cache timeout value */
    102123    int cache_timeout;
     124        /* Chose Cache Type */
    103125    mgs_cache_e cache_type;
    104126    const char* cache_config;
    105127    const char* srp_tpasswd_file;
    106128    const char* srp_tpasswd_conf_file;
     129        /* A list of CA Certificates */
    107130    gnutls_x509_crt_t *ca_list;
     131        /* OpenPGP Key Ring */
    108132    gnutls_openpgp_keyring_t pgp_list;
     133        /* CA Certificate list size */
    109134    unsigned int ca_list_size;
     135        /* Client Certificate Verification Mode */
    110136    int client_verify_mode;
     137        /* Last Cache timestamp */
    111138    apr_time_t last_cache_check;
    112     int tickets; /* whether session tickets are allowed */
     139        /* GnuTLS uses Session Tickets */
     140    int tickets;
     141        /* Is mod_proxy enabled? */
    113142    int proxy_enabled;
     143        /* A Plain HTTP request */
    114144    int non_ssl_request;
    115145} mgs_srvconf_rec;
    116146
     147/* Character Buffer */
    117148typedef struct {
    118149    int length;
     
    120151} mgs_char_buffer_t;
    121152
    122 typedef struct
    123 {
     153/* GnuTLS Handle */
     154typedef struct {
     155        /* Server configuration record */
    124156    mgs_srvconf_rec *sc;
     157        /* Connection record */
    125158    conn_rec* c;
     159        /* GnuTLS Session handle */
    126160    gnutls_session_t session;
     161        /* module input status */
    127162    apr_status_t input_rc;
     163        /* Input filter */
    128164    ap_filter_t *input_filter;
     165        /* Input Bucket Brigade */
    129166    apr_bucket_brigade *input_bb;
     167        /* Input Read Type */
    130168    apr_read_type_e input_block;
     169        /* Input Mode */
    131170    ap_input_mode_t input_mode;
     171        /* Input Character Buffer */
    132172    mgs_char_buffer_t input_cbuf;
     173        /* Input Character Array */
    133174    char input_buffer[AP_IOBUFSIZE];
     175        /* module Output status */
    134176    apr_status_t output_rc;
     177        /* Output filter */
    135178    ap_filter_t *output_filter;
     179        /* Output Bucket Brigade */
    136180    apr_bucket_brigade *output_bb;
     181        /* Output character array */
    137182    char output_buffer[AP_IOBUFSIZE];
     183        /* Output buffer length */
    138184    apr_size_t output_blen;
     185        /* Output length */
    139186    apr_size_t output_length;
     187        /* General Status */
    140188    int status;
    141189} mgs_handle_t;
     190
     191
    142192
    143193/** Functions in gnutls_io.c **/
  • src/gnutls_config.c

    r8c03808 r3b4c0d0  
    9696}
    9797
    98 const char *mgs_set_rsa_export_file(cmd_parms * parms, void *dummy,
    99         const char *arg) {
     98const char *mgs_set_cert_file(cmd_parms * parms, void *dummy, const char *arg) {
     99
    100100    int ret;
    101101    gnutls_datum_t data;
    102102    const char *file;
    103103    apr_pool_t *spool;
    104     mgs_srvconf_rec *sc =
    105             (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    106             module_config,
    107             &gnutls_module);
    108 
     104
     105    mgs_srvconf_rec *sc = (mgs_srvconf_rec *) ap_get_module_config(parms->server->module_config, &gnutls_module);
    109106    apr_pool_create(&spool, parms->pool);
    110107
     
    112109
    113110    if (load_datum_from_file(spool, file, &data) != 0) {
    114         return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
    115                 "RSA params '%s'", file);
    116     }
    117 
    118     ret = gnutls_rsa_params_init(&sc->rsa_params);
    119     if (ret < 0) {
    120         return apr_psprintf(parms->pool,
    121                 "GnuTLS: Failed to initialize"
    122                 ": (%d) %s", ret,
    123                 gnutls_strerror(ret));
    124     }
    125 
    126     ret =
    127             gnutls_rsa_params_import_pkcs1(sc->rsa_params, &data,
    128             GNUTLS_X509_FMT_PEM);
    129     if (ret != 0) {
    130         return apr_psprintf(parms->pool,
    131                 "GnuTLS: Failed to Import "
    132                 "RSA params '%s': (%d) %s", file, ret,
    133                 gnutls_strerror(ret));
    134     }
    135 
    136     apr_pool_destroy(spool);
    137     return NULL;
    138 }
    139 
    140 const char *mgs_set_cert_file(cmd_parms * parms, void *dummy,
    141         const char *arg) {
     111                apr_pool_destroy(spool);
     112        return apr_psprintf(parms->pool, "GnuTLS: Error Reading Certificate '%s'", file);
     113    }
     114
     115    sc->certs_x509_chain_num = MAX_CHAIN_SIZE;
     116    ret = gnutls_x509_crt_list_import(sc->certs_x509_chain, &sc->certs_x509_chain_num, &data, GNUTLS_X509_FMT_PEM, 0);
     117    if (ret < 0) {
     118                apr_pool_destroy(spool);
     119        return apr_psprintf(parms->pool, "GnuTLS: Failed to Import Certificate '%s': (%d) %s", file, ret, gnutls_strerror(ret));
     120    }
     121   
     122        apr_pool_destroy(spool);
     123    return NULL;
     124
     125}
     126
     127const char *mgs_set_key_file(cmd_parms * parms, void *dummy, const char *arg) {
     128
    142129    int ret;
    143130    gnutls_datum_t data;
    144131    const char *file;
    145132    apr_pool_t *spool;
    146     mgs_srvconf_rec *sc =
    147             (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    148             module_config,
    149             &gnutls_module);
    150     apr_pool_create(&spool, parms->pool);
     133
     134        mgs_srvconf_rec *sc = (mgs_srvconf_rec *) ap_get_module_config(parms->server->module_config, &gnutls_module);
     135   
     136        apr_pool_create(&spool, parms->pool);
    151137
    152138    file = ap_server_root_relative(spool, arg);
    153139
    154140    if (load_datum_from_file(spool, file, &data) != 0) {
    155         return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
    156                 "Certificate '%s'", file);
    157     }
    158 
    159     sc->certs_x509_num = MAX_CHAIN_SIZE;
    160     ret =
    161             gnutls_x509_crt_list_import(sc->certs_x509,
    162             &sc->certs_x509_num, &data,
    163             GNUTLS_X509_FMT_PEM, 0);
    164     if (ret < 0) {
    165         return apr_psprintf(parms->pool,
    166                 "GnuTLS: Failed to Import "
    167                 "Certificate '%s': (%d) %s", file, ret,
    168                 gnutls_strerror(ret));
     141                apr_pool_destroy(spool);
     142        return apr_psprintf(parms->pool, "GnuTLS: Error Reading Private Key '%s'", file);
     143    }
     144
     145    ret = gnutls_x509_privkey_init(&sc->privkey_x509);
     146
     147    if (ret < 0) {
     148                apr_pool_destroy(spool);
     149        return apr_psprintf(parms->pool, "GnuTLS: Failed to initialize: (%d) %s", ret, gnutls_strerror(ret));
     150    }
     151
     152    ret = gnutls_x509_privkey_import(sc->privkey_x509, &data, GNUTLS_X509_FMT_PEM);
     153
     154    if (ret < 0) {
     155        ret = gnutls_x509_privkey_import_pkcs8(sc->privkey_x509, &data, GNUTLS_X509_FMT_PEM, NULL, GNUTLS_PKCS_PLAIN);
     156        }
     157
     158    if (ret < 0) {
     159                apr_pool_destroy(spool);
     160        return apr_psprintf(parms->pool, "GnuTLS: Failed to Import Private Key '%s': (%d) %s", file, ret, gnutls_strerror(ret));
    169161    }
    170162
    171163    apr_pool_destroy(spool);
    172     return NULL;
    173 }
    174 
    175 const char *mgs_set_key_file(cmd_parms * parms, void *dummy,
    176         const char *arg) {
    177     int ret;
    178     gnutls_datum_t data;
    179     const char *file;
    180     apr_pool_t *spool;
    181     mgs_srvconf_rec *sc =
    182             (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    183             module_config,
    184             &gnutls_module);
    185     apr_pool_create(&spool, parms->pool);
    186 
    187     file = ap_server_root_relative(spool, arg);
    188 
    189     if (load_datum_from_file(spool, file, &data) != 0) {
    190         return apr_psprintf(parms->pool, "GnuTLS: Error Reading "
    191                 "Private Key '%s'", file);
    192     }
    193 
    194     ret = gnutls_x509_privkey_init(&sc->privkey_x509);
    195     if (ret < 0) {
    196         return apr_psprintf(parms->pool,
    197                 "GnuTLS: Failed to initialize"
    198                 ": (%d) %s", ret,
    199                 gnutls_strerror(ret));
    200     }
    201 
    202     ret =
    203             gnutls_x509_privkey_import(sc->privkey_x509, &data,
    204             GNUTLS_X509_FMT_PEM);
    205 
    206     if (ret < 0)
    207         ret =
    208             gnutls_x509_privkey_import_pkcs8(sc->privkey_x509,
    209             &data,
    210             GNUTLS_X509_FMT_PEM,
    211             NULL,
    212             GNUTLS_PKCS_PLAIN);
    213 
    214     if (ret < 0) {
    215         return apr_psprintf(parms->pool,
    216                 "GnuTLS: Failed to Import "
    217                 "Private Key '%s': (%d) %s", file, ret,
    218                 gnutls_strerror(ret));
    219     }
    220     apr_pool_destroy(spool);
     164
    221165    return NULL;
    222166}
     
    579523}
    580524
    581 const char *mgs_set_export_certificates_enabled(cmd_parms * parms,
    582         void *dummy,
    583         const char *arg) {
    584     mgs_srvconf_rec *sc =
    585             (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    586             module_config,
    587             &gnutls_module);
    588     if (!strcasecmp(arg, "On")) {
    589         sc->export_certificates_enabled = GNUTLS_ENABLED_TRUE;
    590     } else if (!strcasecmp(arg, "Off")) {
    591         sc->export_certificates_enabled = GNUTLS_ENABLED_FALSE;
    592     } else {
    593         return
    594         "GnuTLSExportCertificates must be set to 'On' or 'Off'";
    595     }
    596 
    597     return NULL;
    598 }
    599 
    600 const char *mgs_set_priorities(cmd_parms * parms, void *dummy,
    601         const char *arg) {
    602     int ret;
     525const char *mgs_set_priorities(cmd_parms * parms, void *dummy, const char *arg) {
     526
     527        int ret;
    603528    const char *err;
    604     mgs_srvconf_rec *sc =
    605             (mgs_srvconf_rec *) ap_get_module_config(parms->server->
    606             module_config,
    607             &gnutls_module);
    608 
     529
     530    mgs_srvconf_rec *sc = (mgs_srvconf_rec *)
     531                                                  ap_get_module_config(parms->server->module_config, &gnutls_module);
    609532
    610533    ret = gnutls_priority_init(&sc->priorities, arg, &err);
    611     if (ret < 0) {
    612         if (ret == GNUTLS_E_INVALID_REQUEST)
    613             return apr_psprintf(parms->pool,
    614                 "GnuTLS: Syntax error parsing priorities string at: %s",
    615                 err);
     534
     535    if (ret < 0) {
     536        if (ret == GNUTLS_E_INVALID_REQUEST) {
     537            return apr_psprintf(parms->pool,
     538                                                                "GnuTLS: Syntax error parsing priorities string at: %s", err);
     539                }
    616540        return "Error setting priorities";
    617541    }
     
    652576
    653577    sc->privkey_x509 = NULL;
    654     memset(sc->certs_x509, 0, sizeof (sc->certs_x509));
    655     sc->certs_x509_num = 0;
     578        /* Initialize all Certificate Chains */
     579        sc->certs_x509_chain = malloc(MAX_CHAIN_SIZE * sizeof (*sc->certs_x509_chain));
     580    sc->certs_x509_chain_num = 0;
    656581    sc->cache_timeout = apr_time_from_sec(300);
    657582    sc->cache_type = mgs_cache_none;
    658583    sc->cache_config = ap_server_root_relative(p, "conf/gnutls_cache");
    659     sc->tickets = 1; /* by default enable session tickets */
     584        /* By default enable session tickets */
     585    sc->tickets = GNUTLS_ENABLED_TRUE;
    660586
    661587    sc->client_verify_mode = GNUTLS_CERT_IGNORE;
  • src/gnutls_hooks.c

    r8c03808 r3b4c0d0  
    3535static int mgs_cert_verify(request_rec * r, mgs_handle_t * ctxt);
    3636/* use side==0 for server and side==1 for client */
    37 static void mgs_add_common_cert_vars(request_rec * r,
    38         gnutls_x509_crt_t cert, int side,
    39         int export_certificates_enabled);
    40 static void mgs_add_common_pgpcert_vars(request_rec * r,
    41         gnutls_openpgp_crt_t cert,
    42         int side,
    43         int export_certificates_enabled);
    44 
     37static void mgs_add_common_cert_vars(request_rec * r, gnutls_x509_crt_t cert, int side);
     38static void mgs_add_common_pgpcert_vars(request_rec * r, gnutls_openpgp_crt_t cert, int side);
     39
     40/* Pool Cleanup Function */
    4541apr_status_t mgs_cleanup_pre_config(void *data) {
     42        /* Free all session data */
    4643    gnutls_free(session_ticket_key.data);
    4744    session_ticket_key.data = NULL;
    4845    session_ticket_key.size = 0;
     46        /* Deinitialize GnuTLS Library */
    4947    gnutls_global_deinit();
    5048    return APR_SUCCESS;
    5149}
    5250
     51/* Logging Function for Maintainers */
    5352#if MOD_GNUTLS_DEBUG
    5453static void gnutls_debug_log_all(int level, const char *str) {
     
    6059#endif
    6160
    62 int mgs_hook_pre_config(apr_pool_t * pconf, apr_pool_t * plog,
    63          apr_pool_t * ptemp) {
     61/* Pre-Configuration HOOK: Runs First */
     62int mgs_hook_pre_config(apr_pool_t * pconf, apr_pool_t * plog, apr_pool_t * ptemp) {
     63
     64/* Maintainer Logging */
    6465#if MOD_GNUTLS_DEBUG
    65     apr_file_open(&debug_log_fp, "/tmp/gnutls_debug",
    66             APR_APPEND | APR_WRITE | APR_CREATE, APR_OS_DEFAULT,
    67             pconf);
    68 
     66    apr_file_open(&debug_log_fp, "/tmp/gnutls_debug", APR_APPEND | APR_WRITE | APR_CREATE, APR_OS_DEFAULT, pconf);
    6967    _gnutls_log(debug_log_fp, "%s: %d\n", __func__, __LINE__);
    7068    gnutls_global_set_log_level(9);
     
    7270    _gnutls_log(debug_log_fp, "gnutls: %s\n", gnutls_check_version(NULL));
    7371#endif   
     72
    7473    int ret;
    75 
    76     if (gnutls_check_version(LIBGNUTLS_VERSION) == NULL) {
    77         _gnutls_log(debug_log_fp,
    78                 "gnutls_check_version() failed. Required: gnutls-%s Found: gnutls-%s\n",
    79                 LIBGNUTLS_VERSION, gnutls_check_version(NULL));
    80         return DECLINED;
    81     }
    82 
     74        const char * req_GnuTLSVer = "2.12.0";
     75
     76        /* Check for required GnuTLS Library Version */
     77    if (gnutls_check_version(req_GnuTLSVer) == NULL) {
     78                ap_log_perror(APLOG_MARK, APLOG_DEBUG, 0, plog, "gnutls_check_version() failed. Required: "
     79                                        "gnutls-%s Found: gnutls-%s\n", LIBGNUTLS_VERSION, gnutls_check_version(NULL));
     80                exit(-1);
     81    }
     82
     83        /* Initialize GnuTLS Library */
    8384    ret = gnutls_global_init();
    8485    if (ret < 0) {
    85         _gnutls_log(debug_log_fp, "gnutls_global_init: %s\n",
    86                 gnutls_strerror(ret));
    87         return DECLINED;
    88     }
    89 
     86                ap_log_perror(APLOG_MARK, APLOG_DEBUG, 0, plog, "gnutls_global_init: %s\n", gnutls_strerror(ret));
     87                exit(-1);
     88    }
     89
     90        /* Generate a Session Key */
    9091    ret = gnutls_session_ticket_key_generate(&session_ticket_key);
    9192    if (ret < 0) {
    92         _gnutls_log(debug_log_fp,
    93                 "gnutls_session_ticket_key_generate: %s\n",
    94                 gnutls_strerror(ret));
    95     }
    96 
    97     apr_pool_cleanup_register(pconf, NULL, mgs_cleanup_pre_config,
    98             apr_pool_cleanup_null);
    99 
     93                ap_log_perror(APLOG_MARK, APLOG_DEBUG, 0, plog, "gnutls_session_ticket_key_generate: %s\n", gnutls_strerror(ret));
     94                exit(-1);
     95    }
     96
     97        /* Register a pool clean-up function */
     98    apr_pool_cleanup_register(pconf, NULL, mgs_cleanup_pre_config, apr_pool_cleanup_null);\
    10099
    101100    return OK;
     
    103102
    104103static int mgs_select_virtual_server_cb(gnutls_session_t session) {
    105     mgs_handle_t *ctxt;
    106     mgs_srvconf_rec *tsc;
     104
     105    mgs_handle_t *ctxt = NULL;
     106    mgs_srvconf_rec *tsc = NULL;
    107107    int ret = 0;
    108108
     
    114114    tsc = mgs_find_sni_server(session);
    115115
    116     if (tsc != NULL)
     116    if (tsc == NULL) {
     117        // No TLS vhost configured!
     118                return GNUTLS_E_NO_CERTIFICATE_FOUND;
     119        } else {
     120        // Found a TLS vhost
    117121        ctxt->sc = tsc;
    118 
    119     gnutls_certificate_server_set_request(session,
    120             ctxt->
    121             sc->client_verify_mode);
    122 
    123     /* set the new server credentials
    124      */
    125 
    126     gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE,
    127             ctxt->sc->certs);
    128 
    129     gnutls_credentials_set(session, GNUTLS_CRD_ANON,
    130             ctxt->sc->anon_creds);
     122        }
     123
     124    gnutls_certificate_server_set_request(session, ctxt->sc->client_verify_mode);
     125
     126    /* Set Anon credentials */
     127    gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, ctxt->sc->certs);
     128        /* Set x509 credentials */
     129    gnutls_credentials_set(session, GNUTLS_CRD_ANON, ctxt->sc->anon_creds);
    131130
    132131#ifdef ENABLE_SRP
    133     if (ctxt->sc->srp_tpasswd_conf_file != NULL
    134             && ctxt->sc->srp_tpasswd_file != NULL) {
    135         gnutls_credentials_set(session, GNUTLS_CRD_SRP,
    136                 ctxt->sc->srp_creds);
     132        /* Set SRP credentials */
     133    if (ctxt->sc->srp_tpasswd_conf_file != NULL && ctxt->sc->srp_tpasswd_file != NULL) {
     134        gnutls_credentials_set(session, GNUTLS_CRD_SRP, ctxt->sc->srp_creds);
    137135    }
    138136#endif
     
    142140     * negotiation.
    143141     */
    144     ret = gnutls_priority_set(session, ctxt->sc->priorities);
     142
     143        ret = gnutls_priority_set_direct(session, "NORMAL", NULL);
     144    //ret = gnutls_priority_set(session, ctxt->sc->priorities);
    145145    /* actually it shouldn't fail since we have checked at startup */
    146146    return ret;
    147 }
    148 
    149 static int cert_retrieve_fn(gnutls_session_t session,
    150         const gnutls_datum_t * req_ca_rdn, int nreqs,
    151         const gnutls_pk_algorithm_t * pk_algos, int pk_algos_length,
    152         gnutls_retr2_st *ret) {
     147
     148}
     149
     150static int cert_retrieve_fn(gnutls_session_t session,
     151                                                        const gnutls_datum_t * req_ca_rdn, int nreqs,
     152                                                        const gnutls_pk_algorithm_t * pk_algos, int pk_algos_length,
     153                                                        gnutls_retr2_st *ret) {
    153154   
    154     mgs_handle_t *ctxt;
    155 
    156     _gnutls_log(debug_log_fp, "%s: %d\n", __func__, __LINE__);
    157     ctxt = gnutls_transport_get_ptr(session);
    158 
    159     if (ctxt == NULL)
    160         return GNUTLS_E_INTERNAL_ERROR;
    161 
    162     if (gnutls_certificate_type_get(session) == GNUTLS_CRT_X509) {
    163         ret->cert_type = GNUTLS_CRT_X509;
    164         ret->key_type = GNUTLS_PRIVKEY_X509;
    165         ret->ncerts = ctxt->sc->certs_x509_num;
     155   
     156        _gnutls_log(debug_log_fp, "%s: %d\n", __func__, __LINE__);
     157
     158        mgs_handle_t *ctxt = gnutls_transport_get_ptr(session);
     159
     160    if (session == NULL) {
     161                // ERROR INVALID SESSION
     162                ret->ncerts = 0;
     163                ret->deinit_all = 1;
     164        return -1;
     165        } else if (gnutls_certificate_type_get(session) == GNUTLS_CRT_X509) {
     166                // X509 CERTIFICATE
     167                ret->cert_type = GNUTLS_CRT_X509;
     168                ret->key_type = GNUTLS_PRIVKEY_X509;
     169        ret->ncerts = ctxt->sc->certs_x509_chain_num;
    166170        ret->deinit_all = 0;
    167 
    168         ret->cert.x509 = ctxt->sc->certs_x509;
     171        ret->cert.x509 = ctxt->sc->certs_x509_chain;
    169172        ret->key.x509 = ctxt->sc->privkey_x509;
    170 
    171173        return 0;
    172174    } else if (gnutls_certificate_type_get(session) == GNUTLS_CRT_OPENPGP) {
    173         ret->cert_type = GNUTLS_CRT_OPENPGP;
    174         ret->key_type = GNUTLS_PRIVKEY_OPENPGP;       
     175                // OPENPGP CERTIFICATE
     176                ret->cert_type = GNUTLS_CRT_OPENPGP;
     177                ret->key_type = GNUTLS_PRIVKEY_OPENPGP;       
    175178        ret->ncerts = 1;
    176179        ret->deinit_all = 0;
    177 
    178180        ret->cert.pgp = ctxt->sc->cert_pgp;
    179181        ret->key.pgp = ctxt->sc->privkey_pgp;
    180 
    181182        return 0;
    182 
    183     }
    184 
    185     return GNUTLS_E_INTERNAL_ERROR;
     183    } else {
     184                // UNKNOWN CERTIFICATE
     185                ret->ncerts = 0;
     186                ret->deinit_all = 1;
     187            return -1;
     188        }
    186189}
    187190
     
    201204 * Returns negative on error.
    202205 */
    203 static int read_crt_cn(server_rec * s, apr_pool_t * p,
    204         gnutls_x509_crt_t cert, char **cert_cn) {
     206static int read_crt_cn(server_rec * s, apr_pool_t * p, gnutls_x509_crt_t cert, char **cert_cn) {
     207
    205208    int rv = 0, i;
    206209    size_t data_len;
     
    211214
    212215    data_len = 0;
    213     rv = gnutls_x509_crt_get_dn_by_oid(cert,
    214             GNUTLS_OID_X520_COMMON_NAME,
    215             0, 0, NULL, &data_len);
     216    rv = gnutls_x509_crt_get_dn_by_oid(cert, GNUTLS_OID_X520_COMMON_NAME, 0, 0, NULL, &data_len);
    216217
    217218    if (rv == GNUTLS_E_SHORT_MEMORY_BUFFER && data_len > 1) {
     
    279280}
    280281
    281 int
    282 mgs_hook_post_config(apr_pool_t * p, apr_pool_t * plog,
    283         apr_pool_t * ptemp, server_rec * base_server) {
     282int mgs_hook_post_config(apr_pool_t * p, apr_pool_t * plog, apr_pool_t * ptemp, server_rec * base_server) {
     283
    284284    int rv;
    285285    server_rec *s;
     
    292292
    293293    _gnutls_log(debug_log_fp, "%s: %d\n", __func__, __LINE__);
    294     apr_pool_userdata_get(&data, userdata_key,
    295             base_server->process->pool);
     294
     295    apr_pool_userdata_get(&data, userdata_key, base_server->process->pool);
    296296    if (data == NULL) {
    297297        first_run = 1;
    298         apr_pool_userdata_set((const void *) 1, userdata_key,
    299                 apr_pool_cleanup_null,
    300                 base_server->process->pool);
     298        apr_pool_userdata_set((const void *) 1, userdata_key, apr_pool_cleanup_null, base_server->process->pool);
    301299    }
    302300
    303301
    304302    s = base_server;
    305     sc_base =
    306             (mgs_srvconf_rec *) ap_get_module_config(s->module_config,
    307             &gnutls_module);
     303    sc_base = (mgs_srvconf_rec *) ap_get_module_config(s->module_config, &gnutls_module);
    308304
    309305    gnutls_dh_params_init(&dh_params);
     
    314310            sizeof(static_dh_params)
    315311        };
    316         rv = gnutls_dh_params_import_pkcs3(dh_params, &pdata,
    317                 GNUTLS_X509_FMT_PEM);       
     312        rv = gnutls_dh_params_import_pkcs3(dh_params, &pdata, GNUTLS_X509_FMT_PEM);       
    318313        /* Generate DH Params
    319314        int dh_bits = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH,
     
    348343
    349344    for (s = base_server; s; s = s->next) {
    350         sc = (mgs_srvconf_rec *)
    351                 ap_get_module_config(s->module_config, &gnutls_module);
     345        sc = (mgs_srvconf_rec *) ap_get_module_config(s->module_config, &gnutls_module);
    352346        sc->cache_type = sc_base->cache_type;
    353347        sc->cache_config = sc_base->cache_config;
     
    361355        }
    362356
    363         /* Check if DH or RSA params have been set per host */
    364         if (sc->rsa_params != NULL) {
    365             gnutls_certificate_set_rsa_export_params(sc->certs, sc->rsa_params);       
    366         }
    367         /* else not an error but RSA-EXPORT ciphersuites are not available */
    368 
     357        /* Check if DH params have been set per host */
    369358        if (sc->dh_params != NULL) {
    370359            gnutls_certificate_set_dh_params(sc->certs, sc->dh_params);
     
    395384#endif
    396385
    397         if (sc->certs_x509[0] == NULL &&
    398                 sc->cert_pgp == NULL &&
    399                 sc->enabled == GNUTLS_ENABLED_TRUE) {
    400             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    401                     "[GnuTLS] - Host '%s:%d' is missing a "
    402                     "Certificate File!",
    403                     s->server_hostname, s->port);
     386        if (sc->certs_x509_chain == NULL && sc->cert_pgp == NULL && sc->enabled == GNUTLS_ENABLED_TRUE) {
     387                        ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     388                                                "[GnuTLS] - Host '%s:%d' is missing a Certificate File!",
     389                                                s->server_hostname, s->port);
    404390            exit(-1);
    405391        }
    406392
    407         if (sc->enabled == GNUTLS_ENABLED_TRUE &&
    408                 ((sc->certs_x509[0] != NULL
    409                 && sc->privkey_x509 == NULL) || (sc->cert_pgp != NULL
    410                 && sc->privkey_pgp
    411                 == NULL))) {
    412             ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
    413                     "[GnuTLS] - Host '%s:%d' is missing a "
    414                     "Private Key File!",
    415                     s->server_hostname, s->port);
     393        if (sc->enabled == GNUTLS_ENABLED_TRUE && ((sc->certs_x509_chain != NULL && sc->privkey_x509 == NULL) || (sc->cert_pgp != NULL && sc->privkey_pgp == NULL))) {
     394                        ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     395                                                "[GnuTLS] - Host '%s:%d' is missing a Private Key File!",
     396                                                s->server_hostname, s->port);
    416397            exit(-1);
    417398        }
    418399
    419400        if (sc->enabled == GNUTLS_ENABLED_TRUE) {
    420             rv = read_crt_cn(s, p, sc->certs_x509[0],
    421                     &sc->cert_cn);
    422             if (rv < 0 && sc->cert_pgp != NULL) /* try openpgp certificate */
    423                 rv = read_pgpcrt_cn(s, p, sc->cert_pgp,
    424                     &sc->cert_cn);
     401            rv = read_crt_cn(s, p, sc->certs_x509_chain[sc->certs_x509_chain_num-1], &sc->cert_cn);
     402            if (rv < 0 && sc->cert_pgp != NULL) {
     403                rv = read_pgpcrt_cn(s, p, sc->cert_pgp, &sc->cert_cn);
     404                        }
    425405
    426406            if (rv < 0) {
    427                 ap_log_error(APLOG_MARK, APLOG_STARTUP, 0,
    428                         s,
    429                         "[GnuTLS] - Cannot find a certificate for host '%s:%d'!",
    430                         s->server_hostname, s->port);
     407                ap_log_error(APLOG_MARK, APLOG_STARTUP, 0, s,
     408                                                        "[GnuTLS] - Cannot find a certificate for host '%s:%d'!",
     409                                                        s->server_hostname, s->port);
    431410                sc->cert_cn = NULL;
    432411                continue;
     
    569548        return 0;
    570549    }
     550   
     551        int ret = gnutls_x509_crt_check_hostname(tsc->certs_x509_chain[tsc->certs_x509_chain_num-1], s->server_hostname);
    571552   
    572     return check_server_aliases(x, s, tsc);
     553        return check_server_aliases(x, s, tsc);
    573554}
    574555#endif
     
    662643
    663644    /* Set Default Priority */
    664     gnutls_set_default_priority(ctxt->session);
     645        gnutls_priority_set_direct (ctxt->session, "NORMAL", NULL);
    665646    /* Set Handshake function */
    666647    gnutls_handshake_set_post_client_hello_function(ctxt->session,
     
    771752    apr_table_setn(env, "SSL_SESSION_ID", apr_pstrdup(r->pool, tmp));
    772753
    773     if (gnutls_certificate_type_get(ctxt->session) == GNUTLS_CRT_X509)
    774         mgs_add_common_cert_vars(r, ctxt->sc->certs_x509[0], 0,
    775             ctxt->
    776             sc->export_certificates_enabled);
    777     else if (gnutls_certificate_type_get(ctxt->session) ==
    778             GNUTLS_CRT_OPENPGP)
    779         mgs_add_common_pgpcert_vars(r, ctxt->sc->cert_pgp, 0,
    780             ctxt->sc->export_certificates_enabled);
     754    if (gnutls_certificate_type_get(ctxt->session) == GNUTLS_CRT_X509) {
     755                mgs_add_common_cert_vars(r, ctxt->sc->certs_x509_chain[ctxt->sc->certs_x509_chain_num], 0);
     756        } else if (gnutls_certificate_type_get(ctxt->session) == GNUTLS_CRT_OPENPGP) {
     757        mgs_add_common_pgpcert_vars(r, ctxt->sc->cert_pgp, 0);
     758        }
    781759
    782760    return rv;
     
    853831#define MGS_SIDE ((side==0)?"SSL_SERVER":"SSL_CLIENT")
    854832
    855 static void
    856 mgs_add_common_cert_vars(request_rec * r, gnutls_x509_crt_t cert, int side,
    857         int export_certificates_enabled) {
     833static void mgs_add_common_cert_vars(request_rec * r, gnutls_x509_crt_t cert, int side) {
    858834    unsigned char sbuf[64]; /* buffer to hold serials */
    859835    char buf[AP_IOBUFSIZE];
     
    869845
    870846    _gnutls_log(debug_log_fp, "%s: %d\n", __func__, __LINE__);
    871     if (export_certificates_enabled != 0) {
    872         char cert_buf[10 * 1024];
    873         len = sizeof (cert_buf);
    874 
    875         if (gnutls_x509_crt_export
    876                 (cert, GNUTLS_X509_FMT_PEM, cert_buf, &len) >= 0)
    877             apr_table_setn(env,
    878                 apr_pstrcat(r->pool, MGS_SIDE,
    879                 "_CERT", NULL),
    880                 apr_pstrmemdup(r->pool, cert_buf,
    881                 len));
    882 
    883     }
    884847
    885848    len = sizeof (buf);
     
    992955}
    993956
    994 static void
    995 mgs_add_common_pgpcert_vars(request_rec * r, gnutls_openpgp_crt_t cert,
    996         int side, int export_certificates_enabled) {
    997     unsigned char sbuf[64]; /* buffer to hold serials */
     957static void mgs_add_common_pgpcert_vars(request_rec * r, gnutls_openpgp_crt_t cert, int side) {
     958
     959        unsigned char sbuf[64]; /* buffer to hold serials */
    998960    char buf[AP_IOBUFSIZE];
    999961    const char *tmp;
     
    1006968    _gnutls_log(debug_log_fp, "%s: %d\n", __func__, __LINE__);
    1007969    apr_table_t *env = r->subprocess_env;
    1008 
    1009     if (export_certificates_enabled != 0) {
    1010         char cert_buf[10 * 1024];
    1011         len = sizeof (cert_buf);
    1012 
    1013         if (gnutls_openpgp_crt_export
    1014                 (cert, GNUTLS_OPENPGP_FMT_BASE64, cert_buf, &len) >= 0)
    1015             apr_table_setn(env,
    1016                 apr_pstrcat(r->pool, MGS_SIDE,
    1017                 "_CERT", NULL),
    1018                 apr_pstrmemdup(r->pool, cert_buf,
    1019                 len));
    1020 
    1021     }
    1022970
    1023971    len = sizeof (buf);
     
    12211169
    12221170    if (gnutls_certificate_type_get(ctxt->session) == GNUTLS_CRT_X509)
    1223         mgs_add_common_cert_vars(r, cert.x509[0], 1,
    1224             ctxt->
    1225             sc->export_certificates_enabled);
     1171        mgs_add_common_cert_vars(r, cert.x509[0], 1);
    12261172    else if (gnutls_certificate_type_get(ctxt->session) ==
    12271173            GNUTLS_CRT_OPENPGP)
    1228         mgs_add_common_pgpcert_vars(r, cert.pgp, 1,
    1229             ctxt->
    1230             sc->export_certificates_enabled);
     1174        mgs_add_common_pgpcert_vars(r, cert.pgp, 1);
    12311175
    12321176    {
Note: See TracChangeset for help on using the changeset viewer.