#include <net-snmp/net-snmp-config.h>

#include <net-snmp/net-snmp-features.h>

#include <net-snmp/types.h>

netsnmp_feature_require(cert_util)

#if HAVE_DMALLOC_H

#include <dmalloc.h>

#endif

#if HAVE_STRING_H

#include <string.h>

#else

#include <strings.h>

#endif

#if HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#if HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#if HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

#if HAVE_NETDB_H

#include <netdb.h>

#endif

#include <errno.h>

#include <ctype.h>

/* OpenSSL Includes */

#include <openssl/bio.h>

#include <openssl/ssl.h>

#include <openssl/err.h>

#include <openssl/x509.h>

#include <openssl/x509_vfy.h>

#include <openssl/x509v3.h>

#include <net-snmp/config_api.h>

#include <net-snmp/library/container.h>

#include <net-snmp/library/cert_util.h>

#include <net-snmp/library/snmp_openssl.h>

#include <net-snmp/library/default_store.h>

#include <net-snmp/library/callback.h>

#include <net-snmp/library/snmp_logging.h>

#include <net-snmp/library/snmp_api.h>

#include <net-snmp/library/tools.h>

#include <net-snmp/library/snmp_debug.h>

#include <net-snmp/library/snmp_assert.h>

#include <net-snmp/library/snmp_transport.h>

#include <net-snmp/library/snmp_secmod.h>

#include <net-snmp/library/read_config.h>

#include <net-snmp/library/system.h>

#include <net-snmp/library/snmpTLSBaseDomain.h>

#define LOGANDDIE(msg) do { snmp_log(LOG_ERR, "%s\n", msg); return 0; } while(0)

int openssl_local_index;

/* this is called during negotiation */

int verify_callback(int ok, X509_STORE_CTX *ctx) {

    int err, depth;

    char buf[1024], *fingerprint;

    X509 *thecert;

    netsnmp_cert *cert;

    _netsnmp_verify_info *verify_info;

    SSL *ssl;

    thecert = X509_STORE_CTX_get_current_cert(ctx);

    err = X509_STORE_CTX_get_error(ctx);

    depth = X509_STORE_CTX_get_error_depth(ctx);

    /* things to do: */

    X509_NAME_oneline(X509_get_subject_name(thecert), buf, sizeof(buf));

    fingerprint = netsnmp_openssl_cert_get_fingerprint(thecert, -1);

    DEBUGMSGTL(("tls_x509:verify", "Cert: %s\n", buf));

    DEBUGMSGTL(("tls_x509:verify", "  fp: %s\n", fingerprint ?

                fingerprint : "unknown"));

    ssl = X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());

    verify_info = SSL_get_ex_data(ssl, openssl_local_index);

    if (verify_info && ok && depth > 0) {

        /* remember that a parent certificate has been marked as trusted */

        verify_info->flags |= VRFY_PARENT_WAS_OK;

    }

    /* this ensures for self-signed certificates we have a valid

       locally known fingerprint and then accept it */

    if (!ok &&

        (X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT == err ||

         X509_V_ERR_CERT_UNTRUSTED == err ||

         X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE == err ||

         X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN == err)) {

        cert = netsnmp_cert_find(NS_CERT_REMOTE_PEER, NS_CERTKEY_FINGERPRINT,

                                 (void*)fingerprint);

        if (cert)

            DEBUGMSGTL(("tls_x509:verify", " Found locally: %s/%s\n",

                        cert->info.dir, cert->info.filename));

        if (cert) {

            DEBUGMSGTL(("tls_x509:verify", "verify_callback called with: ok=%d ctx=%p depth=%d err=%i:%s\n", ok, ctx, depth, err, X509_verify_cert_error_string(err)));

            DEBUGMSGTL(("tls_x509:verify", "  accepting matching fp of self-signed certificate found in: %s\n",

                        cert->info.filename));

            SNMP_FREE(fingerprint);

            return 1;

        } else {

            DEBUGMSGTL(("tls_x509:verify", "  no matching fp found\n"));

            /* log where we are and why called */

            snmp_log(LOG_ERR, "tls verification failure: ok=%d ctx=%p depth=%d err=%i:%s\n", ok, ctx, depth, err, X509_verify_cert_error_string(err));

            SNMP_FREE(fingerprint);

            return 0;

        }

#if 0

        /*

         * This code is unreachable because of the return statements above.

         * Comment it out to avoid that Coverity complains about this code.

         */

        if (0 == depth && verify_info &&

            (verify_info->flags & VRFY_PARENT_WAS_OK)) {

            DEBUGMSGTL(("tls_x509:verify", "verify_callback called with: ok=%d ctx=%p depth=%d err=%i:%s\n", ok, ctx, depth, err, X509_verify_cert_error_string(err)));

            DEBUGMSGTL(("tls_x509:verify", "  a parent was ok, so returning ok for this child certificate\n"));

            SNMP_FREE(fingerprint);

            return 1; /* we'll check the hostname later at this level */

        }

#endif

    }

    if (0 == ok)

        snmp_log(LOG_ERR, "tls verification failure: ok=%d ctx=%p depth=%d err=%i:%s\n", ok, ctx, depth, err, X509_verify_cert_error_string(err));

    else

        DEBUGMSGTL(("tls_x509:verify", "verify_callback called with: ok=%d ctx=%p depth=%d err=%i:%s\n", ok, ctx, depth, err, X509_verify_cert_error_string(err)));

    DEBUGMSGTL(("tls_x509:verify", "  returning the passed in value of %d\n",

                ok));

    SNMP_FREE(fingerprint);

    return(ok);

}

