The Tor Browser / file comparison
comparison: security/nss/lib/ssl/ssl.h
security/nss/lib/ssl/ssl.h
- branch
- TOR_BUG_9701
- changeset 15
- b8a032363ba2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:fe1e2a9bd448 |
|---|---|
| 1 /* | |
| 2 * This file contains prototypes for the public SSL functions. | |
| 3 * | |
| 4 * This Source Code Form is subject to the terms of the Mozilla Public | |
| 5 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 6 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 7 | |
| 8 #ifndef __ssl_h_ | |
| 9 #define __ssl_h_ | |
| 10 | |
| 11 #include "prtypes.h" | |
| 12 #include "prerror.h" | |
| 13 #include "prio.h" | |
| 14 #include "seccomon.h" | |
| 15 #include "cert.h" | |
| 16 #include "keyt.h" | |
| 17 | |
| 18 #include "sslt.h" /* public ssl data types */ | |
| 19 | |
| 20 #if defined(_WIN32) && !defined(IN_LIBSSL) && !defined(NSS_USE_STATIC_LIBS) | |
| 21 #define SSL_IMPORT extern __declspec(dllimport) | |
| 22 #else | |
| 23 #define SSL_IMPORT extern | |
| 24 #endif | |
| 25 | |
| 26 SEC_BEGIN_PROTOS | |
| 27 | |
| 28 /* constant table enumerating all implemented SSL 2 and 3 cipher suites. */ | |
| 29 SSL_IMPORT const PRUint16 SSL_ImplementedCiphers[]; | |
| 30 | |
| 31 /* the same as the above, but is a function */ | |
| 32 SSL_IMPORT const PRUint16 *SSL_GetImplementedCiphers(void); | |
| 33 | |
| 34 /* number of entries in the above table. */ | |
| 35 SSL_IMPORT const PRUint16 SSL_NumImplementedCiphers; | |
| 36 | |
| 37 /* the same as the above, but is a function */ | |
| 38 SSL_IMPORT PRUint16 SSL_GetNumImplementedCiphers(void); | |
| 39 | |
| 40 /* Macro to tell which ciphers in table are SSL2 vs SSL3/TLS. */ | |
| 41 #define SSL_IS_SSL2_CIPHER(which) (((which) & 0xfff0) == 0xff00) | |
| 42 | |
| 43 /* | |
| 44 ** Imports fd into SSL, returning a new socket. Copies SSL configuration | |
| 45 ** from model. | |
| 46 */ | |
| 47 SSL_IMPORT PRFileDesc *SSL_ImportFD(PRFileDesc *model, PRFileDesc *fd); | |
| 48 | |
| 49 /* | |
| 50 ** Imports fd into DTLS, returning a new socket. Copies DTLS configuration | |
| 51 ** from model. | |
| 52 */ | |
| 53 SSL_IMPORT PRFileDesc *DTLS_ImportFD(PRFileDesc *model, PRFileDesc *fd); | |
| 54 | |
| 55 /* | |
| 56 ** Enable/disable an ssl mode | |
| 57 ** | |
| 58 ** SSL_SECURITY: | |
| 59 ** enable/disable use of SSL security protocol before connect | |
| 60 ** | |
| 61 ** SSL_SOCKS: | |
| 62 ** enable/disable use of socks before connect | |
| 63 ** (No longer supported). | |
| 64 ** | |
| 65 ** SSL_REQUEST_CERTIFICATE: | |
| 66 ** require a certificate during secure connect | |
| 67 */ | |
| 68 /* options */ | |
| 69 #define SSL_SECURITY 1 /* (on by default) */ | |
| 70 #define SSL_SOCKS 2 /* (off by default) */ | |
| 71 #define SSL_REQUEST_CERTIFICATE 3 /* (off by default) */ | |
| 72 #define SSL_HANDSHAKE_AS_CLIENT 5 /* force accept to hs as client */ | |
| 73 /* (off by default) */ | |
| 74 #define SSL_HANDSHAKE_AS_SERVER 6 /* force connect to hs as server */ | |
| 75 /* (off by default) */ | |
| 76 | |
| 77 /* OBSOLETE: SSL v2 is obsolete and may be removed soon. */ | |
| 78 #define SSL_ENABLE_SSL2 7 /* enable ssl v2 (off by default) */ | |
| 79 | |
| 80 /* OBSOLETE: See "SSL Version Range API" below for the replacement and a | |
| 81 ** description of the non-obvious semantics of using SSL_ENABLE_SSL3. | |
| 82 */ | |
| 83 #define SSL_ENABLE_SSL3 8 /* enable ssl v3 (on by default) */ | |
| 84 | |
| 85 #define SSL_NO_CACHE 9 /* don't use the session cache */ | |
| 86 /* (off by default) */ | |
| 87 #define SSL_REQUIRE_CERTIFICATE 10 /* (SSL_REQUIRE_FIRST_HANDSHAKE */ | |
| 88 /* by default) */ | |
| 89 #define SSL_ENABLE_FDX 11 /* permit simultaneous read/write */ | |
| 90 /* (off by default) */ | |
| 91 | |
| 92 /* OBSOLETE: SSL v2 compatible hellos are not accepted by some TLS servers | |
| 93 ** and cannot negotiate extensions. SSL v2 is obsolete. This option may be | |
| 94 ** removed soon. | |
| 95 */ | |
| 96 #define SSL_V2_COMPATIBLE_HELLO 12 /* send v3 client hello in v2 fmt */ | |
| 97 /* (off by default) */ | |
| 98 | |
| 99 /* OBSOLETE: See "SSL Version Range API" below for the replacement and a | |
| 100 ** description of the non-obvious semantics of using SSL_ENABLE_TLS. | |
| 101 */ | |
| 102 #define SSL_ENABLE_TLS 13 /* enable TLS (on by default) */ | |
| 103 | |
| 104 #define SSL_ROLLBACK_DETECTION 14 /* for compatibility, default: on */ | |
| 105 #define SSL_NO_STEP_DOWN 15 /* Disable export cipher suites */ | |
| 106 /* if step-down keys are needed. */ | |
| 107 /* default: off, generate */ | |
| 108 /* step-down keys if needed. */ | |
| 109 #define SSL_BYPASS_PKCS11 16 /* use PKCS#11 for pub key only */ | |
| 110 #define SSL_NO_LOCKS 17 /* Don't use locks for protection */ | |
| 111 #define SSL_ENABLE_SESSION_TICKETS 18 /* Enable TLS SessionTicket */ | |
| 112 /* extension (off by default) */ | |
| 113 #define SSL_ENABLE_DEFLATE 19 /* Enable TLS compression with */ | |
| 114 /* DEFLATE (off by default) */ | |
| 115 #define SSL_ENABLE_RENEGOTIATION 20 /* Values below (default: never) */ | |
| 116 #define SSL_REQUIRE_SAFE_NEGOTIATION 21 /* Peer must send Signaling */ | |
| 117 /* Cipher Suite Value (SCSV) or */ | |
| 118 /* Renegotiation Info (RI) */ | |
| 119 /* extension in ALL handshakes. */ | |
| 120 /* default: off */ | |
| 121 #define SSL_ENABLE_FALSE_START 22 /* Enable SSL false start (off by */ | |
| 122 /* default, applies only to */ | |
| 123 /* clients). False start is a */ | |
| 124 /* mode where an SSL client will start sending application data before | |
| 125 * verifying the server's Finished message. This means that we could end up | |
| 126 * sending data to an imposter. However, the data will be encrypted and | |
| 127 * only the true server can derive the session key. Thus, so long as the | |
| 128 * cipher isn't broken this is safe. The advantage of false start is that | |
| 129 * it saves a round trip for client-speaks-first protocols when performing a | |
| 130 * full handshake. | |
| 131 * | |
| 132 * In addition to enabling this option, the application must register a | |
| 133 * callback using the SSL_SetCanFalseStartCallback function. | |
| 134 */ | |
| 135 | |
| 136 /* For SSL 3.0 and TLS 1.0, by default we prevent chosen plaintext attacks | |
| 137 * on SSL CBC mode cipher suites (see RFC 4346 Section F.3) by splitting | |
| 138 * non-empty application_data records into two records; the first record has | |
| 139 * only the first byte of plaintext, and the second has the rest. | |
| 140 * | |
| 141 * This only prevents the attack in the sending direction; the connection may | |
| 142 * still be vulnerable to such attacks if the peer does not implement a similar | |
| 143 * countermeasure. | |
| 144 * | |
| 145 * This protection mechanism is on by default; the default can be overridden by | |
| 146 * setting NSS_SSL_CBC_RANDOM_IV=0 in the environment prior to execution, | |
| 147 * and/or by the application setting the option SSL_CBC_RANDOM_IV to PR_FALSE. | |
| 148 * | |
| 149 * The per-record IV in TLS 1.1 and later adds one block of overhead per | |
| 150 * record, whereas this hack will add at least two blocks of overhead per | |
| 151 * record, so TLS 1.1+ will always be more efficient. | |
| 152 * | |
| 153 * Other implementations (e.g. some versions of OpenSSL, in some | |
| 154 * configurations) prevent the same attack by prepending an empty | |
| 155 * application_data record to every application_data record they send; we do | |
| 156 * not do that because some implementations cannot handle empty | |
| 157 * application_data records. Also, we only split application_data records and | |
| 158 * not other types of records, because some implementations will not accept | |
| 159 * fragmented records of some other types (e.g. some versions of NSS do not | |
| 160 * accept fragmented alerts). | |
| 161 */ | |
| 162 #define SSL_CBC_RANDOM_IV 23 | |
| 163 #define SSL_ENABLE_OCSP_STAPLING 24 /* Request OCSP stapling (client) */ | |
| 164 | |
| 165 /* SSL_ENABLE_NPN controls whether the NPN extension is enabled for the initial | |
| 166 * handshake when application layer protocol negotiation is used. | |
| 167 * SSL_SetNextProtoCallback or SSL_SetNextProtoNego must be used to control the | |
| 168 * application layer protocol negotiation; otherwise, the NPN extension will | |
| 169 * not be negotiated. SSL_ENABLE_NPN is currently enabled by default but this | |
| 170 * may change in future versions. | |
| 171 */ | |
| 172 #define SSL_ENABLE_NPN 25 | |
| 173 | |
| 174 /* SSL_ENABLE_ALPN controls whether the ALPN extension is enabled for the | |
| 175 * initial handshake when application layer protocol negotiation is used. | |
| 176 * SSL_SetNextProtoNego (not SSL_SetNextProtoCallback) must be used to control | |
| 177 * the application layer protocol negotiation; otherwise, the ALPN extension | |
| 178 * will not be negotiated. ALPN is not negotiated for renegotiation handshakes, | |
| 179 * even though the ALPN specification defines a way to use ALPN during | |
| 180 * renegotiations. SSL_ENABLE_ALPN is currently disabled by default, but this | |
| 181 * may change in future versions. | |
| 182 */ | |
| 183 #define SSL_ENABLE_ALPN 26 | |
| 184 | |
| 185 #define SSL_ENABLE_FALLBACK_SCSV 28 /* Send fallback SCSV in | |
| 186 * handshakes. */ | |
| 187 | |
| 188 #ifdef SSL_DEPRECATED_FUNCTION | |
| 189 /* Old deprecated function names */ | |
| 190 SSL_IMPORT SECStatus SSL_Enable(PRFileDesc *fd, int option, PRBool on); | |
| 191 SSL_IMPORT SECStatus SSL_EnableDefault(int option, PRBool on); | |
| 192 #endif | |
| 193 | |
| 194 /* New function names */ | |
| 195 SSL_IMPORT SECStatus SSL_OptionSet(PRFileDesc *fd, PRInt32 option, PRBool on); | |
| 196 SSL_IMPORT SECStatus SSL_OptionGet(PRFileDesc *fd, PRInt32 option, PRBool *on); | |
| 197 SSL_IMPORT SECStatus SSL_OptionSetDefault(PRInt32 option, PRBool on); | |
| 198 SSL_IMPORT SECStatus SSL_OptionGetDefault(PRInt32 option, PRBool *on); | |
| 199 SSL_IMPORT SECStatus SSL_CertDBHandleSet(PRFileDesc *fd, CERTCertDBHandle *dbHandle); | |
| 200 | |
| 201 /* SSLNextProtoCallback is called during the handshake for the client, when a | |
| 202 * Next Protocol Negotiation (NPN) extension has been received from the server. | |
| 203 * |protos| and |protosLen| define a buffer which contains the server's | |
| 204 * advertisement. This data is guaranteed to be well formed per the NPN spec. | |
| 205 * |protoOut| is a buffer provided by the caller, of length 255 (the maximum | |
| 206 * allowed by the protocol). On successful return, the protocol to be announced | |
| 207 * to the server will be in |protoOut| and its length in |*protoOutLen|. | |
| 208 * | |
| 209 * The callback must return SECFailure or SECSuccess (not SECWouldBlock). | |
| 210 */ | |
| 211 typedef SECStatus (PR_CALLBACK *SSLNextProtoCallback)( | |
| 212 void *arg, | |
| 213 PRFileDesc *fd, | |
| 214 const unsigned char* protos, | |
| 215 unsigned int protosLen, | |
| 216 unsigned char* protoOut, | |
| 217 unsigned int* protoOutLen, | |
| 218 unsigned int protoMaxOut); | |
| 219 | |
| 220 /* SSL_SetNextProtoCallback sets a callback function to handle Next Protocol | |
| 221 * Negotiation. It causes a client to advertise NPN. */ | |
| 222 SSL_IMPORT SECStatus SSL_SetNextProtoCallback(PRFileDesc *fd, | |
| 223 SSLNextProtoCallback callback, | |
| 224 void *arg); | |
| 225 | |
| 226 /* SSL_SetNextProtoNego can be used as an alternative to | |
| 227 * SSL_SetNextProtoCallback. It also causes a client to advertise NPN and | |
| 228 * installs a default callback function which selects the first supported | |
| 229 * protocol in server-preference order. If no matching protocol is found it | |
| 230 * selects the first supported protocol. | |
| 231 * | |
| 232 * Using this function also allows the client to transparently support ALPN. | |
| 233 * The same set of protocols will be advertised via ALPN and, if the server | |
| 234 * uses ALPN to select a protocol, SSL_GetNextProto will return | |
| 235 * SSL_NEXT_PROTO_SELECTED as the state. | |
| 236 * | |
| 237 * Since NPN uses the first protocol as the fallback protocol, when sending an | |
| 238 * ALPN extension, the first protocol is moved to the end of the list. This | |
| 239 * indicates that the fallback protocol is the least preferred. The other | |
| 240 * protocols should be in preference order. | |
| 241 * | |
| 242 * The supported protocols are specified in |data| in wire-format (8-bit | |
| 243 * length-prefixed). For example: "\010http/1.1\006spdy/2". */ | |
| 244 SSL_IMPORT SECStatus SSL_SetNextProtoNego(PRFileDesc *fd, | |
| 245 const unsigned char *data, | |
| 246 unsigned int length); | |
| 247 | |
| 248 typedef enum SSLNextProtoState { | |
| 249 SSL_NEXT_PROTO_NO_SUPPORT = 0, /* No peer support */ | |
| 250 SSL_NEXT_PROTO_NEGOTIATED = 1, /* Mutual agreement */ | |
| 251 SSL_NEXT_PROTO_NO_OVERLAP = 2, /* No protocol overlap found */ | |
| 252 SSL_NEXT_PROTO_SELECTED = 3 /* Server selected proto (ALPN) */ | |
| 253 } SSLNextProtoState; | |
| 254 | |
| 255 /* SSL_GetNextProto can be used in the HandshakeCallback or any time after | |
| 256 * a handshake to retrieve the result of the Next Protocol negotiation. | |
| 257 * | |
| 258 * The length of the negotiated protocol, if any, is written into *bufLen. | |
| 259 * If the negotiated protocol is longer than bufLenMax, then SECFailure is | |
| 260 * returned. Otherwise, the negotiated protocol, if any, is written into buf, | |
| 261 * and SECSuccess is returned. */ | |
| 262 SSL_IMPORT SECStatus SSL_GetNextProto(PRFileDesc *fd, | |
| 263 SSLNextProtoState *state, | |
| 264 unsigned char *buf, | |
| 265 unsigned int *bufLen, | |
| 266 unsigned int bufLenMax); | |
| 267 | |
| 268 /* | |
| 269 ** Control ciphers that SSL uses. If on is non-zero then the named cipher | |
| 270 ** is enabled, otherwise it is disabled. | |
| 271 ** The "cipher" values are defined in sslproto.h (the SSL_EN_* values). | |
| 272 ** EnableCipher records user preferences. | |
| 273 ** SetPolicy sets the policy according to the policy module. | |
| 274 */ | |
| 275 #ifdef SSL_DEPRECATED_FUNCTION | |
| 276 /* Old deprecated function names */ | |
| 277 SSL_IMPORT SECStatus SSL_EnableCipher(long which, PRBool enabled); | |
| 278 SSL_IMPORT SECStatus SSL_SetPolicy(long which, int policy); | |
| 279 #endif | |
| 280 | |
| 281 /* New function names */ | |
| 282 SSL_IMPORT SECStatus SSL_CipherPrefSet(PRFileDesc *fd, PRInt32 cipher, PRBool enabled); | |
| 283 SSL_IMPORT SECStatus SSL_CipherPrefGet(PRFileDesc *fd, PRInt32 cipher, PRBool *enabled); | |
| 284 SSL_IMPORT SECStatus SSL_CipherPrefSetDefault(PRInt32 cipher, PRBool enabled); | |
| 285 SSL_IMPORT SECStatus SSL_CipherPrefGetDefault(PRInt32 cipher, PRBool *enabled); | |
| 286 SSL_IMPORT SECStatus SSL_CipherPolicySet(PRInt32 cipher, PRInt32 policy); | |
| 287 SSL_IMPORT SECStatus SSL_CipherPolicyGet(PRInt32 cipher, PRInt32 *policy); | |
| 288 | |
| 289 /* SSL Version Range API | |
| 290 ** | |
| 291 ** This API should be used to control SSL 3.0 & TLS support instead of the | |
| 292 ** older SSL_Option* API; however, the SSL_Option* API MUST still be used to | |
| 293 ** control SSL 2.0 support. In this version of libssl, SSL 3.0 and TLS 1.0 are | |
| 294 ** enabled by default. Future versions of libssl may change which versions of | |
| 295 ** the protocol are enabled by default. | |
| 296 ** | |
| 297 ** The SSLProtocolVariant enum indicates whether the protocol is of type | |
| 298 ** stream or datagram. This must be provided to the functions that do not | |
| 299 ** take an fd. Functions which take an fd will get the variant from the fd, | |
| 300 ** which is typed. | |
| 301 ** | |
| 302 ** Using the new version range API in conjunction with the older | |
| 303 ** SSL_OptionSet-based API for controlling the enabled protocol versions may | |
| 304 ** cause unexpected results. Going forward, we guarantee only the following: | |
| 305 ** | |
| 306 ** SSL_OptionGet(SSL_ENABLE_TLS) will return PR_TRUE if *ANY* versions of TLS | |
| 307 ** are enabled. | |
| 308 ** | |
| 309 ** SSL_OptionSet(SSL_ENABLE_TLS, PR_FALSE) will disable *ALL* versions of TLS, | |
| 310 ** including TLS 1.0 and later. | |
| 311 ** | |
| 312 ** The above two properties provide compatibility for applications that use | |
| 313 ** SSL_OptionSet to implement the insecure fallback from TLS 1.x to SSL 3.0. | |
| 314 ** | |
| 315 ** SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE) will enable TLS 1.0, and may also | |
| 316 ** enable some later versions of TLS, if it is necessary to do so in order to | |
| 317 ** keep the set of enabled versions contiguous. For example, if TLS 1.2 is | |
| 318 ** enabled, then after SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE), TLS 1.0, | |
| 319 ** TLS 1.1, and TLS 1.2 will be enabled, and the call will have no effect on | |
| 320 ** whether SSL 3.0 is enabled. If no later versions of TLS are enabled at the | |
| 321 ** time SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE) is called, then no later | |
| 322 ** versions of TLS will be enabled by the call. | |
| 323 ** | |
| 324 ** SSL_OptionSet(SSL_ENABLE_SSL3, PR_FALSE) will disable SSL 3.0, and will not | |
| 325 ** change the set of TLS versions that are enabled. | |
| 326 ** | |
| 327 ** SSL_OptionSet(SSL_ENABLE_SSL3, PR_TRUE) will enable SSL 3.0, and may also | |
| 328 ** enable some versions of TLS if TLS 1.1 or later is enabled at the time of | |
| 329 ** the call, the same way SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE) works, in | |
| 330 ** order to keep the set of enabled versions contiguous. | |
| 331 */ | |
| 332 | |
| 333 /* Returns, in |*vrange|, the range of SSL3/TLS versions supported for the | |
| 334 ** given protocol variant by the version of libssl linked-to at runtime. | |
| 335 */ | |
| 336 SSL_IMPORT SECStatus SSL_VersionRangeGetSupported( | |
| 337 SSLProtocolVariant protocolVariant, SSLVersionRange *vrange); | |
| 338 | |
| 339 /* Returns, in |*vrange|, the range of SSL3/TLS versions enabled by default | |
| 340 ** for the given protocol variant. | |
| 341 */ | |
| 342 SSL_IMPORT SECStatus SSL_VersionRangeGetDefault( | |
| 343 SSLProtocolVariant protocolVariant, SSLVersionRange *vrange); | |
| 344 | |
| 345 /* Sets the range of enabled-by-default SSL3/TLS versions for the given | |
| 346 ** protocol variant to |*vrange|. | |
| 347 */ | |
| 348 SSL_IMPORT SECStatus SSL_VersionRangeSetDefault( | |
| 349 SSLProtocolVariant protocolVariant, const SSLVersionRange *vrange); | |
| 350 | |
| 351 /* Returns, in |*vrange|, the range of enabled SSL3/TLS versions for |fd|. */ | |
| 352 SSL_IMPORT SECStatus SSL_VersionRangeGet(PRFileDesc *fd, | |
| 353 SSLVersionRange *vrange); | |
| 354 | |
| 355 /* Sets the range of enabled SSL3/TLS versions for |fd| to |*vrange|. */ | |
| 356 SSL_IMPORT SECStatus SSL_VersionRangeSet(PRFileDesc *fd, | |
| 357 const SSLVersionRange *vrange); | |
| 358 | |
| 359 | |
| 360 /* Values for "policy" argument to SSL_CipherPolicySet */ | |
| 361 /* Values returned by SSL_CipherPolicyGet. */ | |
| 362 #define SSL_NOT_ALLOWED 0 /* or invalid or unimplemented */ | |
| 363 #define SSL_ALLOWED 1 | |
| 364 #define SSL_RESTRICTED 2 /* only with "Step-Up" certs. */ | |
| 365 | |
| 366 /* Values for "on" with SSL_REQUIRE_CERTIFICATE. */ | |
| 367 #define SSL_REQUIRE_NEVER ((PRBool)0) | |
| 368 #define SSL_REQUIRE_ALWAYS ((PRBool)1) | |
| 369 #define SSL_REQUIRE_FIRST_HANDSHAKE ((PRBool)2) | |
| 370 #define SSL_REQUIRE_NO_ERROR ((PRBool)3) | |
| 371 | |
| 372 /* Values for "on" with SSL_ENABLE_RENEGOTIATION */ | |
| 373 /* Never renegotiate at all. */ | |
| 374 #define SSL_RENEGOTIATE_NEVER ((PRBool)0) | |
| 375 /* Renegotiate without restriction, whether or not the peer's client hello */ | |
| 376 /* bears the renegotiation info extension. Vulnerable, as in the past. */ | |
| 377 #define SSL_RENEGOTIATE_UNRESTRICTED ((PRBool)1) | |
| 378 /* Only renegotiate if the peer's hello bears the TLS renegotiation_info */ | |
| 379 /* extension. This is safe renegotiation. */ | |
| 380 #define SSL_RENEGOTIATE_REQUIRES_XTN ((PRBool)2) | |
| 381 /* Disallow unsafe renegotiation in server sockets only, but allow clients */ | |
| 382 /* to continue to renegotiate with vulnerable servers. */ | |
| 383 /* This value should only be used during the transition period when few */ | |
| 384 /* servers have been upgraded. */ | |
| 385 #define SSL_RENEGOTIATE_TRANSITIONAL ((PRBool)3) | |
| 386 | |
| 387 /* | |
| 388 ** Reset the handshake state for fd. This will make the complete SSL | |
| 389 ** handshake protocol execute from the ground up on the next i/o | |
| 390 ** operation. | |
| 391 */ | |
| 392 SSL_IMPORT SECStatus SSL_ResetHandshake(PRFileDesc *fd, PRBool asServer); | |
| 393 | |
| 394 /* | |
| 395 ** Force the handshake for fd to complete immediately. This blocks until | |
| 396 ** the complete SSL handshake protocol is finished. | |
| 397 */ | |
| 398 SSL_IMPORT SECStatus SSL_ForceHandshake(PRFileDesc *fd); | |
| 399 | |
| 400 /* | |
| 401 ** Same as above, but with an I/O timeout. | |
| 402 */ | |
| 403 SSL_IMPORT SECStatus SSL_ForceHandshakeWithTimeout(PRFileDesc *fd, | |
| 404 PRIntervalTime timeout); | |
| 405 | |
| 406 /* | |
| 407 ** Query security status of socket. *on is set to one if security is | |
| 408 ** enabled. *keySize will contain the stream key size used. *issuer will | |
| 409 ** contain the RFC1485 verison of the name of the issuer of the | |
| 410 ** certificate at the other end of the connection. For a client, this is | |
| 411 ** the issuer of the server's certificate; for a server, this is the | |
| 412 ** issuer of the client's certificate (if any). Subject is the subject of | |
| 413 ** the other end's certificate. The pointers can be zero if the desired | |
| 414 ** data is not needed. All strings returned by this function are owned | |
| 415 ** by the caller, and need to be freed with PORT_Free. | |
| 416 */ | |
| 417 SSL_IMPORT SECStatus SSL_SecurityStatus(PRFileDesc *fd, int *on, char **cipher, | |
| 418 int *keySize, int *secretKeySize, | |
| 419 char **issuer, char **subject); | |
| 420 | |
| 421 /* Values for "on" */ | |
| 422 #define SSL_SECURITY_STATUS_NOOPT -1 | |
| 423 #define SSL_SECURITY_STATUS_OFF 0 | |
| 424 #define SSL_SECURITY_STATUS_ON_HIGH 1 | |
| 425 #define SSL_SECURITY_STATUS_ON_LOW 2 | |
| 426 #define SSL_SECURITY_STATUS_FORTEZZA 3 /* NO LONGER SUPPORTED */ | |
| 427 | |
| 428 /* | |
| 429 ** Return the certificate for our SSL peer. If the client calls this | |
| 430 ** it will always return the server's certificate. If the server calls | |
| 431 ** this, it may return NULL if client authentication is not enabled or | |
| 432 ** if the client had no certificate when asked. | |
| 433 ** "fd" the socket "file" descriptor | |
| 434 */ | |
| 435 SSL_IMPORT CERTCertificate *SSL_PeerCertificate(PRFileDesc *fd); | |
| 436 | |
| 437 /* | |
| 438 ** Return the certificates presented by the SSL peer. If the SSL peer | |
| 439 ** did not present certificates, return NULL with the | |
| 440 ** SSL_ERROR_NO_CERTIFICATE error. On failure, return NULL with an error | |
| 441 ** code other than SSL_ERROR_NO_CERTIFICATE. | |
| 442 ** "fd" the socket "file" descriptor | |
| 443 */ | |
| 444 SSL_IMPORT CERTCertList *SSL_PeerCertificateChain(PRFileDesc *fd); | |
| 445 | |
| 446 /* SSL_PeerStapledOCSPResponses returns the OCSP responses that were provided | |
| 447 * by the TLS server. The return value is a pointer to an internal SECItemArray | |
| 448 * that contains the returned OCSP responses; it is only valid until the | |
| 449 * callback function that calls SSL_PeerStapledOCSPResponses returns. | |
| 450 * | |
| 451 * If no OCSP responses were given by the server then the result will be empty. | |
| 452 * If there was an error, then the result will be NULL. | |
| 453 * | |
| 454 * You must set the SSL_ENABLE_OCSP_STAPLING option to enable OCSP stapling. | |
| 455 * to be provided by a server. | |
| 456 * | |
| 457 * libssl does not do any validation of the OCSP response itself; the | |
| 458 * authenticate certificate hook is responsible for doing so. The default | |
| 459 * authenticate certificate hook, SSL_AuthCertificate, does not implement | |
| 460 * any OCSP stapling funtionality, but this may change in future versions. | |
| 461 */ | |
| 462 SSL_IMPORT const SECItemArray * SSL_PeerStapledOCSPResponses(PRFileDesc *fd); | |
| 463 | |
| 464 /* SSL_SetStapledOCSPResponses stores an array of one or multiple OCSP responses | |
| 465 * in the fd's data, which may be sent as part of a server side cert_status | |
| 466 * handshake message. Parameter |responses| is for the server certificate of | |
| 467 * the key exchange type |kea|. | |
| 468 * The function will duplicate the responses array. | |
| 469 */ | |
| 470 SSL_IMPORT SECStatus | |
| 471 SSL_SetStapledOCSPResponses(PRFileDesc *fd, const SECItemArray *responses, | |
| 472 SSLKEAType kea); | |
| 473 | |
| 474 /* | |
| 475 ** Authenticate certificate hook. Called when a certificate comes in | |
| 476 ** (because of SSL_REQUIRE_CERTIFICATE in SSL_Enable) to authenticate the | |
| 477 ** certificate. | |
| 478 ** | |
| 479 ** The authenticate certificate hook must return SECSuccess to indicate the | |
| 480 ** certificate is valid, SECFailure to indicate the certificate is invalid, | |
| 481 ** or SECWouldBlock if the application will authenticate the certificate | |
| 482 ** asynchronously. SECWouldBlock is only supported for non-blocking sockets. | |
| 483 ** | |
| 484 ** If the authenticate certificate hook returns SECFailure, then the bad cert | |
| 485 ** hook will be called. The bad cert handler is NEVER called if the | |
| 486 ** authenticate certificate hook returns SECWouldBlock. If the application | |
| 487 ** needs to handle and/or override a bad cert, it should do so before it | |
| 488 ** calls SSL_AuthCertificateComplete (modifying the error it passes to | |
| 489 ** SSL_AuthCertificateComplete as needed). | |
| 490 ** | |
| 491 ** See the documentation for SSL_AuthCertificateComplete for more information | |
| 492 ** about the asynchronous behavior that occurs when the authenticate | |
| 493 ** certificate hook returns SECWouldBlock. | |
| 494 ** | |
| 495 ** RFC 6066 says that clients should send the bad_certificate_status_response | |
| 496 ** alert when they encounter an error processing the stapled OCSP response. | |
| 497 ** libssl does not provide a way for the authenticate certificate hook to | |
| 498 ** indicate that an OCSP error (SEC_ERROR_OCSP_*) that it returns is an error | |
| 499 ** in the stapled OCSP response or an error in some other OCSP response. | |
| 500 ** Further, NSS does not provide a convenient way to control or determine | |
| 501 ** which OCSP response(s) were used to validate a certificate chain. | |
| 502 ** Consequently, the current version of libssl does not ever send the | |
| 503 ** bad_certificate_status_response alert. This may change in future releases. | |
| 504 */ | |
| 505 typedef SECStatus (PR_CALLBACK *SSLAuthCertificate)(void *arg, PRFileDesc *fd, | |
| 506 PRBool checkSig, | |
| 507 PRBool isServer); | |
| 508 | |
| 509 SSL_IMPORT SECStatus SSL_AuthCertificateHook(PRFileDesc *fd, | |
| 510 SSLAuthCertificate f, | |
| 511 void *arg); | |
| 512 | |
| 513 /* An implementation of the certificate authentication hook */ | |
| 514 SSL_IMPORT SECStatus SSL_AuthCertificate(void *arg, PRFileDesc *fd, | |
| 515 PRBool checkSig, PRBool isServer); | |
| 516 | |
| 517 /* | |
| 518 * Prototype for SSL callback to get client auth data from the application. | |
| 519 * arg - application passed argument | |
| 520 * caNames - pointer to distinguished names of CAs that the server likes | |
| 521 * pRetCert - pointer to pointer to cert, for return of cert | |
| 522 * pRetKey - pointer to key pointer, for return of key | |
| 523 */ | |
| 524 typedef SECStatus (PR_CALLBACK *SSLGetClientAuthData)(void *arg, | |
| 525 PRFileDesc *fd, | |
| 526 CERTDistNames *caNames, | |
| 527 CERTCertificate **pRetCert,/*return */ | |
| 528 SECKEYPrivateKey **pRetKey);/* return */ | |
| 529 | |
| 530 /* | |
| 531 * Set the client side callback for SSL to retrieve user's private key | |
| 532 * and certificate. | |
| 533 * fd - the file descriptor for the connection in question | |
| 534 * f - the application's callback that delivers the key and cert | |
| 535 * a - application specific data | |
| 536 */ | |
| 537 SSL_IMPORT SECStatus SSL_GetClientAuthDataHook(PRFileDesc *fd, | |
| 538 SSLGetClientAuthData f, void *a); | |
| 539 | |
| 540 | |
| 541 /* | |
| 542 ** SNI extension processing callback function. | |
| 543 ** It is called when SSL socket receives SNI extension in ClientHello message. | |
| 544 ** Upon this callback invocation, application is responsible to reconfigure the | |
| 545 ** socket with the data for a particular server name. | |
| 546 ** There are three potential outcomes of this function invocation: | |
| 547 ** * application does not recognize the name or the type and wants the | |
| 548 ** "unrecognized_name" alert be sent to the client. In this case the callback | |
| 549 ** function must return SSL_SNI_SEND_ALERT status. | |
| 550 ** * application does not recognize the name, but wants to continue with | |
| 551 ** the handshake using the current socket configuration. In this case, | |
| 552 ** no socket reconfiguration is needed and the function should return | |
| 553 ** SSL_SNI_CURRENT_CONFIG_IS_USED. | |
| 554 ** * application recognizes the name and reconfigures the socket with | |
| 555 ** appropriate certs, key, etc. There are many ways to reconfigure. NSS | |
| 556 ** provides SSL_ReconfigFD function that can be used to update the socket | |
| 557 ** data from model socket. To continue with the rest of the handshake, the | |
| 558 ** implementation function should return an index of a name it has chosen. | |
| 559 ** LibSSL will ignore any SNI extension received in a ClientHello message | |
| 560 ** if application does not register a SSLSNISocketConfig callback. | |
| 561 ** Each type field of SECItem indicates the name type. | |
| 562 ** NOTE: currently RFC3546 defines only one name type: sni_host_name. | |
| 563 ** Client is allowed to send only one name per known type. LibSSL will | |
| 564 ** send an "unrecognized_name" alert if SNI extension name list contains more | |
| 565 ** then one name of a type. | |
| 566 */ | |
| 567 typedef PRInt32 (PR_CALLBACK *SSLSNISocketConfig)(PRFileDesc *fd, | |
| 568 const SECItem *srvNameArr, | |
| 569 PRUint32 srvNameArrSize, | |
| 570 void *arg); | |
| 571 | |
| 572 /* | |
| 573 ** SSLSNISocketConfig should return an index within 0 and srvNameArrSize-1 | |
| 574 ** when it has reconfigured the socket fd to use certs and keys, etc | |
| 575 ** for a specific name. There are two other allowed return values. One | |
| 576 ** tells libSSL to use the default cert and key. The other tells libSSL | |
| 577 ** to send the "unrecognized_name" alert. These values are: | |
| 578 **/ | |
| 579 #define SSL_SNI_CURRENT_CONFIG_IS_USED -1 | |
| 580 #define SSL_SNI_SEND_ALERT -2 | |
| 581 | |
| 582 /* | |
| 583 ** Set application implemented SNISocketConfig callback. | |
| 584 */ | |
| 585 SSL_IMPORT SECStatus SSL_SNISocketConfigHook(PRFileDesc *fd, | |
| 586 SSLSNISocketConfig f, | |
| 587 void *arg); | |
| 588 | |
| 589 /* | |
| 590 ** Reconfigure fd SSL socket with model socket parameters. Sets | |
| 591 ** server certs and keys, list of trust anchor, socket options | |
| 592 ** and all SSL socket call backs and parameters. | |
| 593 */ | |
| 594 SSL_IMPORT PRFileDesc *SSL_ReconfigFD(PRFileDesc *model, PRFileDesc *fd); | |
| 595 | |
| 596 /* | |
| 597 * Set the client side argument for SSL to retrieve PKCS #11 pin. | |
| 598 * fd - the file descriptor for the connection in question | |
| 599 * a - pkcs11 application specific data | |
| 600 */ | |
| 601 SSL_IMPORT SECStatus SSL_SetPKCS11PinArg(PRFileDesc *fd, void *a); | |
| 602 | |
| 603 /* | |
| 604 ** This is a callback for dealing with server certs that are not authenticated | |
| 605 ** by the client. The client app can decide that it actually likes the | |
| 606 ** cert by some external means and restart the connection. | |
| 607 ** | |
| 608 ** The bad cert hook must return SECSuccess to override the result of the | |
| 609 ** authenticate certificate hook, SECFailure if the certificate should still be | |
| 610 ** considered invalid, or SECWouldBlock if the application will authenticate | |
| 611 ** the certificate asynchronously. SECWouldBlock is only supported for | |
| 612 ** non-blocking sockets. | |
| 613 ** | |
| 614 ** See the documentation for SSL_AuthCertificateComplete for more information | |
| 615 ** about the asynchronous behavior that occurs when the bad cert hook returns | |
| 616 ** SECWouldBlock. | |
| 617 */ | |
| 618 typedef SECStatus (PR_CALLBACK *SSLBadCertHandler)(void *arg, PRFileDesc *fd); | |
| 619 SSL_IMPORT SECStatus SSL_BadCertHook(PRFileDesc *fd, SSLBadCertHandler f, | |
| 620 void *arg); | |
| 621 | |
| 622 /* | |
| 623 ** Configure SSL socket for running a secure server. Needs the | |
| 624 ** certificate for the server and the servers private key. The arguments | |
| 625 ** are copied. | |
| 626 */ | |
| 627 SSL_IMPORT SECStatus SSL_ConfigSecureServer( | |
| 628 PRFileDesc *fd, CERTCertificate *cert, | |
| 629 SECKEYPrivateKey *key, SSLKEAType kea); | |
| 630 | |
| 631 /* | |
| 632 ** Allows SSL socket configuration with caller-supplied certificate chain. | |
| 633 ** If certChainOpt is NULL, tries to find one. | |
| 634 */ | |
| 635 SSL_IMPORT SECStatus | |
| 636 SSL_ConfigSecureServerWithCertChain(PRFileDesc *fd, CERTCertificate *cert, | |
| 637 const CERTCertificateList *certChainOpt, | |
| 638 SECKEYPrivateKey *key, SSLKEAType kea); | |
| 639 | |
| 640 /* | |
| 641 ** Configure a secure server's session-id cache. Define the maximum number | |
| 642 ** of entries in the cache, the longevity of the entires, and the directory | |
| 643 ** where the cache files will be placed. These values can be zero, and | |
| 644 ** if so, the implementation will choose defaults. | |
| 645 ** This version of the function is for use in applications that have only one | |
| 646 ** process that uses the cache (even if that process has multiple threads). | |
| 647 */ | |
| 648 SSL_IMPORT SECStatus SSL_ConfigServerSessionIDCache(int maxCacheEntries, | |
| 649 PRUint32 timeout, | |
| 650 PRUint32 ssl3_timeout, | |
| 651 const char * directory); | |
| 652 | |
| 653 /* Configure a secure server's session-id cache. Depends on value of | |
| 654 * enableMPCache, configures malti-proc or single proc cache. */ | |
| 655 SSL_IMPORT SECStatus SSL_ConfigServerSessionIDCacheWithOpt( | |
| 656 PRUint32 timeout, | |
| 657 PRUint32 ssl3_timeout, | |
| 658 const char * directory, | |
| 659 int maxCacheEntries, | |
| 660 int maxCertCacheEntries, | |
| 661 int maxSrvNameCacheEntries, | |
| 662 PRBool enableMPCache); | |
| 663 | |
| 664 /* | |
| 665 ** Like SSL_ConfigServerSessionIDCache, with one important difference. | |
| 666 ** If the application will run multiple processes (as opposed to, or in | |
| 667 ** addition to multiple threads), then it must call this function, instead | |
| 668 ** of calling SSL_ConfigServerSessionIDCache(). | |
| 669 ** This has nothing to do with the number of processORs, only processEs. | |
| 670 ** This function sets up a Server Session ID (SID) cache that is safe for | |
| 671 ** access by multiple processes on the same system. | |
| 672 */ | |
| 673 SSL_IMPORT SECStatus SSL_ConfigMPServerSIDCache(int maxCacheEntries, | |
| 674 PRUint32 timeout, | |
| 675 PRUint32 ssl3_timeout, | |
| 676 const char * directory); | |
| 677 | |
| 678 /* Get and set the configured maximum number of mutexes used for the | |
| 679 ** server's store of SSL sessions. This value is used by the server | |
| 680 ** session ID cache initialization functions shown above. Note that on | |
| 681 ** some platforms, these mutexes are actually implemented with POSIX | |
| 682 ** semaphores, or with unnamed pipes. The default value varies by platform. | |
| 683 ** An attempt to set a too-low maximum will return an error and the | |
| 684 ** configured value will not be changed. | |
| 685 */ | |
| 686 SSL_IMPORT PRUint32 SSL_GetMaxServerCacheLocks(void); | |
| 687 SSL_IMPORT SECStatus SSL_SetMaxServerCacheLocks(PRUint32 maxLocks); | |
| 688 | |
| 689 /* environment variable set by SSL_ConfigMPServerSIDCache, and queried by | |
| 690 * SSL_InheritMPServerSIDCache when envString is NULL. | |
| 691 */ | |
| 692 #define SSL_ENV_VAR_NAME "SSL_INHERITANCE" | |
| 693 | |
| 694 /* called in child to inherit SID Cache variables. | |
| 695 * If envString is NULL, this function will use the value of the environment | |
| 696 * variable "SSL_INHERITANCE", otherwise the string value passed in will be | |
| 697 * used. | |
| 698 */ | |
| 699 SSL_IMPORT SECStatus SSL_InheritMPServerSIDCache(const char * envString); | |
| 700 | |
| 701 /* | |
| 702 ** Set the callback that gets called when a TLS handshake is complete. The | |
| 703 ** handshake callback is called after verifying the peer's Finished message and | |
| 704 ** before processing incoming application data. | |
| 705 ** | |
| 706 ** For the initial handshake: If the handshake false started (see | |
| 707 ** SSL_ENABLE_FALSE_START), then application data may already have been sent | |
| 708 ** before the handshake callback is called. If we did not false start then the | |
| 709 ** callback will get called before any application data is sent. | |
| 710 */ | |
| 711 typedef void (PR_CALLBACK *SSLHandshakeCallback)(PRFileDesc *fd, | |
| 712 void *client_data); | |
| 713 SSL_IMPORT SECStatus SSL_HandshakeCallback(PRFileDesc *fd, | |
| 714 SSLHandshakeCallback cb, void *client_data); | |
| 715 | |
| 716 /* Applications that wish to enable TLS false start must set this callback | |
| 717 ** function. NSS will invoke the functon to determine if a particular | |
| 718 ** connection should use false start or not. SECSuccess indicates that the | |
| 719 ** callback completed successfully, and if so *canFalseStart indicates if false | |
| 720 ** start can be used. If the callback does not return SECSuccess then the | |
| 721 ** handshake will be canceled. NSS's recommended criteria can be evaluated by | |
| 722 ** calling SSL_RecommendedCanFalseStart. | |
| 723 ** | |
| 724 ** If no false start callback is registered then false start will never be | |
| 725 ** done, even if the SSL_ENABLE_FALSE_START option is enabled. | |
| 726 **/ | |
| 727 typedef SECStatus (PR_CALLBACK *SSLCanFalseStartCallback)( | |
| 728 PRFileDesc *fd, void *arg, PRBool *canFalseStart); | |
| 729 | |
| 730 SSL_IMPORT SECStatus SSL_SetCanFalseStartCallback( | |
| 731 PRFileDesc *fd, SSLCanFalseStartCallback callback, void *arg); | |
| 732 | |
| 733 /* This function sets *canFalseStart according to the recommended criteria for | |
| 734 ** false start. These criteria may change from release to release and may depend | |
| 735 ** on which handshake features have been negotiated and/or properties of the | |
| 736 ** certifciates/keys used on the connection. | |
| 737 */ | |
| 738 SSL_IMPORT SECStatus SSL_RecommendedCanFalseStart(PRFileDesc *fd, | |
| 739 PRBool *canFalseStart); | |
| 740 | |
| 741 /* | |
| 742 ** For the server, request a new handshake. For the client, begin a new | |
| 743 ** handshake. If flushCache is non-zero, the SSL3 cache entry will be | |
| 744 ** flushed first, ensuring that a full SSL handshake will be done. | |
| 745 ** If flushCache is zero, and an SSL connection is established, it will | |
| 746 ** do the much faster session restart handshake. This will change the | |
| 747 ** session keys without doing another private key operation. | |
| 748 */ | |
| 749 SSL_IMPORT SECStatus SSL_ReHandshake(PRFileDesc *fd, PRBool flushCache); | |
| 750 | |
| 751 /* | |
| 752 ** Same as above, but with an I/O timeout. | |
| 753 */ | |
| 754 SSL_IMPORT SECStatus SSL_ReHandshakeWithTimeout(PRFileDesc *fd, | |
| 755 PRBool flushCache, | |
| 756 PRIntervalTime timeout); | |
| 757 | |
| 758 | |
| 759 #ifdef SSL_DEPRECATED_FUNCTION | |
| 760 /* deprecated! | |
| 761 ** For the server, request a new handshake. For the client, begin a new | |
| 762 ** handshake. Flushes SSL3 session cache entry first, ensuring that a | |
| 763 ** full handshake will be done. | |
| 764 ** This call is equivalent to SSL_ReHandshake(fd, PR_TRUE) | |
| 765 */ | |
| 766 SSL_IMPORT SECStatus SSL_RedoHandshake(PRFileDesc *fd); | |
| 767 #endif | |
| 768 | |
| 769 /* | |
| 770 * Allow the application to pass a URL or hostname into the SSL library. | |
| 771 */ | |
| 772 SSL_IMPORT SECStatus SSL_SetURL(PRFileDesc *fd, const char *url); | |
| 773 | |
| 774 /* | |
| 775 * Allow an application to define a set of trust anchors for peer | |
| 776 * cert validation. | |
| 777 */ | |
| 778 SSL_IMPORT SECStatus SSL_SetTrustAnchors(PRFileDesc *fd, CERTCertList *list); | |
| 779 | |
| 780 /* | |
| 781 ** Return the number of bytes that SSL has waiting in internal buffers. | |
| 782 ** Return 0 if security is not enabled. | |
| 783 */ | |
| 784 SSL_IMPORT int SSL_DataPending(PRFileDesc *fd); | |
| 785 | |
| 786 /* | |
| 787 ** Invalidate the SSL session associated with fd. | |
| 788 */ | |
| 789 SSL_IMPORT SECStatus SSL_InvalidateSession(PRFileDesc *fd); | |
| 790 | |
| 791 /* | |
| 792 ** Return a SECItem containing the SSL session ID associated with the fd. | |
| 793 */ | |
| 794 SSL_IMPORT SECItem *SSL_GetSessionID(PRFileDesc *fd); | |
| 795 | |
| 796 /* | |
| 797 ** Clear out the client's SSL session cache, not the server's session cache. | |
| 798 */ | |
| 799 SSL_IMPORT void SSL_ClearSessionCache(void); | |
| 800 | |
| 801 /* | |
| 802 ** Close the server's SSL session cache. | |
| 803 */ | |
| 804 SSL_IMPORT SECStatus SSL_ShutdownServerSessionIDCache(void); | |
| 805 | |
| 806 /* | |
| 807 ** Set peer information so we can correctly look up SSL session later. | |
| 808 ** You only have to do this if you're tunneling through a proxy. | |
| 809 */ | |
| 810 SSL_IMPORT SECStatus SSL_SetSockPeerID(PRFileDesc *fd, const char *peerID); | |
| 811 | |
| 812 /* | |
| 813 ** Reveal the security information for the peer. | |
| 814 */ | |
| 815 SSL_IMPORT CERTCertificate * SSL_RevealCert(PRFileDesc * socket); | |
| 816 SSL_IMPORT void * SSL_RevealPinArg(PRFileDesc * socket); | |
| 817 SSL_IMPORT char * SSL_RevealURL(PRFileDesc * socket); | |
| 818 | |
| 819 /* This callback may be passed to the SSL library via a call to | |
| 820 * SSL_GetClientAuthDataHook() for each SSL client socket. | |
| 821 * It will be invoked when SSL needs to know what certificate and private key | |
| 822 * (if any) to use to respond to a request for client authentication. | |
| 823 * If arg is non-NULL, it is a pointer to a NULL-terminated string containing | |
| 824 * the nickname of the cert/key pair to use. | |
| 825 * If arg is NULL, this function will search the cert and key databases for | |
| 826 * a suitable match and send it if one is found. | |
| 827 */ | |
| 828 SSL_IMPORT SECStatus | |
| 829 NSS_GetClientAuthData(void * arg, | |
| 830 PRFileDesc * socket, | |
| 831 struct CERTDistNamesStr * caNames, | |
| 832 struct CERTCertificateStr ** pRetCert, | |
| 833 struct SECKEYPrivateKeyStr **pRetKey); | |
| 834 | |
| 835 /* | |
| 836 ** Configure DTLS-SRTP (RFC 5764) cipher suite preferences. | |
| 837 ** Input is a list of ciphers in descending preference order and a length | |
| 838 ** of the list. As a side effect, this causes the use_srtp extension to be | |
| 839 ** negotiated. | |
| 840 ** | |
| 841 ** Invalid or unimplemented cipher suites in |ciphers| are ignored. If at | |
| 842 ** least one cipher suite in |ciphers| is implemented, returns SECSuccess. | |
| 843 ** Otherwise returns SECFailure. | |
| 844 */ | |
| 845 SSL_IMPORT SECStatus SSL_SetSRTPCiphers(PRFileDesc *fd, | |
| 846 const PRUint16 *ciphers, | |
| 847 unsigned int numCiphers); | |
| 848 | |
| 849 /* | |
| 850 ** Get the selected DTLS-SRTP cipher suite (if any). | |
| 851 ** To be called after the handshake completes. | |
| 852 ** Returns SECFailure if not negotiated. | |
| 853 */ | |
| 854 SSL_IMPORT SECStatus SSL_GetSRTPCipher(PRFileDesc *fd, | |
| 855 PRUint16 *cipher); | |
| 856 | |
| 857 /* | |
| 858 * Look to see if any of the signers in the cert chain for "cert" are found | |
| 859 * in the list of caNames. | |
| 860 * Returns SECSuccess if so, SECFailure if not. | |
| 861 * Used by NSS_GetClientAuthData. May be used by other callback functions. | |
| 862 */ | |
| 863 SSL_IMPORT SECStatus NSS_CmpCertChainWCANames(CERTCertificate *cert, | |
| 864 CERTDistNames *caNames); | |
| 865 | |
| 866 /* | |
| 867 * Returns key exchange type of the keys in an SSL server certificate. | |
| 868 */ | |
| 869 SSL_IMPORT SSLKEAType NSS_FindCertKEAType(CERTCertificate * cert); | |
| 870 | |
| 871 /* Set cipher policies to a predefined Domestic (U.S.A.) policy. | |
| 872 * This essentially allows all supported ciphers. | |
| 873 */ | |
| 874 SSL_IMPORT SECStatus NSS_SetDomesticPolicy(void); | |
| 875 | |
| 876 /* Set cipher policies to a predefined Policy that is exportable from the USA | |
| 877 * according to present U.S. policies as we understand them. | |
| 878 * It is the same as NSS_SetDomesticPolicy now. | |
| 879 */ | |
| 880 SSL_IMPORT SECStatus NSS_SetExportPolicy(void); | |
| 881 | |
| 882 /* Set cipher policies to a predefined Policy that is exportable from the USA | |
| 883 * according to present U.S. policies as we understand them, and that the | |
| 884 * nation of France will permit to be imported into their country. | |
| 885 * It is the same as NSS_SetDomesticPolicy now. | |
| 886 */ | |
| 887 SSL_IMPORT SECStatus NSS_SetFrancePolicy(void); | |
| 888 | |
| 889 SSL_IMPORT SSL3Statistics * SSL_GetStatistics(void); | |
| 890 | |
| 891 /* Report more information than SSL_SecurityStatus. | |
| 892 ** Caller supplies the info struct. Function fills it in. | |
| 893 */ | |
| 894 SSL_IMPORT SECStatus SSL_GetChannelInfo(PRFileDesc *fd, SSLChannelInfo *info, | |
| 895 PRUintn len); | |
| 896 SSL_IMPORT SECStatus SSL_GetCipherSuiteInfo(PRUint16 cipherSuite, | |
| 897 SSLCipherSuiteInfo *info, PRUintn len); | |
| 898 | |
| 899 /* Returnes negotiated through SNI host info. */ | |
| 900 SSL_IMPORT SECItem *SSL_GetNegotiatedHostInfo(PRFileDesc *fd); | |
| 901 | |
| 902 /* Export keying material according to RFC 5705. | |
| 903 ** fd must correspond to a TLS 1.0 or higher socket and out must | |
| 904 ** already be allocated. If hasContext is false, it uses the no-context | |
| 905 ** construction from the RFC and ignores the context and contextLen | |
| 906 ** arguments. | |
| 907 */ | |
| 908 SSL_IMPORT SECStatus SSL_ExportKeyingMaterial(PRFileDesc *fd, | |
| 909 const char *label, | |
| 910 unsigned int labelLen, | |
| 911 PRBool hasContext, | |
| 912 const unsigned char *context, | |
| 913 unsigned int contextLen, | |
| 914 unsigned char *out, | |
| 915 unsigned int outLen); | |
| 916 | |
| 917 /* | |
| 918 ** Return a new reference to the certificate that was most recently sent | |
| 919 ** to the peer on this SSL/TLS connection, or NULL if none has been sent. | |
| 920 */ | |
| 921 SSL_IMPORT CERTCertificate * SSL_LocalCertificate(PRFileDesc *fd); | |
| 922 | |
| 923 /* Test an SSL configuration to see if SSL_BYPASS_PKCS11 can be turned on. | |
| 924 ** Check the key exchange algorithm for each cipher in the list to see if | |
| 925 ** a master secret key can be extracted after being derived with the mechanism | |
| 926 ** required by the protocolmask argument. If the KEA will use keys from the | |
| 927 ** specified cert make sure the extract operation is attempted from the slot | |
| 928 ** where the private key resides. | |
| 929 ** If MS can be extracted for all ciphers, (*pcanbypass) is set to TRUE and | |
| 930 ** SECSuccess is returned. In all other cases but one (*pcanbypass) is | |
| 931 ** set to FALSE and SECFailure is returned. | |
| 932 ** In that last case Derive() has been called successfully but the MS is null, | |
| 933 ** CanBypass sets (*pcanbypass) to FALSE and returns SECSuccess indicating the | |
| 934 ** arguments were all valid but the slot cannot be bypassed. | |
| 935 ** | |
| 936 ** Note: A TRUE return code from CanBypass means "Your configuration will perform | |
| 937 ** NO WORSE with the bypass enabled than without"; it does NOT mean that every | |
| 938 ** cipher suite listed will work properly with the selected protocols. | |
| 939 ** | |
| 940 ** Caveat: If export cipher suites are included in the argument list Canbypass | |
| 941 ** will return FALSE. | |
| 942 **/ | |
| 943 | |
| 944 /* protocol mask bits */ | |
| 945 #define SSL_CBP_SSL3 0x0001 /* test SSL v3 mechanisms */ | |
| 946 #define SSL_CBP_TLS1_0 0x0002 /* test TLS v1.0 mechanisms */ | |
| 947 | |
| 948 SSL_IMPORT SECStatus SSL_CanBypass(CERTCertificate *cert, | |
| 949 SECKEYPrivateKey *privKey, | |
| 950 PRUint32 protocolmask, | |
| 951 PRUint16 *ciphers, int nciphers, | |
| 952 PRBool *pcanbypass, void *pwArg); | |
| 953 | |
| 954 /* | |
| 955 ** Did the handshake with the peer negotiate the given extension? | |
| 956 ** Output parameter valid only if function returns SECSuccess | |
| 957 */ | |
| 958 SSL_IMPORT SECStatus SSL_HandshakeNegotiatedExtension(PRFileDesc * socket, | |
| 959 SSLExtensionType extId, | |
| 960 PRBool *yes); | |
| 961 | |
| 962 /* | |
| 963 ** How long should we wait before retransmitting the next flight of | |
| 964 ** the DTLS handshake? Returns SECFailure if not DTLS or not in a | |
| 965 ** handshake. | |
| 966 */ | |
| 967 SSL_IMPORT SECStatus DTLS_GetHandshakeTimeout(PRFileDesc *socket, | |
| 968 PRIntervalTime *timeout); | |
| 969 | |
| 970 /* | |
| 971 * Return a boolean that indicates whether the underlying library | |
| 972 * will perform as the caller expects. | |
| 973 * | |
| 974 * The only argument is a string, which should be the version | |
| 975 * identifier of the NSS library. That string will be compared | |
| 976 * against a string that represents the actual build version of | |
| 977 * the SSL library. | |
| 978 */ | |
| 979 extern PRBool NSSSSL_VersionCheck(const char *importedVersion); | |
| 980 | |
| 981 /* | |
| 982 * Returns a const string of the SSL library version. | |
| 983 */ | |
| 984 extern const char *NSSSSL_GetVersion(void); | |
| 985 | |
| 986 /* Restart an SSL connection that was paused to do asynchronous certificate | |
| 987 * chain validation (when the auth certificate hook or bad cert handler | |
| 988 * returned SECWouldBlock). | |
| 989 * | |
| 990 * This function only works for non-blocking sockets; Do not use it for | |
| 991 * blocking sockets. Currently, this function works only for the client role of | |
| 992 * a connection; it does not work for the server role. | |
| 993 * | |
| 994 * The application must call SSL_AuthCertificateComplete with 0 as the value of | |
| 995 * the error parameter after it has successfully validated the peer's | |
| 996 * certificate, in order to continue the SSL handshake. | |
| 997 * | |
| 998 * The application may call SSL_AuthCertificateComplete with a non-zero value | |
| 999 * for error (e.g. SEC_ERROR_REVOKED_CERTIFICATE) when certificate validation | |
| 1000 * fails, before it closes the connection. If the application does so, an | |
| 1001 * alert corresponding to the error (e.g. certificate_revoked) will be sent to | |
| 1002 * the peer. See the source code of the internal function | |
| 1003 * ssl3_SendAlertForCertError for the current mapping of error to alert. This | |
| 1004 * mapping may change in future versions of libssl. | |
| 1005 * | |
| 1006 * This function will not complete the entire handshake. The application must | |
| 1007 * call SSL_ForceHandshake, PR_Recv, PR_Send, etc. after calling this function | |
| 1008 * to force the handshake to complete. | |
| 1009 * | |
| 1010 * On the first handshake of a connection, libssl will wait for the peer's | |
| 1011 * certificate to be authenticated before calling the handshake callback, | |
| 1012 * sending a client certificate, sending any application data, or returning | |
| 1013 * any application data to the application. On subsequent (renegotiation) | |
| 1014 * handshakes, libssl will block the handshake unconditionally while the | |
| 1015 * certificate is being validated. | |
| 1016 * | |
| 1017 * libssl may send and receive handshake messages while waiting for the | |
| 1018 * application to call SSL_AuthCertificateComplete, and it may call other | |
| 1019 * callbacks (e.g, the client auth data hook) before | |
| 1020 * SSL_AuthCertificateComplete has been called. | |
| 1021 * | |
| 1022 * An application that uses this asynchronous mechanism will usually have lower | |
| 1023 * handshake latency if it has to do public key operations on the certificate | |
| 1024 * chain and/or CRL/OCSP/cert fetching during the authentication, especially if | |
| 1025 * it does so in parallel on another thread. However, if the application can | |
| 1026 * authenticate the peer's certificate quickly then it may be more efficient | |
| 1027 * to use the synchronous mechanism (i.e. returning SECFailure/SECSuccess | |
| 1028 * instead of SECWouldBlock from the authenticate certificate hook). | |
| 1029 * | |
| 1030 * Be careful about converting an application from synchronous cert validation | |
| 1031 * to asynchronous certificate validation. A naive conversion is likely to | |
| 1032 * result in deadlocks; e.g. the application will wait in PR_Poll for network | |
| 1033 * I/O on the connection while all network I/O on the connection is blocked | |
| 1034 * waiting for this function to be called. | |
| 1035 * | |
| 1036 * Returns SECFailure on failure, SECSuccess on success. Never returns | |
| 1037 * SECWouldBlock. Note that SSL_AuthCertificateComplete will (usually) return | |
| 1038 * SECSuccess; do not interpret the return value of SSL_AuthCertificateComplete | |
| 1039 * as an indicator of whether it is OK to continue using the connection. For | |
| 1040 * example, SSL_AuthCertificateComplete(fd, SEC_ERROR_REVOKED_CERTIFICATE) will | |
| 1041 * return SECSuccess (normally), but that does not mean that the application | |
| 1042 * should continue using the connection. If the application passes a non-zero | |
| 1043 * value for second argument (error), or if SSL_AuthCertificateComplete returns | |
| 1044 * anything other than SECSuccess, then the application should close the | |
| 1045 * connection. | |
| 1046 */ | |
| 1047 SSL_IMPORT SECStatus SSL_AuthCertificateComplete(PRFileDesc *fd, | |
| 1048 PRErrorCode error); | |
| 1049 SEC_END_PROTOS | |
| 1050 | |
| 1051 #endif /* __ssl_h_ */ |
