mirror of
https://github.com/rn10950/RetroZilla.git
synced 2024-11-16 04:20:32 +01:00
44b7f056d9
bug1001332, 56b691c003ad, bug1086145, bug1054069, bug1155922, bug991783, bug1125025, bug1162521, bug1162644, bug1132941, bug1164364, bug1166205, bug1166163, bug1166515, bug1138554, bug1167046, bug1167043, bug1169451, bug1172128, bug1170322, bug102794, bug1128184, bug557830, bug1174648, bug1180244, bug1177784, bug1173413, bug1169174, bug1084669, bug951455, bug1183395, bug1177430, bug1183827, bug1160139, bug1154106, bug1142209, bug1185033, bug1193467, bug1182667(with sha512 changes backed out, which breaks VC6 compilation), bug1158489, bug337796
1160 lines
53 KiB
C
1160 lines
53 KiB
C
/*
|
|
* This file contains prototypes for the public SSL functions.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef __ssl_h_
|
|
#define __ssl_h_
|
|
|
|
#include "prtypes.h"
|
|
#include "prerror.h"
|
|
#include "prio.h"
|
|
#include "seccomon.h"
|
|
#include "cert.h"
|
|
#include "keyt.h"
|
|
|
|
#include "sslt.h" /* public ssl data types */
|
|
|
|
#if defined(_WIN32) && !defined(IN_LIBSSL) && !defined(NSS_USE_STATIC_LIBS)
|
|
#define SSL_IMPORT extern __declspec(dllimport)
|
|
#else
|
|
#define SSL_IMPORT extern
|
|
#endif
|
|
|
|
SEC_BEGIN_PROTOS
|
|
|
|
/* constant table enumerating all implemented SSL 2 and 3 cipher suites. */
|
|
SSL_IMPORT const PRUint16 SSL_ImplementedCiphers[];
|
|
|
|
/* the same as the above, but is a function */
|
|
SSL_IMPORT const PRUint16 *SSL_GetImplementedCiphers(void);
|
|
|
|
/* number of entries in the above table. */
|
|
SSL_IMPORT const PRUint16 SSL_NumImplementedCiphers;
|
|
|
|
/* the same as the above, but is a function */
|
|
SSL_IMPORT PRUint16 SSL_GetNumImplementedCiphers(void);
|
|
|
|
/* Macro to tell which ciphers in table are SSL2 vs SSL3/TLS. */
|
|
#define SSL_IS_SSL2_CIPHER(which) (((which) & 0xfff0) == 0xff00)
|
|
|
|
/*
|
|
** Imports fd into SSL, returning a new socket. Copies SSL configuration
|
|
** from model.
|
|
*/
|
|
SSL_IMPORT PRFileDesc *SSL_ImportFD(PRFileDesc *model, PRFileDesc *fd);
|
|
|
|
/*
|
|
** Imports fd into DTLS, returning a new socket. Copies DTLS configuration
|
|
** from model.
|
|
*/
|
|
SSL_IMPORT PRFileDesc *DTLS_ImportFD(PRFileDesc *model, PRFileDesc *fd);
|
|
|
|
/*
|
|
** Enable/disable an ssl mode
|
|
**
|
|
** SSL_SECURITY:
|
|
** enable/disable use of SSL security protocol before connect
|
|
**
|
|
** SSL_SOCKS:
|
|
** enable/disable use of socks before connect
|
|
** (No longer supported).
|
|
**
|
|
** SSL_REQUEST_CERTIFICATE:
|
|
** require a certificate during secure connect
|
|
*/
|
|
/* options */
|
|
#define SSL_SECURITY 1 /* (on by default) */
|
|
#define SSL_SOCKS 2 /* (off by default) */
|
|
#define SSL_REQUEST_CERTIFICATE 3 /* (off by default) */
|
|
#define SSL_HANDSHAKE_AS_CLIENT 5 /* force accept to hs as client */
|
|
/* (off by default) */
|
|
#define SSL_HANDSHAKE_AS_SERVER 6 /* force connect to hs as server */
|
|
/* (off by default) */
|
|
|
|
/* OBSOLETE: SSL v2 is obsolete and may be removed soon. */
|
|
#define SSL_ENABLE_SSL2 7 /* enable ssl v2 (off by default) */
|
|
|
|
/* OBSOLETE: See "SSL Version Range API" below for the replacement and a
|
|
** description of the non-obvious semantics of using SSL_ENABLE_SSL3.
|
|
*/
|
|
#define SSL_ENABLE_SSL3 8 /* enable ssl v3 (on by default) */
|
|
|
|
#define SSL_NO_CACHE 9 /* don't use the session cache */
|
|
/* (off by default) */
|
|
#define SSL_REQUIRE_CERTIFICATE 10 /* (SSL_REQUIRE_FIRST_HANDSHAKE */
|
|
/* by default) */
|
|
#define SSL_ENABLE_FDX 11 /* permit simultaneous read/write */
|
|
/* (off by default) */
|
|
|
|
/* OBSOLETE: SSL v2 compatible hellos are not accepted by some TLS servers
|
|
** and cannot negotiate extensions. SSL v2 is obsolete. This option may be
|
|
** removed soon.
|
|
*/
|
|
#define SSL_V2_COMPATIBLE_HELLO 12 /* send v3 client hello in v2 fmt */
|
|
/* (off by default) */
|
|
|
|
/* OBSOLETE: See "SSL Version Range API" below for the replacement and a
|
|
** description of the non-obvious semantics of using SSL_ENABLE_TLS.
|
|
*/
|
|
#define SSL_ENABLE_TLS 13 /* enable TLS (on by default) */
|
|
|
|
#define SSL_ROLLBACK_DETECTION 14 /* for compatibility, default: on */
|
|
#define SSL_NO_STEP_DOWN 15 /* Disable export cipher suites */
|
|
/* if step-down keys are needed. */
|
|
/* default: off, generate */
|
|
/* step-down keys if needed. */
|
|
#define SSL_BYPASS_PKCS11 16 /* use PKCS#11 for pub key only */
|
|
#define SSL_NO_LOCKS 17 /* Don't use locks for protection */
|
|
#define SSL_ENABLE_SESSION_TICKETS 18 /* Enable TLS SessionTicket */
|
|
/* extension (off by default) */
|
|
#define SSL_ENABLE_DEFLATE 19 /* Enable TLS compression with */
|
|
/* DEFLATE (off by default) */
|
|
#define SSL_ENABLE_RENEGOTIATION 20 /* Values below (default: never) */
|
|
#define SSL_REQUIRE_SAFE_NEGOTIATION 21 /* Peer must send Signaling */
|
|
/* Cipher Suite Value (SCSV) or */
|
|
/* Renegotiation Info (RI) */
|
|
/* extension in ALL handshakes. */
|
|
/* default: off */
|
|
#define SSL_ENABLE_FALSE_START 22 /* Enable SSL false start (off by */
|
|
/* default, applies only to */
|
|
/* clients). False start is a */
|
|
/* mode where an SSL client will start sending application data before
|
|
* verifying the server's Finished message. This means that we could end up
|
|
* sending data to an imposter. However, the data will be encrypted and
|
|
* only the true server can derive the session key. Thus, so long as the
|
|
* cipher isn't broken this is safe. The advantage of false start is that
|
|
* it saves a round trip for client-speaks-first protocols when performing a
|
|
* full handshake.
|
|
*
|
|
* In addition to enabling this option, the application must register a
|
|
* callback using the SSL_SetCanFalseStartCallback function.
|
|
*/
|
|
|
|
/* For SSL 3.0 and TLS 1.0, by default we prevent chosen plaintext attacks
|
|
* on SSL CBC mode cipher suites (see RFC 4346 Section F.3) by splitting
|
|
* non-empty application_data records into two records; the first record has
|
|
* only the first byte of plaintext, and the second has the rest.
|
|
*
|
|
* This only prevents the attack in the sending direction; the connection may
|
|
* still be vulnerable to such attacks if the peer does not implement a similar
|
|
* countermeasure.
|
|
*
|
|
* This protection mechanism is on by default; the default can be overridden by
|
|
* setting NSS_SSL_CBC_RANDOM_IV=0 in the environment prior to execution,
|
|
* and/or by the application setting the option SSL_CBC_RANDOM_IV to PR_FALSE.
|
|
*
|
|
* The per-record IV in TLS 1.1 and later adds one block of overhead per
|
|
* record, whereas this hack will add at least two blocks of overhead per
|
|
* record, so TLS 1.1+ will always be more efficient.
|
|
*
|
|
* Other implementations (e.g. some versions of OpenSSL, in some
|
|
* configurations) prevent the same attack by prepending an empty
|
|
* application_data record to every application_data record they send; we do
|
|
* not do that because some implementations cannot handle empty
|
|
* application_data records. Also, we only split application_data records and
|
|
* not other types of records, because some implementations will not accept
|
|
* fragmented records of some other types (e.g. some versions of NSS do not
|
|
* accept fragmented alerts).
|
|
*/
|
|
#define SSL_CBC_RANDOM_IV 23
|
|
#define SSL_ENABLE_OCSP_STAPLING 24 /* Request OCSP stapling (client) */
|
|
|
|
/* SSL_ENABLE_NPN controls whether the NPN extension is enabled for the initial
|
|
* handshake when application layer protocol negotiation is used.
|
|
* SSL_SetNextProtoCallback or SSL_SetNextProtoNego must be used to control the
|
|
* application layer protocol negotiation; otherwise, the NPN extension will
|
|
* not be negotiated. SSL_ENABLE_NPN is currently enabled by default but this
|
|
* may change in future versions.
|
|
*/
|
|
#define SSL_ENABLE_NPN 25
|
|
|
|
/* SSL_ENABLE_ALPN controls whether the ALPN extension is enabled for the
|
|
* initial handshake when application layer protocol negotiation is used.
|
|
* SSL_SetNextProtoNego (not SSL_SetNextProtoCallback) must be used to control
|
|
* the application layer protocol negotiation; otherwise, the ALPN extension
|
|
* will not be negotiated. ALPN is not negotiated for renegotiation handshakes,
|
|
* even though the ALPN specification defines a way to use ALPN during
|
|
* renegotiations. SSL_ENABLE_ALPN is currently disabled by default, but this
|
|
* may change in future versions.
|
|
*/
|
|
#define SSL_ENABLE_ALPN 26
|
|
|
|
/* SSL_REUSE_SERVER_ECDHE_KEY controls whether the ECDHE server key is
|
|
* reused for multiple handshakes or generated each time.
|
|
* SSL_REUSE_SERVER_ECDHE_KEY is currently enabled by default.
|
|
* This socket option is for ECDHE, only. It is unrelated to DHE.
|
|
*/
|
|
#define SSL_REUSE_SERVER_ECDHE_KEY 27
|
|
|
|
#define SSL_ENABLE_FALLBACK_SCSV 28 /* Send fallback SCSV in
|
|
* handshakes. */
|
|
|
|
/* SSL_ENABLE_SERVER_DHE controls whether DHE is enabled for the server socket.
|
|
*/
|
|
#define SSL_ENABLE_SERVER_DHE 29
|
|
|
|
#ifdef SSL_DEPRECATED_FUNCTION
|
|
/* Old deprecated function names */
|
|
SSL_IMPORT SECStatus SSL_Enable(PRFileDesc *fd, int option, PRBool on);
|
|
SSL_IMPORT SECStatus SSL_EnableDefault(int option, PRBool on);
|
|
#endif
|
|
|
|
/* New function names */
|
|
SSL_IMPORT SECStatus SSL_OptionSet(PRFileDesc *fd, PRInt32 option, PRBool on);
|
|
SSL_IMPORT SECStatus SSL_OptionGet(PRFileDesc *fd, PRInt32 option, PRBool *on);
|
|
SSL_IMPORT SECStatus SSL_OptionSetDefault(PRInt32 option, PRBool on);
|
|
SSL_IMPORT SECStatus SSL_OptionGetDefault(PRInt32 option, PRBool *on);
|
|
SSL_IMPORT SECStatus SSL_CertDBHandleSet(PRFileDesc *fd, CERTCertDBHandle *dbHandle);
|
|
|
|
/* SSLNextProtoCallback is called during the handshake for the client, when a
|
|
* Next Protocol Negotiation (NPN) extension has been received from the server.
|
|
* |protos| and |protosLen| define a buffer which contains the server's
|
|
* advertisement. This data is guaranteed to be well formed per the NPN spec.
|
|
* |protoOut| is a buffer provided by the caller, of length 255 (the maximum
|
|
* allowed by the protocol). On successful return, the protocol to be announced
|
|
* to the server will be in |protoOut| and its length in |*protoOutLen|.
|
|
*
|
|
* The callback must return SECFailure or SECSuccess (not SECWouldBlock).
|
|
*/
|
|
typedef SECStatus (PR_CALLBACK *SSLNextProtoCallback)(
|
|
void *arg,
|
|
PRFileDesc *fd,
|
|
const unsigned char* protos,
|
|
unsigned int protosLen,
|
|
unsigned char* protoOut,
|
|
unsigned int* protoOutLen,
|
|
unsigned int protoMaxOut);
|
|
|
|
/* SSL_SetNextProtoCallback sets a callback function to handle Next Protocol
|
|
* Negotiation. It causes a client to advertise NPN. */
|
|
SSL_IMPORT SECStatus SSL_SetNextProtoCallback(PRFileDesc *fd,
|
|
SSLNextProtoCallback callback,
|
|
void *arg);
|
|
|
|
/* SSL_SetNextProtoNego can be used as an alternative to
|
|
* SSL_SetNextProtoCallback. It also causes a client to advertise NPN and
|
|
* installs a default callback function which selects the first supported
|
|
* protocol in server-preference order. If no matching protocol is found it
|
|
* selects the first supported protocol.
|
|
*
|
|
* Using this function also allows the client to transparently support ALPN.
|
|
* The same set of protocols will be advertised via ALPN and, if the server
|
|
* uses ALPN to select a protocol, SSL_GetNextProto will return
|
|
* SSL_NEXT_PROTO_SELECTED as the state.
|
|
*
|
|
* Since NPN uses the first protocol as the fallback protocol, when sending an
|
|
* ALPN extension, the first protocol is moved to the end of the list. This
|
|
* indicates that the fallback protocol is the least preferred. The other
|
|
* protocols should be in preference order.
|
|
*
|
|
* The supported protocols are specified in |data| in wire-format (8-bit
|
|
* length-prefixed). For example: "\010http/1.1\006spdy/2". */
|
|
SSL_IMPORT SECStatus SSL_SetNextProtoNego(PRFileDesc *fd,
|
|
const unsigned char *data,
|
|
unsigned int length);
|
|
|
|
typedef enum SSLNextProtoState {
|
|
SSL_NEXT_PROTO_NO_SUPPORT = 0, /* No peer support */
|
|
SSL_NEXT_PROTO_NEGOTIATED = 1, /* Mutual agreement */
|
|
SSL_NEXT_PROTO_NO_OVERLAP = 2, /* No protocol overlap found */
|
|
SSL_NEXT_PROTO_SELECTED = 3 /* Server selected proto (ALPN) */
|
|
} SSLNextProtoState;
|
|
|
|
/* SSL_GetNextProto can be used in the HandshakeCallback or any time after
|
|
* a handshake to retrieve the result of the Next Protocol negotiation.
|
|
*
|
|
* The length of the negotiated protocol, if any, is written into *bufLen.
|
|
* If the negotiated protocol is longer than bufLenMax, then SECFailure is
|
|
* returned. Otherwise, the negotiated protocol, if any, is written into buf,
|
|
* and SECSuccess is returned. */
|
|
SSL_IMPORT SECStatus SSL_GetNextProto(PRFileDesc *fd,
|
|
SSLNextProtoState *state,
|
|
unsigned char *buf,
|
|
unsigned int *bufLen,
|
|
unsigned int bufLenMax);
|
|
|
|
/*
|
|
** Control ciphers that SSL uses. If on is non-zero then the named cipher
|
|
** is enabled, otherwise it is disabled.
|
|
** The "cipher" values are defined in sslproto.h (the SSL_EN_* values).
|
|
** EnableCipher records user preferences.
|
|
** SetPolicy sets the policy according to the policy module.
|
|
*/
|
|
#ifdef SSL_DEPRECATED_FUNCTION
|
|
/* Old deprecated function names */
|
|
SSL_IMPORT SECStatus SSL_EnableCipher(long which, PRBool enabled);
|
|
SSL_IMPORT SECStatus SSL_SetPolicy(long which, int policy);
|
|
#endif
|
|
|
|
/* New function names */
|
|
SSL_IMPORT SECStatus SSL_CipherPrefSet(PRFileDesc *fd, PRInt32 cipher, PRBool enabled);
|
|
SSL_IMPORT SECStatus SSL_CipherPrefGet(PRFileDesc *fd, PRInt32 cipher, PRBool *enabled);
|
|
SSL_IMPORT SECStatus SSL_CipherPrefSetDefault(PRInt32 cipher, PRBool enabled);
|
|
SSL_IMPORT SECStatus SSL_CipherPrefGetDefault(PRInt32 cipher, PRBool *enabled);
|
|
SSL_IMPORT SECStatus SSL_CipherPolicySet(PRInt32 cipher, PRInt32 policy);
|
|
SSL_IMPORT SECStatus SSL_CipherPolicyGet(PRInt32 cipher, PRInt32 *policy);
|
|
|
|
/*
|
|
** Control for TLS signature algorithms for TLS 1.2 only.
|
|
**
|
|
** This governs what signature algorithms are sent by a client in the
|
|
** signature_algorithms extension. A client will not accept a signature from a
|
|
** server unless it uses an enabled algorithm.
|
|
**
|
|
** This also governs what the server sends in the supported_signature_algorithms
|
|
** field of a CertificateRequest. It also changes what the server uses to sign
|
|
** ServerKeyExchange: a server uses the first entry from this list that is
|
|
** compatible with the client's advertised signature_algorithms extension and
|
|
** the selected server certificate.
|
|
**
|
|
** Omitting SHA-256 from this list might be foolish. Support is mandatory in
|
|
** TLS 1.2 and there might be interoperability issues. For a server, NSS only
|
|
** supports SHA-256 for verifying a TLS 1.2 CertificateVerify. This list needs
|
|
** to include SHA-256 if client authentication is requested or required, or
|
|
** creating a CertificateRequest will fail.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_SignaturePrefSet(
|
|
PRFileDesc *fd, const SSLSignatureAndHashAlg *algorithms,
|
|
unsigned int count);
|
|
|
|
/*
|
|
** Get the currently configured signature algorithms.
|
|
**
|
|
** The algorithms are written to |algorithms| but not if there are more than
|
|
** |maxCount| values configured. The number of algorithms that are in use are
|
|
** written to |count|. This fails if |maxCount| is insufficiently large.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_SignaturePrefGet(
|
|
PRFileDesc *fd, SSLSignatureAndHashAlg *algorithms, unsigned int *count,
|
|
unsigned int maxCount);
|
|
|
|
/*
|
|
** Returns the maximum number of signature algorithms that are supported and
|
|
** can be set or retrieved using SSL_SignaturePrefSet or SSL_SignaturePrefGet.
|
|
*/
|
|
SSL_IMPORT unsigned int SSL_SignatureMaxCount();
|
|
|
|
/* SSL_DHEGroupPrefSet is used to configure the set of allowed/enabled DHE group
|
|
** parameters that can be used by NSS for the given server socket.
|
|
** The first item in the array is used as the default group, if no other
|
|
** selection criteria can be used by NSS.
|
|
** The set is provided as an array of identifiers as defined by SSLDHEGroupType.
|
|
** If more than one group identifier is provided, NSS will select the one to use.
|
|
** For example, a TLS extension sent by the client might indicate a preference.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_DHEGroupPrefSet(PRFileDesc *fd,
|
|
SSLDHEGroupType *groups,
|
|
PRUint16 num_groups);
|
|
|
|
/* Enable the use of a DHE group that's smaller than the library default,
|
|
** for backwards compatibility reasons. The DH parameters will be created
|
|
** at the time this function is called, which might take a very long time.
|
|
** The function will block until generation is completed.
|
|
** The intention is to enforce that fresh and safe parameters are generated
|
|
** each time a process is started.
|
|
** At the time this API was initially implemented, the API will enable the
|
|
** use of 1024 bit DHE parameters. This value might get increased in future
|
|
** versions of NSS.
|
|
**
|
|
** It is allowed to call this API will a NULL value for parameter fd,
|
|
** which will prepare the global parameters that NSS will reuse for the remainder
|
|
** of the process lifetime. This can be used early after startup of a process,
|
|
** to avoid a delay when handling incoming client connections.
|
|
** This preparation with a NULL for parameter fd will NOT enable the weak group
|
|
** on sockets. The function needs to be called again for every socket that
|
|
** should use the weak group.
|
|
**
|
|
** It is allowed to use this API in combination with the SSL_DHEGroupPrefSet API.
|
|
** If both APIs have been called, the weakest group will be used,
|
|
** unless it is certain that the client supports larger group parameters.
|
|
** The weak group will be used as the default group, overriding the preference
|
|
** for the first group potentially set with a call to SSL_DHEGroupPrefSet
|
|
** (The first group set using SSL_DHEGroupPrefSet will still be enabled, but
|
|
** it's no longer the default group.)
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_EnableWeakDHEPrimeGroup(PRFileDesc *fd, PRBool enabled);
|
|
|
|
/* SSL Version Range API
|
|
**
|
|
** This API should be used to control SSL 3.0 & TLS support instead of the
|
|
** older SSL_Option* API; however, the SSL_Option* API MUST still be used to
|
|
** control SSL 2.0 support. In this version of libssl, SSL 3.0 and TLS 1.0 are
|
|
** enabled by default. Future versions of libssl may change which versions of
|
|
** the protocol are enabled by default.
|
|
**
|
|
** The SSLProtocolVariant enum indicates whether the protocol is of type
|
|
** stream or datagram. This must be provided to the functions that do not
|
|
** take an fd. Functions which take an fd will get the variant from the fd,
|
|
** which is typed.
|
|
**
|
|
** Using the new version range API in conjunction with the older
|
|
** SSL_OptionSet-based API for controlling the enabled protocol versions may
|
|
** cause unexpected results. Going forward, we guarantee only the following:
|
|
**
|
|
** SSL_OptionGet(SSL_ENABLE_TLS) will return PR_TRUE if *ANY* versions of TLS
|
|
** are enabled.
|
|
**
|
|
** SSL_OptionSet(SSL_ENABLE_TLS, PR_FALSE) will disable *ALL* versions of TLS,
|
|
** including TLS 1.0 and later.
|
|
**
|
|
** The above two properties provide compatibility for applications that use
|
|
** SSL_OptionSet to implement the insecure fallback from TLS 1.x to SSL 3.0.
|
|
**
|
|
** SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE) will enable TLS 1.0, and may also
|
|
** enable some later versions of TLS, if it is necessary to do so in order to
|
|
** keep the set of enabled versions contiguous. For example, if TLS 1.2 is
|
|
** enabled, then after SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE), TLS 1.0,
|
|
** TLS 1.1, and TLS 1.2 will be enabled, and the call will have no effect on
|
|
** whether SSL 3.0 is enabled. If no later versions of TLS are enabled at the
|
|
** time SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE) is called, then no later
|
|
** versions of TLS will be enabled by the call.
|
|
**
|
|
** SSL_OptionSet(SSL_ENABLE_SSL3, PR_FALSE) will disable SSL 3.0, and will not
|
|
** change the set of TLS versions that are enabled.
|
|
**
|
|
** SSL_OptionSet(SSL_ENABLE_SSL3, PR_TRUE) will enable SSL 3.0, and may also
|
|
** enable some versions of TLS if TLS 1.1 or later is enabled at the time of
|
|
** the call, the same way SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE) works, in
|
|
** order to keep the set of enabled versions contiguous.
|
|
*/
|
|
|
|
/* Returns, in |*vrange|, the range of SSL3/TLS versions supported for the
|
|
** given protocol variant by the version of libssl linked-to at runtime.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_VersionRangeGetSupported(
|
|
SSLProtocolVariant protocolVariant, SSLVersionRange *vrange);
|
|
|
|
/* Returns, in |*vrange|, the range of SSL3/TLS versions enabled by default
|
|
** for the given protocol variant.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_VersionRangeGetDefault(
|
|
SSLProtocolVariant protocolVariant, SSLVersionRange *vrange);
|
|
|
|
/* Sets the range of enabled-by-default SSL3/TLS versions for the given
|
|
** protocol variant to |*vrange|.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_VersionRangeSetDefault(
|
|
SSLProtocolVariant protocolVariant, const SSLVersionRange *vrange);
|
|
|
|
/* Returns, in |*vrange|, the range of enabled SSL3/TLS versions for |fd|. */
|
|
SSL_IMPORT SECStatus SSL_VersionRangeGet(PRFileDesc *fd,
|
|
SSLVersionRange *vrange);
|
|
|
|
/* Sets the range of enabled SSL3/TLS versions for |fd| to |*vrange|. */
|
|
SSL_IMPORT SECStatus SSL_VersionRangeSet(PRFileDesc *fd,
|
|
const SSLVersionRange *vrange);
|
|
|
|
|
|
/* Values for "policy" argument to SSL_CipherPolicySet */
|
|
/* Values returned by SSL_CipherPolicyGet. */
|
|
#define SSL_NOT_ALLOWED 0 /* or invalid or unimplemented */
|
|
#define SSL_ALLOWED 1
|
|
#define SSL_RESTRICTED 2 /* only with "Step-Up" certs. */
|
|
|
|
/* Values for "on" with SSL_REQUIRE_CERTIFICATE. */
|
|
#define SSL_REQUIRE_NEVER ((PRBool)0)
|
|
#define SSL_REQUIRE_ALWAYS ((PRBool)1)
|
|
#define SSL_REQUIRE_FIRST_HANDSHAKE ((PRBool)2)
|
|
#define SSL_REQUIRE_NO_ERROR ((PRBool)3)
|
|
|
|
/* Values for "on" with SSL_ENABLE_RENEGOTIATION */
|
|
/* Never renegotiate at all. */
|
|
#define SSL_RENEGOTIATE_NEVER ((PRBool)0)
|
|
/* Renegotiate without restriction, whether or not the peer's client hello */
|
|
/* bears the renegotiation info extension. Vulnerable, as in the past. */
|
|
#define SSL_RENEGOTIATE_UNRESTRICTED ((PRBool)1)
|
|
/* Only renegotiate if the peer's hello bears the TLS renegotiation_info */
|
|
/* extension. This is safe renegotiation. */
|
|
#define SSL_RENEGOTIATE_REQUIRES_XTN ((PRBool)2)
|
|
/* Disallow unsafe renegotiation in server sockets only, but allow clients */
|
|
/* to continue to renegotiate with vulnerable servers. */
|
|
/* This value should only be used during the transition period when few */
|
|
/* servers have been upgraded. */
|
|
#define SSL_RENEGOTIATE_TRANSITIONAL ((PRBool)3)
|
|
|
|
/*
|
|
** Reset the handshake state for fd. This will make the complete SSL
|
|
** handshake protocol execute from the ground up on the next i/o
|
|
** operation.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_ResetHandshake(PRFileDesc *fd, PRBool asServer);
|
|
|
|
/*
|
|
** Force the handshake for fd to complete immediately. This blocks until
|
|
** the complete SSL handshake protocol is finished.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_ForceHandshake(PRFileDesc *fd);
|
|
|
|
/*
|
|
** Same as above, but with an I/O timeout.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_ForceHandshakeWithTimeout(PRFileDesc *fd,
|
|
PRIntervalTime timeout);
|
|
|
|
/*
|
|
** Query security status of socket. *on is set to one if security is
|
|
** enabled. *keySize will contain the stream key size used. *issuer will
|
|
** contain the RFC1485 verison of the name of the issuer of the
|
|
** certificate at the other end of the connection. For a client, this is
|
|
** the issuer of the server's certificate; for a server, this is the
|
|
** issuer of the client's certificate (if any). Subject is the subject of
|
|
** the other end's certificate. The pointers can be zero if the desired
|
|
** data is not needed. All strings returned by this function are owned
|
|
** by the caller, and need to be freed with PORT_Free.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_SecurityStatus(PRFileDesc *fd, int *on, char **cipher,
|
|
int *keySize, int *secretKeySize,
|
|
char **issuer, char **subject);
|
|
|
|
/* Values for "on" */
|
|
#define SSL_SECURITY_STATUS_NOOPT -1
|
|
#define SSL_SECURITY_STATUS_OFF 0
|
|
#define SSL_SECURITY_STATUS_ON_HIGH 1
|
|
#define SSL_SECURITY_STATUS_ON_LOW 2
|
|
#define SSL_SECURITY_STATUS_FORTEZZA 3 /* NO LONGER SUPPORTED */
|
|
|
|
/*
|
|
** Return the certificate for our SSL peer. If the client calls this
|
|
** it will always return the server's certificate. If the server calls
|
|
** this, it may return NULL if client authentication is not enabled or
|
|
** if the client had no certificate when asked.
|
|
** "fd" the socket "file" descriptor
|
|
*/
|
|
SSL_IMPORT CERTCertificate *SSL_PeerCertificate(PRFileDesc *fd);
|
|
|
|
/*
|
|
** Return the certificates presented by the SSL peer. If the SSL peer
|
|
** did not present certificates, return NULL with the
|
|
** SSL_ERROR_NO_CERTIFICATE error. On failure, return NULL with an error
|
|
** code other than SSL_ERROR_NO_CERTIFICATE.
|
|
** "fd" the socket "file" descriptor
|
|
*/
|
|
SSL_IMPORT CERTCertList *SSL_PeerCertificateChain(PRFileDesc *fd);
|
|
|
|
/* SSL_PeerStapledOCSPResponses returns the OCSP responses that were provided
|
|
* by the TLS server. The return value is a pointer to an internal SECItemArray
|
|
* that contains the returned OCSP responses; it is only valid until the
|
|
* callback function that calls SSL_PeerStapledOCSPResponses returns.
|
|
*
|
|
* If no OCSP responses were given by the server then the result will be empty.
|
|
* If there was an error, then the result will be NULL.
|
|
*
|
|
* You must set the SSL_ENABLE_OCSP_STAPLING option to enable OCSP stapling.
|
|
* to be provided by a server.
|
|
*
|
|
* libssl does not do any validation of the OCSP response itself; the
|
|
* authenticate certificate hook is responsible for doing so. The default
|
|
* authenticate certificate hook, SSL_AuthCertificate, does not implement
|
|
* any OCSP stapling funtionality, but this may change in future versions.
|
|
*/
|
|
SSL_IMPORT const SECItemArray * SSL_PeerStapledOCSPResponses(PRFileDesc *fd);
|
|
|
|
/* SSL_SetStapledOCSPResponses stores an array of one or multiple OCSP responses
|
|
* in the fd's data, which may be sent as part of a server side cert_status
|
|
* handshake message. Parameter |responses| is for the server certificate of
|
|
* the key exchange type |kea|.
|
|
* The function will duplicate the responses array.
|
|
*/
|
|
SSL_IMPORT SECStatus
|
|
SSL_SetStapledOCSPResponses(PRFileDesc *fd, const SECItemArray *responses,
|
|
SSLKEAType kea);
|
|
|
|
/*
|
|
** Authenticate certificate hook. Called when a certificate comes in
|
|
** (because of SSL_REQUIRE_CERTIFICATE in SSL_Enable) to authenticate the
|
|
** certificate.
|
|
**
|
|
** The authenticate certificate hook must return SECSuccess to indicate the
|
|
** certificate is valid, SECFailure to indicate the certificate is invalid,
|
|
** or SECWouldBlock if the application will authenticate the certificate
|
|
** asynchronously. SECWouldBlock is only supported for non-blocking sockets.
|
|
**
|
|
** If the authenticate certificate hook returns SECFailure, then the bad cert
|
|
** hook will be called. The bad cert handler is NEVER called if the
|
|
** authenticate certificate hook returns SECWouldBlock. If the application
|
|
** needs to handle and/or override a bad cert, it should do so before it
|
|
** calls SSL_AuthCertificateComplete (modifying the error it passes to
|
|
** SSL_AuthCertificateComplete as needed).
|
|
**
|
|
** See the documentation for SSL_AuthCertificateComplete for more information
|
|
** about the asynchronous behavior that occurs when the authenticate
|
|
** certificate hook returns SECWouldBlock.
|
|
**
|
|
** RFC 6066 says that clients should send the bad_certificate_status_response
|
|
** alert when they encounter an error processing the stapled OCSP response.
|
|
** libssl does not provide a way for the authenticate certificate hook to
|
|
** indicate that an OCSP error (SEC_ERROR_OCSP_*) that it returns is an error
|
|
** in the stapled OCSP response or an error in some other OCSP response.
|
|
** Further, NSS does not provide a convenient way to control or determine
|
|
** which OCSP response(s) were used to validate a certificate chain.
|
|
** Consequently, the current version of libssl does not ever send the
|
|
** bad_certificate_status_response alert. This may change in future releases.
|
|
*/
|
|
typedef SECStatus (PR_CALLBACK *SSLAuthCertificate)(void *arg, PRFileDesc *fd,
|
|
PRBool checkSig,
|
|
PRBool isServer);
|
|
|
|
SSL_IMPORT SECStatus SSL_AuthCertificateHook(PRFileDesc *fd,
|
|
SSLAuthCertificate f,
|
|
void *arg);
|
|
|
|
/* An implementation of the certificate authentication hook */
|
|
SSL_IMPORT SECStatus SSL_AuthCertificate(void *arg, PRFileDesc *fd,
|
|
PRBool checkSig, PRBool isServer);
|
|
|
|
/*
|
|
* Prototype for SSL callback to get client auth data from the application.
|
|
* arg - application passed argument
|
|
* caNames - pointer to distinguished names of CAs that the server likes
|
|
* pRetCert - pointer to pointer to cert, for return of cert
|
|
* pRetKey - pointer to key pointer, for return of key
|
|
*/
|
|
typedef SECStatus (PR_CALLBACK *SSLGetClientAuthData)(void *arg,
|
|
PRFileDesc *fd,
|
|
CERTDistNames *caNames,
|
|
CERTCertificate **pRetCert,/*return */
|
|
SECKEYPrivateKey **pRetKey);/* return */
|
|
|
|
/*
|
|
* Set the client side callback for SSL to retrieve user's private key
|
|
* and certificate.
|
|
* fd - the file descriptor for the connection in question
|
|
* f - the application's callback that delivers the key and cert
|
|
* a - application specific data
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_GetClientAuthDataHook(PRFileDesc *fd,
|
|
SSLGetClientAuthData f, void *a);
|
|
|
|
|
|
/*
|
|
** SNI extension processing callback function.
|
|
** It is called when SSL socket receives SNI extension in ClientHello message.
|
|
** Upon this callback invocation, application is responsible to reconfigure the
|
|
** socket with the data for a particular server name.
|
|
** There are three potential outcomes of this function invocation:
|
|
** * application does not recognize the name or the type and wants the
|
|
** "unrecognized_name" alert be sent to the client. In this case the callback
|
|
** function must return SSL_SNI_SEND_ALERT status.
|
|
** * application does not recognize the name, but wants to continue with
|
|
** the handshake using the current socket configuration. In this case,
|
|
** no socket reconfiguration is needed and the function should return
|
|
** SSL_SNI_CURRENT_CONFIG_IS_USED.
|
|
** * application recognizes the name and reconfigures the socket with
|
|
** appropriate certs, key, etc. There are many ways to reconfigure. NSS
|
|
** provides SSL_ReconfigFD function that can be used to update the socket
|
|
** data from model socket. To continue with the rest of the handshake, the
|
|
** implementation function should return an index of a name it has chosen.
|
|
** LibSSL will ignore any SNI extension received in a ClientHello message
|
|
** if application does not register a SSLSNISocketConfig callback.
|
|
** Each type field of SECItem indicates the name type.
|
|
** NOTE: currently RFC3546 defines only one name type: sni_host_name.
|
|
** Client is allowed to send only one name per known type. LibSSL will
|
|
** send an "unrecognized_name" alert if SNI extension name list contains more
|
|
** then one name of a type.
|
|
*/
|
|
typedef PRInt32 (PR_CALLBACK *SSLSNISocketConfig)(PRFileDesc *fd,
|
|
const SECItem *srvNameArr,
|
|
PRUint32 srvNameArrSize,
|
|
void *arg);
|
|
|
|
/*
|
|
** SSLSNISocketConfig should return an index within 0 and srvNameArrSize-1
|
|
** when it has reconfigured the socket fd to use certs and keys, etc
|
|
** for a specific name. There are two other allowed return values. One
|
|
** tells libSSL to use the default cert and key. The other tells libSSL
|
|
** to send the "unrecognized_name" alert. These values are:
|
|
**/
|
|
#define SSL_SNI_CURRENT_CONFIG_IS_USED -1
|
|
#define SSL_SNI_SEND_ALERT -2
|
|
|
|
/*
|
|
** Set application implemented SNISocketConfig callback.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_SNISocketConfigHook(PRFileDesc *fd,
|
|
SSLSNISocketConfig f,
|
|
void *arg);
|
|
|
|
/*
|
|
** Reconfigure fd SSL socket with model socket parameters. Sets
|
|
** server certs and keys, list of trust anchor, socket options
|
|
** and all SSL socket call backs and parameters.
|
|
*/
|
|
SSL_IMPORT PRFileDesc *SSL_ReconfigFD(PRFileDesc *model, PRFileDesc *fd);
|
|
|
|
/*
|
|
* Set the client side argument for SSL to retrieve PKCS #11 pin.
|
|
* fd - the file descriptor for the connection in question
|
|
* a - pkcs11 application specific data
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_SetPKCS11PinArg(PRFileDesc *fd, void *a);
|
|
|
|
/*
|
|
** This is a callback for dealing with server certs that are not authenticated
|
|
** by the client. The client app can decide that it actually likes the
|
|
** cert by some external means and restart the connection.
|
|
**
|
|
** The bad cert hook must return SECSuccess to override the result of the
|
|
** authenticate certificate hook, SECFailure if the certificate should still be
|
|
** considered invalid, or SECWouldBlock if the application will authenticate
|
|
** the certificate asynchronously. SECWouldBlock is only supported for
|
|
** non-blocking sockets.
|
|
**
|
|
** See the documentation for SSL_AuthCertificateComplete for more information
|
|
** about the asynchronous behavior that occurs when the bad cert hook returns
|
|
** SECWouldBlock.
|
|
*/
|
|
typedef SECStatus (PR_CALLBACK *SSLBadCertHandler)(void *arg, PRFileDesc *fd);
|
|
SSL_IMPORT SECStatus SSL_BadCertHook(PRFileDesc *fd, SSLBadCertHandler f,
|
|
void *arg);
|
|
|
|
/*
|
|
** Configure SSL socket for running a secure server. Needs the
|
|
** certificate for the server and the servers private key. The arguments
|
|
** are copied.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_ConfigSecureServer(
|
|
PRFileDesc *fd, CERTCertificate *cert,
|
|
SECKEYPrivateKey *key, SSLKEAType kea);
|
|
|
|
/*
|
|
** Allows SSL socket configuration with caller-supplied certificate chain.
|
|
** If certChainOpt is NULL, tries to find one.
|
|
*/
|
|
SSL_IMPORT SECStatus
|
|
SSL_ConfigSecureServerWithCertChain(PRFileDesc *fd, CERTCertificate *cert,
|
|
const CERTCertificateList *certChainOpt,
|
|
SECKEYPrivateKey *key, SSLKEAType kea);
|
|
|
|
/*
|
|
** Configure a secure server's session-id cache. Define the maximum number
|
|
** of entries in the cache, the longevity of the entires, and the directory
|
|
** where the cache files will be placed. These values can be zero, and
|
|
** if so, the implementation will choose defaults.
|
|
** This version of the function is for use in applications that have only one
|
|
** process that uses the cache (even if that process has multiple threads).
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_ConfigServerSessionIDCache(int maxCacheEntries,
|
|
PRUint32 timeout,
|
|
PRUint32 ssl3_timeout,
|
|
const char * directory);
|
|
|
|
/* Configure a secure server's session-id cache. Depends on value of
|
|
* enableMPCache, configures malti-proc or single proc cache. */
|
|
SSL_IMPORT SECStatus SSL_ConfigServerSessionIDCacheWithOpt(
|
|
PRUint32 timeout,
|
|
PRUint32 ssl3_timeout,
|
|
const char * directory,
|
|
int maxCacheEntries,
|
|
int maxCertCacheEntries,
|
|
int maxSrvNameCacheEntries,
|
|
PRBool enableMPCache);
|
|
|
|
/*
|
|
** Like SSL_ConfigServerSessionIDCache, with one important difference.
|
|
** If the application will run multiple processes (as opposed to, or in
|
|
** addition to multiple threads), then it must call this function, instead
|
|
** of calling SSL_ConfigServerSessionIDCache().
|
|
** This has nothing to do with the number of processORs, only processEs.
|
|
** This function sets up a Server Session ID (SID) cache that is safe for
|
|
** access by multiple processes on the same system.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_ConfigMPServerSIDCache(int maxCacheEntries,
|
|
PRUint32 timeout,
|
|
PRUint32 ssl3_timeout,
|
|
const char * directory);
|
|
|
|
/* Get and set the configured maximum number of mutexes used for the
|
|
** server's store of SSL sessions. This value is used by the server
|
|
** session ID cache initialization functions shown above. Note that on
|
|
** some platforms, these mutexes are actually implemented with POSIX
|
|
** semaphores, or with unnamed pipes. The default value varies by platform.
|
|
** An attempt to set a too-low maximum will return an error and the
|
|
** configured value will not be changed.
|
|
*/
|
|
SSL_IMPORT PRUint32 SSL_GetMaxServerCacheLocks(void);
|
|
SSL_IMPORT SECStatus SSL_SetMaxServerCacheLocks(PRUint32 maxLocks);
|
|
|
|
/* environment variable set by SSL_ConfigMPServerSIDCache, and queried by
|
|
* SSL_InheritMPServerSIDCache when envString is NULL.
|
|
*/
|
|
#define SSL_ENV_VAR_NAME "SSL_INHERITANCE"
|
|
|
|
/* called in child to inherit SID Cache variables.
|
|
* If envString is NULL, this function will use the value of the environment
|
|
* variable "SSL_INHERITANCE", otherwise the string value passed in will be
|
|
* used.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_InheritMPServerSIDCache(const char * envString);
|
|
|
|
/*
|
|
** Set the callback that gets called when a TLS handshake is complete. The
|
|
** handshake callback is called after verifying the peer's Finished message and
|
|
** before processing incoming application data.
|
|
**
|
|
** For the initial handshake: If the handshake false started (see
|
|
** SSL_ENABLE_FALSE_START), then application data may already have been sent
|
|
** before the handshake callback is called. If we did not false start then the
|
|
** callback will get called before any application data is sent.
|
|
*/
|
|
typedef void (PR_CALLBACK *SSLHandshakeCallback)(PRFileDesc *fd,
|
|
void *client_data);
|
|
SSL_IMPORT SECStatus SSL_HandshakeCallback(PRFileDesc *fd,
|
|
SSLHandshakeCallback cb, void *client_data);
|
|
|
|
/* Applications that wish to enable TLS false start must set this callback
|
|
** function. NSS will invoke the functon to determine if a particular
|
|
** connection should use false start or not. SECSuccess indicates that the
|
|
** callback completed successfully, and if so *canFalseStart indicates if false
|
|
** start can be used. If the callback does not return SECSuccess then the
|
|
** handshake will be canceled. NSS's recommended criteria can be evaluated by
|
|
** calling SSL_RecommendedCanFalseStart.
|
|
**
|
|
** If no false start callback is registered then false start will never be
|
|
** done, even if the SSL_ENABLE_FALSE_START option is enabled.
|
|
**/
|
|
typedef SECStatus (PR_CALLBACK *SSLCanFalseStartCallback)(
|
|
PRFileDesc *fd, void *arg, PRBool *canFalseStart);
|
|
|
|
SSL_IMPORT SECStatus SSL_SetCanFalseStartCallback(
|
|
PRFileDesc *fd, SSLCanFalseStartCallback callback, void *arg);
|
|
|
|
/* This function sets *canFalseStart according to the recommended criteria for
|
|
** false start. These criteria may change from release to release and may depend
|
|
** on which handshake features have been negotiated and/or properties of the
|
|
** certifciates/keys used on the connection.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_RecommendedCanFalseStart(PRFileDesc *fd,
|
|
PRBool *canFalseStart);
|
|
|
|
/*
|
|
** For the server, request a new handshake. For the client, begin a new
|
|
** handshake. If flushCache is non-zero, the SSL3 cache entry will be
|
|
** flushed first, ensuring that a full SSL handshake will be done.
|
|
** If flushCache is zero, and an SSL connection is established, it will
|
|
** do the much faster session restart handshake. This will change the
|
|
** session keys without doing another private key operation.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_ReHandshake(PRFileDesc *fd, PRBool flushCache);
|
|
|
|
/*
|
|
** Same as above, but with an I/O timeout.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_ReHandshakeWithTimeout(PRFileDesc *fd,
|
|
PRBool flushCache,
|
|
PRIntervalTime timeout);
|
|
|
|
|
|
#ifdef SSL_DEPRECATED_FUNCTION
|
|
/* deprecated!
|
|
** For the server, request a new handshake. For the client, begin a new
|
|
** handshake. Flushes SSL3 session cache entry first, ensuring that a
|
|
** full handshake will be done.
|
|
** This call is equivalent to SSL_ReHandshake(fd, PR_TRUE)
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_RedoHandshake(PRFileDesc *fd);
|
|
#endif
|
|
|
|
/*
|
|
* Allow the application to pass a URL or hostname into the SSL library.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_SetURL(PRFileDesc *fd, const char *url);
|
|
|
|
/*
|
|
* Allow an application to define a set of trust anchors for peer
|
|
* cert validation.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_SetTrustAnchors(PRFileDesc *fd, CERTCertList *list);
|
|
|
|
/*
|
|
** Return the number of bytes that SSL has waiting in internal buffers.
|
|
** Return 0 if security is not enabled.
|
|
*/
|
|
SSL_IMPORT int SSL_DataPending(PRFileDesc *fd);
|
|
|
|
/*
|
|
** Invalidate the SSL session associated with fd.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_InvalidateSession(PRFileDesc *fd);
|
|
|
|
/*
|
|
** Return a SECItem containing the SSL session ID associated with the fd.
|
|
*/
|
|
SSL_IMPORT SECItem *SSL_GetSessionID(PRFileDesc *fd);
|
|
|
|
/*
|
|
** Clear out the client's SSL session cache, not the server's session cache.
|
|
*/
|
|
SSL_IMPORT void SSL_ClearSessionCache(void);
|
|
|
|
/*
|
|
** Close the server's SSL session cache.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_ShutdownServerSessionIDCache(void);
|
|
|
|
/*
|
|
** Set peer information so we can correctly look up SSL session later.
|
|
** You only have to do this if you're tunneling through a proxy.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_SetSockPeerID(PRFileDesc *fd, const char *peerID);
|
|
|
|
/*
|
|
** Reveal the security information for the peer.
|
|
*/
|
|
SSL_IMPORT CERTCertificate * SSL_RevealCert(PRFileDesc * socket);
|
|
SSL_IMPORT void * SSL_RevealPinArg(PRFileDesc * socket);
|
|
SSL_IMPORT char * SSL_RevealURL(PRFileDesc * socket);
|
|
|
|
/* This callback may be passed to the SSL library via a call to
|
|
* SSL_GetClientAuthDataHook() for each SSL client socket.
|
|
* It will be invoked when SSL needs to know what certificate and private key
|
|
* (if any) to use to respond to a request for client authentication.
|
|
* If arg is non-NULL, it is a pointer to a NULL-terminated string containing
|
|
* the nickname of the cert/key pair to use.
|
|
* If arg is NULL, this function will search the cert and key databases for
|
|
* a suitable match and send it if one is found.
|
|
*/
|
|
SSL_IMPORT SECStatus
|
|
NSS_GetClientAuthData(void * arg,
|
|
PRFileDesc * socket,
|
|
struct CERTDistNamesStr * caNames,
|
|
struct CERTCertificateStr ** pRetCert,
|
|
struct SECKEYPrivateKeyStr **pRetKey);
|
|
|
|
/*
|
|
** Configure DTLS-SRTP (RFC 5764) cipher suite preferences.
|
|
** Input is a list of ciphers in descending preference order and a length
|
|
** of the list. As a side effect, this causes the use_srtp extension to be
|
|
** negotiated.
|
|
**
|
|
** Invalid or unimplemented cipher suites in |ciphers| are ignored. If at
|
|
** least one cipher suite in |ciphers| is implemented, returns SECSuccess.
|
|
** Otherwise returns SECFailure.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_SetSRTPCiphers(PRFileDesc *fd,
|
|
const PRUint16 *ciphers,
|
|
unsigned int numCiphers);
|
|
|
|
/*
|
|
** Get the selected DTLS-SRTP cipher suite (if any).
|
|
** To be called after the handshake completes.
|
|
** Returns SECFailure if not negotiated.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_GetSRTPCipher(PRFileDesc *fd,
|
|
PRUint16 *cipher);
|
|
|
|
/*
|
|
* Look to see if any of the signers in the cert chain for "cert" are found
|
|
* in the list of caNames.
|
|
* Returns SECSuccess if so, SECFailure if not.
|
|
* Used by NSS_GetClientAuthData. May be used by other callback functions.
|
|
*/
|
|
SSL_IMPORT SECStatus NSS_CmpCertChainWCANames(CERTCertificate *cert,
|
|
CERTDistNames *caNames);
|
|
|
|
/*
|
|
* Returns key exchange type of the keys in an SSL server certificate.
|
|
*/
|
|
SSL_IMPORT SSLKEAType NSS_FindCertKEAType(CERTCertificate * cert);
|
|
|
|
/* Set cipher policies to a predefined Domestic (U.S.A.) policy.
|
|
* This essentially allows all supported ciphers.
|
|
*/
|
|
SSL_IMPORT SECStatus NSS_SetDomesticPolicy(void);
|
|
|
|
/* Set cipher policies to a predefined Policy that is exportable from the USA
|
|
* according to present U.S. policies as we understand them.
|
|
* It is the same as NSS_SetDomesticPolicy now.
|
|
*/
|
|
SSL_IMPORT SECStatus NSS_SetExportPolicy(void);
|
|
|
|
/* Set cipher policies to a predefined Policy that is exportable from the USA
|
|
* according to present U.S. policies as we understand them, and that the
|
|
* nation of France will permit to be imported into their country.
|
|
* It is the same as NSS_SetDomesticPolicy now.
|
|
*/
|
|
SSL_IMPORT SECStatus NSS_SetFrancePolicy(void);
|
|
|
|
SSL_IMPORT SSL3Statistics * SSL_GetStatistics(void);
|
|
|
|
/* Report more information than SSL_SecurityStatus.
|
|
* Caller supplies the info struct. This function fills it in.
|
|
* The information here will be zeroed prior to details being confirmed. The
|
|
* details are confirmed either when a Finished message is received, or - for a
|
|
* client - when the second flight of messages have been sent. This function
|
|
* therefore produces unreliable results prior to receiving the
|
|
* SSLHandshakeCallback or the SSLCanFalseStartCallback.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_GetChannelInfo(PRFileDesc *fd, SSLChannelInfo *info,
|
|
PRUintn len);
|
|
/* Get preliminary information about a channel.
|
|
* This function can be called prior to handshake details being confirmed (see
|
|
* SSL_GetChannelInfo above for what that means). Thus, information provided by
|
|
* this function is available to SSLAuthCertificate, SSLGetClientAuthData,
|
|
* SSLSNISocketConfig, and other callbacks that might be called during the
|
|
* processing of the first flight of client of server handshake messages.
|
|
* Values are marked as being unavailable when renegotiation is initiated.
|
|
*/
|
|
SSL_IMPORT SECStatus
|
|
SSL_GetPreliminaryChannelInfo(PRFileDesc *fd,
|
|
SSLPreliminaryChannelInfo *info,
|
|
PRUintn len);
|
|
SSL_IMPORT SECStatus SSL_GetCipherSuiteInfo(PRUint16 cipherSuite,
|
|
SSLCipherSuiteInfo *info, PRUintn len);
|
|
|
|
/* Returnes negotiated through SNI host info. */
|
|
SSL_IMPORT SECItem *SSL_GetNegotiatedHostInfo(PRFileDesc *fd);
|
|
|
|
/* Export keying material according to RFC 5705.
|
|
** fd must correspond to a TLS 1.0 or higher socket and out must
|
|
** already be allocated. If hasContext is false, it uses the no-context
|
|
** construction from the RFC and ignores the context and contextLen
|
|
** arguments.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_ExportKeyingMaterial(PRFileDesc *fd,
|
|
const char *label,
|
|
unsigned int labelLen,
|
|
PRBool hasContext,
|
|
const unsigned char *context,
|
|
unsigned int contextLen,
|
|
unsigned char *out,
|
|
unsigned int outLen);
|
|
|
|
/*
|
|
** Return a new reference to the certificate that was most recently sent
|
|
** to the peer on this SSL/TLS connection, or NULL if none has been sent.
|
|
*/
|
|
SSL_IMPORT CERTCertificate * SSL_LocalCertificate(PRFileDesc *fd);
|
|
|
|
/* Test an SSL configuration to see if SSL_BYPASS_PKCS11 can be turned on.
|
|
** Check the key exchange algorithm for each cipher in the list to see if
|
|
** a master secret key can be extracted after being derived with the mechanism
|
|
** required by the protocolmask argument. If the KEA will use keys from the
|
|
** specified cert make sure the extract operation is attempted from the slot
|
|
** where the private key resides.
|
|
** If MS can be extracted for all ciphers, (*pcanbypass) is set to TRUE and
|
|
** SECSuccess is returned. In all other cases but one (*pcanbypass) is
|
|
** set to FALSE and SECFailure is returned.
|
|
** In that last case Derive() has been called successfully but the MS is null,
|
|
** CanBypass sets (*pcanbypass) to FALSE and returns SECSuccess indicating the
|
|
** arguments were all valid but the slot cannot be bypassed.
|
|
**
|
|
** Note: A TRUE return code from CanBypass means "Your configuration will perform
|
|
** NO WORSE with the bypass enabled than without"; it does NOT mean that every
|
|
** cipher suite listed will work properly with the selected protocols.
|
|
**
|
|
** Caveat: If export cipher suites are included in the argument list Canbypass
|
|
** will return FALSE.
|
|
**/
|
|
|
|
/* protocol mask bits */
|
|
#define SSL_CBP_SSL3 0x0001 /* test SSL v3 mechanisms */
|
|
#define SSL_CBP_TLS1_0 0x0002 /* test TLS v1.0 mechanisms */
|
|
|
|
SSL_IMPORT SECStatus SSL_CanBypass(CERTCertificate *cert,
|
|
SECKEYPrivateKey *privKey,
|
|
PRUint32 protocolmask,
|
|
PRUint16 *ciphers, int nciphers,
|
|
PRBool *pcanbypass, void *pwArg);
|
|
|
|
/*
|
|
** Did the handshake with the peer negotiate the given extension?
|
|
** Output parameter valid only if function returns SECSuccess
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_HandshakeNegotiatedExtension(PRFileDesc * socket,
|
|
SSLExtensionType extId,
|
|
PRBool *yes);
|
|
|
|
/*
|
|
** How long should we wait before retransmitting the next flight of
|
|
** the DTLS handshake? Returns SECFailure if not DTLS or not in a
|
|
** handshake.
|
|
*/
|
|
SSL_IMPORT SECStatus DTLS_GetHandshakeTimeout(PRFileDesc *socket,
|
|
PRIntervalTime *timeout);
|
|
|
|
/*
|
|
* Return a boolean that indicates whether the underlying library
|
|
* will perform as the caller expects.
|
|
*
|
|
* The only argument is a string, which should be the version
|
|
* identifier of the NSS library. That string will be compared
|
|
* against a string that represents the actual build version of
|
|
* the SSL library.
|
|
*/
|
|
extern PRBool NSSSSL_VersionCheck(const char *importedVersion);
|
|
|
|
/*
|
|
* Returns a const string of the SSL library version.
|
|
*/
|
|
extern const char *NSSSSL_GetVersion(void);
|
|
|
|
/* Restart an SSL connection that was paused to do asynchronous certificate
|
|
* chain validation (when the auth certificate hook or bad cert handler
|
|
* returned SECWouldBlock).
|
|
*
|
|
* This function only works for non-blocking sockets; Do not use it for
|
|
* blocking sockets. Currently, this function works only for the client role of
|
|
* a connection; it does not work for the server role.
|
|
*
|
|
* The application must call SSL_AuthCertificateComplete with 0 as the value of
|
|
* the error parameter after it has successfully validated the peer's
|
|
* certificate, in order to continue the SSL handshake.
|
|
*
|
|
* The application may call SSL_AuthCertificateComplete with a non-zero value
|
|
* for error (e.g. SEC_ERROR_REVOKED_CERTIFICATE) when certificate validation
|
|
* fails, before it closes the connection. If the application does so, an
|
|
* alert corresponding to the error (e.g. certificate_revoked) will be sent to
|
|
* the peer. See the source code of the internal function
|
|
* ssl3_SendAlertForCertError for the current mapping of error to alert. This
|
|
* mapping may change in future versions of libssl.
|
|
*
|
|
* This function will not complete the entire handshake. The application must
|
|
* call SSL_ForceHandshake, PR_Recv, PR_Send, etc. after calling this function
|
|
* to force the handshake to complete.
|
|
*
|
|
* On the first handshake of a connection, libssl will wait for the peer's
|
|
* certificate to be authenticated before calling the handshake callback,
|
|
* sending a client certificate, sending any application data, or returning
|
|
* any application data to the application. On subsequent (renegotiation)
|
|
* handshakes, libssl will block the handshake unconditionally while the
|
|
* certificate is being validated.
|
|
*
|
|
* libssl may send and receive handshake messages while waiting for the
|
|
* application to call SSL_AuthCertificateComplete, and it may call other
|
|
* callbacks (e.g, the client auth data hook) before
|
|
* SSL_AuthCertificateComplete has been called.
|
|
*
|
|
* An application that uses this asynchronous mechanism will usually have lower
|
|
* handshake latency if it has to do public key operations on the certificate
|
|
* chain and/or CRL/OCSP/cert fetching during the authentication, especially if
|
|
* it does so in parallel on another thread. However, if the application can
|
|
* authenticate the peer's certificate quickly then it may be more efficient
|
|
* to use the synchronous mechanism (i.e. returning SECFailure/SECSuccess
|
|
* instead of SECWouldBlock from the authenticate certificate hook).
|
|
*
|
|
* Be careful about converting an application from synchronous cert validation
|
|
* to asynchronous certificate validation. A naive conversion is likely to
|
|
* result in deadlocks; e.g. the application will wait in PR_Poll for network
|
|
* I/O on the connection while all network I/O on the connection is blocked
|
|
* waiting for this function to be called.
|
|
*
|
|
* Returns SECFailure on failure, SECSuccess on success. Never returns
|
|
* SECWouldBlock. Note that SSL_AuthCertificateComplete will (usually) return
|
|
* SECSuccess; do not interpret the return value of SSL_AuthCertificateComplete
|
|
* as an indicator of whether it is OK to continue using the connection. For
|
|
* example, SSL_AuthCertificateComplete(fd, SEC_ERROR_REVOKED_CERTIFICATE) will
|
|
* return SECSuccess (normally), but that does not mean that the application
|
|
* should continue using the connection. If the application passes a non-zero
|
|
* value for second argument (error), or if SSL_AuthCertificateComplete returns
|
|
* anything other than SECSuccess, then the application should close the
|
|
* connection.
|
|
*/
|
|
SSL_IMPORT SECStatus SSL_AuthCertificateComplete(PRFileDesc *fd,
|
|
PRErrorCode error);
|
|
SEC_END_PROTOS
|
|
|
|
#endif /* __ssl_h_ */
|