#define VERIFIED_FINGERPRINT      0

#define NO_FINGERPRINT_AVAILABLE  1

#define FAILED_FINGERPRINT_VERIFY 2

static int

_netsnmp_tlsbase_verify_remote_fingerprint(X509 *remote_cert,

                                           _netsnmpTLSBaseData *tlsdata,

                                           int try_default) {

    char            *fingerprint;

    fingerprint =

        netsnmp_openssl_cert_get_fingerprint(remote_cert, -1);

    if (!fingerprint) {

        /* no peer cert */

        snmp_log(LOG_ERR, "failed to get fingerprint of remote certificate\n");

        return FAILED_FINGERPRINT_VERIFY;

    }

    if (!tlsdata->their_fingerprint && tlsdata->their_identity) {

        /* we have an identity; try and find it's fingerprint */

        netsnmp_cert *peer_cert;

        peer_cert =

            netsnmp_cert_find(NS_CERT_REMOTE_PEER, NS_CERTKEY_MULTIPLE,

                              tlsdata->their_identity);

        if (peer_cert)

            tlsdata->their_fingerprint =

                netsnmp_openssl_cert_get_fingerprint(peer_cert->ocert, -1);

    }

    if (!tlsdata->their_fingerprint && try_default) {

        /* try for the default instead */

        netsnmp_cert *peer_cert;

        peer_cert =

            netsnmp_cert_find(NS_CERT_REMOTE_PEER, NS_CERTKEY_DEFAULT,

                              NULL);

        if (peer_cert)

            tlsdata->their_fingerprint =

                netsnmp_openssl_cert_get_fingerprint(peer_cert->ocert, -1);

    }

    if (tlsdata->their_fingerprint) {

        netsnmp_fp_lowercase_and_strip_colon(tlsdata->their_fingerprint);

        if (0 != strcmp(tlsdata->their_fingerprint, fingerprint)) {

            snmp_log(LOG_ERR, "The fingerprint from the remote side's certificate didn't match the expected\n");

            snmp_log(LOG_ERR, "  got %s, expected %s\n",

                     fingerprint, tlsdata->their_fingerprint);

            free(fingerprint);

            return FAILED_FINGERPRINT_VERIFY;

        }

    } else {

        DEBUGMSGTL(("tls_x509:verify", "No fingerprint for the remote entity available to verify\n"));

        free(fingerprint);

        return NO_FINGERPRINT_AVAILABLE;

    }

    free(fingerprint);

    return VERIFIED_FINGERPRINT;

}

/* this is called after the connection on the client side by us to check

   other aspects about the connection */

int

