michael@0: /* michael@0: * vtables (and methods that call through them) for the 4 types of michael@0: * SSLSockets supported. Only one type is still supported. michael@0: * Various other functions. michael@0: * michael@0: * This Source Code Form is subject to the terms of the Mozilla Public michael@0: * License, v. 2.0. If a copy of the MPL was not distributed with this michael@0: * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ michael@0: #include "seccomon.h" michael@0: #include "cert.h" michael@0: #include "keyhi.h" michael@0: #include "ssl.h" michael@0: #include "sslimpl.h" michael@0: #include "sslproto.h" michael@0: #include "nspr.h" michael@0: #include "private/pprio.h" michael@0: #ifndef NO_PKCS11_BYPASS michael@0: #include "blapi.h" michael@0: #endif michael@0: #include "nss.h" michael@0: michael@0: #define SET_ERROR_CODE /* reminder */ michael@0: michael@0: static const sslSocketOps ssl_default_ops = { /* No SSL. */ michael@0: ssl_DefConnect, michael@0: NULL, michael@0: ssl_DefBind, michael@0: ssl_DefListen, michael@0: ssl_DefShutdown, michael@0: ssl_DefClose, michael@0: ssl_DefRecv, michael@0: ssl_DefSend, michael@0: ssl_DefRead, michael@0: ssl_DefWrite, michael@0: ssl_DefGetpeername, michael@0: ssl_DefGetsockname michael@0: }; michael@0: michael@0: static const sslSocketOps ssl_secure_ops = { /* SSL. */ michael@0: ssl_SecureConnect, michael@0: NULL, michael@0: ssl_DefBind, michael@0: ssl_DefListen, michael@0: ssl_SecureShutdown, michael@0: ssl_SecureClose, michael@0: ssl_SecureRecv, michael@0: ssl_SecureSend, michael@0: ssl_SecureRead, michael@0: ssl_SecureWrite, michael@0: ssl_DefGetpeername, michael@0: ssl_DefGetsockname michael@0: }; michael@0: michael@0: /* michael@0: ** default settings for socket enables michael@0: */ michael@0: static sslOptions ssl_defaults = { michael@0: { siBuffer, NULL, 0 }, /* nextProtoNego */ michael@0: PR_TRUE, /* useSecurity */ michael@0: PR_FALSE, /* useSocks */ michael@0: PR_FALSE, /* requestCertificate */ michael@0: 2, /* requireCertificate */ michael@0: PR_FALSE, /* handshakeAsClient */ michael@0: PR_FALSE, /* handshakeAsServer */ michael@0: PR_FALSE, /* enableSSL2 */ /* now defaults to off in NSS 3.13 */ michael@0: PR_FALSE, /* unusedBit9 */ michael@0: PR_FALSE, /* unusedBit10 */ michael@0: PR_FALSE, /* noCache */ michael@0: PR_FALSE, /* fdx */ michael@0: PR_FALSE, /* v2CompatibleHello */ /* now defaults to off in NSS 3.13 */ michael@0: PR_TRUE, /* detectRollBack */ michael@0: PR_FALSE, /* noStepDown */ michael@0: PR_FALSE, /* bypassPKCS11 */ michael@0: PR_FALSE, /* noLocks */ michael@0: PR_FALSE, /* enableSessionTickets */ michael@0: PR_FALSE, /* enableDeflate */ michael@0: 2, /* enableRenegotiation (default: requires extension) */ michael@0: PR_FALSE, /* requireSafeNegotiation */ michael@0: PR_FALSE, /* enableFalseStart */ michael@0: PR_TRUE, /* cbcRandomIV */ michael@0: PR_FALSE, /* enableOCSPStapling */ michael@0: PR_TRUE, /* enableNPN */ michael@0: PR_FALSE, /* enableALPN */ michael@0: PR_FALSE, /* dummy */ michael@0: PR_FALSE /* enableFallbackSCSV */ michael@0: }; michael@0: michael@0: /* michael@0: * default range of enabled SSL/TLS protocols michael@0: */ michael@0: static SSLVersionRange versions_defaults_stream = { michael@0: SSL_LIBRARY_VERSION_3_0, michael@0: SSL_LIBRARY_VERSION_TLS_1_0 michael@0: }; michael@0: michael@0: static SSLVersionRange versions_defaults_datagram = { michael@0: SSL_LIBRARY_VERSION_TLS_1_1, michael@0: SSL_LIBRARY_VERSION_TLS_1_1 michael@0: }; michael@0: michael@0: #define VERSIONS_DEFAULTS(variant) \ michael@0: (variant == ssl_variant_stream ? &versions_defaults_stream : \ michael@0: &versions_defaults_datagram) michael@0: michael@0: sslSessionIDLookupFunc ssl_sid_lookup; michael@0: sslSessionIDCacheFunc ssl_sid_cache; michael@0: sslSessionIDUncacheFunc ssl_sid_uncache; michael@0: michael@0: static PRBool ssl_inited = PR_FALSE; michael@0: static PRDescIdentity ssl_layer_id; michael@0: michael@0: PRBool locksEverDisabled; /* implicitly PR_FALSE */ michael@0: PRBool ssl_force_locks; /* implicitly PR_FALSE */ michael@0: int ssl_lock_readers = 1; /* default true. */ michael@0: char ssl_debug; michael@0: char ssl_trace; michael@0: FILE * ssl_trace_iob; michael@0: FILE * ssl_keylog_iob; michael@0: char lockStatus[] = "Locks are ENABLED. "; michael@0: #define LOCKSTATUS_OFFSET 10 /* offset of ENABLED */ michael@0: michael@0: /* SRTP_NULL_HMAC_SHA1_80 and SRTP_NULL_HMAC_SHA1_32 are not implemented. */ michael@0: static const PRUint16 srtpCiphers[] = { michael@0: SRTP_AES128_CM_HMAC_SHA1_80, michael@0: SRTP_AES128_CM_HMAC_SHA1_32, michael@0: 0 michael@0: }; michael@0: michael@0: /* forward declarations. */ michael@0: static sslSocket *ssl_NewSocket(PRBool makeLocks, SSLProtocolVariant variant); michael@0: static SECStatus ssl_MakeLocks(sslSocket *ss); michael@0: static void ssl_SetDefaultsFromEnvironment(void); michael@0: static PRStatus ssl_PushIOLayer(sslSocket *ns, PRFileDesc *stack, michael@0: PRDescIdentity id); michael@0: michael@0: /************************************************************************/ michael@0: michael@0: /* michael@0: ** Lookup a socket structure from a file descriptor. michael@0: ** Only functions called through the PRIOMethods table should use this. michael@0: ** Other app-callable functions should use ssl_FindSocket. michael@0: */ michael@0: static sslSocket * michael@0: ssl_GetPrivate(PRFileDesc *fd) michael@0: { michael@0: sslSocket *ss; michael@0: michael@0: PORT_Assert(fd != NULL); michael@0: PORT_Assert(fd->methods->file_type == PR_DESC_LAYERED); michael@0: PORT_Assert(fd->identity == ssl_layer_id); michael@0: michael@0: if (fd->methods->file_type != PR_DESC_LAYERED || michael@0: fd->identity != ssl_layer_id) { michael@0: PORT_SetError(PR_BAD_DESCRIPTOR_ERROR); michael@0: return NULL; michael@0: } michael@0: michael@0: ss = (sslSocket *)fd->secret; michael@0: /* Set ss->fd lazily. We can't rely on the value of ss->fd set by michael@0: * ssl_PushIOLayer because another PR_PushIOLayer call will switch the michael@0: * contents of the PRFileDesc pointed by ss->fd and the new layer. michael@0: * See bug 807250. michael@0: */ michael@0: ss->fd = fd; michael@0: return ss; michael@0: } michael@0: michael@0: /* This function tries to find the SSL layer in the stack. michael@0: * It searches for the first SSL layer at or below the argument fd, michael@0: * and failing that, it searches for the nearest SSL layer above the michael@0: * argument fd. It returns the private sslSocket from the found layer. michael@0: */ michael@0: sslSocket * michael@0: ssl_FindSocket(PRFileDesc *fd) michael@0: { michael@0: PRFileDesc *layer; michael@0: sslSocket *ss; michael@0: michael@0: PORT_Assert(fd != NULL); michael@0: PORT_Assert(ssl_layer_id != 0); michael@0: michael@0: layer = PR_GetIdentitiesLayer(fd, ssl_layer_id); michael@0: if (layer == NULL) { michael@0: PORT_SetError(PR_BAD_DESCRIPTOR_ERROR); michael@0: return NULL; michael@0: } michael@0: michael@0: ss = (sslSocket *)layer->secret; michael@0: /* Set ss->fd lazily. We can't rely on the value of ss->fd set by michael@0: * ssl_PushIOLayer because another PR_PushIOLayer call will switch the michael@0: * contents of the PRFileDesc pointed by ss->fd and the new layer. michael@0: * See bug 807250. michael@0: */ michael@0: ss->fd = layer; michael@0: return ss; michael@0: } michael@0: michael@0: static sslSocket * michael@0: ssl_DupSocket(sslSocket *os) michael@0: { michael@0: sslSocket *ss; michael@0: SECStatus rv; michael@0: michael@0: ss = ssl_NewSocket((PRBool)(!os->opt.noLocks), os->protocolVariant); michael@0: if (ss) { michael@0: ss->opt = os->opt; michael@0: ss->opt.useSocks = PR_FALSE; michael@0: ss->vrange = os->vrange; michael@0: michael@0: ss->peerID = !os->peerID ? NULL : PORT_Strdup(os->peerID); michael@0: ss->url = !os->url ? NULL : PORT_Strdup(os->url); michael@0: michael@0: ss->ops = os->ops; michael@0: ss->rTimeout = os->rTimeout; michael@0: ss->wTimeout = os->wTimeout; michael@0: ss->cTimeout = os->cTimeout; michael@0: ss->dbHandle = os->dbHandle; michael@0: michael@0: /* copy ssl2&3 policy & prefs, even if it's not selected (yet) */ michael@0: ss->allowedByPolicy = os->allowedByPolicy; michael@0: ss->maybeAllowedByPolicy= os->maybeAllowedByPolicy; michael@0: ss->chosenPreference = os->chosenPreference; michael@0: PORT_Memcpy(ss->cipherSuites, os->cipherSuites, sizeof os->cipherSuites); michael@0: PORT_Memcpy(ss->ssl3.dtlsSRTPCiphers, os->ssl3.dtlsSRTPCiphers, michael@0: sizeof(PRUint16) * os->ssl3.dtlsSRTPCipherCount); michael@0: ss->ssl3.dtlsSRTPCipherCount = os->ssl3.dtlsSRTPCipherCount; michael@0: michael@0: if (os->cipherSpecs) { michael@0: ss->cipherSpecs = (unsigned char*)PORT_Alloc(os->sizeCipherSpecs); michael@0: if (ss->cipherSpecs) michael@0: PORT_Memcpy(ss->cipherSpecs, os->cipherSpecs, michael@0: os->sizeCipherSpecs); michael@0: ss->sizeCipherSpecs = os->sizeCipherSpecs; michael@0: ss->preferredCipher = os->preferredCipher; michael@0: } else { michael@0: ss->cipherSpecs = NULL; /* produced lazily */ michael@0: ss->sizeCipherSpecs = 0; michael@0: ss->preferredCipher = NULL; michael@0: } michael@0: if (ss->opt.useSecurity) { michael@0: /* This int should be SSLKEAType, but CC on Irix complains, michael@0: * during the for loop. michael@0: */ michael@0: int i; michael@0: sslServerCerts * oc = os->serverCerts; michael@0: sslServerCerts * sc = ss->serverCerts; michael@0: michael@0: for (i=kt_null; i < kt_kea_size; i++, oc++, sc++) { michael@0: if (oc->serverCert && oc->serverCertChain) { michael@0: sc->serverCert = CERT_DupCertificate(oc->serverCert); michael@0: sc->serverCertChain = CERT_DupCertList(oc->serverCertChain); michael@0: if (!sc->serverCertChain) michael@0: goto loser; michael@0: } else { michael@0: sc->serverCert = NULL; michael@0: sc->serverCertChain = NULL; michael@0: } michael@0: sc->serverKeyPair = oc->serverKeyPair ? michael@0: ssl3_GetKeyPairRef(oc->serverKeyPair) : NULL; michael@0: if (oc->serverKeyPair && !sc->serverKeyPair) michael@0: goto loser; michael@0: sc->serverKeyBits = oc->serverKeyBits; michael@0: ss->certStatusArray[i] = !os->certStatusArray[i] ? NULL : michael@0: SECITEM_DupArray(NULL, os->certStatusArray[i]); michael@0: } michael@0: ss->stepDownKeyPair = !os->stepDownKeyPair ? NULL : michael@0: ssl3_GetKeyPairRef(os->stepDownKeyPair); michael@0: ss->ephemeralECDHKeyPair = !os->ephemeralECDHKeyPair ? NULL : michael@0: ssl3_GetKeyPairRef(os->ephemeralECDHKeyPair); michael@0: /* michael@0: * XXX the preceding CERT_ and SECKEY_ functions can fail and return NULL. michael@0: * XXX We should detect this, and not just march on with NULL pointers. michael@0: */ michael@0: ss->authCertificate = os->authCertificate; michael@0: ss->authCertificateArg = os->authCertificateArg; michael@0: ss->getClientAuthData = os->getClientAuthData; michael@0: ss->getClientAuthDataArg = os->getClientAuthDataArg; michael@0: ss->sniSocketConfig = os->sniSocketConfig; michael@0: ss->sniSocketConfigArg = os->sniSocketConfigArg; michael@0: ss->handleBadCert = os->handleBadCert; michael@0: ss->badCertArg = os->badCertArg; michael@0: ss->handshakeCallback = os->handshakeCallback; michael@0: ss->handshakeCallbackData = os->handshakeCallbackData; michael@0: ss->canFalseStartCallback = os->canFalseStartCallback; michael@0: ss->canFalseStartCallbackData = os->canFalseStartCallbackData; michael@0: ss->pkcs11PinArg = os->pkcs11PinArg; michael@0: michael@0: /* Create security data */ michael@0: rv = ssl_CopySecurityInfo(ss, os); michael@0: if (rv != SECSuccess) { michael@0: goto loser; michael@0: } michael@0: } michael@0: } michael@0: return ss; michael@0: michael@0: loser: michael@0: ssl_FreeSocket(ss); michael@0: return NULL; michael@0: } michael@0: michael@0: static void michael@0: ssl_DestroyLocks(sslSocket *ss) michael@0: { michael@0: /* Destroy locks. */ michael@0: if (ss->firstHandshakeLock) { michael@0: PZ_DestroyMonitor(ss->firstHandshakeLock); michael@0: ss->firstHandshakeLock = NULL; michael@0: } michael@0: if (ss->ssl3HandshakeLock) { michael@0: PZ_DestroyMonitor(ss->ssl3HandshakeLock); michael@0: ss->ssl3HandshakeLock = NULL; michael@0: } michael@0: if (ss->specLock) { michael@0: NSSRWLock_Destroy(ss->specLock); michael@0: ss->specLock = NULL; michael@0: } michael@0: michael@0: if (ss->recvLock) { michael@0: PZ_DestroyLock(ss->recvLock); michael@0: ss->recvLock = NULL; michael@0: } michael@0: if (ss->sendLock) { michael@0: PZ_DestroyLock(ss->sendLock); michael@0: ss->sendLock = NULL; michael@0: } michael@0: if (ss->xmitBufLock) { michael@0: PZ_DestroyMonitor(ss->xmitBufLock); michael@0: ss->xmitBufLock = NULL; michael@0: } michael@0: if (ss->recvBufLock) { michael@0: PZ_DestroyMonitor(ss->recvBufLock); michael@0: ss->recvBufLock = NULL; michael@0: } michael@0: } michael@0: michael@0: /* Caller holds any relevant locks */ michael@0: static void michael@0: ssl_DestroySocketContents(sslSocket *ss) michael@0: { michael@0: /* "i" should be of type SSLKEAType, but CC on IRIX complains during michael@0: * the for loop. michael@0: */ michael@0: int i; michael@0: michael@0: /* Free up socket */ michael@0: ssl_DestroySecurityInfo(&ss->sec); michael@0: michael@0: ssl3_DestroySSL3Info(ss); michael@0: michael@0: PORT_Free(ss->saveBuf.buf); michael@0: PORT_Free(ss->pendingBuf.buf); michael@0: ssl_DestroyGather(&ss->gs); michael@0: michael@0: if (ss->peerID != NULL) michael@0: PORT_Free(ss->peerID); michael@0: if (ss->url != NULL) michael@0: PORT_Free((void *)ss->url); /* CONST */ michael@0: if (ss->cipherSpecs) { michael@0: PORT_Free(ss->cipherSpecs); michael@0: ss->cipherSpecs = NULL; michael@0: ss->sizeCipherSpecs = 0; michael@0: } michael@0: michael@0: /* Clean up server configuration */ michael@0: for (i=kt_null; i < kt_kea_size; i++) { michael@0: sslServerCerts * sc = ss->serverCerts + i; michael@0: if (sc->serverCert != NULL) michael@0: CERT_DestroyCertificate(sc->serverCert); michael@0: if (sc->serverCertChain != NULL) michael@0: CERT_DestroyCertificateList(sc->serverCertChain); michael@0: if (sc->serverKeyPair != NULL) michael@0: ssl3_FreeKeyPair(sc->serverKeyPair); michael@0: if (ss->certStatusArray[i] != NULL) { michael@0: SECITEM_FreeArray(ss->certStatusArray[i], PR_TRUE); michael@0: ss->certStatusArray[i] = NULL; michael@0: } michael@0: } michael@0: if (ss->stepDownKeyPair) { michael@0: ssl3_FreeKeyPair(ss->stepDownKeyPair); michael@0: ss->stepDownKeyPair = NULL; michael@0: } michael@0: if (ss->ephemeralECDHKeyPair) { michael@0: ssl3_FreeKeyPair(ss->ephemeralECDHKeyPair); michael@0: ss->ephemeralECDHKeyPair = NULL; michael@0: } michael@0: SECITEM_FreeItem(&ss->opt.nextProtoNego, PR_FALSE); michael@0: PORT_Assert(!ss->xtnData.sniNameArr); michael@0: if (ss->xtnData.sniNameArr) { michael@0: PORT_Free(ss->xtnData.sniNameArr); michael@0: ss->xtnData.sniNameArr = NULL; michael@0: } michael@0: } michael@0: michael@0: /* michael@0: * free an sslSocket struct, and all the stuff that hangs off of it michael@0: */ michael@0: void michael@0: ssl_FreeSocket(sslSocket *ss) michael@0: { michael@0: /* Get every lock you can imagine! michael@0: ** Caller already holds these: michael@0: ** SSL_LOCK_READER(ss); michael@0: ** SSL_LOCK_WRITER(ss); michael@0: */ michael@0: ssl_Get1stHandshakeLock(ss); michael@0: ssl_GetRecvBufLock(ss); michael@0: ssl_GetSSL3HandshakeLock(ss); michael@0: ssl_GetXmitBufLock(ss); michael@0: ssl_GetSpecWriteLock(ss); michael@0: michael@0: ssl_DestroySocketContents(ss); michael@0: michael@0: /* Release all the locks acquired above. */ michael@0: SSL_UNLOCK_READER(ss); michael@0: SSL_UNLOCK_WRITER(ss); michael@0: ssl_Release1stHandshakeLock(ss); michael@0: ssl_ReleaseRecvBufLock(ss); michael@0: ssl_ReleaseSSL3HandshakeLock(ss); michael@0: ssl_ReleaseXmitBufLock(ss); michael@0: ssl_ReleaseSpecWriteLock(ss); michael@0: michael@0: ssl_DestroyLocks(ss); michael@0: michael@0: #ifdef DEBUG michael@0: PORT_Memset(ss, 0x1f, sizeof *ss); michael@0: #endif michael@0: PORT_Free(ss); michael@0: return; michael@0: } michael@0: michael@0: /************************************************************************/ michael@0: SECStatus michael@0: ssl_EnableNagleDelay(sslSocket *ss, PRBool enabled) michael@0: { michael@0: PRFileDesc * osfd = ss->fd->lower; michael@0: SECStatus rv = SECFailure; michael@0: PRSocketOptionData opt; michael@0: michael@0: opt.option = PR_SockOpt_NoDelay; michael@0: opt.value.no_delay = (PRBool)!enabled; michael@0: michael@0: if (osfd->methods->setsocketoption) { michael@0: rv = (SECStatus) osfd->methods->setsocketoption(osfd, &opt); michael@0: } else { michael@0: PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); michael@0: } michael@0: michael@0: return rv; michael@0: } michael@0: michael@0: static void michael@0: ssl_ChooseOps(sslSocket *ss) michael@0: { michael@0: ss->ops = ss->opt.useSecurity ? &ssl_secure_ops : &ssl_default_ops; michael@0: } michael@0: michael@0: /* Called from SSL_Enable (immediately below) */ michael@0: static SECStatus michael@0: PrepareSocket(sslSocket *ss) michael@0: { michael@0: SECStatus rv = SECSuccess; michael@0: michael@0: ssl_ChooseOps(ss); michael@0: return rv; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_Enable(PRFileDesc *fd, int which, PRBool on) michael@0: { michael@0: return SSL_OptionSet(fd, which, on); michael@0: } michael@0: michael@0: #ifndef NO_PKCS11_BYPASS michael@0: static const PRCallOnceType pristineCallOnce; michael@0: static PRCallOnceType setupBypassOnce; michael@0: michael@0: static SECStatus SSL_BypassShutdown(void* appData, void* nssData) michael@0: { michael@0: /* unload freeBL shared library from memory */ michael@0: BL_Unload(); michael@0: setupBypassOnce = pristineCallOnce; michael@0: return SECSuccess; michael@0: } michael@0: michael@0: static PRStatus SSL_BypassRegisterShutdown(void) michael@0: { michael@0: SECStatus rv = NSS_RegisterShutdown(SSL_BypassShutdown, NULL); michael@0: PORT_Assert(SECSuccess == rv); michael@0: return SECSuccess == rv ? PR_SUCCESS : PR_FAILURE; michael@0: } michael@0: #endif michael@0: michael@0: static PRStatus SSL_BypassSetup(void) michael@0: { michael@0: #ifdef NO_PKCS11_BYPASS michael@0: /* Guarantee binary compatibility */ michael@0: return PR_SUCCESS; michael@0: #else michael@0: return PR_CallOnce(&setupBypassOnce, &SSL_BypassRegisterShutdown); michael@0: #endif michael@0: } michael@0: michael@0: /* Implements the semantics for SSL_OptionSet(SSL_ENABLE_TLS, on) described in michael@0: * ssl.h in the section "SSL version range setting API". michael@0: */ michael@0: static void michael@0: ssl_EnableTLS(SSLVersionRange *vrange, PRBool on) michael@0: { michael@0: if (SSL3_ALL_VERSIONS_DISABLED(vrange)) { michael@0: if (on) { michael@0: vrange->min = SSL_LIBRARY_VERSION_TLS_1_0; michael@0: vrange->max = SSL_LIBRARY_VERSION_TLS_1_0; michael@0: } /* else don't change anything */ michael@0: return; michael@0: } michael@0: michael@0: if (on) { michael@0: /* Expand the range of enabled version to include TLS 1.0 */ michael@0: vrange->min = PR_MIN(vrange->min, SSL_LIBRARY_VERSION_TLS_1_0); michael@0: vrange->max = PR_MAX(vrange->max, SSL_LIBRARY_VERSION_TLS_1_0); michael@0: } else { michael@0: /* Disable all TLS versions, leaving only SSL 3.0 if it was enabled */ michael@0: if (vrange->min == SSL_LIBRARY_VERSION_3_0) { michael@0: vrange->max = SSL_LIBRARY_VERSION_3_0; michael@0: } else { michael@0: /* Only TLS was enabled, so now no versions are. */ michael@0: vrange->min = SSL_LIBRARY_VERSION_NONE; michael@0: vrange->max = SSL_LIBRARY_VERSION_NONE; michael@0: } michael@0: } michael@0: } michael@0: michael@0: /* Implements the semantics for SSL_OptionSet(SSL_ENABLE_SSL3, on) described in michael@0: * ssl.h in the section "SSL version range setting API". michael@0: */ michael@0: static void michael@0: ssl_EnableSSL3(SSLVersionRange *vrange, PRBool on) michael@0: { michael@0: if (SSL3_ALL_VERSIONS_DISABLED(vrange)) { michael@0: if (on) { michael@0: vrange->min = SSL_LIBRARY_VERSION_3_0; michael@0: vrange->max = SSL_LIBRARY_VERSION_3_0; michael@0: } /* else don't change anything */ michael@0: return; michael@0: } michael@0: michael@0: if (on) { michael@0: /* Expand the range of enabled versions to include SSL 3.0. We know michael@0: * SSL 3.0 or some version of TLS is already enabled at this point, so michael@0: * we don't need to change vrange->max. michael@0: */ michael@0: vrange->min = SSL_LIBRARY_VERSION_3_0; michael@0: } else { michael@0: /* Disable SSL 3.0, leaving TLS unaffected. */ michael@0: if (vrange->max > SSL_LIBRARY_VERSION_3_0) { michael@0: vrange->min = PR_MAX(vrange->min, SSL_LIBRARY_VERSION_TLS_1_0); michael@0: } else { michael@0: /* Only SSL 3.0 was enabled, so now no versions are. */ michael@0: vrange->min = SSL_LIBRARY_VERSION_NONE; michael@0: vrange->max = SSL_LIBRARY_VERSION_NONE; michael@0: } michael@0: } michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_OptionSet(PRFileDesc *fd, PRInt32 which, PRBool on) michael@0: { michael@0: sslSocket *ss = ssl_FindSocket(fd); michael@0: SECStatus rv = SECSuccess; michael@0: PRBool holdingLocks; michael@0: michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in Enable", SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: michael@0: holdingLocks = (!ss->opt.noLocks); michael@0: ssl_Get1stHandshakeLock(ss); michael@0: ssl_GetSSL3HandshakeLock(ss); michael@0: michael@0: switch (which) { michael@0: case SSL_SOCKS: michael@0: ss->opt.useSocks = PR_FALSE; michael@0: rv = PrepareSocket(ss); michael@0: if (on) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; michael@0: } michael@0: break; michael@0: michael@0: case SSL_SECURITY: michael@0: ss->opt.useSecurity = on; michael@0: rv = PrepareSocket(ss); michael@0: break; michael@0: michael@0: case SSL_REQUEST_CERTIFICATE: michael@0: ss->opt.requestCertificate = on; michael@0: break; michael@0: michael@0: case SSL_REQUIRE_CERTIFICATE: michael@0: ss->opt.requireCertificate = on; michael@0: break; michael@0: michael@0: case SSL_HANDSHAKE_AS_CLIENT: michael@0: if ( ss->opt.handshakeAsServer && on ) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; michael@0: break; michael@0: } michael@0: ss->opt.handshakeAsClient = on; michael@0: break; michael@0: michael@0: case SSL_HANDSHAKE_AS_SERVER: michael@0: if ( ss->opt.handshakeAsClient && on ) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; michael@0: break; michael@0: } michael@0: ss->opt.handshakeAsServer = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_TLS: michael@0: if (IS_DTLS(ss)) { michael@0: if (on) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; /* not allowed */ michael@0: } michael@0: break; michael@0: } michael@0: ssl_EnableTLS(&ss->vrange, on); michael@0: ss->preferredCipher = NULL; michael@0: if (ss->cipherSpecs) { michael@0: PORT_Free(ss->cipherSpecs); michael@0: ss->cipherSpecs = NULL; michael@0: ss->sizeCipherSpecs = 0; michael@0: } michael@0: break; michael@0: michael@0: case SSL_ENABLE_SSL3: michael@0: if (IS_DTLS(ss)) { michael@0: if (on) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; /* not allowed */ michael@0: } michael@0: break; michael@0: } michael@0: ssl_EnableSSL3(&ss->vrange, on); michael@0: ss->preferredCipher = NULL; michael@0: if (ss->cipherSpecs) { michael@0: PORT_Free(ss->cipherSpecs); michael@0: ss->cipherSpecs = NULL; michael@0: ss->sizeCipherSpecs = 0; michael@0: } michael@0: break; michael@0: michael@0: case SSL_ENABLE_SSL2: michael@0: if (IS_DTLS(ss)) { michael@0: if (on) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; /* not allowed */ michael@0: } michael@0: break; michael@0: } michael@0: ss->opt.enableSSL2 = on; michael@0: if (on) { michael@0: ss->opt.v2CompatibleHello = on; michael@0: } michael@0: ss->preferredCipher = NULL; michael@0: if (ss->cipherSpecs) { michael@0: PORT_Free(ss->cipherSpecs); michael@0: ss->cipherSpecs = NULL; michael@0: ss->sizeCipherSpecs = 0; michael@0: } michael@0: break; michael@0: michael@0: case SSL_NO_CACHE: michael@0: ss->opt.noCache = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_FDX: michael@0: if (on && ss->opt.noLocks) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; michael@0: } michael@0: ss->opt.fdx = on; michael@0: break; michael@0: michael@0: case SSL_V2_COMPATIBLE_HELLO: michael@0: if (IS_DTLS(ss)) { michael@0: if (on) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; /* not allowed */ michael@0: } michael@0: break; michael@0: } michael@0: ss->opt.v2CompatibleHello = on; michael@0: if (!on) { michael@0: ss->opt.enableSSL2 = on; michael@0: } michael@0: break; michael@0: michael@0: case SSL_ROLLBACK_DETECTION: michael@0: ss->opt.detectRollBack = on; michael@0: break; michael@0: michael@0: case SSL_NO_STEP_DOWN: michael@0: ss->opt.noStepDown = on; michael@0: if (on) michael@0: SSL_DisableExportCipherSuites(fd); michael@0: break; michael@0: michael@0: case SSL_BYPASS_PKCS11: michael@0: if (ss->handshakeBegun) { michael@0: PORT_SetError(PR_INVALID_STATE_ERROR); michael@0: rv = SECFailure; michael@0: } else { michael@0: if (PR_FALSE != on) { michael@0: if (PR_SUCCESS == SSL_BypassSetup() ) { michael@0: #ifdef NO_PKCS11_BYPASS michael@0: ss->opt.bypassPKCS11 = PR_FALSE; michael@0: #else michael@0: ss->opt.bypassPKCS11 = on; michael@0: #endif michael@0: } else { michael@0: rv = SECFailure; michael@0: } michael@0: } else { michael@0: ss->opt.bypassPKCS11 = PR_FALSE; michael@0: } michael@0: } michael@0: break; michael@0: michael@0: case SSL_NO_LOCKS: michael@0: if (on && ss->opt.fdx) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; michael@0: } michael@0: if (on && ssl_force_locks) michael@0: on = PR_FALSE; /* silent override */ michael@0: ss->opt.noLocks = on; michael@0: if (on) { michael@0: locksEverDisabled = PR_TRUE; michael@0: strcpy(lockStatus + LOCKSTATUS_OFFSET, "DISABLED."); michael@0: } else if (!holdingLocks) { michael@0: rv = ssl_MakeLocks(ss); michael@0: if (rv != SECSuccess) { michael@0: ss->opt.noLocks = PR_TRUE; michael@0: } michael@0: } michael@0: break; michael@0: michael@0: case SSL_ENABLE_SESSION_TICKETS: michael@0: ss->opt.enableSessionTickets = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_DEFLATE: michael@0: ss->opt.enableDeflate = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_RENEGOTIATION: michael@0: ss->opt.enableRenegotiation = on; michael@0: break; michael@0: michael@0: case SSL_REQUIRE_SAFE_NEGOTIATION: michael@0: ss->opt.requireSafeNegotiation = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_FALSE_START: michael@0: ss->opt.enableFalseStart = on; michael@0: break; michael@0: michael@0: case SSL_CBC_RANDOM_IV: michael@0: ss->opt.cbcRandomIV = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_OCSP_STAPLING: michael@0: ss->opt.enableOCSPStapling = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_NPN: michael@0: ss->opt.enableNPN = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_ALPN: michael@0: ss->opt.enableALPN = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_FALLBACK_SCSV: michael@0: ss->opt.enableFallbackSCSV = on; michael@0: break; michael@0: michael@0: default: michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; michael@0: } michael@0: michael@0: /* We can't use the macros for releasing the locks here, michael@0: * because ss->opt.noLocks might have changed just above. michael@0: * We must release these locks (monitors) here, if we aquired them above, michael@0: * regardless of the current value of ss->opt.noLocks. michael@0: */ michael@0: if (holdingLocks) { michael@0: PZ_ExitMonitor((ss)->ssl3HandshakeLock); michael@0: PZ_ExitMonitor((ss)->firstHandshakeLock); michael@0: } michael@0: michael@0: return rv; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_OptionGet(PRFileDesc *fd, PRInt32 which, PRBool *pOn) michael@0: { michael@0: sslSocket *ss = ssl_FindSocket(fd); michael@0: SECStatus rv = SECSuccess; michael@0: PRBool on = PR_FALSE; michael@0: michael@0: if (!pOn) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in Enable", SSL_GETPID(), fd)); michael@0: *pOn = PR_FALSE; michael@0: return SECFailure; michael@0: } michael@0: michael@0: ssl_Get1stHandshakeLock(ss); michael@0: ssl_GetSSL3HandshakeLock(ss); michael@0: michael@0: switch (which) { michael@0: case SSL_SOCKS: on = PR_FALSE; break; michael@0: case SSL_SECURITY: on = ss->opt.useSecurity; break; michael@0: case SSL_REQUEST_CERTIFICATE: on = ss->opt.requestCertificate; break; michael@0: case SSL_REQUIRE_CERTIFICATE: on = ss->opt.requireCertificate; break; michael@0: case SSL_HANDSHAKE_AS_CLIENT: on = ss->opt.handshakeAsClient; break; michael@0: case SSL_HANDSHAKE_AS_SERVER: on = ss->opt.handshakeAsServer; break; michael@0: case SSL_ENABLE_TLS: michael@0: on = ss->vrange.max >= SSL_LIBRARY_VERSION_TLS_1_0; michael@0: break; michael@0: case SSL_ENABLE_SSL3: michael@0: on = ss->vrange.min == SSL_LIBRARY_VERSION_3_0; michael@0: break; michael@0: case SSL_ENABLE_SSL2: on = ss->opt.enableSSL2; break; michael@0: case SSL_NO_CACHE: on = ss->opt.noCache; break; michael@0: case SSL_ENABLE_FDX: on = ss->opt.fdx; break; michael@0: case SSL_V2_COMPATIBLE_HELLO: on = ss->opt.v2CompatibleHello; break; michael@0: case SSL_ROLLBACK_DETECTION: on = ss->opt.detectRollBack; break; michael@0: case SSL_NO_STEP_DOWN: on = ss->opt.noStepDown; break; michael@0: case SSL_BYPASS_PKCS11: on = ss->opt.bypassPKCS11; break; michael@0: case SSL_NO_LOCKS: on = ss->opt.noLocks; break; michael@0: case SSL_ENABLE_SESSION_TICKETS: michael@0: on = ss->opt.enableSessionTickets; michael@0: break; michael@0: case SSL_ENABLE_DEFLATE: on = ss->opt.enableDeflate; break; michael@0: case SSL_ENABLE_RENEGOTIATION: michael@0: on = ss->opt.enableRenegotiation; break; michael@0: case SSL_REQUIRE_SAFE_NEGOTIATION: michael@0: on = ss->opt.requireSafeNegotiation; break; michael@0: case SSL_ENABLE_FALSE_START: on = ss->opt.enableFalseStart; break; michael@0: case SSL_CBC_RANDOM_IV: on = ss->opt.cbcRandomIV; break; michael@0: case SSL_ENABLE_OCSP_STAPLING: on = ss->opt.enableOCSPStapling; break; michael@0: case SSL_ENABLE_NPN: on = ss->opt.enableNPN; break; michael@0: case SSL_ENABLE_ALPN: on = ss->opt.enableALPN; break; michael@0: case SSL_ENABLE_FALLBACK_SCSV: on = ss->opt.enableFallbackSCSV; break; michael@0: michael@0: default: michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; michael@0: } michael@0: michael@0: ssl_ReleaseSSL3HandshakeLock(ss); michael@0: ssl_Release1stHandshakeLock(ss); michael@0: michael@0: *pOn = on; michael@0: return rv; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_OptionGetDefault(PRInt32 which, PRBool *pOn) michael@0: { michael@0: SECStatus rv = SECSuccess; michael@0: PRBool on = PR_FALSE; michael@0: michael@0: if (!pOn) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: michael@0: ssl_SetDefaultsFromEnvironment(); michael@0: michael@0: switch (which) { michael@0: case SSL_SOCKS: on = PR_FALSE; break; michael@0: case SSL_SECURITY: on = ssl_defaults.useSecurity; break; michael@0: case SSL_REQUEST_CERTIFICATE: on = ssl_defaults.requestCertificate; break; michael@0: case SSL_REQUIRE_CERTIFICATE: on = ssl_defaults.requireCertificate; break; michael@0: case SSL_HANDSHAKE_AS_CLIENT: on = ssl_defaults.handshakeAsClient; break; michael@0: case SSL_HANDSHAKE_AS_SERVER: on = ssl_defaults.handshakeAsServer; break; michael@0: case SSL_ENABLE_TLS: michael@0: on = versions_defaults_stream.max >= SSL_LIBRARY_VERSION_TLS_1_0; michael@0: break; michael@0: case SSL_ENABLE_SSL3: michael@0: on = versions_defaults_stream.min == SSL_LIBRARY_VERSION_3_0; michael@0: break; michael@0: case SSL_ENABLE_SSL2: on = ssl_defaults.enableSSL2; break; michael@0: case SSL_NO_CACHE: on = ssl_defaults.noCache; break; michael@0: case SSL_ENABLE_FDX: on = ssl_defaults.fdx; break; michael@0: case SSL_V2_COMPATIBLE_HELLO: on = ssl_defaults.v2CompatibleHello; break; michael@0: case SSL_ROLLBACK_DETECTION: on = ssl_defaults.detectRollBack; break; michael@0: case SSL_NO_STEP_DOWN: on = ssl_defaults.noStepDown; break; michael@0: case SSL_BYPASS_PKCS11: on = ssl_defaults.bypassPKCS11; break; michael@0: case SSL_NO_LOCKS: on = ssl_defaults.noLocks; break; michael@0: case SSL_ENABLE_SESSION_TICKETS: michael@0: on = ssl_defaults.enableSessionTickets; michael@0: break; michael@0: case SSL_ENABLE_DEFLATE: on = ssl_defaults.enableDeflate; break; michael@0: case SSL_ENABLE_RENEGOTIATION: michael@0: on = ssl_defaults.enableRenegotiation; break; michael@0: case SSL_REQUIRE_SAFE_NEGOTIATION: michael@0: on = ssl_defaults.requireSafeNegotiation; michael@0: break; michael@0: case SSL_ENABLE_FALSE_START: on = ssl_defaults.enableFalseStart; break; michael@0: case SSL_CBC_RANDOM_IV: on = ssl_defaults.cbcRandomIV; break; michael@0: case SSL_ENABLE_OCSP_STAPLING: michael@0: on = ssl_defaults.enableOCSPStapling; michael@0: break; michael@0: case SSL_ENABLE_NPN: on = ssl_defaults.enableNPN; break; michael@0: case SSL_ENABLE_ALPN: on = ssl_defaults.enableALPN; break; michael@0: case SSL_ENABLE_FALLBACK_SCSV: michael@0: on = ssl_defaults.enableFallbackSCSV; michael@0: break; michael@0: michael@0: default: michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: rv = SECFailure; michael@0: } michael@0: michael@0: *pOn = on; michael@0: return rv; michael@0: } michael@0: michael@0: /* XXX Use Global Lock to protect this stuff. */ michael@0: SECStatus michael@0: SSL_EnableDefault(int which, PRBool on) michael@0: { michael@0: return SSL_OptionSetDefault(which, on); michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_OptionSetDefault(PRInt32 which, PRBool on) michael@0: { michael@0: SECStatus status = ssl_Init(); michael@0: michael@0: if (status != SECSuccess) { michael@0: return status; michael@0: } michael@0: michael@0: ssl_SetDefaultsFromEnvironment(); michael@0: michael@0: switch (which) { michael@0: case SSL_SOCKS: michael@0: ssl_defaults.useSocks = PR_FALSE; michael@0: if (on) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: break; michael@0: michael@0: case SSL_SECURITY: michael@0: ssl_defaults.useSecurity = on; michael@0: break; michael@0: michael@0: case SSL_REQUEST_CERTIFICATE: michael@0: ssl_defaults.requestCertificate = on; michael@0: break; michael@0: michael@0: case SSL_REQUIRE_CERTIFICATE: michael@0: ssl_defaults.requireCertificate = on; michael@0: break; michael@0: michael@0: case SSL_HANDSHAKE_AS_CLIENT: michael@0: if ( ssl_defaults.handshakeAsServer && on ) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: ssl_defaults.handshakeAsClient = on; michael@0: break; michael@0: michael@0: case SSL_HANDSHAKE_AS_SERVER: michael@0: if ( ssl_defaults.handshakeAsClient && on ) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: ssl_defaults.handshakeAsServer = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_TLS: michael@0: ssl_EnableTLS(&versions_defaults_stream, on); michael@0: break; michael@0: michael@0: case SSL_ENABLE_SSL3: michael@0: ssl_EnableSSL3(&versions_defaults_stream, on); michael@0: break; michael@0: michael@0: case SSL_ENABLE_SSL2: michael@0: ssl_defaults.enableSSL2 = on; michael@0: if (on) { michael@0: ssl_defaults.v2CompatibleHello = on; michael@0: } michael@0: break; michael@0: michael@0: case SSL_NO_CACHE: michael@0: ssl_defaults.noCache = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_FDX: michael@0: if (on && ssl_defaults.noLocks) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: ssl_defaults.fdx = on; michael@0: break; michael@0: michael@0: case SSL_V2_COMPATIBLE_HELLO: michael@0: ssl_defaults.v2CompatibleHello = on; michael@0: if (!on) { michael@0: ssl_defaults.enableSSL2 = on; michael@0: } michael@0: break; michael@0: michael@0: case SSL_ROLLBACK_DETECTION: michael@0: ssl_defaults.detectRollBack = on; michael@0: break; michael@0: michael@0: case SSL_NO_STEP_DOWN: michael@0: ssl_defaults.noStepDown = on; michael@0: if (on) michael@0: SSL_DisableDefaultExportCipherSuites(); michael@0: break; michael@0: michael@0: case SSL_BYPASS_PKCS11: michael@0: if (PR_FALSE != on) { michael@0: if (PR_SUCCESS == SSL_BypassSetup()) { michael@0: #ifdef NO_PKCS11_BYPASS michael@0: ssl_defaults.bypassPKCS11 = PR_FALSE; michael@0: #else michael@0: ssl_defaults.bypassPKCS11 = on; michael@0: #endif michael@0: } else { michael@0: return SECFailure; michael@0: } michael@0: } else { michael@0: ssl_defaults.bypassPKCS11 = PR_FALSE; michael@0: } michael@0: break; michael@0: michael@0: case SSL_NO_LOCKS: michael@0: if (on && ssl_defaults.fdx) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: if (on && ssl_force_locks) michael@0: on = PR_FALSE; /* silent override */ michael@0: ssl_defaults.noLocks = on; michael@0: if (on) { michael@0: locksEverDisabled = PR_TRUE; michael@0: strcpy(lockStatus + LOCKSTATUS_OFFSET, "DISABLED."); michael@0: } michael@0: break; michael@0: michael@0: case SSL_ENABLE_SESSION_TICKETS: michael@0: ssl_defaults.enableSessionTickets = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_DEFLATE: michael@0: ssl_defaults.enableDeflate = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_RENEGOTIATION: michael@0: ssl_defaults.enableRenegotiation = on; michael@0: break; michael@0: michael@0: case SSL_REQUIRE_SAFE_NEGOTIATION: michael@0: ssl_defaults.requireSafeNegotiation = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_FALSE_START: michael@0: ssl_defaults.enableFalseStart = on; michael@0: break; michael@0: michael@0: case SSL_CBC_RANDOM_IV: michael@0: ssl_defaults.cbcRandomIV = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_OCSP_STAPLING: michael@0: ssl_defaults.enableOCSPStapling = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_NPN: michael@0: ssl_defaults.enableNPN = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_ALPN: michael@0: ssl_defaults.enableALPN = on; michael@0: break; michael@0: michael@0: case SSL_ENABLE_FALLBACK_SCSV: michael@0: ssl_defaults.enableFallbackSCSV = on; michael@0: break; michael@0: michael@0: default: michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: return SECSuccess; michael@0: } michael@0: michael@0: /* function tells us if the cipher suite is one that we no longer support. */ michael@0: static PRBool michael@0: ssl_IsRemovedCipherSuite(PRInt32 suite) michael@0: { michael@0: switch (suite) { michael@0: case SSL_FORTEZZA_DMS_WITH_NULL_SHA: michael@0: case SSL_FORTEZZA_DMS_WITH_FORTEZZA_CBC_SHA: michael@0: case SSL_FORTEZZA_DMS_WITH_RC4_128_SHA: michael@0: return PR_TRUE; michael@0: default: michael@0: return PR_FALSE; michael@0: } michael@0: } michael@0: michael@0: /* Part of the public NSS API. michael@0: * Since this is a global (not per-socket) setting, we cannot use the michael@0: * HandshakeLock to protect this. Probably want a global lock. michael@0: */ michael@0: SECStatus michael@0: SSL_SetPolicy(long which, int policy) michael@0: { michael@0: if ((which & 0xfffe) == SSL_RSA_OLDFIPS_WITH_3DES_EDE_CBC_SHA) { michael@0: /* one of the two old FIPS ciphers */ michael@0: if (which == SSL_RSA_OLDFIPS_WITH_3DES_EDE_CBC_SHA) michael@0: which = SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA; michael@0: else if (which == SSL_RSA_OLDFIPS_WITH_DES_CBC_SHA) michael@0: which = SSL_RSA_FIPS_WITH_DES_CBC_SHA; michael@0: } michael@0: if (ssl_IsRemovedCipherSuite(which)) michael@0: return SECSuccess; michael@0: return SSL_CipherPolicySet(which, policy); michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_CipherPolicySet(PRInt32 which, PRInt32 policy) michael@0: { michael@0: SECStatus rv = ssl_Init(); michael@0: michael@0: if (rv != SECSuccess) { michael@0: return rv; michael@0: } michael@0: michael@0: if (ssl_IsRemovedCipherSuite(which)) { michael@0: rv = SECSuccess; michael@0: } else if (SSL_IS_SSL2_CIPHER(which)) { michael@0: rv = ssl2_SetPolicy(which, policy); michael@0: } else { michael@0: rv = ssl3_SetPolicy((ssl3CipherSuite)which, policy); michael@0: } michael@0: return rv; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_CipherPolicyGet(PRInt32 which, PRInt32 *oPolicy) michael@0: { michael@0: SECStatus rv; michael@0: michael@0: if (!oPolicy) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: if (ssl_IsRemovedCipherSuite(which)) { michael@0: *oPolicy = SSL_NOT_ALLOWED; michael@0: rv = SECSuccess; michael@0: } else if (SSL_IS_SSL2_CIPHER(which)) { michael@0: rv = ssl2_GetPolicy(which, oPolicy); michael@0: } else { michael@0: rv = ssl3_GetPolicy((ssl3CipherSuite)which, oPolicy); michael@0: } michael@0: return rv; michael@0: } michael@0: michael@0: /* Part of the public NSS API. michael@0: * Since this is a global (not per-socket) setting, we cannot use the michael@0: * HandshakeLock to protect this. Probably want a global lock. michael@0: * These changes have no effect on any sslSockets already created. michael@0: */ michael@0: SECStatus michael@0: SSL_EnableCipher(long which, PRBool enabled) michael@0: { michael@0: if ((which & 0xfffe) == SSL_RSA_OLDFIPS_WITH_3DES_EDE_CBC_SHA) { michael@0: /* one of the two old FIPS ciphers */ michael@0: if (which == SSL_RSA_OLDFIPS_WITH_3DES_EDE_CBC_SHA) michael@0: which = SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA; michael@0: else if (which == SSL_RSA_OLDFIPS_WITH_DES_CBC_SHA) michael@0: which = SSL_RSA_FIPS_WITH_DES_CBC_SHA; michael@0: } michael@0: if (ssl_IsRemovedCipherSuite(which)) michael@0: return SECSuccess; michael@0: return SSL_CipherPrefSetDefault(which, enabled); michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_CipherPrefSetDefault(PRInt32 which, PRBool enabled) michael@0: { michael@0: SECStatus rv = ssl_Init(); michael@0: michael@0: if (rv != SECSuccess) { michael@0: return rv; michael@0: } michael@0: michael@0: if (ssl_IsRemovedCipherSuite(which)) michael@0: return SECSuccess; michael@0: if (enabled && ssl_defaults.noStepDown && SSL_IsExportCipherSuite(which)) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ALGORITHM); michael@0: return SECFailure; michael@0: } michael@0: if (SSL_IS_SSL2_CIPHER(which)) { michael@0: rv = ssl2_CipherPrefSetDefault(which, enabled); michael@0: } else { michael@0: rv = ssl3_CipherPrefSetDefault((ssl3CipherSuite)which, enabled); michael@0: } michael@0: return rv; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_CipherPrefGetDefault(PRInt32 which, PRBool *enabled) michael@0: { michael@0: SECStatus rv; michael@0: michael@0: if (!enabled) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: if (ssl_IsRemovedCipherSuite(which)) { michael@0: *enabled = PR_FALSE; michael@0: rv = SECSuccess; michael@0: } else if (SSL_IS_SSL2_CIPHER(which)) { michael@0: rv = ssl2_CipherPrefGetDefault(which, enabled); michael@0: } else { michael@0: rv = ssl3_CipherPrefGetDefault((ssl3CipherSuite)which, enabled); michael@0: } michael@0: return rv; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_CipherPrefSet(PRFileDesc *fd, PRInt32 which, PRBool enabled) michael@0: { michael@0: SECStatus rv; michael@0: sslSocket *ss = ssl_FindSocket(fd); michael@0: michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in CipherPrefSet", SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: if (ssl_IsRemovedCipherSuite(which)) michael@0: return SECSuccess; michael@0: if (enabled && ss->opt.noStepDown && SSL_IsExportCipherSuite(which)) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ALGORITHM); michael@0: return SECFailure; michael@0: } michael@0: if (SSL_IS_SSL2_CIPHER(which)) { michael@0: rv = ssl2_CipherPrefSet(ss, which, enabled); michael@0: } else { michael@0: rv = ssl3_CipherPrefSet(ss, (ssl3CipherSuite)which, enabled); michael@0: } michael@0: return rv; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_CipherPrefGet(PRFileDesc *fd, PRInt32 which, PRBool *enabled) michael@0: { michael@0: SECStatus rv; michael@0: sslSocket *ss = ssl_FindSocket(fd); michael@0: michael@0: if (!enabled) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in CipherPrefGet", SSL_GETPID(), fd)); michael@0: *enabled = PR_FALSE; michael@0: return SECFailure; michael@0: } michael@0: if (ssl_IsRemovedCipherSuite(which)) { michael@0: *enabled = PR_FALSE; michael@0: rv = SECSuccess; michael@0: } else if (SSL_IS_SSL2_CIPHER(which)) { michael@0: rv = ssl2_CipherPrefGet(ss, which, enabled); michael@0: } else { michael@0: rv = ssl3_CipherPrefGet(ss, (ssl3CipherSuite)which, enabled); michael@0: } michael@0: return rv; michael@0: } michael@0: michael@0: SECStatus michael@0: NSS_SetDomesticPolicy(void) michael@0: { michael@0: SECStatus status = SECSuccess; michael@0: const PRUint16 *cipher; michael@0: michael@0: for (cipher = SSL_ImplementedCiphers; *cipher != 0; ++cipher) { michael@0: status = SSL_SetPolicy(*cipher, SSL_ALLOWED); michael@0: if (status != SECSuccess) michael@0: break; michael@0: } michael@0: return status; michael@0: } michael@0: michael@0: SECStatus michael@0: NSS_SetExportPolicy(void) michael@0: { michael@0: return NSS_SetDomesticPolicy(); michael@0: } michael@0: michael@0: SECStatus michael@0: NSS_SetFrancePolicy(void) michael@0: { michael@0: return NSS_SetDomesticPolicy(); michael@0: } michael@0: michael@0: michael@0: michael@0: /* LOCKS ??? XXX */ michael@0: static PRFileDesc * michael@0: ssl_ImportFD(PRFileDesc *model, PRFileDesc *fd, SSLProtocolVariant variant) michael@0: { michael@0: sslSocket * ns = NULL; michael@0: PRStatus rv; michael@0: PRNetAddr addr; michael@0: SECStatus status = ssl_Init(); michael@0: michael@0: if (status != SECSuccess) { michael@0: return NULL; michael@0: } michael@0: michael@0: if (model == NULL) { michael@0: /* Just create a default socket if we're given NULL for the model */ michael@0: ns = ssl_NewSocket((PRBool)(!ssl_defaults.noLocks), variant); michael@0: } else { michael@0: sslSocket * ss = ssl_FindSocket(model); michael@0: if (ss == NULL || ss->protocolVariant != variant) { michael@0: SSL_DBG(("%d: SSL[%d]: bad model socket in ssl_ImportFD", michael@0: SSL_GETPID(), model)); michael@0: return NULL; michael@0: } michael@0: ns = ssl_DupSocket(ss); michael@0: } michael@0: if (ns == NULL) michael@0: return NULL; michael@0: michael@0: rv = ssl_PushIOLayer(ns, fd, PR_TOP_IO_LAYER); michael@0: if (rv != PR_SUCCESS) { michael@0: ssl_FreeSocket(ns); michael@0: SET_ERROR_CODE michael@0: return NULL; michael@0: } michael@0: #if defined(DEBUG) || defined(FORCE_PR_ASSERT) michael@0: { michael@0: sslSocket * ss = ssl_FindSocket(fd); michael@0: PORT_Assert(ss == ns); michael@0: } michael@0: #endif michael@0: ns->TCPconnected = (PR_SUCCESS == ssl_DefGetpeername(ns, &addr)); michael@0: return fd; michael@0: } michael@0: michael@0: PRFileDesc * michael@0: SSL_ImportFD(PRFileDesc *model, PRFileDesc *fd) michael@0: { michael@0: return ssl_ImportFD(model, fd, ssl_variant_stream); michael@0: } michael@0: michael@0: PRFileDesc * michael@0: DTLS_ImportFD(PRFileDesc *model, PRFileDesc *fd) michael@0: { michael@0: return ssl_ImportFD(model, fd, ssl_variant_datagram); michael@0: } michael@0: michael@0: /* SSL_SetNextProtoCallback is used to select an application protocol michael@0: * for ALPN and NPN. For ALPN, this runs on the server; for NPN it michael@0: * runs on the client. */ michael@0: /* Note: The ALPN version doesn't allow for the use of a default, setting a michael@0: * status of SSL_NEXT_PROTO_NO_OVERLAP is treated as a failure. */ michael@0: SECStatus michael@0: SSL_SetNextProtoCallback(PRFileDesc *fd, SSLNextProtoCallback callback, michael@0: void *arg) michael@0: { michael@0: sslSocket *ss = ssl_FindSocket(fd); michael@0: michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetNextProtoCallback", SSL_GETPID(), michael@0: fd)); michael@0: return SECFailure; michael@0: } michael@0: michael@0: ssl_GetSSL3HandshakeLock(ss); michael@0: ss->nextProtoCallback = callback; michael@0: ss->nextProtoArg = arg; michael@0: ssl_ReleaseSSL3HandshakeLock(ss); michael@0: michael@0: return SECSuccess; michael@0: } michael@0: michael@0: /* ssl_NextProtoNegoCallback is set as an ALPN/NPN callback when michael@0: * SSL_SetNextProtoNego is used. michael@0: */ michael@0: static SECStatus michael@0: ssl_NextProtoNegoCallback(void *arg, PRFileDesc *fd, michael@0: const unsigned char *protos, unsigned int protos_len, michael@0: unsigned char *protoOut, unsigned int *protoOutLen, michael@0: unsigned int protoMaxLen) michael@0: { michael@0: unsigned int i, j; michael@0: const unsigned char *result; michael@0: sslSocket *ss = ssl_FindSocket(fd); michael@0: michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in ssl_NextProtoNegoCallback", michael@0: SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: michael@0: /* For each protocol in server preference, see if we support it. */ michael@0: for (i = 0; i < protos_len; ) { michael@0: for (j = 0; j < ss->opt.nextProtoNego.len; ) { michael@0: if (protos[i] == ss->opt.nextProtoNego.data[j] && michael@0: PORT_Memcmp(&protos[i+1], &ss->opt.nextProtoNego.data[j+1], michael@0: protos[i]) == 0) { michael@0: /* We found a match. */ michael@0: ss->ssl3.nextProtoState = SSL_NEXT_PROTO_NEGOTIATED; michael@0: result = &protos[i]; michael@0: goto found; michael@0: } michael@0: j += 1 + (unsigned int)ss->opt.nextProtoNego.data[j]; michael@0: } michael@0: i += 1 + (unsigned int)protos[i]; michael@0: } michael@0: michael@0: /* The other side supports the extension, and either doesn't have any michael@0: * protocols configured, or none of its options match ours. In this case we michael@0: * request our favoured protocol. */ michael@0: /* This will be treated as a failure for ALPN. */ michael@0: ss->ssl3.nextProtoState = SSL_NEXT_PROTO_NO_OVERLAP; michael@0: result = ss->opt.nextProtoNego.data; michael@0: michael@0: found: michael@0: if (protoMaxLen < result[0]) { michael@0: PORT_SetError(SEC_ERROR_OUTPUT_LEN); michael@0: return SECFailure; michael@0: } michael@0: memcpy(protoOut, result + 1, result[0]); michael@0: *protoOutLen = result[0]; michael@0: return SECSuccess; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_SetNextProtoNego(PRFileDesc *fd, const unsigned char *data, michael@0: unsigned int length) michael@0: { michael@0: sslSocket *ss; michael@0: SECStatus rv; michael@0: SECItem dataItem = { siBuffer, (unsigned char *) data, length }; michael@0: michael@0: ss = ssl_FindSocket(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetNextProtoNego", michael@0: SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: michael@0: if (ssl3_ValidateNextProtoNego(data, length) != SECSuccess) michael@0: return SECFailure; michael@0: michael@0: ssl_GetSSL3HandshakeLock(ss); michael@0: SECITEM_FreeItem(&ss->opt.nextProtoNego, PR_FALSE); michael@0: rv = SECITEM_CopyItem(NULL, &ss->opt.nextProtoNego, &dataItem); michael@0: ssl_ReleaseSSL3HandshakeLock(ss); michael@0: michael@0: if (rv != SECSuccess) michael@0: return rv; michael@0: michael@0: return SSL_SetNextProtoCallback(fd, ssl_NextProtoNegoCallback, NULL); michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_GetNextProto(PRFileDesc *fd, SSLNextProtoState *state, unsigned char *buf, michael@0: unsigned int *bufLen, unsigned int bufLenMax) michael@0: { michael@0: sslSocket *ss = ssl_FindSocket(fd); michael@0: michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in SSL_GetNextProto", SSL_GETPID(), michael@0: fd)); michael@0: return SECFailure; michael@0: } michael@0: michael@0: if (!state || !buf || !bufLen) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: michael@0: *state = ss->ssl3.nextProtoState; michael@0: michael@0: if (ss->ssl3.nextProtoState != SSL_NEXT_PROTO_NO_SUPPORT && michael@0: ss->ssl3.nextProto.data) { michael@0: if (ss->ssl3.nextProto.len > bufLenMax) { michael@0: PORT_SetError(SEC_ERROR_OUTPUT_LEN); michael@0: return SECFailure; michael@0: } michael@0: PORT_Memcpy(buf, ss->ssl3.nextProto.data, ss->ssl3.nextProto.len); michael@0: *bufLen = ss->ssl3.nextProto.len; michael@0: } else { michael@0: *bufLen = 0; michael@0: } michael@0: michael@0: return SECSuccess; michael@0: } michael@0: michael@0: SECStatus SSL_SetSRTPCiphers(PRFileDesc *fd, michael@0: const PRUint16 *ciphers, michael@0: unsigned int numCiphers) michael@0: { michael@0: sslSocket *ss; michael@0: unsigned int i; michael@0: michael@0: ss = ssl_FindSocket(fd); michael@0: if (!ss || !IS_DTLS(ss)) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetSRTPCiphers", michael@0: SSL_GETPID(), fd)); michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: michael@0: if (numCiphers > MAX_DTLS_SRTP_CIPHER_SUITES) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: michael@0: ss->ssl3.dtlsSRTPCipherCount = 0; michael@0: for (i = 0; i < numCiphers; i++) { michael@0: const PRUint16 *srtpCipher = srtpCiphers; michael@0: michael@0: while (*srtpCipher) { michael@0: if (ciphers[i] == *srtpCipher) michael@0: break; michael@0: srtpCipher++; michael@0: } michael@0: if (*srtpCipher) { michael@0: ss->ssl3.dtlsSRTPCiphers[ss->ssl3.dtlsSRTPCipherCount++] = michael@0: ciphers[i]; michael@0: } else { michael@0: SSL_DBG(("%d: SSL[%d]: invalid or unimplemented SRTP cipher " michael@0: "suite specified: 0x%04hx", SSL_GETPID(), fd, michael@0: ciphers[i])); michael@0: } michael@0: } michael@0: michael@0: if (ss->ssl3.dtlsSRTPCipherCount == 0) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: michael@0: return SECSuccess; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_GetSRTPCipher(PRFileDesc *fd, PRUint16 *cipher) michael@0: { michael@0: sslSocket * ss; michael@0: michael@0: ss = ssl_FindSocket(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in SSL_GetSRTPCipher", michael@0: SSL_GETPID(), fd)); michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: michael@0: if (!ss->ssl3.dtlsSRTPCipherSuite) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: michael@0: *cipher = ss->ssl3.dtlsSRTPCipherSuite; michael@0: return SECSuccess; michael@0: } michael@0: michael@0: PRFileDesc * michael@0: SSL_ReconfigFD(PRFileDesc *model, PRFileDesc *fd) michael@0: { michael@0: sslSocket * sm = NULL, *ss = NULL; michael@0: int i; michael@0: sslServerCerts * mc = NULL; michael@0: sslServerCerts * sc = NULL; michael@0: michael@0: if (model == NULL) { michael@0: PR_SetError(SEC_ERROR_INVALID_ARGS, 0); michael@0: return NULL; michael@0: } michael@0: sm = ssl_FindSocket(model); michael@0: if (sm == NULL) { michael@0: SSL_DBG(("%d: SSL[%d]: bad model socket in ssl_ReconfigFD", michael@0: SSL_GETPID(), model)); michael@0: return NULL; michael@0: } michael@0: ss = ssl_FindSocket(fd); michael@0: PORT_Assert(ss); michael@0: if (ss == NULL) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return NULL; michael@0: } michael@0: michael@0: ss->opt = sm->opt; michael@0: ss->vrange = sm->vrange; michael@0: PORT_Memcpy(ss->cipherSuites, sm->cipherSuites, sizeof sm->cipherSuites); michael@0: PORT_Memcpy(ss->ssl3.dtlsSRTPCiphers, sm->ssl3.dtlsSRTPCiphers, michael@0: sizeof(PRUint16) * sm->ssl3.dtlsSRTPCipherCount); michael@0: ss->ssl3.dtlsSRTPCipherCount = sm->ssl3.dtlsSRTPCipherCount; michael@0: michael@0: if (!ss->opt.useSecurity) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return NULL; michael@0: } michael@0: /* This int should be SSLKEAType, but CC on Irix complains, michael@0: * during the for loop. michael@0: */ michael@0: for (i=kt_null; i < kt_kea_size; i++) { michael@0: mc = &(sm->serverCerts[i]); michael@0: sc = &(ss->serverCerts[i]); michael@0: if (mc->serverCert && mc->serverCertChain) { michael@0: if (sc->serverCert) { michael@0: CERT_DestroyCertificate(sc->serverCert); michael@0: } michael@0: sc->serverCert = CERT_DupCertificate(mc->serverCert); michael@0: if (sc->serverCertChain) { michael@0: CERT_DestroyCertificateList(sc->serverCertChain); michael@0: } michael@0: sc->serverCertChain = CERT_DupCertList(mc->serverCertChain); michael@0: if (!sc->serverCertChain) michael@0: goto loser; michael@0: if (sm->certStatusArray[i]) { michael@0: if (ss->certStatusArray[i]) { michael@0: SECITEM_FreeArray(ss->certStatusArray[i], PR_TRUE); michael@0: ss->certStatusArray[i] = NULL; michael@0: } michael@0: ss->certStatusArray[i] = SECITEM_DupArray(NULL, sm->certStatusArray[i]); michael@0: if (!ss->certStatusArray[i]) michael@0: goto loser; michael@0: } michael@0: } michael@0: if (mc->serverKeyPair) { michael@0: if (sc->serverKeyPair) { michael@0: ssl3_FreeKeyPair(sc->serverKeyPair); michael@0: } michael@0: sc->serverKeyPair = ssl3_GetKeyPairRef(mc->serverKeyPair); michael@0: sc->serverKeyBits = mc->serverKeyBits; michael@0: } michael@0: } michael@0: if (sm->stepDownKeyPair) { michael@0: if (ss->stepDownKeyPair) { michael@0: ssl3_FreeKeyPair(ss->stepDownKeyPair); michael@0: } michael@0: ss->stepDownKeyPair = ssl3_GetKeyPairRef(sm->stepDownKeyPair); michael@0: } michael@0: if (sm->ephemeralECDHKeyPair) { michael@0: if (ss->ephemeralECDHKeyPair) { michael@0: ssl3_FreeKeyPair(ss->ephemeralECDHKeyPair); michael@0: } michael@0: ss->ephemeralECDHKeyPair = michael@0: ssl3_GetKeyPairRef(sm->ephemeralECDHKeyPair); michael@0: } michael@0: /* copy trust anchor names */ michael@0: if (sm->ssl3.ca_list) { michael@0: if (ss->ssl3.ca_list) { michael@0: CERT_FreeDistNames(ss->ssl3.ca_list); michael@0: } michael@0: ss->ssl3.ca_list = CERT_DupDistNames(sm->ssl3.ca_list); michael@0: if (!ss->ssl3.ca_list) { michael@0: goto loser; michael@0: } michael@0: } michael@0: michael@0: if (sm->authCertificate) michael@0: ss->authCertificate = sm->authCertificate; michael@0: if (sm->authCertificateArg) michael@0: ss->authCertificateArg = sm->authCertificateArg; michael@0: if (sm->getClientAuthData) michael@0: ss->getClientAuthData = sm->getClientAuthData; michael@0: if (sm->getClientAuthDataArg) michael@0: ss->getClientAuthDataArg = sm->getClientAuthDataArg; michael@0: if (sm->sniSocketConfig) michael@0: ss->sniSocketConfig = sm->sniSocketConfig; michael@0: if (sm->sniSocketConfigArg) michael@0: ss->sniSocketConfigArg = sm->sniSocketConfigArg; michael@0: if (sm->handleBadCert) michael@0: ss->handleBadCert = sm->handleBadCert; michael@0: if (sm->badCertArg) michael@0: ss->badCertArg = sm->badCertArg; michael@0: if (sm->handshakeCallback) michael@0: ss->handshakeCallback = sm->handshakeCallback; michael@0: if (sm->handshakeCallbackData) michael@0: ss->handshakeCallbackData = sm->handshakeCallbackData; michael@0: if (sm->pkcs11PinArg) michael@0: ss->pkcs11PinArg = sm->pkcs11PinArg; michael@0: return fd; michael@0: loser: michael@0: return NULL; michael@0: } michael@0: michael@0: PRBool michael@0: ssl3_VersionIsSupported(SSLProtocolVariant protocolVariant, michael@0: SSL3ProtocolVersion version) michael@0: { michael@0: switch (protocolVariant) { michael@0: case ssl_variant_stream: michael@0: return (version >= SSL_LIBRARY_VERSION_3_0 && michael@0: version <= SSL_LIBRARY_VERSION_MAX_SUPPORTED); michael@0: case ssl_variant_datagram: michael@0: return (version >= SSL_LIBRARY_VERSION_TLS_1_1 && michael@0: version <= SSL_LIBRARY_VERSION_MAX_SUPPORTED); michael@0: default: michael@0: /* Can't get here */ michael@0: PORT_Assert(PR_FALSE); michael@0: return PR_FALSE; michael@0: } michael@0: } michael@0: michael@0: /* Returns PR_TRUE if the given version range is valid and michael@0: ** fully supported; otherwise, returns PR_FALSE. michael@0: */ michael@0: static PRBool michael@0: ssl3_VersionRangeIsValid(SSLProtocolVariant protocolVariant, michael@0: const SSLVersionRange *vrange) michael@0: { michael@0: return vrange && michael@0: vrange->min <= vrange->max && michael@0: ssl3_VersionIsSupported(protocolVariant, vrange->min) && michael@0: ssl3_VersionIsSupported(protocolVariant, vrange->max); michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_VersionRangeGetSupported(SSLProtocolVariant protocolVariant, michael@0: SSLVersionRange *vrange) michael@0: { michael@0: if (!vrange) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: michael@0: switch (protocolVariant) { michael@0: case ssl_variant_stream: michael@0: vrange->min = SSL_LIBRARY_VERSION_3_0; michael@0: vrange->max = SSL_LIBRARY_VERSION_MAX_SUPPORTED; michael@0: break; michael@0: case ssl_variant_datagram: michael@0: vrange->min = SSL_LIBRARY_VERSION_TLS_1_1; michael@0: vrange->max = SSL_LIBRARY_VERSION_MAX_SUPPORTED; michael@0: break; michael@0: default: michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: michael@0: return SECSuccess; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_VersionRangeGetDefault(SSLProtocolVariant protocolVariant, michael@0: SSLVersionRange *vrange) michael@0: { michael@0: if ((protocolVariant != ssl_variant_stream && michael@0: protocolVariant != ssl_variant_datagram) || !vrange) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: michael@0: *vrange = *VERSIONS_DEFAULTS(protocolVariant); michael@0: michael@0: return SECSuccess; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_VersionRangeSetDefault(SSLProtocolVariant protocolVariant, michael@0: const SSLVersionRange *vrange) michael@0: { michael@0: if (!ssl3_VersionRangeIsValid(protocolVariant, vrange)) { michael@0: PORT_SetError(SSL_ERROR_INVALID_VERSION_RANGE); michael@0: return SECFailure; michael@0: } michael@0: michael@0: *VERSIONS_DEFAULTS(protocolVariant) = *vrange; michael@0: michael@0: return SECSuccess; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_VersionRangeGet(PRFileDesc *fd, SSLVersionRange *vrange) michael@0: { michael@0: sslSocket *ss = ssl_FindSocket(fd); michael@0: michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in SSL3_VersionRangeGet", michael@0: SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: michael@0: if (!vrange) { michael@0: PORT_SetError(SEC_ERROR_INVALID_ARGS); michael@0: return SECFailure; michael@0: } michael@0: michael@0: ssl_Get1stHandshakeLock(ss); michael@0: ssl_GetSSL3HandshakeLock(ss); michael@0: michael@0: *vrange = ss->vrange; michael@0: michael@0: ssl_ReleaseSSL3HandshakeLock(ss); michael@0: ssl_Release1stHandshakeLock(ss); michael@0: michael@0: return SECSuccess; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_VersionRangeSet(PRFileDesc *fd, const SSLVersionRange *vrange) michael@0: { michael@0: sslSocket *ss = ssl_FindSocket(fd); michael@0: michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in SSL3_VersionRangeSet", michael@0: SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: michael@0: if (!ssl3_VersionRangeIsValid(ss->protocolVariant, vrange)) { michael@0: PORT_SetError(SSL_ERROR_INVALID_VERSION_RANGE); michael@0: return SECFailure; michael@0: } michael@0: michael@0: ssl_Get1stHandshakeLock(ss); michael@0: ssl_GetSSL3HandshakeLock(ss); michael@0: michael@0: ss->vrange = *vrange; michael@0: michael@0: ssl_ReleaseSSL3HandshakeLock(ss); michael@0: ssl_Release1stHandshakeLock(ss); michael@0: michael@0: return SECSuccess; michael@0: } michael@0: michael@0: const SECItemArray * michael@0: SSL_PeerStapledOCSPResponses(PRFileDesc *fd) michael@0: { michael@0: sslSocket *ss = ssl_FindSocket(fd); michael@0: michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in SSL_PeerStapledOCSPResponses", michael@0: SSL_GETPID(), fd)); michael@0: return NULL; michael@0: } michael@0: michael@0: if (!ss->sec.ci.sid) { michael@0: PORT_SetError(SEC_ERROR_NOT_INITIALIZED); michael@0: return NULL; michael@0: } michael@0: michael@0: return &ss->sec.ci.sid->peerCertStatus; michael@0: } michael@0: michael@0: /************************************************************************/ michael@0: /* The following functions are the TOP LEVEL SSL functions. michael@0: ** They all get called through the NSPRIOMethods table below. michael@0: */ michael@0: michael@0: static PRFileDesc * PR_CALLBACK michael@0: ssl_Accept(PRFileDesc *fd, PRNetAddr *sockaddr, PRIntervalTime timeout) michael@0: { michael@0: sslSocket *ss; michael@0: sslSocket *ns = NULL; michael@0: PRFileDesc *newfd = NULL; michael@0: PRFileDesc *osfd; michael@0: PRStatus status; michael@0: michael@0: ss = ssl_GetPrivate(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in accept", SSL_GETPID(), fd)); michael@0: return NULL; michael@0: } michael@0: michael@0: /* IF this is a listen socket, there shouldn't be any I/O going on */ michael@0: SSL_LOCK_READER(ss); michael@0: SSL_LOCK_WRITER(ss); michael@0: ssl_Get1stHandshakeLock(ss); michael@0: ssl_GetSSL3HandshakeLock(ss); michael@0: michael@0: ss->cTimeout = timeout; michael@0: michael@0: osfd = ss->fd->lower; michael@0: michael@0: /* First accept connection */ michael@0: newfd = osfd->methods->accept(osfd, sockaddr, timeout); michael@0: if (newfd == NULL) { michael@0: SSL_DBG(("%d: SSL[%d]: accept failed, errno=%d", michael@0: SSL_GETPID(), ss->fd, PORT_GetError())); michael@0: } else { michael@0: /* Create ssl module */ michael@0: ns = ssl_DupSocket(ss); michael@0: } michael@0: michael@0: ssl_ReleaseSSL3HandshakeLock(ss); michael@0: ssl_Release1stHandshakeLock(ss); michael@0: SSL_UNLOCK_WRITER(ss); michael@0: SSL_UNLOCK_READER(ss); /* ss isn't used below here. */ michael@0: michael@0: if (ns == NULL) michael@0: goto loser; michael@0: michael@0: /* push ssl module onto the new socket */ michael@0: status = ssl_PushIOLayer(ns, newfd, PR_TOP_IO_LAYER); michael@0: if (status != PR_SUCCESS) michael@0: goto loser; michael@0: michael@0: /* Now start server connection handshake with client. michael@0: ** Don't need locks here because nobody else has a reference to ns yet. michael@0: */ michael@0: if ( ns->opt.useSecurity ) { michael@0: if ( ns->opt.handshakeAsClient ) { michael@0: ns->handshake = ssl2_BeginClientHandshake; michael@0: ss->handshaking = sslHandshakingAsClient; michael@0: } else { michael@0: ns->handshake = ssl2_BeginServerHandshake; michael@0: ss->handshaking = sslHandshakingAsServer; michael@0: } michael@0: } michael@0: ns->TCPconnected = 1; michael@0: return newfd; michael@0: michael@0: loser: michael@0: if (ns != NULL) michael@0: ssl_FreeSocket(ns); michael@0: if (newfd != NULL) michael@0: PR_Close(newfd); michael@0: return NULL; michael@0: } michael@0: michael@0: static PRStatus PR_CALLBACK michael@0: ssl_Connect(PRFileDesc *fd, const PRNetAddr *sockaddr, PRIntervalTime timeout) michael@0: { michael@0: sslSocket *ss; michael@0: PRStatus rv; michael@0: michael@0: ss = ssl_GetPrivate(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in connect", SSL_GETPID(), fd)); michael@0: return PR_FAILURE; michael@0: } michael@0: michael@0: /* IF this is a listen socket, there shouldn't be any I/O going on */ michael@0: SSL_LOCK_READER(ss); michael@0: SSL_LOCK_WRITER(ss); michael@0: michael@0: ss->cTimeout = timeout; michael@0: rv = (PRStatus)(*ss->ops->connect)(ss, sockaddr); michael@0: michael@0: SSL_UNLOCK_WRITER(ss); michael@0: SSL_UNLOCK_READER(ss); michael@0: michael@0: return rv; michael@0: } michael@0: michael@0: static PRStatus PR_CALLBACK michael@0: ssl_Bind(PRFileDesc *fd, const PRNetAddr *addr) michael@0: { michael@0: sslSocket * ss = ssl_GetPrivate(fd); michael@0: PRStatus rv; michael@0: michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in bind", SSL_GETPID(), fd)); michael@0: return PR_FAILURE; michael@0: } michael@0: SSL_LOCK_READER(ss); michael@0: SSL_LOCK_WRITER(ss); michael@0: michael@0: rv = (PRStatus)(*ss->ops->bind)(ss, addr); michael@0: michael@0: SSL_UNLOCK_WRITER(ss); michael@0: SSL_UNLOCK_READER(ss); michael@0: return rv; michael@0: } michael@0: michael@0: static PRStatus PR_CALLBACK michael@0: ssl_Listen(PRFileDesc *fd, PRIntn backlog) michael@0: { michael@0: sslSocket * ss = ssl_GetPrivate(fd); michael@0: PRStatus rv; michael@0: michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in listen", SSL_GETPID(), fd)); michael@0: return PR_FAILURE; michael@0: } michael@0: SSL_LOCK_READER(ss); michael@0: SSL_LOCK_WRITER(ss); michael@0: michael@0: rv = (PRStatus)(*ss->ops->listen)(ss, backlog); michael@0: michael@0: SSL_UNLOCK_WRITER(ss); michael@0: SSL_UNLOCK_READER(ss); michael@0: return rv; michael@0: } michael@0: michael@0: static PRStatus PR_CALLBACK michael@0: ssl_Shutdown(PRFileDesc *fd, PRIntn how) michael@0: { michael@0: sslSocket * ss = ssl_GetPrivate(fd); michael@0: PRStatus rv; michael@0: michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in shutdown", SSL_GETPID(), fd)); michael@0: return PR_FAILURE; michael@0: } michael@0: if (how == PR_SHUTDOWN_RCV || how == PR_SHUTDOWN_BOTH) { michael@0: SSL_LOCK_READER(ss); michael@0: } michael@0: if (how == PR_SHUTDOWN_SEND || how == PR_SHUTDOWN_BOTH) { michael@0: SSL_LOCK_WRITER(ss); michael@0: } michael@0: michael@0: rv = (PRStatus)(*ss->ops->shutdown)(ss, how); michael@0: michael@0: if (how == PR_SHUTDOWN_SEND || how == PR_SHUTDOWN_BOTH) { michael@0: SSL_UNLOCK_WRITER(ss); michael@0: } michael@0: if (how == PR_SHUTDOWN_RCV || how == PR_SHUTDOWN_BOTH) { michael@0: SSL_UNLOCK_READER(ss); michael@0: } michael@0: return rv; michael@0: } michael@0: michael@0: static PRStatus PR_CALLBACK michael@0: ssl_Close(PRFileDesc *fd) michael@0: { michael@0: sslSocket *ss; michael@0: PRStatus rv; michael@0: michael@0: ss = ssl_GetPrivate(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in close", SSL_GETPID(), fd)); michael@0: return PR_FAILURE; michael@0: } michael@0: michael@0: /* There must not be any I/O going on */ michael@0: SSL_LOCK_READER(ss); michael@0: SSL_LOCK_WRITER(ss); michael@0: michael@0: /* By the time this function returns, michael@0: ** ss is an invalid pointer, and the locks to which it points have michael@0: ** been unlocked and freed. So, this is the ONE PLACE in all of SSL michael@0: ** where the LOCK calls and the corresponding UNLOCK calls are not in michael@0: ** the same function scope. The unlock calls are in ssl_FreeSocket(). michael@0: */ michael@0: rv = (PRStatus)(*ss->ops->close)(ss); michael@0: michael@0: return rv; michael@0: } michael@0: michael@0: static int PR_CALLBACK michael@0: ssl_Recv(PRFileDesc *fd, void *buf, PRInt32 len, PRIntn flags, michael@0: PRIntervalTime timeout) michael@0: { michael@0: sslSocket *ss; michael@0: int rv; michael@0: michael@0: ss = ssl_GetPrivate(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in recv", SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: SSL_LOCK_READER(ss); michael@0: ss->rTimeout = timeout; michael@0: if (!ss->opt.fdx) michael@0: ss->wTimeout = timeout; michael@0: rv = (*ss->ops->recv)(ss, (unsigned char*)buf, len, flags); michael@0: SSL_UNLOCK_READER(ss); michael@0: return rv; michael@0: } michael@0: michael@0: static int PR_CALLBACK michael@0: ssl_Send(PRFileDesc *fd, const void *buf, PRInt32 len, PRIntn flags, michael@0: PRIntervalTime timeout) michael@0: { michael@0: sslSocket *ss; michael@0: int rv; michael@0: michael@0: ss = ssl_GetPrivate(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in send", SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: SSL_LOCK_WRITER(ss); michael@0: ss->wTimeout = timeout; michael@0: if (!ss->opt.fdx) michael@0: ss->rTimeout = timeout; michael@0: rv = (*ss->ops->send)(ss, (const unsigned char*)buf, len, flags); michael@0: SSL_UNLOCK_WRITER(ss); michael@0: return rv; michael@0: } michael@0: michael@0: static int PR_CALLBACK michael@0: ssl_Read(PRFileDesc *fd, void *buf, PRInt32 len) michael@0: { michael@0: sslSocket *ss; michael@0: int rv; michael@0: michael@0: ss = ssl_GetPrivate(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in read", SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: SSL_LOCK_READER(ss); michael@0: ss->rTimeout = PR_INTERVAL_NO_TIMEOUT; michael@0: if (!ss->opt.fdx) michael@0: ss->wTimeout = PR_INTERVAL_NO_TIMEOUT; michael@0: rv = (*ss->ops->read)(ss, (unsigned char*)buf, len); michael@0: SSL_UNLOCK_READER(ss); michael@0: return rv; michael@0: } michael@0: michael@0: static int PR_CALLBACK michael@0: ssl_Write(PRFileDesc *fd, const void *buf, PRInt32 len) michael@0: { michael@0: sslSocket *ss; michael@0: int rv; michael@0: michael@0: ss = ssl_GetPrivate(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in write", SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: SSL_LOCK_WRITER(ss); michael@0: ss->wTimeout = PR_INTERVAL_NO_TIMEOUT; michael@0: if (!ss->opt.fdx) michael@0: ss->rTimeout = PR_INTERVAL_NO_TIMEOUT; michael@0: rv = (*ss->ops->write)(ss, (const unsigned char*)buf, len); michael@0: SSL_UNLOCK_WRITER(ss); michael@0: return rv; michael@0: } michael@0: michael@0: static PRStatus PR_CALLBACK michael@0: ssl_GetPeerName(PRFileDesc *fd, PRNetAddr *addr) michael@0: { michael@0: sslSocket *ss; michael@0: michael@0: ss = ssl_GetPrivate(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in getpeername", SSL_GETPID(), fd)); michael@0: return PR_FAILURE; michael@0: } michael@0: return (PRStatus)(*ss->ops->getpeername)(ss, addr); michael@0: } michael@0: michael@0: /* michael@0: */ michael@0: SECStatus michael@0: ssl_GetPeerInfo(sslSocket *ss) michael@0: { michael@0: PRFileDesc * osfd; michael@0: int rv; michael@0: PRNetAddr sin; michael@0: michael@0: osfd = ss->fd->lower; michael@0: michael@0: PORT_Memset(&sin, 0, sizeof(sin)); michael@0: rv = osfd->methods->getpeername(osfd, &sin); michael@0: if (rv < 0) { michael@0: return SECFailure; michael@0: } michael@0: ss->TCPconnected = 1; michael@0: if (sin.inet.family == PR_AF_INET) { michael@0: PR_ConvertIPv4AddrToIPv6(sin.inet.ip, &ss->sec.ci.peer); michael@0: ss->sec.ci.port = sin.inet.port; michael@0: } else if (sin.ipv6.family == PR_AF_INET6) { michael@0: ss->sec.ci.peer = sin.ipv6.ip; michael@0: ss->sec.ci.port = sin.ipv6.port; michael@0: } else { michael@0: PORT_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR); michael@0: return SECFailure; michael@0: } michael@0: return SECSuccess; michael@0: } michael@0: michael@0: static PRStatus PR_CALLBACK michael@0: ssl_GetSockName(PRFileDesc *fd, PRNetAddr *name) michael@0: { michael@0: sslSocket *ss; michael@0: michael@0: ss = ssl_GetPrivate(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in getsockname", SSL_GETPID(), fd)); michael@0: return PR_FAILURE; michael@0: } michael@0: return (PRStatus)(*ss->ops->getsockname)(ss, name); michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_SetStapledOCSPResponses(PRFileDesc *fd, const SECItemArray *responses, michael@0: SSLKEAType kea) michael@0: { michael@0: sslSocket *ss; michael@0: michael@0: ss = ssl_FindSocket(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetStapledOCSPResponses", michael@0: SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: michael@0: if ( kea <= 0 || kea >= kt_kea_size) { michael@0: SSL_DBG(("%d: SSL[%d]: invalid key in SSL_SetStapledOCSPResponses", michael@0: SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: michael@0: if (ss->certStatusArray[kea]) { michael@0: SECITEM_FreeArray(ss->certStatusArray[kea], PR_TRUE); michael@0: ss->certStatusArray[kea] = NULL; michael@0: } michael@0: if (responses) { michael@0: ss->certStatusArray[kea] = SECITEM_DupArray(NULL, responses); michael@0: } michael@0: return (ss->certStatusArray[kea] || !responses) ? SECSuccess : SECFailure; michael@0: } michael@0: michael@0: SECStatus michael@0: SSL_SetSockPeerID(PRFileDesc *fd, const char *peerID) michael@0: { michael@0: sslSocket *ss; michael@0: michael@0: ss = ssl_FindSocket(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in SSL_SetSockPeerID", michael@0: SSL_GETPID(), fd)); michael@0: return SECFailure; michael@0: } michael@0: michael@0: if (ss->peerID) { michael@0: PORT_Free(ss->peerID); michael@0: ss->peerID = NULL; michael@0: } michael@0: if (peerID) michael@0: ss->peerID = PORT_Strdup(peerID); michael@0: return (ss->peerID || !peerID) ? SECSuccess : SECFailure; michael@0: } michael@0: michael@0: #define PR_POLL_RW (PR_POLL_WRITE | PR_POLL_READ) michael@0: michael@0: static PRInt16 PR_CALLBACK michael@0: ssl_Poll(PRFileDesc *fd, PRInt16 how_flags, PRInt16 *p_out_flags) michael@0: { michael@0: sslSocket *ss; michael@0: PRInt16 new_flags = how_flags; /* should select on these flags. */ michael@0: PRNetAddr addr; michael@0: michael@0: *p_out_flags = 0; michael@0: ss = ssl_GetPrivate(fd); michael@0: if (!ss) { michael@0: SSL_DBG(("%d: SSL[%d]: bad socket in SSL_Poll", michael@0: SSL_GETPID(), fd)); michael@0: return 0; /* don't poll on this socket */ michael@0: } michael@0: michael@0: if (ss->opt.useSecurity && michael@0: ss->handshaking != sslHandshakingUndetermined && michael@0: !ss->firstHsDone && michael@0: (how_flags & PR_POLL_RW)) { michael@0: if (!ss->TCPconnected) { michael@0: ss->TCPconnected = (PR_SUCCESS == ssl_DefGetpeername(ss, &addr)); michael@0: } michael@0: /* If it's not connected, then presumably the application is polling michael@0: ** on read or write appropriately, so don't change it. michael@0: */ michael@0: if (ss->TCPconnected) { michael@0: if (!ss->handshakeBegun) { michael@0: /* If the handshake has not begun, poll on read or write michael@0: ** based on the local application's role in the handshake, michael@0: ** not based on what the application requested. michael@0: */ michael@0: new_flags &= ~PR_POLL_RW; michael@0: if (ss->handshaking == sslHandshakingAsClient) { michael@0: new_flags |= PR_POLL_WRITE; michael@0: } else { /* handshaking as server */ michael@0: new_flags |= PR_POLL_READ; michael@0: } michael@0: } else michael@0: /* First handshake is in progress */ michael@0: if (ss->lastWriteBlocked) { michael@0: if (new_flags & PR_POLL_READ) { michael@0: /* The caller is waiting for data to be received, michael@0: ** but the initial handshake is blocked on write, or the michael@0: ** client's first handshake record has not been written. michael@0: ** The code should select on write, not read. michael@0: */ michael@0: new_flags ^= PR_POLL_READ; /* don't select on read. */ michael@0: new_flags |= PR_POLL_WRITE; /* do select on write. */ michael@0: } michael@0: } else if (new_flags & PR_POLL_WRITE) { michael@0: /* The caller is trying to write, but the handshake is michael@0: ** blocked waiting for data to read, and the first michael@0: ** handshake has been sent. So do NOT to poll on write michael@0: ** unless we did false start. michael@0: */ michael@0: if (!(ss->version >= SSL_LIBRARY_VERSION_3_0 && michael@0: ss->ssl3.hs.canFalseStart)) { michael@0: new_flags ^= PR_POLL_WRITE; /* don't select on write. */ michael@0: } michael@0: new_flags |= PR_POLL_READ; /* do select on read. */ michael@0: } michael@0: } michael@0: } else if ((new_flags & PR_POLL_READ) && (SSL_DataPending(fd) > 0)) { michael@0: *p_out_flags = PR_POLL_READ; /* it's ready already. */ michael@0: return new_flags; michael@0: } else if ((ss->lastWriteBlocked) && (how_flags & PR_POLL_READ) && michael@0: (ss->pendingBuf.len != 0)) { /* write data waiting to be sent */ michael@0: new_flags |= PR_POLL_WRITE; /* also select on write. */ michael@0: } michael@0: michael@0: if (ss->version >= SSL_LIBRARY_VERSION_3_0 && michael@0: ss->ssl3.hs.restartTarget != NULL) { michael@0: /* Read and write will block until the asynchronous callback completes michael@0: * (e.g. until SSL_AuthCertificateComplete is called), so don't tell michael@0: * the caller to poll the socket unless there is pending write data. michael@0: */ michael@0: if (ss->lastWriteBlocked && ss->pendingBuf.len != 0) { michael@0: /* Ignore any newly-received data on the socket, but do wait for michael@0: * the socket to become writable again. Here, it is OK for an error michael@0: * to be detected, because our logic for sending pending write data michael@0: * will allow us to report the error to the caller without the risk michael@0: * of the application spinning. michael@0: */ michael@0: new_flags &= (PR_POLL_WRITE | PR_POLL_EXCEPT); michael@0: } else { michael@0: /* Unfortunately, clearing new_flags will make it impossible for michael@0: * the application to detect errors that it would otherwise be michael@0: * able to detect with PR_POLL_EXCEPT, until the asynchronous michael@0: * callback completes. However, we must clear all the flags to michael@0: * prevent the application from spinning (alternating between michael@0: * calling PR_Poll that would return PR_POLL_EXCEPT, and send/recv michael@0: * which won't actually report the I/O error while we are waiting michael@0: * for the asynchronous callback to complete). michael@0: */ michael@0: new_flags = 0; michael@0: } michael@0: } michael@0: michael@0: if (new_flags && (fd->lower->methods->poll != NULL)) { michael@0: PRInt16 lower_out_flags = 0; michael@0: PRInt16 lower_new_flags; michael@0: lower_new_flags = fd->lower->methods->poll(fd->lower, new_flags, michael@0: &lower_out_flags); michael@0: if ((lower_new_flags & lower_out_flags) && (how_flags != new_flags)) { michael@0: PRInt16 out_flags = lower_out_flags & ~PR_POLL_RW; michael@0: if (lower_out_flags & PR_POLL_READ) michael@0: out_flags |= PR_POLL_WRITE; michael@0: if (lower_out_flags & PR_POLL_WRITE) michael@0: out_flags |= PR_POLL_READ; michael@0: *p_out_flags = out_flags; michael@0: new_flags = how_flags; michael@0: } else { michael@0: *p_out_flags = lower_out_flags; michael@0: new_flags = lower_new_flags; michael@0: } michael@0: } michael@0: michael@0: return new_flags; michael@0: } michael@0: michael@0: static PRInt32 PR_CALLBACK michael@0: ssl_TransmitFile(PRFileDesc *sd, PRFileDesc *fd, michael@0: const void *headers, PRInt32 hlen, michael@0: PRTransmitFileFlags flags, PRIntervalTime timeout) michael@0: { michael@0: PRSendFileData sfd; michael@0: michael@0: sfd.fd = fd; michael@0: sfd.file_offset = 0; michael@0: sfd.file_nbytes = 0; michael@0: sfd.header = headers; michael@0: sfd.hlen = hlen; michael@0: sfd.trailer = NULL; michael@0: sfd.tlen = 0; michael@0: michael@0: return sd->methods->sendfile(sd, &sfd, flags, timeout); michael@0: } michael@0: michael@0: michael@0: PRBool michael@0: ssl_FdIsBlocking(PRFileDesc *fd) michael@0: { michael@0: PRSocketOptionData opt; michael@0: PRStatus status; michael@0: michael@0: opt.option = PR_SockOpt_Nonblocking; michael@0: opt.value.non_blocking = PR_FALSE; michael@0: status = PR_GetSocketOption(fd, &opt); michael@0: if (status != PR_SUCCESS) michael@0: return PR_FALSE; michael@0: return (PRBool)!opt.value.non_blocking; michael@0: } michael@0: michael@0: PRBool michael@0: ssl_SocketIsBlocking(sslSocket *ss) michael@0: { michael@0: return ssl_FdIsBlocking(ss->fd); michael@0: } michael@0: michael@0: PRInt32 sslFirstBufSize = 8 * 1024; michael@0: PRInt32 sslCopyLimit = 1024; michael@0: michael@0: static PRInt32 PR_CALLBACK michael@0: ssl_WriteV(PRFileDesc *fd, const PRIOVec *iov, PRInt32 vectors, michael@0: PRIntervalTime timeout) michael@0: { michael@0: PRInt32 i; michael@0: PRInt32 bufLen; michael@0: PRInt32 left; michael@0: PRInt32 rv; michael@0: PRInt32 sent = 0; michael@0: const PRInt32 first_len = sslFirstBufSize; michael@0: const PRInt32 limit = sslCopyLimit; michael@0: PRBool blocking; michael@0: PRIOVec myIov = { 0, 0 }; michael@0: char buf[MAX_FRAGMENT_LENGTH]; michael@0: michael@0: if (vectors < 0) { michael@0: PORT_SetError(PR_INVALID_ARGUMENT_ERROR); michael@0: return -1; michael@0: } michael@0: if (vectors > PR_MAX_IOVECTOR_SIZE) { michael@0: PORT_SetError(PR_BUFFER_OVERFLOW_ERROR); michael@0: return -1; michael@0: } michael@0: for (i = 0; i < vectors; i++) { michael@0: if (iov[i].iov_len < 0) { michael@0: PORT_SetError(PR_INVALID_ARGUMENT_ERROR); michael@0: return -1; michael@0: } michael@0: } michael@0: blocking = ssl_FdIsBlocking(fd); michael@0: michael@0: #define K16 sizeof(buf) michael@0: #define KILL_VECTORS while (vectors && !iov->iov_len) { ++iov; --vectors; } michael@0: #define GET_VECTOR do { myIov = *iov++; --vectors; KILL_VECTORS } while (0) michael@0: #define HANDLE_ERR(rv, len) \ michael@0: if (rv != len) { \ michael@0: if (rv < 0) { \ michael@0: if (!blocking \ michael@0: && (PR_GetError() == PR_WOULD_BLOCK_ERROR) \ michael@0: && (sent > 0)) { \ michael@0: return sent; \ michael@0: } else { \ michael@0: return -1; \ michael@0: } \ michael@0: } \ michael@0: /* Only a nonblocking socket can have partial sends */ \ michael@0: PR_ASSERT(!blocking); \ michael@0: return sent + rv; \ michael@0: } michael@0: #define SEND(bfr, len) \ michael@0: do { \ michael@0: rv = ssl_Send(fd, bfr, len, 0, timeout); \ michael@0: HANDLE_ERR(rv, len) \ michael@0: sent += len; \ michael@0: } while (0) michael@0: michael@0: /* Make sure the first write is at least 8 KB, if possible. */ michael@0: KILL_VECTORS michael@0: if (!vectors) michael@0: return ssl_Send(fd, 0, 0, 0, timeout); michael@0: GET_VECTOR; michael@0: if (!vectors) { michael@0: return ssl_Send(fd, myIov.iov_base, myIov.iov_len, 0, timeout); michael@0: } michael@0: if (myIov.iov_len < first_len) { michael@0: PORT_Memcpy(buf, myIov.iov_base, myIov.iov_len); michael@0: bufLen = myIov.iov_len; michael@0: left = first_len - bufLen; michael@0: while (vectors && left) { michael@0: int toCopy; michael@0: GET_VECTOR; michael@0: toCopy = PR_MIN(left, myIov.iov_len); michael@0: PORT_Memcpy(buf + bufLen, myIov.iov_base, toCopy); michael@0: bufLen += toCopy; michael@0: left -= toCopy; michael@0: myIov.iov_base += toCopy; michael@0: myIov.iov_len -= toCopy; michael@0: } michael@0: SEND( buf, bufLen ); michael@0: } michael@0: michael@0: while (vectors || myIov.iov_len) { michael@0: PRInt32 addLen; michael@0: if (!myIov.iov_len) { michael@0: GET_VECTOR; michael@0: } michael@0: while (myIov.iov_len >= K16) { michael@0: SEND(myIov.iov_base, K16); michael@0: myIov.iov_base += K16; michael@0: myIov.iov_len -= K16; michael@0: } michael@0: if (!myIov.iov_len) michael@0: continue; michael@0: michael@0: if (!vectors || myIov.iov_len > limit) { michael@0: addLen = 0; michael@0: } else if ((addLen = iov->iov_len % K16) + myIov.iov_len <= limit) { michael@0: /* Addlen is already computed. */; michael@0: } else if (vectors > 1 && michael@0: iov[1].iov_len % K16 + addLen + myIov.iov_len <= 2 * limit) { michael@0: addLen = limit - myIov.iov_len; michael@0: } else michael@0: addLen = 0; michael@0: michael@0: if (!addLen) { michael@0: SEND( myIov.iov_base, myIov.iov_len ); michael@0: myIov.iov_len = 0; michael@0: continue; michael@0: } michael@0: PORT_Memcpy(buf, myIov.iov_base, myIov.iov_len); michael@0: bufLen = myIov.iov_len; michael@0: do { michael@0: GET_VECTOR; michael@0: PORT_Memcpy(buf + bufLen, myIov.iov_base, addLen); michael@0: myIov.iov_base += addLen; michael@0: myIov.iov_len -= addLen; michael@0: bufLen += addLen; michael@0: michael@0: left = PR_MIN( limit, K16 - bufLen); michael@0: if (!vectors /* no more left */ michael@0: || myIov.iov_len > 0 /* we didn't use that one all up */ michael@0: || bufLen >= K16 /* it's full. */ michael@0: ) { michael@0: addLen = 0; michael@0: } else if ((addLen = iov->iov_len % K16) <= left) { michael@0: /* Addlen is already computed. */; michael@0: } else if (vectors > 1 && michael@0: iov[1].iov_len % K16 + addLen <= left + limit) { michael@0: addLen = left; michael@0: } else michael@0: addLen = 0; michael@0: michael@0: } while (addLen); michael@0: SEND( buf, bufLen ); michael@0: } michael@0: return sent; michael@0: } michael@0: michael@0: /* michael@0: * These functions aren't implemented. michael@0: */ michael@0: michael@0: static PRInt32 PR_CALLBACK michael@0: ssl_Available(PRFileDesc *fd) michael@0: { michael@0: PORT_Assert(0); michael@0: PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); michael@0: return SECFailure; michael@0: } michael@0: michael@0: static PRInt64 PR_CALLBACK michael@0: ssl_Available64(PRFileDesc *fd) michael@0: { michael@0: PRInt64 res; michael@0: michael@0: PORT_Assert(0); michael@0: PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); michael@0: LL_I2L(res, -1L); michael@0: return res; michael@0: } michael@0: michael@0: static PRStatus PR_CALLBACK michael@0: ssl_FSync(PRFileDesc *fd) michael@0: { michael@0: PORT_Assert(0); michael@0: PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); michael@0: return PR_FAILURE; michael@0: } michael@0: michael@0: static PRInt32 PR_CALLBACK michael@0: ssl_Seek(PRFileDesc *fd, PRInt32 offset, PRSeekWhence how) { michael@0: PORT_Assert(0); michael@0: PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); michael@0: return SECFailure; michael@0: } michael@0: michael@0: static PRInt64 PR_CALLBACK michael@0: ssl_Seek64(PRFileDesc *fd, PRInt64 offset, PRSeekWhence how) { michael@0: PRInt64 res; michael@0: michael@0: PORT_Assert(0); michael@0: PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); michael@0: LL_I2L(res, -1L); michael@0: return res; michael@0: } michael@0: michael@0: static PRStatus PR_CALLBACK michael@0: ssl_FileInfo(PRFileDesc *fd, PRFileInfo *info) michael@0: { michael@0: PORT_Assert(0); michael@0: PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); michael@0: return PR_FAILURE; michael@0: } michael@0: michael@0: static PRStatus PR_CALLBACK michael@0: ssl_FileInfo64(PRFileDesc *fd, PRFileInfo64 *info) michael@0: { michael@0: PORT_Assert(0); michael@0: PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); michael@0: return PR_FAILURE; michael@0: } michael@0: michael@0: static PRInt32 PR_CALLBACK michael@0: ssl_RecvFrom(PRFileDesc *fd, void *buf, PRInt32 amount, PRIntn flags, michael@0: PRNetAddr *addr, PRIntervalTime timeout) michael@0: { michael@0: PORT_Assert(0); michael@0: PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); michael@0: return SECFailure; michael@0: } michael@0: michael@0: static PRInt32 PR_CALLBACK michael@0: ssl_SendTo(PRFileDesc *fd, const void *buf, PRInt32 amount, PRIntn flags, michael@0: const PRNetAddr *addr, PRIntervalTime timeout) michael@0: { michael@0: PORT_Assert(0); michael@0: PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0); michael@0: return SECFailure; michael@0: } michael@0: michael@0: static const PRIOMethods ssl_methods = { michael@0: PR_DESC_LAYERED, michael@0: ssl_Close, /* close */ michael@0: ssl_Read, /* read */ michael@0: ssl_Write, /* write */ michael@0: ssl_Available, /* available */ michael@0: ssl_Available64, /* available64 */ michael@0: ssl_FSync, /* fsync */ michael@0: ssl_Seek, /* seek */ michael@0: ssl_Seek64, /* seek64 */ michael@0: ssl_FileInfo, /* fileInfo */ michael@0: ssl_FileInfo64, /* fileInfo64 */ michael@0: ssl_WriteV, /* writev */ michael@0: ssl_Connect, /* connect */ michael@0: ssl_Accept, /* accept */ michael@0: ssl_Bind, /* bind */ michael@0: ssl_Listen, /* listen */ michael@0: ssl_Shutdown, /* shutdown */ michael@0: ssl_Recv, /* recv */ michael@0: ssl_Send, /* send */ michael@0: ssl_RecvFrom, /* recvfrom */ michael@0: ssl_SendTo, /* sendto */ michael@0: ssl_Poll, /* poll */ michael@0: PR_EmulateAcceptRead, /* acceptread */ michael@0: ssl_TransmitFile, /* transmitfile */ michael@0: ssl_GetSockName, /* getsockname */ michael@0: ssl_GetPeerName, /* getpeername */ michael@0: NULL, /* getsockopt OBSOLETE */ michael@0: NULL, /* setsockopt OBSOLETE */ michael@0: NULL, /* getsocketoption */ michael@0: NULL, /* setsocketoption */ michael@0: PR_EmulateSendFile, /* Send a (partial) file with header/trailer*/ michael@0: NULL, /* reserved for future use */ michael@0: NULL, /* reserved for future use */ michael@0: NULL, /* reserved for future use */ michael@0: NULL, /* reserved for future use */ michael@0: NULL /* reserved for future use */ michael@0: }; michael@0: michael@0: michael@0: static PRIOMethods combined_methods; michael@0: michael@0: static void michael@0: ssl_SetupIOMethods(void) michael@0: { michael@0: PRIOMethods *new_methods = &combined_methods; michael@0: const PRIOMethods *nspr_methods = PR_GetDefaultIOMethods(); michael@0: const PRIOMethods *my_methods = &ssl_methods; michael@0: michael@0: *new_methods = *nspr_methods; michael@0: michael@0: new_methods->file_type = my_methods->file_type; michael@0: new_methods->close = my_methods->close; michael@0: new_methods->read = my_methods->read; michael@0: new_methods->write = my_methods->write; michael@0: new_methods->available = my_methods->available; michael@0: new_methods->available64 = my_methods->available64; michael@0: new_methods->fsync = my_methods->fsync; michael@0: new_methods->seek = my_methods->seek; michael@0: new_methods->seek64 = my_methods->seek64; michael@0: new_methods->fileInfo = my_methods->fileInfo; michael@0: new_methods->fileInfo64 = my_methods->fileInfo64; michael@0: new_methods->writev = my_methods->writev; michael@0: new_methods->connect = my_methods->connect; michael@0: new_methods->accept = my_methods->accept; michael@0: new_methods->bind = my_methods->bind; michael@0: new_methods->listen = my_methods->listen; michael@0: new_methods->shutdown = my_methods->shutdown; michael@0: new_methods->recv = my_methods->recv; michael@0: new_methods->send = my_methods->send; michael@0: new_methods->recvfrom = my_methods->recvfrom; michael@0: new_methods->sendto = my_methods->sendto; michael@0: new_methods->poll = my_methods->poll; michael@0: new_methods->acceptread = my_methods->acceptread; michael@0: new_methods->transmitfile = my_methods->transmitfile; michael@0: new_methods->getsockname = my_methods->getsockname; michael@0: new_methods->getpeername = my_methods->getpeername; michael@0: /* new_methods->getsocketoption = my_methods->getsocketoption; */ michael@0: /* new_methods->setsocketoption = my_methods->setsocketoption; */ michael@0: new_methods->sendfile = my_methods->sendfile; michael@0: michael@0: } michael@0: michael@0: static PRCallOnceType initIoLayerOnce; michael@0: michael@0: static PRStatus michael@0: ssl_InitIOLayer(void) michael@0: { michael@0: ssl_layer_id = PR_GetUniqueIdentity("SSL"); michael@0: ssl_SetupIOMethods(); michael@0: ssl_inited = PR_TRUE; michael@0: return PR_SUCCESS; michael@0: } michael@0: michael@0: static PRStatus michael@0: ssl_PushIOLayer(sslSocket *ns, PRFileDesc *stack, PRDescIdentity id) michael@0: { michael@0: PRFileDesc *layer = NULL; michael@0: PRStatus status; michael@0: michael@0: if (!ssl_inited) { michael@0: status = PR_CallOnce(&initIoLayerOnce, &ssl_InitIOLayer); michael@0: if (status != PR_SUCCESS) michael@0: goto loser; michael@0: } michael@0: michael@0: if (ns == NULL) michael@0: goto loser; michael@0: michael@0: layer = PR_CreateIOLayerStub(ssl_layer_id, &combined_methods); michael@0: if (layer == NULL) michael@0: goto loser; michael@0: layer->secret = (PRFilePrivate *)ns; michael@0: michael@0: /* Here, "stack" points to the PRFileDesc on the top of the stack. michael@0: ** "layer" points to a new FD that is to be inserted into the stack. michael@0: ** If layer is being pushed onto the top of the stack, then michael@0: ** PR_PushIOLayer switches the contents of stack and layer, and then michael@0: ** puts stack on top of layer, so that after it is done, the top of michael@0: ** stack is the same "stack" as it was before, and layer is now the michael@0: ** FD for the former top of stack. michael@0: ** After this call, stack always points to the top PRFD on the stack. michael@0: ** If this function fails, the contents of stack and layer are as michael@0: ** they were before the call. michael@0: */ michael@0: status = PR_PushIOLayer(stack, id, layer); michael@0: if (status != PR_SUCCESS) michael@0: goto loser; michael@0: michael@0: ns->fd = (id == PR_TOP_IO_LAYER) ? stack : layer; michael@0: return PR_SUCCESS; michael@0: michael@0: loser: michael@0: if (layer) { michael@0: layer->dtor(layer); /* free layer */ michael@0: } michael@0: return PR_FAILURE; michael@0: } michael@0: michael@0: /* if this fails, caller must destroy socket. */ michael@0: static SECStatus michael@0: ssl_MakeLocks(sslSocket *ss) michael@0: { michael@0: ss->firstHandshakeLock = PZ_NewMonitor(nssILockSSL); michael@0: if (!ss->firstHandshakeLock) michael@0: goto loser; michael@0: ss->ssl3HandshakeLock = PZ_NewMonitor(nssILockSSL); michael@0: if (!ss->ssl3HandshakeLock) michael@0: goto loser; michael@0: ss->specLock = NSSRWLock_New(SSL_LOCK_RANK_SPEC, NULL); michael@0: if (!ss->specLock) michael@0: goto loser; michael@0: ss->recvBufLock = PZ_NewMonitor(nssILockSSL); michael@0: if (!ss->recvBufLock) michael@0: goto loser; michael@0: ss->xmitBufLock = PZ_NewMonitor(nssILockSSL); michael@0: if (!ss->xmitBufLock) michael@0: goto loser; michael@0: ss->writerThread = NULL; michael@0: if (ssl_lock_readers) { michael@0: ss->recvLock = PZ_NewLock(nssILockSSL); michael@0: if (!ss->recvLock) michael@0: goto loser; michael@0: ss->sendLock = PZ_NewLock(nssILockSSL); michael@0: if (!ss->sendLock) michael@0: goto loser; michael@0: } michael@0: return SECSuccess; michael@0: loser: michael@0: ssl_DestroyLocks(ss); michael@0: return SECFailure; michael@0: } michael@0: michael@0: #if defined(XP_UNIX) || defined(XP_WIN32) || defined(XP_BEOS) michael@0: #define NSS_HAVE_GETENV 1 michael@0: #endif michael@0: michael@0: #define LOWER(x) (x | 0x20) /* cheap ToLower function ignores LOCALE */ michael@0: michael@0: static void michael@0: ssl_SetDefaultsFromEnvironment(void) michael@0: { michael@0: #if defined( NSS_HAVE_GETENV ) michael@0: static int firsttime = 1; michael@0: michael@0: if (firsttime) { michael@0: char * ev; michael@0: firsttime = 0; michael@0: #ifdef DEBUG michael@0: ev = getenv("SSLDEBUGFILE"); michael@0: if (ev && ev[0]) { michael@0: ssl_trace_iob = fopen(ev, "w"); michael@0: } michael@0: if (!ssl_trace_iob) { michael@0: ssl_trace_iob = stderr; michael@0: } michael@0: #ifdef TRACE michael@0: ev = getenv("SSLTRACE"); michael@0: if (ev && ev[0]) { michael@0: ssl_trace = atoi(ev); michael@0: SSL_TRACE(("SSL: tracing set to %d", ssl_trace)); michael@0: } michael@0: #endif /* TRACE */ michael@0: ev = getenv("SSLDEBUG"); michael@0: if (ev && ev[0]) { michael@0: ssl_debug = atoi(ev); michael@0: SSL_TRACE(("SSL: debugging set to %d", ssl_debug)); michael@0: } michael@0: #endif /* DEBUG */ michael@0: ev = getenv("SSLKEYLOGFILE"); michael@0: if (ev && ev[0]) { michael@0: ssl_keylog_iob = fopen(ev, "a"); michael@0: if (!ssl_keylog_iob) { michael@0: SSL_TRACE(("SSL: failed to open key log file")); michael@0: } else { michael@0: if (ftell(ssl_keylog_iob) == 0) { michael@0: fputs("# SSL/TLS secrets log file, generated by NSS\n", michael@0: ssl_keylog_iob); michael@0: } michael@0: SSL_TRACE(("SSL: logging SSL/TLS secrets to %s", ev)); michael@0: } michael@0: } michael@0: #ifndef NO_PKCS11_BYPASS michael@0: ev = getenv("SSLBYPASS"); michael@0: if (ev && ev[0]) { michael@0: ssl_defaults.bypassPKCS11 = (ev[0] == '1'); michael@0: SSL_TRACE(("SSL: bypass default set to %d", \ michael@0: ssl_defaults.bypassPKCS11)); michael@0: } michael@0: #endif /* NO_PKCS11_BYPASS */ michael@0: ev = getenv("SSLFORCELOCKS"); michael@0: if (ev && ev[0] == '1') { michael@0: ssl_force_locks = PR_TRUE; michael@0: ssl_defaults.noLocks = 0; michael@0: strcpy(lockStatus + LOCKSTATUS_OFFSET, "FORCED. "); michael@0: SSL_TRACE(("SSL: force_locks set to %d", ssl_force_locks)); michael@0: } michael@0: ev = getenv("NSS_SSL_ENABLE_RENEGOTIATION"); michael@0: if (ev) { michael@0: if (ev[0] == '1' || LOWER(ev[0]) == 'u') michael@0: ssl_defaults.enableRenegotiation = SSL_RENEGOTIATE_UNRESTRICTED; michael@0: else if (ev[0] == '0' || LOWER(ev[0]) == 'n') michael@0: ssl_defaults.enableRenegotiation = SSL_RENEGOTIATE_NEVER; michael@0: else if (ev[0] == '2' || LOWER(ev[0]) == 'r') michael@0: ssl_defaults.enableRenegotiation = SSL_RENEGOTIATE_REQUIRES_XTN; michael@0: else if (ev[0] == '3' || LOWER(ev[0]) == 't') michael@0: ssl_defaults.enableRenegotiation = SSL_RENEGOTIATE_TRANSITIONAL; michael@0: SSL_TRACE(("SSL: enableRenegotiation set to %d", michael@0: ssl_defaults.enableRenegotiation)); michael@0: } michael@0: ev = getenv("NSS_SSL_REQUIRE_SAFE_NEGOTIATION"); michael@0: if (ev && ev[0] == '1') { michael@0: ssl_defaults.requireSafeNegotiation = PR_TRUE; michael@0: SSL_TRACE(("SSL: requireSafeNegotiation set to %d", michael@0: PR_TRUE)); michael@0: } michael@0: ev = getenv("NSS_SSL_CBC_RANDOM_IV"); michael@0: if (ev && ev[0] == '0') { michael@0: ssl_defaults.cbcRandomIV = PR_FALSE; michael@0: SSL_TRACE(("SSL: cbcRandomIV set to 0")); michael@0: } michael@0: } michael@0: #endif /* NSS_HAVE_GETENV */ michael@0: } michael@0: michael@0: /* michael@0: ** Create a newsocket structure for a file descriptor. michael@0: */ michael@0: static sslSocket * michael@0: ssl_NewSocket(PRBool makeLocks, SSLProtocolVariant protocolVariant) michael@0: { michael@0: sslSocket *ss; michael@0: michael@0: ssl_SetDefaultsFromEnvironment(); michael@0: michael@0: if (ssl_force_locks) michael@0: makeLocks = PR_TRUE; michael@0: michael@0: /* Make a new socket and get it ready */ michael@0: ss = (sslSocket*) PORT_ZAlloc(sizeof(sslSocket)); michael@0: if (ss) { michael@0: /* This should be of type SSLKEAType, but CC on IRIX michael@0: * complains during the for loop. michael@0: */ michael@0: int i; michael@0: SECStatus status; michael@0: michael@0: ss->opt = ssl_defaults; michael@0: ss->opt.useSocks = PR_FALSE; michael@0: ss->opt.noLocks = !makeLocks; michael@0: ss->vrange = *VERSIONS_DEFAULTS(protocolVariant); michael@0: ss->protocolVariant = protocolVariant; michael@0: michael@0: ss->peerID = NULL; michael@0: ss->rTimeout = PR_INTERVAL_NO_TIMEOUT; michael@0: ss->wTimeout = PR_INTERVAL_NO_TIMEOUT; michael@0: ss->cTimeout = PR_INTERVAL_NO_TIMEOUT; michael@0: ss->cipherSpecs = NULL; michael@0: ss->sizeCipherSpecs = 0; /* produced lazily */ michael@0: ss->preferredCipher = NULL; michael@0: ss->url = NULL; michael@0: michael@0: for (i=kt_null; i < kt_kea_size; i++) { michael@0: sslServerCerts * sc = ss->serverCerts + i; michael@0: sc->serverCert = NULL; michael@0: sc->serverCertChain = NULL; michael@0: sc->serverKeyPair = NULL; michael@0: sc->serverKeyBits = 0; michael@0: ss->certStatusArray[i] = NULL; michael@0: } michael@0: ss->stepDownKeyPair = NULL; michael@0: ss->dbHandle = CERT_GetDefaultCertDB(); michael@0: michael@0: /* Provide default implementation of hooks */ michael@0: ss->authCertificate = SSL_AuthCertificate; michael@0: ss->authCertificateArg = (void *)ss->dbHandle; michael@0: ss->sniSocketConfig = NULL; michael@0: ss->sniSocketConfigArg = NULL; michael@0: ss->getClientAuthData = NULL; michael@0: ss->handleBadCert = NULL; michael@0: ss->badCertArg = NULL; michael@0: ss->pkcs11PinArg = NULL; michael@0: ss->ephemeralECDHKeyPair = NULL; michael@0: michael@0: ssl_ChooseOps(ss); michael@0: ssl2_InitSocketPolicy(ss); michael@0: ssl3_InitSocketPolicy(ss); michael@0: PR_INIT_CLIST(&ss->ssl3.hs.lastMessageFlight); michael@0: michael@0: if (makeLocks) { michael@0: status = ssl_MakeLocks(ss); michael@0: if (status != SECSuccess) michael@0: goto loser; michael@0: } michael@0: status = ssl_CreateSecurityInfo(ss); michael@0: if (status != SECSuccess) michael@0: goto loser; michael@0: status = ssl_InitGather(&ss->gs); michael@0: if (status != SECSuccess) { michael@0: loser: michael@0: ssl_DestroySocketContents(ss); michael@0: ssl_DestroyLocks(ss); michael@0: PORT_Free(ss); michael@0: ss = NULL; michael@0: } michael@0: } michael@0: return ss; michael@0: }