/* Portions of this file are subject to the following copyright(s). See
* the Net-SNMP's COPYING file for more details and other copyrights
* that may apply:
*/
/*
* See the following web pages for useful documentation on this transport:
* http://www.net-snmp.org/wiki/index.php/TUT:Using_TLS
* http://www.net-snmp.org/wiki/index.php/Using_DTLS
*/
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-features.h>
netsnmp_feature_require(cert_util)
#include <stdio.h>
#include <sys/types.h>
#include <ctype.h>
#include <errno.h>
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if HAVE_UNISTD_H
#include <unistd.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
#if HAVE_SYS_UIO_H
#include <sys/uio.h>
#endif
#if HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#if HAVE_DMALLOC_H
#include <dmalloc.h>
#endif
#include <net-snmp/types.h>
#include <net-snmp/output_api.h>
#include <net-snmp/config_api.h>
#include <net-snmp/library/snmp_assert.h>
#include <net-snmp/library/snmpIPv4BaseDomain.h>
#include <net-snmp/library/snmpSocketBaseDomain.h>
#include <net-snmp/library/snmpTLSBaseDomain.h>
#include <net-snmp/library/snmpTLSTCPDomain.h>
#include <net-snmp/library/system.h>
#include <net-snmp/library/tools.h>
#include <net-snmp/library/cert_util.h>
#include <net-snmp/library/snmp_openssl.h>
#include <net-snmp/library/callback.h>
#include "openssl/bio.h"
#include "openssl/ssl.h"
#include "openssl/err.h"
#ifndef INADDR_NONE
#define INADDR_NONE -1
#endif
#define WE_ARE_SERVER 0
#define WE_ARE_CLIENT 1
oid netsnmpTLSTCPDomain[] = { TRANSPORT_DOMAIN_TLS_TCP_IP };
size_t netsnmpTLSTCPDomain_len = OID_LENGTH(netsnmpTLSTCPDomain);
static netsnmp_tdomain tlstcpDomain;
/*
* Return a string representing the address in data, or else the "far end"
* address if data is NULL.
*/
static char *
netsnmp_tlstcp_fmtaddr(netsnmp_transport *t, const void *data, int len)
{
if (t && !data) {
data = t->data;
len = t->data_length;
}
switch (data ? len : 0) {
case sizeof(netsnmp_indexed_addr_pair):
return netsnmp_ipv4_fmtaddr("TLSTCP", t, data, len);
case sizeof(netsnmp_tmStateReference): {
const netsnmp_tmStateReference *r = data;
const netsnmp_indexed_addr_pair *p = &r->addresses;
return netsnmp_ipv4_fmtaddr("TLSTCP", t, p, sizeof(*p));
}
case sizeof(_netsnmpTLSBaseData): {
const _netsnmpTLSBaseData *b = data;
char *buf;
if (asprintf(&buf, "TLSTCP: %s", b->addr_string) < 0)
buf = NULL;
return buf;
}
case 0:
return strdup("TLSTCP: unknown");
default: {
char *buf;
if (asprintf(&buf, "TLSTCP: len %d", len) < 0)
buf = NULL;
return buf;
}
}
}
static void netsnmp_tlstcp_get_taddr(struct netsnmp_transport_s *t,
void **addr, size_t *addr_len)
{
*addr_len = t->remote_length;
*addr = netsnmp_memdup(t->remote, *addr_len);
}
/*
* You can write something into opaque that will subsequently get passed back
* to your send function if you like. For instance, you might want to
* remember where a PDU came from, so that you can send a reply there...
*/
static int
netsnmp_tlstcp_copy(const netsnmp_transport *oldt, netsnmp_transport *newt)
{
_netsnmpTLSBaseData *oldtlsdata = (_netsnmpTLSBaseData *) oldt->data;
_netsnmpTLSBaseData *newtlsdata = (_netsnmpTLSBaseData *) newt->data;
oldtlsdata->accepted_bio = NULL;
oldtlsdata->ssl = NULL;
newtlsdata->ssl_context = NULL;
if (oldtlsdata->addr_string)
newtlsdata->addr_string = strdup(oldtlsdata->addr_string);
if (oldtlsdata->securityName)
newtlsdata->securityName = strdup(oldtlsdata->securityName);
if (oldtlsdata->our_identity)
newtlsdata->our_identity = strdup(oldtlsdata->our_identity);
if (oldtlsdata->their_identity)
newtlsdata->their_identity = strdup(oldtlsdata->their_identity);
if (oldtlsdata->their_fingerprint)
newtlsdata->their_fingerprint = strdup(oldtlsdata->their_fingerprint);
if (oldtlsdata->their_hostname)
newtlsdata->their_hostname = strdup(oldtlsdata->their_hostname);
if (oldtlsdata->trust_cert)
newtlsdata->trust_cert = strdup(oldtlsdata->trust_cert);
if (oldtlsdata->addr)
newtlsdata->addr = netsnmp_memdup(oldtlsdata->addr,
sizeof(*oldtlsdata->addr));
return 0;
}
static int
netsnmp_tlstcp_recv(netsnmp_transport *t, void *buf, int size,
void **opaque, int *olength)
{
int rc = -1;
netsnmp_tmStateReference *tmStateRef = NULL;
_netsnmpTLSBaseData *tlsdata;
if (NULL == t || t->sock < 0 || NULL == t->data) {
snmp_log(LOG_ERR,
"tlstcp received an invalid invocation with missing data\n");
DEBUGMSGTL(("tlstcp", "recvfrom fd %d err %d (\"%s\")\n",
(t ? t->sock : -1), errno, strerror(errno)));
if (t)
DEBUGMSGTL(("tlstcp", " tdata = %p", t->data));
DEBUGMSGTL(("tlstcp", "\n"));
return -1;
}
/* RFC5953 Section 5.1.2 step 1:
1) Determine the tlstmSessionID for the incoming message. The
tlstmSessionID MUST be a unique session identifier for this
(D)TLS connection. The contents and format of this identifier
are implementation-dependent as long as it is unique to the
session. A session identifier MUST NOT be reused until all
references to it are no longer in use. The tmSessionID is
equal to the tlstmSessionID discussed in Section 5.1.1.
tmSessionID refers to the session identifier when stored in the
tmStateReference and tlstmSessionID refers to the session
identifier when stored in the LCD. They MUST always be equal
when processing a given session's traffic.
*/
/* For this implementation we use the t->data memory pointer as
the sessionID. As it's a pointer to session specific data tied
with the transport object we know it'll never be realloated
(ie, duplicated) until release by this transport object and is
safe to use as a unique session identifier. */
tlsdata = t->data;
if (NULL == tlsdata->ssl) {
snmp_log(LOG_ERR,
"tlstcp received an invalid invocation without ssl data\n");
return -1;
}
/* RFC5953 Section 5.1.2 step 1, part2:
* This part (incrementing the counter) is done in the
netsnmp_tlstcp_accept function.
*/
/* RFC5953 Section 5.1.2 step 2:
* Create a tmStateReference cache for the subsequent reference and
assign the following values within it:
tmTransportDomain = snmpTLSTCPDomain or snmpDTLSUDPDomain as
appropriate.
tmTransportAddress = The address the message originated from.
tmSecurityLevel = The derived tmSecurityLevel for the session,
as discussed in Section 3.1.2 and Section 5.3.
tmSecurityName = The fderived tmSecurityName for the session as
discussed in Section 5.3. This value MUST
be constant during the lifetime of the
session.
tmSessionID = The tlstmSessionID described in step 1 above.
*/
/* Implementation notes:
* - The tmTransportDomain is represented by the transport object
* - The tmpSessionID is represented by the tlsdata pointer (as
discussed above)
* - The following items are handled later in netsnmp_tlsbase_wrapup_recv:
- tmSecurityLevel
- tmSecurityName
- tmSessionID
*/
/* create a tmStateRef cache for slow fill-in */
tmStateRef = SNMP_MALLOC_TYPEDEF(netsnmp_tmStateReference);
if (tmStateRef == NULL) {
*opaque = NULL;
*olength = 0;
return -1;
}
/* Set the transportDomain */
memcpy(tmStateRef->transportDomain,
netsnmpTLSTCPDomain, sizeof(netsnmpTLSTCPDomain[0]) *
netsnmpTLSTCPDomain_len);
tmStateRef->transportDomainLen = netsnmpTLSTCPDomain_len;
/* Set the tmTransportAddress */
tmStateRef->have_addresses = 1;
/* RFC5953 Section 5.1.2 step 1:
* 3) The incomingMessage and incomingMessageLength are assigned values
from the (D)TLS processing.
*/
/* Implementation notes:
- incomingMessage = buf pointer
- incomingMessageLength = rc
*/
/* read the packet from openssl */
do {
rc = SSL_read(tlsdata->ssl, buf, size);
if (rc == 0) {
/* XXX closed connection */
DEBUGMSGTL(("tlstcp", "remote side closed connection\n"));
/* XXX: openssl cleanup */
SNMP_FREE(tmStateRef);
return -1;
}
if (rc == -1) {
int err = SSL_get_error(tlsdata->ssl, rc);
if (err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE) {
/* error detected */
_openssl_log_error(rc, tlsdata->ssl, "SSL_read");
SNMP_FREE(tmStateRef);
return rc;
}
}
/* retry read for SSL_ERROR_WANT_READ || SSL_ERROR_WANT_WRITE */
} while (rc <= 0);
DEBUGMSGTL(("tlstcp", "received %d decoded bytes from tls\n", rc));
/* log the packet */
DEBUGIF("tlstcp") {
char *str = netsnmp_tlstcp_fmtaddr(t, NULL, 0);
DEBUGMSGTL(("tlstcp",
"recvfrom fd %d got %d bytes (from %s)\n",
t->sock, rc, str));
free(str);
}
/* Other wrap-up things common to TLS and DTLS */
if (netsnmp_tlsbase_wrapup_recv(tmStateRef, tlsdata, opaque, olength) !=
SNMPERR_SUCCESS)
return SNMPERR_GENERR;
/* RFC5953 Section 5.1.2 step 1:
* 4) The TLS Transport Model passes the transportDomain,
transportAddress, incomingMessage, and incomingMessageLength to
the Dispatcher using the receiveMessage ASI:
*/
/* In our implementation, this is done simply by returning */
return rc;
}
static int
netsnmp_tlstcp_send(netsnmp_transport *t, const void *buf, int size,
void **opaque, int *olength)
{
int rc = -1;
const netsnmp_tmStateReference *tmStateRef = NULL;
_netsnmpTLSBaseData *tlsdata;
DEBUGTRACETOK("tlstcp");
/* RFC5953 section 5.2:
1) If tmStateReference does not refer to a cache containing values
for tmTransportDomain, tmTransportAddress, tmSecurityName,
tmRequestedSecurityLevel, and tmSameSecurity, then increment the
snmpTlstmSessionInvalidCaches counter, discard the message, and
return the error indication in the statusInformation. Processing
of this message stops.
*/
/* Implementation Notes: the tmStateReference is stored in the opaque ptr */
if (opaque != NULL && *opaque != NULL &&
*olength == sizeof(netsnmp_tmStateReference)) {
tmStateRef = (const netsnmp_tmStateReference *) *opaque;
} else {
snmp_log(LOG_ERR, "TLSTCP was called with an invalid state; possibly the wrong security model is in use. It should be 'tsm'.\n");
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONINVALIDCACHES);
return SNMPERR_GENERR;
}
/* RFC5953 section 5.2:
2) Extract the tmSessionID, tmTransportDomain, tmTransportAddress,
tmSecurityName, tmRequestedSecurityLevel, and tmSameSecurity
values from the tmStateReference. Note: The tmSessionID value
may be undefined if no session exists yet over which the message
can be sent.
*/
/* Implementation Notes:
- Our session will always exist by now as it's created when the
transport object is created. Auto-session creation is handled
higher in the stack.
- We don't "extract" per say since we just leave the data in
the structure.
- The sessionID is stored in the t->data memory pointer.
*/
/* RFC5953 section 5.2:
3) If tmSameSecurity is true and either tmSessionID is undefined or
refers to a session that is no longer open then increment the
snmpTlstmSessionNoSessions counter, discard the message and
return the error indication in the statusInformation. Processing
of this message stops.
*/
/* Implementation Notes:
- We would never get here if the sessionID was either undefined
or different. We tie packets directly to the transport
object and it could never be sent back over a different
transport, which is what the above text is trying to prevent.
*/
/* RFC5953 section 5.2:
4) If tmSameSecurity is false and tmSessionID refers to a session
that is no longer available then an implementation SHOULD open a
new session using the openSession() ASI (described in greater
detail in step 5b). Instead of opening a new session an
implementation MAY return a snmpTlstmSessionNoSessions error to
the calling module and stop processing of the message.
*/
/* Implementation Notes:
- We would never get here if the sessionID was either undefined
or different. We tie packets directly to the transport
object and it could never be sent back over a different
transport, which is what the above text is trying to prevent.
- Auto-connections are handled higher in the Net-SNMP library stack
*/
/* RFC5953 section 5.2:
5) If tmSessionID is undefined, then use tmTransportDomain,
tmTransportAddress, tmSecurityName and tmRequestedSecurityLevel
to see if there is a corresponding entry in the LCD suitable to
send the message over.
5a) If there is a corresponding LCD entry, then this session
will be used to send the message.
5b) If there is not a corresponding LCD entry, then open a
session using the openSession() ASI (discussed further in
Section 5.3.1). Implementations MAY wish to offer message
buffering to prevent redundant openSession() calls for the
same cache entry. If an error is returned from
openSession(), then discard the message, discard the
tmStateReference, increment the snmpTlstmSessionOpenErrors,
return an error indication to the calling module and stop
processing of the message.
*/
/* Implementation Notes:
- We would never get here if the sessionID was either undefined
or different. We tie packets directly to the transport
object and it could never be sent back over a different
transport, which is what the above text is trying to prevent.
- Auto-connections are handled higher in the Net-SNMP library stack
*/
/* our session pointer is functionally t->data */
if (NULL == t->data) {
snmp_log(LOG_ERR, "netsnmp_tlstcp_send received no incoming data\n");
return -1;
}
tlsdata = t->data;
if (tlsdata->ssl == NULL) {
snmp_log(LOG_ERR, "tlstcp_send was called without a SSL connection.\n");
return SNMPERR_GENERR;
}
/* If the first packet and we have no secname, then copy the
important securityName data into the longer-lived session
reference information. */
if ((tlsdata->flags & NETSNMP_TLSBASE_IS_CLIENT) &&
!tlsdata->securityName && tmStateRef && tmStateRef->securityNameLen > 0)
tlsdata->securityName = strdup(tmStateRef->securityName);
/* RFC5953 section 5.2:
6) Using either the session indicated by the tmSessionID if there
was one or the session resulting from a previous step (4 or 5),
pass the outgoingMessage to (D)TLS for encapsulation and
transmission.
*/
rc = SSL_write(tlsdata->ssl, buf, size);
DEBUGMSGTL(("tlstcp", "wrote %d bytes\n", size));
if (rc < 0) {
_openssl_log_error(rc, tlsdata->ssl, "SSL_write");
}
return rc;
}
static int
netsnmp_tlstcp_close(netsnmp_transport *t)
{
_netsnmpTLSBaseData *tlsdata;
if (NULL == t || NULL == t->data)
return -1;
/* RFC5953 Section 5.4. Closing a Session
1) Increment either the snmpTlstmSessionClientCloses or the
snmpTlstmSessionServerCloses counter as appropriate.
*/
if (t->flags & NETSNMP_TLSBASE_IS_CLIENT)
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONCLIENTCLOSES);
else
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONSERVERCLOSES);
/* RFC5953 Section 5.4. Closing a Session
2) Look up the session using the tmSessionID.
*/
tlsdata = (_netsnmpTLSBaseData *) t->data;
/* RFC5953 Section 5.4. Closing a Session
3) If there is no open session associated with the tmSessionID, then
closeSession processing is completed.
*/
/* Implementation notes: if we have a non-zero tlsdata then it's
always true */
/* RFC5953 Section 5.3.1: Establishing a Session as a Client
4) Have (D)TLS close the specified connection. This SHOULD include
sending a close_notify TLS Alert to inform the other side that
session cleanup may be performed.
*/
DEBUGMSGTL(("tlstcp", "Shutting down SSL connection\n"));
if (tlsdata->ssl) {
SSL_shutdown(tlsdata->ssl);
}
netsnmp_tlsbase_free_tlsdata(tlsdata);
t->data = NULL;
return netsnmp_socketbase_close(t);
}
static int
netsnmp_tlstcp_accept(netsnmp_transport *t)
{
BIO *accepted_bio;
int rc;
SSL_CTX *ctx;
SSL *ssl;
_netsnmpTLSBaseData *tlsdata = NULL;
DEBUGMSGTL(("tlstcp", "netsnmp_tlstcp_accept called\n"));
tlsdata = (_netsnmpTLSBaseData *) t->data;
rc = BIO_do_accept(tlsdata->accept_bio);
if (rc <= 0) {
snmp_log(LOG_ERR, "BIO_do_accept failed\n");
_openssl_log_error(rc, NULL, "BIO_do_accept");
/* XXX: need to close the listening connection here? */
return -1;
}
tlsdata->accepted_bio = accepted_bio = BIO_pop(tlsdata->accept_bio);
if (!accepted_bio) {
snmp_log(LOG_ERR, "Failed to pop an accepted bio off the bio stack\n");
/* XXX: need to close the listening connection here? */
return -1;
}
/* create the OpenSSL TLS context */
ctx = tlsdata->ssl_context;
/* create the server's main SSL bio */
ssl = tlsdata->ssl = SSL_new(ctx);
if (!tlsdata->ssl) {
snmp_log(LOG_ERR, "TLSTCP: Failed to create a SSL BIO\n");
BIO_free(accepted_bio);
tlsdata->accepted_bio = NULL;
return -1;
}
SSL_set_bio(ssl, accepted_bio, accepted_bio);
if ((rc = SSL_accept(ssl)) <= 0) {
snmp_log(LOG_ERR, "TLSTCP: Failed SSL_accept\n");
_openssl_log_error(rc, ssl, "SSL_accept");
SSL_shutdown(tlsdata->ssl);
SSL_free(tlsdata->ssl);
tlsdata->accepted_bio = NULL; /* freed by SSL_free */
tlsdata->ssl = NULL;
return -1;
}
/*
* currently netsnmp_tlsbase_wrapup_recv is where we check for
* algorithm compliance, but for tls we know the algorithms
* at this point, so we could bail earlier...
*/
#if 0 /* moved checks to netsnmp_tlsbase_wrapup_recv */
netsnmp_openssl_null_checks(tlsdata->ssl, &no_auth, NULL);
if (no_auth != 0) { /* null/unknown authentication */
/* xxx-rks: snmp_increment_statistic(STAT_???); */
snmp_log(LOG_ERR, "tlstcp: connection with NULL authentication\n");
SSL_shutdown(tlsdata->ssl);
SSL_free(tlsdata->ssl);
tlsdata->accepted_bio = NULL; /* freed by SSL_free */
tlsdata->ssl = NULL;
return -1;
}
#endif
/* RFC5953 Section 5.3.2: Accepting a Session as a Server
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.
The (D)TLS server identifies the authenticated identity from the
(D)TLS client's principal certificate using configuration information
from the snmpTlstmCertToTSNTable mapping table. The (D)TLS server
MUST request and expect a certificate from the client and MUST NOT
accept SNMP messages over the (D)TLS connection until the client has
sent a certificate and it has been authenticated. The resulting
derived tmSecurityName is recorded in the tmStateReference cache as
tmSecurityName. The details of the lookup process are fully
described in the DESCRIPTION clause of the snmpTlstmCertToTSNTable
MIB object. If any verification fails in any way (for example
because of failures in cryptographic verification or because of the
lack of an appropriate row in the snmpTlstmCertToTSNTable) then the
session establishment MUST fail, and the
snmpTlstmSessionInvalidClientCertificates object is incremented. If
the session can not be opened for any reason at all, including
cryptographic verification failures, then the
snmpTlstmSessionOpenErrors counter is incremented and processing
stops.
Servers that wish to support multiple principals at a particular port
SHOULD make use of a (D)TLS extension that allows server-side
principal selection like the Server Name Indication extension defined
in Section 3.1 of [RFC4366]. Supporting this will allow, for
example, sending notifications to a specific principal at a given TCP
or UDP port.
*/
/* Implementation notes:
- we expect fingerprints to be stored in the transport config
- we do not currently support mulitple principals and only offer one
*/
if ((rc = netsnmp_tlsbase_verify_client_cert(ssl, tlsdata))
!= SNMPERR_SUCCESS) {
/* XXX: free needed memory */
snmp_log(LOG_ERR, "TLSTCP: Falied checking client certificate\n");
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONINVALIDCLIENTCERTIFICATES);
SSL_shutdown(tlsdata->ssl);
SSL_free(tlsdata->ssl);
tlsdata->accepted_bio = NULL; /* freed by SSL_free */
tlsdata->ssl = NULL;
return -1;
}
/* XXX: check acceptance criteria here */
DEBUGMSGTL(("tlstcp", "accept succeeded on sock %d\n", t->sock));
/* RFC5953 Section 5.1.2 step 1, part2::
* If this is the first message received through this session and
the session does not have an assigned tlstmSessionID yet then the
snmpTlstmSessionAccepts counter is incremented and a
tlstmSessionID for the session is created. This will only happen
on the server side of a connection because a client would have
already assigned a tlstmSessionID during the openSession()
invocation. Implementations may have performed the procedures
described in Section 5.3.2 prior to this point or they may
perform them now, but the procedures described in Section 5.3.2
MUST be performed before continuing beyond this point.
*/
/* We're taking option 2 and incrementing the session accepts here
rather than upon receiving the first packet */
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONACCEPTS);
/* XXX: check that it returns something so we can free stuff? */
return BIO_get_fd(tlsdata->accepted_bio, NULL);
}
netsnmp_transport *
netsnmp_tlstcp_open(netsnmp_transport *t)
{
_netsnmpTLSBaseData *tlsdata;
BIO *bio;
SSL_CTX *ctx;
SSL *ssl;
int rc = 0;
_netsnmp_verify_info *verify_info;
netsnmp_assert_or_return(t != NULL, NULL);
netsnmp_assert_or_return(t->data != NULL, NULL);
netsnmp_assert_or_return(sizeof(_netsnmpTLSBaseData) == t->data_length,
NULL);
tlsdata = t->data;
if (tlsdata->flags & NETSNMP_TLSBASE_IS_CLIENT) {
/* Is the client */
/* RFC5953 Section 5.3.1: Establishing a Session as a Client
* 1) The snmpTlstmSessionOpens counter is incremented.
*/
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONOPENS);
/* RFC5953 Section 5.3.1: Establishing a Session as a Client
2) The client selects the appropriate certificate and cipher_suites
for the key agreement based on the tmSecurityName and the
tmRequestedSecurityLevel for the session. For sessions being
established as a result of a SNMP-TARGET-MIB based operation, the
certificate will potentially have been identified via the
snmpTlstmParamsTable mapping and the cipher_suites will have to
be taken from system-wide or implementation-specific
configuration. If no row in the snmpTlstmParamsTable exists then
implementations MAY choose to establish the connection using a
default client certificate available to the application.
Otherwise, the certificate and appropriate cipher_suites will
need to be passed to the openSession() ASI as supplemental
information or configured through an implementation-dependent
mechanism. It is also implementation-dependent and possibly
policy-dependent how tmRequestedSecurityLevel will be used to
influence the security capabilities provided by the (D)TLS
connection. However this is done, the security capabilities
provided by (D)TLS MUST be at least as high as the level of
security indicated by the tmRequestedSecurityLevel parameter.
The actual security level of the session is reported in the
tmStateReference cache as tmSecurityLevel. For (D)TLS to provide
strong authentication, each principal acting as a command
generator SHOULD have its own certificate.
*/
/*
Implementation notes: we do most of this in the
sslctx_client_setup The transport should have been
f_config()ed with the proper fingerprints to use (which is
stored in tlsdata), or we'll use the default identity
fingerprint if that can be found.
*/
/* XXX: check securityLevel and ensure no NULL fingerprints are used */
/* set up the needed SSL context */
tlsdata->ssl_context = ctx = sslctx_client_setup(TLS_method(), tlsdata);
if (!ctx) {
snmp_log(LOG_ERR, "failed to create TLS context\n");
return NULL;
}
/* RFC5953 Section 5.3.1: Establishing a Session as a Client
3) Using the destTransportDomain and destTransportAddress values,
the client will initiate the (D)TLS handshake protocol to
establish session keys for message integrity and encryption.
*/
/* Implementation note:
The transport domain and address are pre-processed by this point
*/
/* Create a BIO connection for it */
DEBUGMSGTL(("tlstcp", "connecting to tlstcp %s\n",
tlsdata->addr_string));
t->remote = (void *) strdup(tlsdata->addr_string);
t->remote_length = strlen(tlsdata->addr_string) + 1;
bio = BIO_new_connect(tlsdata->addr_string);
/* RFC5953 Section 5.3.1: Establishing a Session as a Client
3) continued:
If the attempt to establish a session is unsuccessful, then
snmpTlstmSessionOpenErrors is incremented, an error indication is
returned, and processing stops.
*/
if (NULL == bio) {
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONOPENERRORS);
snmp_log(LOG_ERR, "tlstcp: failed to create bio\n");
_openssl_log_error(rc, NULL, "BIO creation");
return NULL;
}
/* Tell the BIO to actually do the connection */
if ((rc = BIO_do_connect(bio)) <= 0) {
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONOPENERRORS);
snmp_log(LOG_ERR, "tlstcp: failed to connect to %s\n",
tlsdata->addr_string);
_openssl_log_error(rc, NULL, "BIO_do_connect");
BIO_free(bio);
return NULL;
}
/* Create the SSL layer on top of the socket bio */
ssl = tlsdata->ssl = SSL_new(ctx);
if (NULL == ssl) {
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONOPENERRORS);
snmp_log(LOG_ERR, "tlstcp: failed to create a SSL connection\n");
BIO_free(bio);
return NULL;
}
/* Bind the SSL layer to the BIO */
SSL_set_bio(ssl, bio, bio);
SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);
verify_info = SNMP_MALLOC_TYPEDEF(_netsnmp_verify_info);
if (NULL == verify_info) {
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONOPENERRORS);
snmp_log(LOG_ERR, "tlstcp: failed to create a SSL connection\n");
SSL_shutdown(ssl);
BIO_free(bio);
return NULL;
}
SSL_set_ex_data(ssl, tls_get_verify_info_index(), verify_info);
/* Then have SSL do it's connection over the BIO */
if ((rc = SSL_connect(ssl)) <= 0) {
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONOPENERRORS);
snmp_log(LOG_ERR, "tlstcp: failed to ssl_connect\n");
BIO_free(bio);
return NULL;
}
/* RFC5953 Section 5.3.1: Establishing a Session as a Client
3) continued:
If the session failed to open because the presented
server certificate was unknown or invalid then the
snmpTlstmSessionUnknownServerCertificate or
snmpTlstmSessionInvalidServerCertificates MUST be
incremented and a snmpTlstmServerCertificateUnknown or
snmpTlstmServerInvalidCertificate notification SHOULD be
sent as appropriate. Reasons for server certificate
invalidation includes, but is not limited to,
cryptographic validation failures and an unexpected
presented certificate identity.
*/
/* RFC5953 Section 5.3.1: Establishing a Session as a Client
4) The (D)TLS client MUST then verify that the (D)TLS server's
presented certificate is the expected certificate. The (D)TLS
client MUST NOT transmit SNMP messages until the server
certificate has been authenticated, the client certificate has
been transmitted and the TLS connection has been fully
established.
If the connection is being established from configuration based
on SNMP-TARGET-MIB configuration, then the snmpTlstmAddrTable
DESCRIPTION clause describes how the verification is done (using
either a certificate fingerprint, or an identity authenticated
via certification path validation).
If the connection is being established for reasons other than
configuration found in the SNMP-TARGET-MIB then configuration and
procedures outside the scope of this document should be followed.
Configuration mechanisms SHOULD be similar in nature to those
defined in the snmpTlstmAddrTable to ensure consistency across
management configuration systems. For example, a command-line
tool for generating SNMP GETs might support specifying either the
server's certificate fingerprint or the expected host name as a
command line argument.
*/
/* Implementation notes:
- All remote certificate fingerprints are expected to be
stored in the transport's config information. This is
true both for CLI clients and TARGET-MIB sessions.
- netsnmp_tlsbase_verify_server_cert implements these checks
*/
if (netsnmp_tlsbase_verify_server_cert(ssl, tlsdata) != SNMPERR_SUCCESS) {
/* XXX: unknown vs invalid; two counters */
snmp_increment_statistic(STAT_TLSTM_SNMPTLSTMSESSIONUNKNOWNSERVERCERTIFICATE);
snmp_log(LOG_ERR, "tlstcp: failed to verify ssl certificate\n");
SSL_shutdown(ssl);
BIO_free(bio);
return NULL;
}
/* RFC5953 Section 5.3.1: Establishing a Session as a Client
5) (D)TLS provides assurance that the authenticated identity has
been signed by a trusted configured certification authority. If
verification of the server's certificate fails in any way (for
example because of failures in cryptographic verification or the
presented identity did not match the expected named entity) then
the session establishment MUST fail, the
snmpTlstmSessionInvalidServerCertificates object is incremented.
If the session can not be opened for any reason at all, including
cryptographic verification failures, then the
snmpTlstmSessionOpenErrors counter is incremented and processing
stops.
*/
/* XXX: add snmpTlstmSessionInvalidServerCertificates on
crypto failure */
/* RFC5953 Section 5.3.1: Establishing a Session as a Client
6) The TLSTM-specific session identifier (tlstmSessionID) is set in
the tmSessionID of the tmStateReference passed to the TLS
Transport Model to indicate that the session has been established
successfully and to point to a specific (D)TLS connection for
future use. The tlstmSessionID is also stored in the LCD for
later lookup during processing of incoming messages
(Section 5.1.2).
*/
/* Implementation notes:
- the tlsdata pointer is used as our session identifier, as
noted in the netsnmp_tlstcp_recv() function comments.
*/
t->sock = BIO_get_fd(bio, NULL);
} else {
#ifndef NETSNMP_NO_LISTEN_SUPPORT
/* Is the server */
/* Create the socket bio */
DEBUGMSGTL(("tlstcp", "listening on tlstcp port %s\n",
tlsdata->addr_string));
tlsdata->accept_bio = BIO_new_accept(tlsdata->addr_string);
t->local = (void *) strdup(tlsdata->addr_string);
t->local_length = strlen(tlsdata->addr_string)+1;
if (NULL == tlsdata->accept_bio) {
snmp_log(LOG_ERR, "TLSTCP: Falied to create a accept BIO\n");
return NULL;
}
/* openssl requires an initial accept to bind() the socket */
if (BIO_do_accept(tlsdata->accept_bio) <= 0) {
_openssl_log_error(rc, tlsdata->ssl, "BIO_do__accept");
snmp_log(LOG_ERR, "TLSTCP: Falied to do first accept on the TLS accept BIO\n");
return NULL;
}
/* create the OpenSSL TLS context */
tlsdata->ssl_context = sslctx_server_setup(TLS_method());
t->sock = BIO_get_fd(tlsdata->accept_bio, NULL);
t->flags |= NETSNMP_TRANSPORT_FLAG_LISTEN;
#else /* NETSNMP_NO_LISTEN_SUPPORT */
return NULL;
#endif /* NETSNMP_NO_LISTEN_SUPPORT */
}
return t;
}
/*
* Create a TLS-based transport for SNMP. Local is TRUE if addr is the local
* address to bind to (i.e. this is a server-type session); otherwise addr is
* the remote address to send things to.
*/
netsnmp_transport *
netsnmp_tlstcp_transport(const char *addr_string, int isserver)
{
netsnmp_transport *t = NULL;
_netsnmpTLSBaseData *tlsdata;
char *cp;
char buf[SPRINT_MAX_LEN];
#ifdef NETSNMP_NO_LISTEN_SUPPORT
if (isserver)
return NULL;
#endif /* NETSNMP_NO_LISTEN_SUPPORT */
/* allocate our transport structure */
t = SNMP_MALLOC_TYPEDEF(netsnmp_transport);
if (NULL == t) {
return NULL;
}
/* allocate our TLS specific data */
if (NULL == (tlsdata = netsnmp_tlsbase_allocate_tlsdata(t, isserver)))
return NULL;
if (!isserver)
t->flags |= NETSNMP_TLSBASE_IS_CLIENT;
tlsdata->addr_string = strdup(addr_string);
/* see if we can extract the remote hostname */
if (!isserver && tlsdata && addr_string) {
/* search for a : */
if (NULL != (cp = strrchr(addr_string, ':'))) {
sprintf(buf, "%.*s",
(int) SNMP_MIN(cp - addr_string, sizeof(buf) - 1),
addr_string);
} else {
/* else the entire spec is a host name only */
strlcpy(buf, addr_string, sizeof(buf));
}
tlsdata->their_hostname = strdup(buf);
}
t->data = tlsdata;
t->data_length = sizeof(_netsnmpTLSBaseData);
/*
* Set Domain
*/
t->domain = netsnmpTLSTCPDomain;
t->domain_length = netsnmpTLSTCPDomain_len;
/*
* 16-bit length field, 8 byte TLS header, 20 byte IPv4 header
*/
t->msgMaxSize = 0xffff - 8 - 20;
t->f_recv = netsnmp_tlstcp_recv;
t->f_send = netsnmp_tlstcp_send;
t->f_open = netsnmp_tlstcp_open;
t->f_close = netsnmp_tlstcp_close;
t->f_accept = netsnmp_tlstcp_accept;
t->f_copy = netsnmp_tlstcp_copy;
t->f_config = netsnmp_tlsbase_config;
t->f_setup_session = netsnmp_tlsbase_session_init;
t->f_fmtaddr = netsnmp_tlstcp_fmtaddr;
t->f_get_taddr = netsnmp_tlstcp_get_taddr;
t->flags |= NETSNMP_TRANSPORT_FLAG_TUNNELED | NETSNMP_TRANSPORT_FLAG_STREAM;
return t;
}
netsnmp_transport *
netsnmp_tlstcp_create_tstring(const char *str, int local,
const char *default_target)
{
char buf[SPRINT_MAX_LEN];
if (str == NULL || *str == '\0')
str = default_target + 1; /* drop the leading : */
else if (!strchr(str, ':')) {
/* it's either :port or :address. Try to guess which. */
const char *cp;
int isport = 1;
for(cp = str; *cp != '\0'; cp++) {
/* if ALL numbers, it must be just a port */
/* if it contains anything else, assume a host or ip address */
if (!isdigit(0xFF & *cp)) {
isport = 0;
break;
}
}
if (isport) {
/* Just :NNN can be passed to openssl */
snprintf(buf, sizeof(buf)-1, "0.0.0.0:%s", str);
} else {
/* add the default port */
snprintf(buf, sizeof(buf)-1, "%s%s", str, default_target);
}
str = buf;
}
return netsnmp_tlstcp_transport(str, local);
}
netsnmp_transport *
netsnmp_tlstcp_create_ostring(const void *o, size_t o_len, int local)
{
char buf[SPRINT_MAX_LEN];
/* ensure buf is big enough */
if (o_len > SPRINT_MAX_LEN - 1)
return NULL;
memcpy(buf, o, o_len);
buf[o_len] = '\0';
return netsnmp_tlstcp_transport(buf, local);
}
void
netsnmp_tlstcp_ctor(void)
{
DEBUGMSGTL(("tlstcp", "registering TLS constructor\n"));
/* config settings */
tlstcpDomain.name = netsnmpTLSTCPDomain;
tlstcpDomain.name_length = netsnmpTLSTCPDomain_len;
tlstcpDomain.prefix = (const char**)calloc(3, sizeof(char *));
tlstcpDomain.prefix[0] = "tlstcp";
tlstcpDomain.prefix[1] = "tls";
tlstcpDomain.f_create_from_tstring = NULL;
tlstcpDomain.f_create_from_tstring_new = netsnmp_tlstcp_create_tstring;
tlstcpDomain.f_create_from_ostring = netsnmp_tlstcp_create_ostring;
netsnmp_tdomain_register(&tlstcpDomain);
}