netsnmp_tlsbase_verify_server_cert(SSL *ssl, _netsnmpTLSBaseData *tlsdata) {

    /* XXX */

    X509            *remote_cert;

    char            *check_name;

    int              ret;

    netsnmp_assert_or_return(ssl != NULL, SNMPERR_GENERR);

    netsnmp_assert_or_return(tlsdata != NULL, SNMPERR_GENERR);

    if (NULL == (remote_cert = SSL_get_peer_certificate(ssl))) {

        /* no peer cert */

        DEBUGMSGTL(("tls_x509:verify",

                    "remote connection provided no certificate (yet)\n"));

        return SNMPERR_TLS_NO_CERTIFICATE;

    }

    /* make sure that the fingerprint matches */

    ret = _netsnmp_tlsbase_verify_remote_fingerprint(remote_cert, tlsdata, 1);

    switch(ret) {

    case VERIFIED_FINGERPRINT:

        return SNMPERR_SUCCESS;

    case FAILED_FINGERPRINT_VERIFY:

        return SNMPERR_GENERR;

    case NO_FINGERPRINT_AVAILABLE:

        if (tlsdata->their_hostname && tlsdata->their_hostname[0] != '\0') {

            GENERAL_NAMES      *onames;

            const GENERAL_NAME *oname = NULL;

            int                 i, j;

            int                 count;

            char                buf[SPRINT_MAX_LEN];

            int                 is_wildcarded = 0;

            char               *compare_to;

            /* see if the requested hostname has a wildcard prefix */

            if (strncmp(tlsdata->their_hostname, "*.", 2) == 0) {

                is_wildcarded = 1;

                compare_to = tlsdata->their_hostname + 2;

            } else {

                compare_to = tlsdata->their_hostname;

            }

            /* if the hostname we were expecting to talk to matches

               the cert, then we can accept this connection. */

            /* check against the DNS subjectAltName */

            onames = (GENERAL_NAMES *)X509_get_ext_d2i(remote_cert,

                                                       NID_subject_alt_name,

                                                       NULL, NULL );

            if (NULL != onames) {

                count = sk_GENERAL_NAME_num(onames);

                for (i=0 ; i 

                    oname = sk_GENERAL_NAME_value(onames, i);

                    if (GEN_DNS == oname->type) {

                        /* get the value */

                        ASN1_STRING_to_UTF8((unsigned char**)&check_name,

                                            oname->d.ia5);

                        /* convert to lowercase for comparisons */

                        for (j = 0 ;

                             *check_name && j < sizeof(buf)-1;

                             ++check_name, ++j ) {

                            if (isascii(*check_name))

                                buf[j] = tolower(0xFF & *check_name);

                        }

                        if (j < sizeof(buf))

                            buf[j] = '\0';

                        check_name = buf;

                        if (is_wildcarded) {

                            /* we *only* allow passing till the first '.' */

                            /* ie *.example.com can't match a.b.example.com */

                            check_name = strchr(check_name, '.') + 1;

                        }

                        DEBUGMSGTL(("tls_x509:verify", "checking subjectAltname of dns:%s\n", check_name));

                        if (strcmp(compare_to, check_name) == 0) {

                            DEBUGMSGTL(("tls_x509:verify", "Successful match on a subjectAltname of dns:%s\n", check_name));

                            return SNMPERR_SUCCESS;

                        }

                    }

                }

            }

            /* check the common name for a match */

            check_name =

                netsnmp_openssl_cert_get_commonName(remote_cert, NULL, NULL);

            if (is_wildcarded) {

                /* we *only* allow passing till the first '.' */

                /* ie *.example.com can't match a.b.example.com */

                if (check_name)

                    check_name = strchr(check_name, '.');

                if (check_name)

                    check_name++;

            }

            if (check_name && strcmp(compare_to, check_name) == 0) {

                DEBUGMSGTL(("tls_x509:verify", "Successful match on a common name of %s\n", check_name));

                return SNMPERR_SUCCESS;

            }

            snmp_log(LOG_ERR, "No matching names in the certificate to match the expected %s\n", tlsdata->their_hostname);

            return SNMPERR_GENERR;

        }

        /* XXX: check for hostname match instead */

        snmp_log(LOG_ERR, "Can not verify a remote server identity without configuration\n");

        return SNMPERR_GENERR;

    }

    DEBUGMSGTL(("tls_x509:verify", "shouldn't get here\n"));

    return SNMPERR_GENERR;

}

/* this is called after the connection on the server side by us to check

   the validity of the client's certificate */

int

