/* 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 #include netsnmp_feature_require(cert_util) #include #include #include #include #if HAVE_STRING_H #include #else #include #endif #if HAVE_STDLIB_H #include #endif #if HAVE_UNISTD_H #include #endif #if HAVE_SYS_SOCKET_H #include #endif #if HAVE_NETINET_IN_H #include #endif #if HAVE_ARPA_INET_H #include #endif #if HAVE_NETDB_H #include #endif #if HAVE_SYS_UIO_H #include #endif #if HAVE_ARPA_INET_H #include #endif #if HAVE_DMALLOC_H #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #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); }