netsnmp_tlsbase_verify_client_cert(SSL *ssl, _netsnmpTLSBaseData *tlsdata) {

    /* XXX */

    X509            *remote_cert;

    int ret;

    /* RFC5953: section 5.3.2, paragraph 1:

       A (D)TLS server should accept new session connections from any client

       that it is able to verify the client's credentials for.  This is done

       by authenticating the client's presented certificate through a

       certificate path validation process (e.g.  [RFC5280]) or through

       certificate fingerprint verification using fingerprints configured in

       the snmpTlstmCertToTSNTable.  Afterward the server will determine the

       identity of the remote entity using the following procedures.

    */

    /* Implementation notes:

       + path validation is taken care of during the openssl verify

         routines, our part of which is hanlded in verify_callback

         above.

       + fingerprint verification happens below.

    */

    if (NULL == (remote_cert = SSL_get_peer_certificate(ssl))) {

        /* no peer cert */

        DEBUGMSGTL(("tls_x509:verify",

                    "remote connection provided no certificate (yet)\n"));

        return SNMPERR_TLS_NO_CERTIFICATE;

    }

    /* we don't force a known remote fingerprint for a client since we

       will accept any certificate we know about (and later derive the

       securityName from it and apply access control) */

    ret = _netsnmp_tlsbase_verify_remote_fingerprint(remote_cert, tlsdata, 0);

    switch(ret) {

    case FAILED_FINGERPRINT_VERIFY:

        DEBUGMSGTL(("tls_x509:verify", "failed to verify a client fingerprint\n"));

        return SNMPERR_GENERR;

    case NO_FINGERPRINT_AVAILABLE:

        DEBUGMSGTL(("tls_x509:verify", "no known fingerprint available (not a failure case)\n"));

        return SNMPERR_SUCCESS;

    case VERIFIED_FINGERPRINT:

        DEBUGMSGTL(("tls_x509:verify", "Verified client fingerprint\n"));

        tlsdata->flags |= NETSNMP_TLSBASE_CERT_FP_VERIFIED;

        return SNMPERR_SUCCESS;

    }

    DEBUGMSGTL(("tls_x509:verify", "shouldn't get here\n"));

    return SNMPERR_GENERR;

}

/* this is called after the connection on the server side by us to

   check other aspects about the connection and obtain the

   securityName from the remote certificate. */

int

netsnmp_tlsbase_extract_security_name(SSL *ssl, _netsnmpTLSBaseData *tlsdata) {

    netsnmp_container  *chain_maps;

    netsnmp_cert_map   *cert_map, *peer_cert;

    netsnmp_iterator  *itr;

    int                 rc;

    netsnmp_assert_or_return(ssl != NULL, SNMPERR_GENERR);

    netsnmp_assert_or_return(tlsdata != NULL, SNMPERR_GENERR);

    if (NULL == (chain_maps = netsnmp_openssl_get_cert_chain(ssl)))

        return SNMPERR_GENERR;

    /*

     * map fingerprints to mapping entries

     */

    rc = netsnmp_cert_get_secname_maps(chain_maps);

    if ((-1 == rc) || (CONTAINER_SIZE(chain_maps) == 0)) {

        netsnmp_cert_map_container_free(chain_maps);

        return SNMPERR_GENERR;

    }

    /*

     * change container to sorted (by clearing unsorted option), then

     * iterate over it until we find a map that returns a secname.

     */

    CONTAINER_SET_OPTIONS(chain_maps, 0, rc);

    itr = CONTAINER_ITERATOR(chain_maps);

    if (NULL == itr) {

        snmp_log(LOG_ERR, "could not get iterator for secname fingerprints\n");

        netsnmp_cert_map_container_free(chain_maps);

        return SNMPERR_GENERR;

    }

    peer_cert = cert_map = ITERATOR_FIRST(itr);

    for( ; !tlsdata->securityName && cert_map; cert_map = ITERATOR_NEXT(itr))

        tlsdata->securityName =

            netsnmp_openssl_extract_secname(cert_map, peer_cert);

    ITERATOR_RELEASE(itr);

    netsnmp_cert_map_container_free(chain_maps);

    return (tlsdata->securityName ? SNMPERR_SUCCESS : SNMPERR_GENERR);

}

int

_trust_this_cert(SSL_CTX *the_ctx, char *certspec) {

    netsnmp_cert *trustcert;

    DEBUGMSGTL(("sslctx_client", "Trying to load a trusted certificate: %s\n",

                certspec));

    /* load this identifier into the trust chain */

    trustcert = netsnmp_cert_find(NS_CERT_CA,

                                  NS_CERTKEY_MULTIPLE,

                                  certspec);

    if (!trustcert)

        trustcert = netsnmp_cert_find(NS_CERT_REMOTE_PEER,

                                      NS_CERTKEY_MULTIPLE,

                                      certspec);

    if (!trustcert)

        LOGANDDIE("failed to find requested certificate to trust");

    /* Add the certificate to the context */

    if (netsnmp_cert_trust_ca(the_ctx, trustcert) != SNMPERR_SUCCESS)

        LOGANDDIE("failed to load trust certificate");

    return 1;

}

void

_load_trusted_certs(SSL_CTX *the_ctx) {

    netsnmp_container *trusted_certs = NULL;

    netsnmp_iterator  *trusted_cert_iterator = NULL;

    char *fingerprint;

    trusted_certs = netsnmp_cert_get_trustlist();

    trusted_cert_iterator = CONTAINER_ITERATOR(trusted_certs);

    if (trusted_cert_iterator) {

        for (fingerprint = (char *) ITERATOR_FIRST(trusted_cert_iterator);

             fingerprint; fingerprint = ITERATOR_NEXT(trusted_cert_iterator)) {

            if (!_trust_this_cert(the_ctx, fingerprint))

                snmp_log(LOG_ERR, "failed to load trust cert: %s\n",

                         fingerprint);

        }

        ITERATOR_RELEASE(trusted_cert_iterator);

    }

}    

SSL_CTX *

_sslctx_common_setup(SSL_CTX *the_ctx, _netsnmpTLSBaseData *tlsbase) {

    char         *crlFile;

    char         *cipherList;

    X509_LOOKUP  *lookup;

    X509_STORE   *cert_store = NULL;

    _load_trusted_certs(the_ctx);

    /* add in the CRLs if available */

    crlFile = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,

                                    NETSNMP_DS_LIB_X509_CRL_FILE);

    if (NULL != crlFile) {

        cert_store = SSL_CTX_get_cert_store(the_ctx);

        DEBUGMSGTL(("sslctx_client", "loading CRL: %s\n", crlFile));

        if (!cert_store)

            LOGANDDIE("failed to find certificate store");

        if (!(lookup = X509_STORE_add_lookup(cert_store, X509_LOOKUP_file())))

            LOGANDDIE("failed to create a lookup function for the CRL file");

        if (X509_load_crl_file(lookup, crlFile, X509_FILETYPE_PEM) != 1)

            LOGANDDIE("failed to load the CRL file");

        /* tell openssl to check CRLs */

        X509_STORE_set_flags(cert_store,

                             X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);

    }

    cipherList = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,

                                       NETSNMP_DS_LIB_TLS_ALGORITMS);

    if (NULL != cipherList) {

        if (SSL_CTX_set_cipher_list(the_ctx, cipherList) != 1)

            LOGANDDIE("failed to set the cipher list to the requested value");

        else

            snmp_log(LOG_INFO,"set SSL cipher list to '%s'\n", cipherList);

    }

    return the_ctx;

}

SSL_CTX *

sslctx_client_setup(const SSL_METHOD *method, _netsnmpTLSBaseData *tlsbase) {

    netsnmp_cert *id_cert, *peer_cert;

    SSL_CTX      *the_ctx;

    /***********************************************************************

     * Set up the client context

     */

    the_ctx = SSL_CTX_new(NETSNMP_REMOVE_CONST(SSL_METHOD *, method));

    if (!the_ctx) {

        snmp_log(LOG_ERR, "ack: %p\n", the_ctx);

        LOGANDDIE("can't create a new context");

    }

    SSL_CTX_set_read_ahead (the_ctx, 1); /* Required for DTLS */

    SSL_CTX_set_verify(the_ctx,

                       SSL_VERIFY_PEER|

                       SSL_VERIFY_FAIL_IF_NO_PEER_CERT|

                       SSL_VERIFY_CLIENT_ONCE,

                       &verify_callback);

    if (tlsbase->our_identity) {

        DEBUGMSGTL(("sslctx_client", "looking for local id: %s\n", tlsbase->our_identity));

        id_cert = netsnmp_cert_find(NS_CERT_IDENTITY, NS_CERTKEY_MULTIPLE,

                                    tlsbase->our_identity);

    } else {

        DEBUGMSGTL(("sslctx_client", "looking for default local id: %s\n", tlsbase->our_identity));

        id_cert = netsnmp_cert_find(NS_CERT_IDENTITY, NS_CERTKEY_DEFAULT, NULL);

    }

    if (!id_cert)

        LOGANDDIE ("error finding client identity keys");

    if (!id_cert->key || !id_cert->key->okey)

        LOGANDDIE("failed to load private key");

    DEBUGMSGTL(("sslctx_client", "using public key: %s\n",

                id_cert->info.filename));

    DEBUGMSGTL(("sslctx_client", "using private key: %s\n",

                id_cert->key->info.filename));

    if (SSL_CTX_use_certificate(the_ctx, id_cert->ocert) <= 0)

        LOGANDDIE("failed to set the certificate to use");

    if (SSL_CTX_use_PrivateKey(the_ctx, id_cert->key->okey) <= 0)

        LOGANDDIE("failed to set the private key to use");

    if (!SSL_CTX_check_private_key(the_ctx))

        LOGANDDIE("public and private keys incompatible");

    if (tlsbase->their_identity)

        peer_cert = netsnmp_cert_find(NS_CERT_REMOTE_PEER,

                                      NS_CERTKEY_MULTIPLE,

                                      tlsbase->their_identity);

    else

        peer_cert = netsnmp_cert_find(NS_CERT_REMOTE_PEER, NS_CERTKEY_DEFAULT,

                                      NULL);

    if (peer_cert) {

        DEBUGMSGTL(("sslctx_client", "server's expected public key: %s\n",

                    peer_cert ? peer_cert->info.filename : "none"));

        /* Trust the expected certificate */

        if (netsnmp_cert_trust_ca(the_ctx, peer_cert) != SNMPERR_SUCCESS)

            LOGANDDIE ("failed to set verify paths");

    }

    /* trust a certificate (possibly a CA) aspecifically passed in */

    if (tlsbase->trust_cert) {

        if (!_trust_this_cert(the_ctx, tlsbase->trust_cert))

            return 0;

    }

    return _sslctx_common_setup(the_ctx, tlsbase);

}

SSL_CTX *

sslctx_server_setup(const SSL_METHOD *method) {

    netsnmp_cert *id_cert;

    /***********************************************************************

     * Set up the server context

     */

    /* setting up for ssl */

    SSL_CTX *the_ctx = SSL_CTX_new(NETSNMP_REMOVE_CONST(SSL_METHOD *, method));

    if (!the_ctx) {

        LOGANDDIE("can't create a new context");

    }

    id_cert = netsnmp_cert_find(NS_CERT_IDENTITY, NS_CERTKEY_DEFAULT, NULL);

    if (!id_cert)

        LOGANDDIE ("error finding server identity keys");

    if (!id_cert->key || !id_cert->key->okey)

        LOGANDDIE("failed to load private key");

    DEBUGMSGTL(("sslctx_server", "using public key: %s\n",

                id_cert->info.filename));

    DEBUGMSGTL(("sslctx_server", "using private key: %s\n",

                id_cert->key->info.filename));

    if (SSL_CTX_use_certificate(the_ctx, id_cert->ocert) <= 0)

        LOGANDDIE("failed to set the certificate to use");

    if (SSL_CTX_use_PrivateKey(the_ctx, id_cert->key->okey) <= 0)

        LOGANDDIE("failed to set the private key to use");

    if (!SSL_CTX_check_private_key(the_ctx))

        LOGANDDIE("public and private keys incompatible");

    SSL_CTX_set_read_ahead(the_ctx, 1); /* XXX: DTLS only? */

    SSL_CTX_set_verify(the_ctx,

                       SSL_VERIFY_PEER|

                       SSL_VERIFY_FAIL_IF_NO_PEER_CERT|

                       SSL_VERIFY_CLIENT_ONCE,

                       &verify_callback);

    return _sslctx_common_setup(the_ctx, NULL);

}

int

netsnmp_tlsbase_config(struct netsnmp_transport_s *t, const char *token, const char *value) {

    _netsnmpTLSBaseData *tlsdata;

    netsnmp_assert_or_return(t != NULL, -1);

    netsnmp_assert_or_return(t->data != NULL, -1);

    tlsdata = t->data;

    if ((strcmp(token, "localCert") == 0) ||

        (strcmp(token, "our_identity") == 0)) {

        SNMP_FREE(tlsdata->our_identity);

        tlsdata->our_identity = strdup(value);

        DEBUGMSGT(("tls:config","our identity %s\n", value));

    }

    if ((strcmp(token, "peerCert") == 0) ||

        (strcmp(token, "their_identity") == 0)) {

        SNMP_FREE(tlsdata->their_identity);

        tlsdata->their_identity = strdup(value);

        DEBUGMSGT(("tls:config","their identity %s\n", value));

    }

    if ((strcmp(token, "peerHostname") == 0) ||

        (strcmp(token, "their_hostname") == 0)) {

        SNMP_FREE(tlsdata->their_hostname);

        tlsdata->their_hostname = strdup(value);

    }

    if ((strcmp(token, "trust_cert") == 0) ||

        (strcmp(token, "trustCert") == 0)) {

        SNMP_FREE(tlsdata->trust_cert);

        tlsdata->trust_cert = strdup(value);

    }

    return SNMPERR_SUCCESS;

}

int

netsnmp_tlsbase_session_init(struct netsnmp_transport_s *transport,

                             struct snmp_session *sess) {

    /* the default security model here should be TSM; most other

       things won't work with TLS because we'll throw out the packet

       if it doesn't have a proper tmStateRef (and onyl TSM generates

       this at the moment */

    if (!(transport->flags & NETSNMP_TRANSPORT_FLAG_LISTEN)) {

        if (sess->securityModel == SNMP_DEFAULT_SECMODEL) {

            sess->securityModel = SNMP_SEC_MODEL_TSM;

        } else if (sess->securityModel != SNMP_SEC_MODEL_TSM) {

            sess->securityModel = SNMP_SEC_MODEL_TSM;

            snmp_log(LOG_ERR, "A security model other than TSM is being used with (D)TLS; using TSM anyways\n");

        }

        if (NULL == sess->securityName) {

            /* client side doesn't need a real securityName */

            /* XXX: call-home issues require them to set one for VACM; but

               we don't do callhome yet */

            sess->securityName = strdup("__BOGUS__");

            sess->securityNameLen = strlen(sess->securityName);

        }

        if (sess->version != SNMP_VERSION_3) {

            sess->version = SNMP_VERSION_3;

            snmp_log(LOG_ERR, "A SNMP version other than 3 was requested with (D)TLS; using 3 anyways\n");

        }

        if (sess->securityLevel <= 0) {

            sess->securityLevel = SNMP_SEC_LEVEL_AUTHPRIV;

        }

    }

    return SNMPERR_SUCCESS;

}

static int have_done_bootstrap = 0;

static int

tls_bootstrap(int majorid, int minorid, void *serverarg, void *clientarg) {

    char indexname[] = "_netsnmp_verify_info";

    /* don't do this more than once */

    if (have_done_bootstrap)

        return 0;

    have_done_bootstrap = 1;

    netsnmp_certs_load();

    openssl_local_index =

        SSL_get_ex_new_index(0, indexname, NULL, NULL, NULL);

    return 0;

}

int

tls_get_verify_info_index() {

    return openssl_local_index;

}

static void _parse_client_cert(const char *tok, char *line)

{

    config_pwarn("clientCert is deprecated. Clients should use localCert, servers should use peerCert");

    if (*line == '"') {

        char buf[SNMP_MAXBUF];

        copy_nword(line, buf, sizeof(buf));

        netsnmp_ds_set_string(NETSNMP_DS_LIBRARY_ID,

                              NETSNMP_DS_LIB_X509_CLIENT_PUB, buf);

    } else

        netsnmp_ds_set_string(NETSNMP_DS_LIBRARY_ID,

                              NETSNMP_DS_LIB_X509_CLIENT_PUB, line);

}

static void _parse_server_cert(const char *tok, char *line)

{

    config_pwarn("serverCert is deprecated. Clients should use peerCert, servers should use localCert.");

    if (*line == '"') {

        char buf[SNMP_MAXBUF];

        copy_nword(line, buf, sizeof(buf));

        netsnmp_ds_set_string(NETSNMP_DS_LIBRARY_ID,

                              NETSNMP_DS_LIB_X509_CLIENT_PUB, buf);

    } else

        netsnmp_ds_set_string(NETSNMP_DS_LIBRARY_ID,

                              NETSNMP_DS_LIB_X509_SERVER_PUB, line);

}

void

netsnmp_tlsbase_ctor(void) {

    /* bootstrap ssl since we'll need it */

    netsnmp_init_openssl();

    /* the private client cert to authenticate with */

    netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "extraX509SubDir",

                               NETSNMP_DS_LIBRARY_ID,

                               NETSNMP_DS_LIB_CERT_EXTRA_SUBDIR);

    /* Do we have a CRL list? */

    netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "x509CRLFile",

                               NETSNMP_DS_LIBRARY_ID,

                               NETSNMP_DS_LIB_X509_CRL_FILE);

    /* What TLS algorithms should be use */

    netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "tlsAlgorithms",

                               NETSNMP_DS_LIBRARY_ID,

                               NETSNMP_DS_LIB_TLS_ALGORITMS);

    /*

     * for the client

     */

    /* the public client cert to authenticate with */

    register_config_handler("snmp", "clientCert", _parse_client_cert, NULL,

                            NULL);

    /*

     * for the server

     */

    /* The X509 server key to use */

    register_config_handler("snmp", "serverCert", _parse_server_cert, NULL,

                            NULL);

    /*

     * remove cert config ambiguity: localCert, peerCert

     */

    netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "localCert",

                               NETSNMP_DS_LIBRARY_ID,

                               NETSNMP_DS_LIB_TLS_LOCAL_CERT);

    netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "peerCert",

                               NETSNMP_DS_LIBRARY_ID,

                               NETSNMP_DS_LIB_TLS_PEER_CERT);

    /*

     * register our boot-strapping needs

     */

    snmp_register_callback(SNMP_CALLBACK_LIBRARY,

			   SNMP_CALLBACK_POST_PREMIB_READ_CONFIG,

			   tls_bootstrap, NULL);

}

_netsnmpTLSBaseData *

netsnmp_tlsbase_allocate_tlsdata(netsnmp_transport *t, int isserver) {

    _netsnmpTLSBaseData *tlsdata;

    if (NULL == t)

        return NULL;

    /* allocate our TLS specific data */

    tlsdata = SNMP_MALLOC_TYPEDEF(_netsnmpTLSBaseData);

    if (NULL == tlsdata) {

        SNMP_FREE(t);

        return NULL;

    }

    if (!isserver)

        tlsdata->flags |= NETSNMP_TLSBASE_IS_CLIENT;

    return tlsdata;

}

void netsnmp_tlsbase_free_tlsdata(_netsnmpTLSBaseData *tlsbase) {

    if (!tlsbase)

        return;

    DEBUGMSGTL(("tlsbase","Freeing TLS Base data for a session\n"));

    if (tlsbase->ssl)

        SSL_free(tlsbase->ssl);

    if (tlsbase->ssl_context)

        SSL_CTX_free(tlsbase->ssl_context);

   /* don't free the accept_bio since it's the parent bio */

    /*

    if (tlsbase->accept_bio)

        BIO_free(tlsbase->accept_bio);

    */

    /* and this is freed by the SSL shutdown */

    /* 

    if (tlsbase->accepted_bio)

      BIO_free(tlsbase->accept_bio);

    */

    /* free the config data */

    SNMP_FREE(tlsbase->securityName);

    SNMP_FREE(tlsbase->addr_string);

    SNMP_FREE(tlsbase->our_identity);

    SNMP_FREE(tlsbase->their_identity);

    SNMP_FREE(tlsbase->their_fingerprint);

    SNMP_FREE(tlsbase->their_hostname);

    SNMP_FREE(tlsbase->trust_cert);

    /* free the base itself */

    SNMP_FREE(tlsbase);

}

int netsnmp_tlsbase_wrapup_recv(netsnmp_tmStateReference *tmStateRef,

                                _netsnmpTLSBaseData *tlsdata,

                                void **opaque, int *olength) {

    int no_auth, no_priv;

    if (NULL == tlsdata)

        return SNMPERR_GENERR;

    /* RFC5953 Section 5.1.2 step 2: tmSecurityLevel */

    /*

     * Don't accept null authentication. Null encryption ok.

     *

     * XXX: this should actually check for a configured list of encryption

     *      algorithms to map to NOPRIV, but for the moment we'll

     *      accept any encryption alogrithms that openssl is using.

     */

    netsnmp_openssl_null_checks(tlsdata->ssl, &no_auth, &no_priv);

    if (no_auth == 1) { /* null/unknown authentication */

        /* xxx-rks: snmp_increment_statistic(STAT_???); */

        snmp_log(LOG_ERR, "tls connection with NULL authentication\n");