Check USB device path access when prompting users to select a device.
[chromium-blink-merge.git] / net / third_party / nss / ssl / ssl.h
blob57771cd5b9803fa6412d1b20dce6feb496a8abd0
1 /*
2 * This file contains prototypes for the public SSL functions.
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/. */
8 #ifndef __ssl_h_
9 #define __ssl_h_
11 #include "prtypes.h"
12 #include "prerror.h"
13 #include "prio.h"
14 #include "seccomon.h"
15 #include "cert.h"
16 #include "keyt.h"
18 #include "sslt.h" /* public ssl data types */
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
26 SEC_BEGIN_PROTOS
28 /* constant table enumerating all implemented SSL 2 and 3 cipher suites. */
29 SSL_IMPORT const PRUint16 SSL_ImplementedCiphers[];
31 /* the same as the above, but is a function */
32 SSL_IMPORT const PRUint16 *SSL_GetImplementedCiphers(void);
34 /* number of entries in the above table. */
35 SSL_IMPORT const PRUint16 SSL_NumImplementedCiphers;
37 /* the same as the above, but is a function */
38 SSL_IMPORT PRUint16 SSL_GetNumImplementedCiphers(void);
40 /* Macro to tell which ciphers in table are SSL2 vs SSL3/TLS. */
41 #define SSL_IS_SSL2_CIPHER(which) (((which) & 0xfff0) == 0xff00)
44 ** Imports fd into SSL, returning a new socket. Copies SSL configuration
45 ** from model.
47 SSL_IMPORT PRFileDesc *SSL_ImportFD(PRFileDesc *model, PRFileDesc *fd);
50 ** Imports fd into DTLS, returning a new socket. Copies DTLS configuration
51 ** from model.
53 SSL_IMPORT PRFileDesc *DTLS_ImportFD(PRFileDesc *model, PRFileDesc *fd);
56 ** Enable/disable an ssl mode
58 ** SSL_SECURITY:
59 ** enable/disable use of SSL security protocol before connect
61 ** SSL_SOCKS:
62 ** enable/disable use of socks before connect
63 ** (No longer supported).
65 ** SSL_REQUEST_CERTIFICATE:
66 ** require a certificate during secure connect
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) */
77 /* OBSOLETE: SSL v2 is obsolete and may be removed soon. */
78 #define SSL_ENABLE_SSL2 7 /* enable ssl v2 (off by default) */
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.
83 #define SSL_ENABLE_SSL3 8 /* enable ssl v3 (on by default) */
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) */
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.
96 #define SSL_V2_COMPATIBLE_HELLO 12 /* send v3 client hello in v2 fmt */
97 /* (off by default) */
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.
102 #define SSL_ENABLE_TLS 13 /* enable TLS (on by default) */
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.
132 * In addition to enabling this option, the application must register a
133 * callback using the SSL_SetCanFalseStartCallback function.
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.
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.
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.
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.
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).
162 #define SSL_CBC_RANDOM_IV 23
163 #define SSL_ENABLE_OCSP_STAPLING 24 /* Request OCSP stapling (client) */
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.
172 #define SSL_ENABLE_NPN 25
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.
183 #define SSL_ENABLE_ALPN 26
185 /* SSL_REUSE_SERVER_ECDHE_KEY controls whether the ECDHE server key is
186 * reused for multiple handshakes or generated each time.
187 * SSL_REUSE_SERVER_ECDHE_KEY is currently enabled by default.
189 #define SSL_REUSE_SERVER_ECDHE_KEY 27
191 #define SSL_ENABLE_FALLBACK_SCSV 28 /* Send fallback SCSV in
192 * handshakes. */
194 /* Request Signed Certificate Timestamps via TLS extension (client) */
195 #define SSL_ENABLE_SIGNED_CERT_TIMESTAMPS 29
197 #ifdef SSL_DEPRECATED_FUNCTION
198 /* Old deprecated function names */
199 SSL_IMPORT SECStatus SSL_Enable(PRFileDesc *fd, int option, PRBool on);
200 SSL_IMPORT SECStatus SSL_EnableDefault(int option, PRBool on);
201 #endif
203 /* New function names */
204 SSL_IMPORT SECStatus SSL_OptionSet(PRFileDesc *fd, PRInt32 option, PRBool on);
205 SSL_IMPORT SECStatus SSL_OptionGet(PRFileDesc *fd, PRInt32 option, PRBool *on);
206 SSL_IMPORT SECStatus SSL_OptionSetDefault(PRInt32 option, PRBool on);
207 SSL_IMPORT SECStatus SSL_OptionGetDefault(PRInt32 option, PRBool *on);
208 SSL_IMPORT SECStatus SSL_CertDBHandleSet(PRFileDesc *fd, CERTCertDBHandle *dbHandle);
210 /* SSLNextProtoCallback is called during the handshake for the client, when a
211 * Next Protocol Negotiation (NPN) extension has been received from the server.
212 * |protos| and |protosLen| define a buffer which contains the server's
213 * advertisement. This data is guaranteed to be well formed per the NPN spec.
214 * |protoOut| is a buffer provided by the caller, of length 255 (the maximum
215 * allowed by the protocol). On successful return, the protocol to be announced
216 * to the server will be in |protoOut| and its length in |*protoOutLen|.
218 * The callback must return SECFailure or SECSuccess (not SECWouldBlock).
220 typedef SECStatus (PR_CALLBACK *SSLNextProtoCallback)(
221 void *arg,
222 PRFileDesc *fd,
223 const unsigned char* protos,
224 unsigned int protosLen,
225 unsigned char* protoOut,
226 unsigned int* protoOutLen,
227 unsigned int protoMaxOut);
229 /* SSL_SetNextProtoCallback sets a callback function to handle Next Protocol
230 * Negotiation. It causes a client to advertise NPN. */
231 SSL_IMPORT SECStatus SSL_SetNextProtoCallback(PRFileDesc *fd,
232 SSLNextProtoCallback callback,
233 void *arg);
235 /* SSL_SetNextProtoNego can be used as an alternative to
236 * SSL_SetNextProtoCallback. It also causes a client to advertise NPN and
237 * installs a default callback function which selects the first supported
238 * protocol in server-preference order. If no matching protocol is found it
239 * selects the first supported protocol.
241 * Using this function also allows the client to transparently support ALPN.
242 * The same set of protocols will be advertised via ALPN and, if the server
243 * uses ALPN to select a protocol, SSL_GetNextProto will return
244 * SSL_NEXT_PROTO_SELECTED as the state.
246 * Since NPN uses the first protocol as the fallback protocol, when sending an
247 * ALPN extension, the first protocol is moved to the end of the list. This
248 * indicates that the fallback protocol is the least preferred. The other
249 * protocols should be in preference order.
251 * The supported protocols are specified in |data| in wire-format (8-bit
252 * length-prefixed). For example: "\010http/1.1\006spdy/2". */
253 SSL_IMPORT SECStatus SSL_SetNextProtoNego(PRFileDesc *fd,
254 const unsigned char *data,
255 unsigned int length);
257 typedef enum SSLNextProtoState {
258 SSL_NEXT_PROTO_NO_SUPPORT = 0, /* No peer support */
259 SSL_NEXT_PROTO_NEGOTIATED = 1, /* Mutual agreement */
260 SSL_NEXT_PROTO_NO_OVERLAP = 2, /* No protocol overlap found */
261 SSL_NEXT_PROTO_SELECTED = 3 /* Server selected proto (ALPN) */
262 } SSLNextProtoState;
264 /* SSL_GetNextProto can be used in the HandshakeCallback or any time after
265 * a handshake to retrieve the result of the Next Protocol negotiation.
267 * The length of the negotiated protocol, if any, is written into *bufLen.
268 * If the negotiated protocol is longer than bufLenMax, then SECFailure is
269 * returned. Otherwise, the negotiated protocol, if any, is written into buf,
270 * and SECSuccess is returned. */
271 SSL_IMPORT SECStatus SSL_GetNextProto(PRFileDesc *fd,
272 SSLNextProtoState *state,
273 unsigned char *buf,
274 unsigned int *bufLen,
275 unsigned int bufLenMax);
278 ** Control ciphers that SSL uses. If on is non-zero then the named cipher
279 ** is enabled, otherwise it is disabled.
280 ** The "cipher" values are defined in sslproto.h (the SSL_EN_* values).
281 ** EnableCipher records user preferences.
282 ** SetPolicy sets the policy according to the policy module.
284 #ifdef SSL_DEPRECATED_FUNCTION
285 /* Old deprecated function names */
286 SSL_IMPORT SECStatus SSL_EnableCipher(long which, PRBool enabled);
287 SSL_IMPORT SECStatus SSL_SetPolicy(long which, int policy);
288 #endif
290 /* New function names */
291 SSL_IMPORT SECStatus SSL_CipherPrefSet(PRFileDesc *fd, PRInt32 cipher, PRBool enabled);
292 SSL_IMPORT SECStatus SSL_CipherPrefGet(PRFileDesc *fd, PRInt32 cipher, PRBool *enabled);
293 SSL_IMPORT SECStatus SSL_CipherPrefSetDefault(PRInt32 cipher, PRBool enabled);
294 SSL_IMPORT SECStatus SSL_CipherPrefGetDefault(PRInt32 cipher, PRBool *enabled);
295 SSL_IMPORT SECStatus SSL_CipherPolicySet(PRInt32 cipher, PRInt32 policy);
296 SSL_IMPORT SECStatus SSL_CipherPolicyGet(PRInt32 cipher, PRInt32 *policy);
298 /* SSL_CipherOrderSet sets the cipher suite preference order from |ciphers|,
299 * which must be an array of cipher suite ids of length |len|. All the given
300 * cipher suite ids must appear in the array that is returned by
301 * |SSL_GetImplementedCiphers| and may only appear once, at most. */
302 SSL_IMPORT SECStatus SSL_CipherOrderSet(PRFileDesc *fd, const PRUint16 *ciphers,
303 unsigned int len);
305 /* SSLChannelBindingType enumerates the types of supported channel binding
306 * values. See RFC 5929. */
307 typedef enum SSLChannelBindingType {
308 SSL_CHANNEL_BINDING_TLS_UNIQUE = 1,
309 } SSLChannelBindingType;
311 /* SSL_GetChannelBinding copies the requested channel binding value, as defined
312 * in RFC 5929, into |out|. The full length of the binding value is written
313 * into |*outLen|.
315 * At most |outLenMax| bytes of data are copied. If |outLenMax| is
316 * insufficient then the function returns SECFailure and sets the error to
317 * SEC_ERROR_OUTPUT_LEN, but |*outLen| is still set.
319 * This call will fail if made during a renegotiation. */
320 SSL_IMPORT SECStatus SSL_GetChannelBinding(PRFileDesc *fd,
321 SSLChannelBindingType binding_type,
322 unsigned char *out,
323 unsigned int *outLen,
324 unsigned int outLenMax);
326 /* SSL Version Range API
328 ** This API should be used to control SSL 3.0 & TLS support instead of the
329 ** older SSL_Option* API; however, the SSL_Option* API MUST still be used to
330 ** control SSL 2.0 support. In this version of libssl, SSL 3.0 and TLS 1.0 are
331 ** enabled by default. Future versions of libssl may change which versions of
332 ** the protocol are enabled by default.
334 ** The SSLProtocolVariant enum indicates whether the protocol is of type
335 ** stream or datagram. This must be provided to the functions that do not
336 ** take an fd. Functions which take an fd will get the variant from the fd,
337 ** which is typed.
339 ** Using the new version range API in conjunction with the older
340 ** SSL_OptionSet-based API for controlling the enabled protocol versions may
341 ** cause unexpected results. Going forward, we guarantee only the following:
343 ** SSL_OptionGet(SSL_ENABLE_TLS) will return PR_TRUE if *ANY* versions of TLS
344 ** are enabled.
346 ** SSL_OptionSet(SSL_ENABLE_TLS, PR_FALSE) will disable *ALL* versions of TLS,
347 ** including TLS 1.0 and later.
349 ** The above two properties provide compatibility for applications that use
350 ** SSL_OptionSet to implement the insecure fallback from TLS 1.x to SSL 3.0.
352 ** SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE) will enable TLS 1.0, and may also
353 ** enable some later versions of TLS, if it is necessary to do so in order to
354 ** keep the set of enabled versions contiguous. For example, if TLS 1.2 is
355 ** enabled, then after SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE), TLS 1.0,
356 ** TLS 1.1, and TLS 1.2 will be enabled, and the call will have no effect on
357 ** whether SSL 3.0 is enabled. If no later versions of TLS are enabled at the
358 ** time SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE) is called, then no later
359 ** versions of TLS will be enabled by the call.
361 ** SSL_OptionSet(SSL_ENABLE_SSL3, PR_FALSE) will disable SSL 3.0, and will not
362 ** change the set of TLS versions that are enabled.
364 ** SSL_OptionSet(SSL_ENABLE_SSL3, PR_TRUE) will enable SSL 3.0, and may also
365 ** enable some versions of TLS if TLS 1.1 or later is enabled at the time of
366 ** the call, the same way SSL_OptionSet(SSL_ENABLE_TLS, PR_TRUE) works, in
367 ** order to keep the set of enabled versions contiguous.
370 /* Returns, in |*vrange|, the range of SSL3/TLS versions supported for the
371 ** given protocol variant by the version of libssl linked-to at runtime.
373 SSL_IMPORT SECStatus SSL_VersionRangeGetSupported(
374 SSLProtocolVariant protocolVariant, SSLVersionRange *vrange);
376 /* Returns, in |*vrange|, the range of SSL3/TLS versions enabled by default
377 ** for the given protocol variant.
379 SSL_IMPORT SECStatus SSL_VersionRangeGetDefault(
380 SSLProtocolVariant protocolVariant, SSLVersionRange *vrange);
382 /* Sets the range of enabled-by-default SSL3/TLS versions for the given
383 ** protocol variant to |*vrange|.
385 SSL_IMPORT SECStatus SSL_VersionRangeSetDefault(
386 SSLProtocolVariant protocolVariant, const SSLVersionRange *vrange);
388 /* Returns, in |*vrange|, the range of enabled SSL3/TLS versions for |fd|. */
389 SSL_IMPORT SECStatus SSL_VersionRangeGet(PRFileDesc *fd,
390 SSLVersionRange *vrange);
392 /* Sets the range of enabled SSL3/TLS versions for |fd| to |*vrange|. */
393 SSL_IMPORT SECStatus SSL_VersionRangeSet(PRFileDesc *fd,
394 const SSLVersionRange *vrange);
397 /* Values for "policy" argument to SSL_CipherPolicySet */
398 /* Values returned by SSL_CipherPolicyGet. */
399 #define SSL_NOT_ALLOWED 0 /* or invalid or unimplemented */
400 #define SSL_ALLOWED 1
401 #define SSL_RESTRICTED 2 /* only with "Step-Up" certs. */
403 /* Values for "on" with SSL_REQUIRE_CERTIFICATE. */
404 #define SSL_REQUIRE_NEVER ((PRBool)0)
405 #define SSL_REQUIRE_ALWAYS ((PRBool)1)
406 #define SSL_REQUIRE_FIRST_HANDSHAKE ((PRBool)2)
407 #define SSL_REQUIRE_NO_ERROR ((PRBool)3)
409 /* Values for "on" with SSL_ENABLE_RENEGOTIATION */
410 /* Never renegotiate at all. */
411 #define SSL_RENEGOTIATE_NEVER ((PRBool)0)
412 /* Renegotiate without restriction, whether or not the peer's client hello */
413 /* bears the renegotiation info extension. Vulnerable, as in the past. */
414 #define SSL_RENEGOTIATE_UNRESTRICTED ((PRBool)1)
415 /* Only renegotiate if the peer's hello bears the TLS renegotiation_info */
416 /* extension. This is safe renegotiation. */
417 #define SSL_RENEGOTIATE_REQUIRES_XTN ((PRBool)2)
418 /* Disallow unsafe renegotiation in server sockets only, but allow clients */
419 /* to continue to renegotiate with vulnerable servers. */
420 /* This value should only be used during the transition period when few */
421 /* servers have been upgraded. */
422 #define SSL_RENEGOTIATE_TRANSITIONAL ((PRBool)3)
425 ** Reset the handshake state for fd. This will make the complete SSL
426 ** handshake protocol execute from the ground up on the next i/o
427 ** operation.
429 SSL_IMPORT SECStatus SSL_ResetHandshake(PRFileDesc *fd, PRBool asServer);
432 ** Force the handshake for fd to complete immediately. This blocks until
433 ** the complete SSL handshake protocol is finished.
435 SSL_IMPORT SECStatus SSL_ForceHandshake(PRFileDesc *fd);
438 ** Same as above, but with an I/O timeout.
440 SSL_IMPORT SECStatus SSL_ForceHandshakeWithTimeout(PRFileDesc *fd,
441 PRIntervalTime timeout);
443 SSL_IMPORT SECStatus SSL_RestartHandshakeAfterCertReq(PRFileDesc *fd,
444 CERTCertificate *cert,
445 SECKEYPrivateKey *key,
446 CERTCertificateList *certChain);
449 ** Query security status of socket. *on is set to one if security is
450 ** enabled. *keySize will contain the stream key size used. *issuer will
451 ** contain the RFC1485 verison of the name of the issuer of the
452 ** certificate at the other end of the connection. For a client, this is
453 ** the issuer of the server's certificate; for a server, this is the
454 ** issuer of the client's certificate (if any). Subject is the subject of
455 ** the other end's certificate. The pointers can be zero if the desired
456 ** data is not needed. All strings returned by this function are owned
457 ** by the caller, and need to be freed with PORT_Free.
459 SSL_IMPORT SECStatus SSL_SecurityStatus(PRFileDesc *fd, int *on, char **cipher,
460 int *keySize, int *secretKeySize,
461 char **issuer, char **subject);
463 /* Values for "on" */
464 #define SSL_SECURITY_STATUS_NOOPT -1
465 #define SSL_SECURITY_STATUS_OFF 0
466 #define SSL_SECURITY_STATUS_ON_HIGH 1
467 #define SSL_SECURITY_STATUS_ON_LOW 2
468 #define SSL_SECURITY_STATUS_FORTEZZA 3 /* NO LONGER SUPPORTED */
471 ** Return the certificate for our SSL peer. If the client calls this
472 ** it will always return the server's certificate. If the server calls
473 ** this, it may return NULL if client authentication is not enabled or
474 ** if the client had no certificate when asked.
475 ** "fd" the socket "file" descriptor
477 SSL_IMPORT CERTCertificate *SSL_PeerCertificate(PRFileDesc *fd);
480 ** Return the certificates presented by the SSL peer. If the SSL peer
481 ** did not present certificates, return NULL with the
482 ** SSL_ERROR_NO_CERTIFICATE error. On failure, return NULL with an error
483 ** code other than SSL_ERROR_NO_CERTIFICATE.
484 ** "fd" the socket "file" descriptor
486 SSL_IMPORT CERTCertList *SSL_PeerCertificateChain(PRFileDesc *fd);
488 /* SSL_PeerStapledOCSPResponses returns the OCSP responses that were provided
489 * by the TLS server. The return value is a pointer to an internal SECItemArray
490 * that contains the returned OCSP responses; it is only valid until the
491 * callback function that calls SSL_PeerStapledOCSPResponses returns.
493 * If no OCSP responses were given by the server then the result will be empty.
494 * If there was an error, then the result will be NULL.
496 * You must set the SSL_ENABLE_OCSP_STAPLING option to enable OCSP stapling.
497 * to be provided by a server.
499 * libssl does not do any validation of the OCSP response itself; the
500 * authenticate certificate hook is responsible for doing so. The default
501 * authenticate certificate hook, SSL_AuthCertificate, does not implement
502 * any OCSP stapling funtionality, but this may change in future versions.
504 SSL_IMPORT const SECItemArray * SSL_PeerStapledOCSPResponses(PRFileDesc *fd);
506 /* SSL_PeerSignedCertTimestamps returns the signed_certificate_timestamp
507 * extension data provided by the TLS server. The return value is a pointer
508 * to an internal SECItem that contains the returned response (as a serialized
509 * SignedCertificateTimestampList, see RFC 6962). The returned pointer is only
510 * valid until the callback function that calls SSL_PeerSignedCertTimestamps
511 * (e.g. the authenticate certificate hook, or the handshake callback) returns.
513 * If no Signed Certificate Timestamps were given by the server then the result
514 * will be empty. If there was an error, then the result will be NULL.
516 * You must set the SSL_ENABLE_SIGNED_CERT_TIMESTAMPS option to indicate support
517 * for Signed Certificate Timestamps to a server.
519 * libssl does not do any parsing or validation of the response itself.
521 SSL_IMPORT const SECItem * SSL_PeerSignedCertTimestamps(PRFileDesc *fd);
523 /* SSL_SetStapledOCSPResponses stores an array of one or multiple OCSP responses
524 * in the fd's data, which may be sent as part of a server side cert_status
525 * handshake message. Parameter |responses| is for the server certificate of
526 * the key exchange type |kea|.
527 * The function will duplicate the responses array.
529 SSL_IMPORT SECStatus
530 SSL_SetStapledOCSPResponses(PRFileDesc *fd, const SECItemArray *responses,
531 SSLKEAType kea);
534 ** Authenticate certificate hook. Called when a certificate comes in
535 ** (because of SSL_REQUIRE_CERTIFICATE in SSL_Enable) to authenticate the
536 ** certificate.
538 ** The authenticate certificate hook must return SECSuccess to indicate the
539 ** certificate is valid, SECFailure to indicate the certificate is invalid,
540 ** or SECWouldBlock if the application will authenticate the certificate
541 ** asynchronously. SECWouldBlock is only supported for non-blocking sockets.
543 ** If the authenticate certificate hook returns SECFailure, then the bad cert
544 ** hook will be called. The bad cert handler is NEVER called if the
545 ** authenticate certificate hook returns SECWouldBlock. If the application
546 ** needs to handle and/or override a bad cert, it should do so before it
547 ** calls SSL_AuthCertificateComplete (modifying the error it passes to
548 ** SSL_AuthCertificateComplete as needed).
550 ** See the documentation for SSL_AuthCertificateComplete for more information
551 ** about the asynchronous behavior that occurs when the authenticate
552 ** certificate hook returns SECWouldBlock.
554 ** RFC 6066 says that clients should send the bad_certificate_status_response
555 ** alert when they encounter an error processing the stapled OCSP response.
556 ** libssl does not provide a way for the authenticate certificate hook to
557 ** indicate that an OCSP error (SEC_ERROR_OCSP_*) that it returns is an error
558 ** in the stapled OCSP response or an error in some other OCSP response.
559 ** Further, NSS does not provide a convenient way to control or determine
560 ** which OCSP response(s) were used to validate a certificate chain.
561 ** Consequently, the current version of libssl does not ever send the
562 ** bad_certificate_status_response alert. This may change in future releases.
564 typedef SECStatus (PR_CALLBACK *SSLAuthCertificate)(void *arg, PRFileDesc *fd,
565 PRBool checkSig,
566 PRBool isServer);
568 SSL_IMPORT SECStatus SSL_AuthCertificateHook(PRFileDesc *fd,
569 SSLAuthCertificate f,
570 void *arg);
572 /* An implementation of the certificate authentication hook */
573 SSL_IMPORT SECStatus SSL_AuthCertificate(void *arg, PRFileDesc *fd,
574 PRBool checkSig, PRBool isServer);
577 * Prototype for SSL callback to get client auth data from the application.
578 * arg - application passed argument
579 * caNames - pointer to distinguished names of CAs that the server likes
580 * pRetCert - pointer to pointer to cert, for return of cert
581 * pRetKey - pointer to key pointer, for return of key
583 typedef SECStatus (PR_CALLBACK *SSLGetClientAuthData)(void *arg,
584 PRFileDesc *fd,
585 CERTDistNames *caNames,
586 CERTCertificate **pRetCert,/*return */
587 SECKEYPrivateKey **pRetKey);/* return */
590 * Set the client side callback for SSL to retrieve user's private key
591 * and certificate.
592 * fd - the file descriptor for the connection in question
593 * f - the application's callback that delivers the key and cert
594 * a - application specific data
596 SSL_IMPORT SECStatus SSL_GetClientAuthDataHook(PRFileDesc *fd,
597 SSLGetClientAuthData f, void *a);
600 * Prototype for SSL callback to get client auth data from the application,
601 * optionally using the underlying platform's cryptographic primitives.
602 * To use the platform cryptographic primitives, caNames and pRetCerts
603 * should be set. To use NSS, pRetNSSCert and pRetNSSKey should be set.
604 * Returning SECFailure will cause the socket to send no client certificate.
605 * arg - application passed argument
606 * caNames - pointer to distinguished names of CAs that the server likes
607 * pRetCerts - pointer to pointer to list of certs, with the first being
608 * the client cert, and any following being used for chain
609 * building
610 * pRetKey - pointer to native key pointer, for return of key
611 * - Windows: A pointer to a PCERT_KEY_CONTEXT that was allocated
612 * via PORT_Alloc(). Ownership of the PCERT_KEY_CONTEXT
613 * is transferred to NSS, which will free via
614 * PORT_Free().
615 * - Mac OS X: A pointer to a SecKeyRef. Ownership is
616 * transferred to NSS, which will free via CFRelease().
617 * pRetNSSCert - pointer to pointer to NSS cert, for return of cert.
618 * pRetNSSKey - pointer to NSS key pointer, for return of key.
620 typedef SECStatus (PR_CALLBACK *SSLGetPlatformClientAuthData)(void *arg,
621 PRFileDesc *fd,
622 CERTDistNames *caNames,
623 CERTCertList **pRetCerts,/*return */
624 void **pRetKey,/* return */
625 CERTCertificate **pRetNSSCert,/*return */
626 SECKEYPrivateKey **pRetNSSKey);/* return */
629 * Set the client side callback for SSL to retrieve user's private key
630 * and certificate.
631 * Note: If a platform client auth callback is set, the callback configured by
632 * SSL_GetClientAuthDataHook, if any, will not be called.
634 * fd - the file descriptor for the connection in question
635 * f - the application's callback that delivers the key and cert
636 * a - application specific data
638 SSL_IMPORT SECStatus
639 SSL_GetPlatformClientAuthDataHook(PRFileDesc *fd,
640 SSLGetPlatformClientAuthData f, void *a);
643 ** SNI extension processing callback function.
644 ** It is called when SSL socket receives SNI extension in ClientHello message.
645 ** Upon this callback invocation, application is responsible to reconfigure the
646 ** socket with the data for a particular server name.
647 ** There are three potential outcomes of this function invocation:
648 ** * application does not recognize the name or the type and wants the
649 ** "unrecognized_name" alert be sent to the client. In this case the callback
650 ** function must return SSL_SNI_SEND_ALERT status.
651 ** * application does not recognize the name, but wants to continue with
652 ** the handshake using the current socket configuration. In this case,
653 ** no socket reconfiguration is needed and the function should return
654 ** SSL_SNI_CURRENT_CONFIG_IS_USED.
655 ** * application recognizes the name and reconfigures the socket with
656 ** appropriate certs, key, etc. There are many ways to reconfigure. NSS
657 ** provides SSL_ReconfigFD function that can be used to update the socket
658 ** data from model socket. To continue with the rest of the handshake, the
659 ** implementation function should return an index of a name it has chosen.
660 ** LibSSL will ignore any SNI extension received in a ClientHello message
661 ** if application does not register a SSLSNISocketConfig callback.
662 ** Each type field of SECItem indicates the name type.
663 ** NOTE: currently RFC3546 defines only one name type: sni_host_name.
664 ** Client is allowed to send only one name per known type. LibSSL will
665 ** send an "unrecognized_name" alert if SNI extension name list contains more
666 ** then one name of a type.
668 typedef PRInt32 (PR_CALLBACK *SSLSNISocketConfig)(PRFileDesc *fd,
669 const SECItem *srvNameArr,
670 PRUint32 srvNameArrSize,
671 void *arg);
674 ** SSLSNISocketConfig should return an index within 0 and srvNameArrSize-1
675 ** when it has reconfigured the socket fd to use certs and keys, etc
676 ** for a specific name. There are two other allowed return values. One
677 ** tells libSSL to use the default cert and key. The other tells libSSL
678 ** to send the "unrecognized_name" alert. These values are:
680 #define SSL_SNI_CURRENT_CONFIG_IS_USED -1
681 #define SSL_SNI_SEND_ALERT -2
684 ** Set application implemented SNISocketConfig callback.
686 SSL_IMPORT SECStatus SSL_SNISocketConfigHook(PRFileDesc *fd,
687 SSLSNISocketConfig f,
688 void *arg);
691 ** Reconfigure fd SSL socket with model socket parameters. Sets
692 ** server certs and keys, list of trust anchor, socket options
693 ** and all SSL socket call backs and parameters.
695 SSL_IMPORT PRFileDesc *SSL_ReconfigFD(PRFileDesc *model, PRFileDesc *fd);
698 * Set the client side argument for SSL to retrieve PKCS #11 pin.
699 * fd - the file descriptor for the connection in question
700 * a - pkcs11 application specific data
702 SSL_IMPORT SECStatus SSL_SetPKCS11PinArg(PRFileDesc *fd, void *a);
705 ** This is a callback for dealing with server certs that are not authenticated
706 ** by the client. The client app can decide that it actually likes the
707 ** cert by some external means and restart the connection.
709 ** The bad cert hook must return SECSuccess to override the result of the
710 ** authenticate certificate hook, SECFailure if the certificate should still be
711 ** considered invalid, or SECWouldBlock if the application will authenticate
712 ** the certificate asynchronously. SECWouldBlock is only supported for
713 ** non-blocking sockets.
715 ** See the documentation for SSL_AuthCertificateComplete for more information
716 ** about the asynchronous behavior that occurs when the bad cert hook returns
717 ** SECWouldBlock.
719 typedef SECStatus (PR_CALLBACK *SSLBadCertHandler)(void *arg, PRFileDesc *fd);
720 SSL_IMPORT SECStatus SSL_BadCertHook(PRFileDesc *fd, SSLBadCertHandler f,
721 void *arg);
724 ** Configure SSL socket for running a secure server. Needs the
725 ** certificate for the server and the servers private key. The arguments
726 ** are copied.
728 SSL_IMPORT SECStatus SSL_ConfigSecureServer(
729 PRFileDesc *fd, CERTCertificate *cert,
730 SECKEYPrivateKey *key, SSLKEAType kea);
733 ** Allows SSL socket configuration with caller-supplied certificate chain.
734 ** If certChainOpt is NULL, tries to find one.
736 SSL_IMPORT SECStatus
737 SSL_ConfigSecureServerWithCertChain(PRFileDesc *fd, CERTCertificate *cert,
738 const CERTCertificateList *certChainOpt,
739 SECKEYPrivateKey *key, SSLKEAType kea);
742 ** Configure a secure server's session-id cache. Define the maximum number
743 ** of entries in the cache, the longevity of the entires, and the directory
744 ** where the cache files will be placed. These values can be zero, and
745 ** if so, the implementation will choose defaults.
746 ** This version of the function is for use in applications that have only one
747 ** process that uses the cache (even if that process has multiple threads).
749 SSL_IMPORT SECStatus SSL_ConfigServerSessionIDCache(int maxCacheEntries,
750 PRUint32 timeout,
751 PRUint32 ssl3_timeout,
752 const char * directory);
754 /* Configure a secure server's session-id cache. Depends on value of
755 * enableMPCache, configures malti-proc or single proc cache. */
756 SSL_IMPORT SECStatus SSL_ConfigServerSessionIDCacheWithOpt(
757 PRUint32 timeout,
758 PRUint32 ssl3_timeout,
759 const char * directory,
760 int maxCacheEntries,
761 int maxCertCacheEntries,
762 int maxSrvNameCacheEntries,
763 PRBool enableMPCache);
766 ** Like SSL_ConfigServerSessionIDCache, with one important difference.
767 ** If the application will run multiple processes (as opposed to, or in
768 ** addition to multiple threads), then it must call this function, instead
769 ** of calling SSL_ConfigServerSessionIDCache().
770 ** This has nothing to do with the number of processORs, only processEs.
771 ** This function sets up a Server Session ID (SID) cache that is safe for
772 ** access by multiple processes on the same system.
774 SSL_IMPORT SECStatus SSL_ConfigMPServerSIDCache(int maxCacheEntries,
775 PRUint32 timeout,
776 PRUint32 ssl3_timeout,
777 const char * directory);
779 /* Get and set the configured maximum number of mutexes used for the
780 ** server's store of SSL sessions. This value is used by the server
781 ** session ID cache initialization functions shown above. Note that on
782 ** some platforms, these mutexes are actually implemented with POSIX
783 ** semaphores, or with unnamed pipes. The default value varies by platform.
784 ** An attempt to set a too-low maximum will return an error and the
785 ** configured value will not be changed.
787 SSL_IMPORT PRUint32 SSL_GetMaxServerCacheLocks(void);
788 SSL_IMPORT SECStatus SSL_SetMaxServerCacheLocks(PRUint32 maxLocks);
790 /* environment variable set by SSL_ConfigMPServerSIDCache, and queried by
791 * SSL_InheritMPServerSIDCache when envString is NULL.
793 #define SSL_ENV_VAR_NAME "SSL_INHERITANCE"
795 /* called in child to inherit SID Cache variables.
796 * If envString is NULL, this function will use the value of the environment
797 * variable "SSL_INHERITANCE", otherwise the string value passed in will be
798 * used.
800 SSL_IMPORT SECStatus SSL_InheritMPServerSIDCache(const char * envString);
803 ** Set the callback that gets called when a TLS handshake is complete. The
804 ** handshake callback is called after verifying the peer's Finished message and
805 ** before processing incoming application data.
807 ** For the initial handshake: If the handshake false started (see
808 ** SSL_ENABLE_FALSE_START), then application data may already have been sent
809 ** before the handshake callback is called. If we did not false start then the
810 ** callback will get called before any application data is sent.
812 typedef void (PR_CALLBACK *SSLHandshakeCallback)(PRFileDesc *fd,
813 void *client_data);
814 SSL_IMPORT SECStatus SSL_HandshakeCallback(PRFileDesc *fd,
815 SSLHandshakeCallback cb, void *client_data);
817 /* Applications that wish to enable TLS false start must set this callback
818 ** function. NSS will invoke the functon to determine if a particular
819 ** connection should use false start or not. SECSuccess indicates that the
820 ** callback completed successfully, and if so *canFalseStart indicates if false
821 ** start can be used. If the callback does not return SECSuccess then the
822 ** handshake will be canceled. NSS's recommended criteria can be evaluated by
823 ** calling SSL_RecommendedCanFalseStart.
825 ** If no false start callback is registered then false start will never be
826 ** done, even if the SSL_ENABLE_FALSE_START option is enabled.
828 typedef SECStatus (PR_CALLBACK *SSLCanFalseStartCallback)(
829 PRFileDesc *fd, void *arg, PRBool *canFalseStart);
831 SSL_IMPORT SECStatus SSL_SetCanFalseStartCallback(
832 PRFileDesc *fd, SSLCanFalseStartCallback callback, void *arg);
834 /* This function sets *canFalseStart according to the recommended criteria for
835 ** false start. These criteria may change from release to release and may depend
836 ** on which handshake features have been negotiated and/or properties of the
837 ** certifciates/keys used on the connection.
839 SSL_IMPORT SECStatus SSL_RecommendedCanFalseStart(PRFileDesc *fd,
840 PRBool *canFalseStart);
843 ** For the server, request a new handshake. For the client, begin a new
844 ** handshake. If flushCache is non-zero, the SSL3 cache entry will be
845 ** flushed first, ensuring that a full SSL handshake will be done.
846 ** If flushCache is zero, and an SSL connection is established, it will
847 ** do the much faster session restart handshake. This will change the
848 ** session keys without doing another private key operation.
850 SSL_IMPORT SECStatus SSL_ReHandshake(PRFileDesc *fd, PRBool flushCache);
853 ** Same as above, but with an I/O timeout.
855 SSL_IMPORT SECStatus SSL_ReHandshakeWithTimeout(PRFileDesc *fd,
856 PRBool flushCache,
857 PRIntervalTime timeout);
859 /* Returns a SECItem containing the certificate_types field of the
860 ** CertificateRequest message. Each byte of the data is a TLS
861 ** ClientCertificateType value, and they are ordered from most preferred to
862 ** least. This function should only be called from the
863 ** SSL_GetClientAuthDataHook callback, and will return NULL if called at any
864 ** other time. The returned value is valid only until the callback returns, and
865 ** should not be freed.
867 SSL_IMPORT const SECItem *
868 SSL_GetRequestedClientCertificateTypes(PRFileDesc *fd);
870 #ifdef SSL_DEPRECATED_FUNCTION
871 /* deprecated!
872 ** For the server, request a new handshake. For the client, begin a new
873 ** handshake. Flushes SSL3 session cache entry first, ensuring that a
874 ** full handshake will be done.
875 ** This call is equivalent to SSL_ReHandshake(fd, PR_TRUE)
877 SSL_IMPORT SECStatus SSL_RedoHandshake(PRFileDesc *fd);
878 #endif
881 * Allow the application to pass a URL or hostname into the SSL library.
883 SSL_IMPORT SECStatus SSL_SetURL(PRFileDesc *fd, const char *url);
886 * Allow an application to define a set of trust anchors for peer
887 * cert validation.
889 SSL_IMPORT SECStatus SSL_SetTrustAnchors(PRFileDesc *fd, CERTCertList *list);
892 ** Return the number of bytes that SSL has waiting in internal buffers.
893 ** Return 0 if security is not enabled.
895 SSL_IMPORT int SSL_DataPending(PRFileDesc *fd);
898 ** Invalidate the SSL session associated with fd.
900 SSL_IMPORT SECStatus SSL_InvalidateSession(PRFileDesc *fd);
903 ** Cache the SSL session associated with fd, if it has not already been cached.
905 SSL_IMPORT SECStatus SSL_CacheSession(PRFileDesc *fd);
908 ** Cache the SSL session associated with fd, if it has not already been cached.
909 ** This function may only be called when processing within a callback assigned
910 ** via SSL_HandshakeCallback
912 SSL_IMPORT SECStatus SSL_CacheSessionUnlocked(PRFileDesc *fd);
915 ** Return a SECItem containing the SSL session ID associated with the fd.
917 SSL_IMPORT SECItem *SSL_GetSessionID(PRFileDesc *fd);
920 ** Clear out the client's SSL session cache, not the server's session cache.
922 SSL_IMPORT void SSL_ClearSessionCache(void);
925 ** Close the server's SSL session cache.
927 SSL_IMPORT SECStatus SSL_ShutdownServerSessionIDCache(void);
930 ** Set peer information so we can correctly look up SSL session later.
931 ** You only have to do this if you're tunneling through a proxy.
933 SSL_IMPORT SECStatus SSL_SetSockPeerID(PRFileDesc *fd, const char *peerID);
936 ** Reveal the security information for the peer.
938 SSL_IMPORT CERTCertificate * SSL_RevealCert(PRFileDesc * socket);
939 SSL_IMPORT void * SSL_RevealPinArg(PRFileDesc * socket);
940 SSL_IMPORT char * SSL_RevealURL(PRFileDesc * socket);
942 /* This callback may be passed to the SSL library via a call to
943 * SSL_GetClientAuthDataHook() for each SSL client socket.
944 * It will be invoked when SSL needs to know what certificate and private key
945 * (if any) to use to respond to a request for client authentication.
946 * If arg is non-NULL, it is a pointer to a NULL-terminated string containing
947 * the nickname of the cert/key pair to use.
948 * If arg is NULL, this function will search the cert and key databases for
949 * a suitable match and send it if one is found.
951 SSL_IMPORT SECStatus
952 NSS_GetClientAuthData(void * arg,
953 PRFileDesc * socket,
954 struct CERTDistNamesStr * caNames,
955 struct CERTCertificateStr ** pRetCert,
956 struct SECKEYPrivateKeyStr **pRetKey);
959 ** Configure DTLS-SRTP (RFC 5764) cipher suite preferences.
960 ** Input is a list of ciphers in descending preference order and a length
961 ** of the list. As a side effect, this causes the use_srtp extension to be
962 ** negotiated.
964 ** Invalid or unimplemented cipher suites in |ciphers| are ignored. If at
965 ** least one cipher suite in |ciphers| is implemented, returns SECSuccess.
966 ** Otherwise returns SECFailure.
968 SSL_IMPORT SECStatus SSL_SetSRTPCiphers(PRFileDesc *fd,
969 const PRUint16 *ciphers,
970 unsigned int numCiphers);
973 ** Get the selected DTLS-SRTP cipher suite (if any).
974 ** To be called after the handshake completes.
975 ** Returns SECFailure if not negotiated.
977 SSL_IMPORT SECStatus SSL_GetSRTPCipher(PRFileDesc *fd,
978 PRUint16 *cipher);
981 * Look to see if any of the signers in the cert chain for "cert" are found
982 * in the list of caNames.
983 * Returns SECSuccess if so, SECFailure if not.
984 * Used by NSS_GetClientAuthData. May be used by other callback functions.
986 SSL_IMPORT SECStatus NSS_CmpCertChainWCANames(CERTCertificate *cert,
987 CERTDistNames *caNames);
990 * Returns key exchange type of the keys in an SSL server certificate.
992 SSL_IMPORT SSLKEAType NSS_FindCertKEAType(CERTCertificate * cert);
994 /* Set cipher policies to a predefined Domestic (U.S.A.) policy.
995 * This essentially allows all supported ciphers.
997 SSL_IMPORT SECStatus NSS_SetDomesticPolicy(void);
999 /* Set cipher policies to a predefined Policy that is exportable from the USA
1000 * according to present U.S. policies as we understand them.
1001 * It is the same as NSS_SetDomesticPolicy now.
1003 SSL_IMPORT SECStatus NSS_SetExportPolicy(void);
1005 /* Set cipher policies to a predefined Policy that is exportable from the USA
1006 * according to present U.S. policies as we understand them, and that the
1007 * nation of France will permit to be imported into their country.
1008 * It is the same as NSS_SetDomesticPolicy now.
1010 SSL_IMPORT SECStatus NSS_SetFrancePolicy(void);
1012 SSL_IMPORT SSL3Statistics * SSL_GetStatistics(void);
1014 /* Report more information than SSL_SecurityStatus.
1015 ** Caller supplies the info struct. Function fills it in.
1017 SSL_IMPORT SECStatus SSL_GetChannelInfo(PRFileDesc *fd, SSLChannelInfo *info,
1018 PRUintn len);
1019 SSL_IMPORT SECStatus SSL_GetCipherSuiteInfo(PRUint16 cipherSuite,
1020 SSLCipherSuiteInfo *info, PRUintn len);
1022 /* Returnes negotiated through SNI host info. */
1023 SSL_IMPORT SECItem *SSL_GetNegotiatedHostInfo(PRFileDesc *fd);
1025 /* Export keying material according to RFC 5705.
1026 ** fd must correspond to a TLS 1.0 or higher socket and out must
1027 ** already be allocated. If hasContext is false, it uses the no-context
1028 ** construction from the RFC and ignores the context and contextLen
1029 ** arguments.
1031 SSL_IMPORT SECStatus SSL_ExportKeyingMaterial(PRFileDesc *fd,
1032 const char *label,
1033 unsigned int labelLen,
1034 PRBool hasContext,
1035 const unsigned char *context,
1036 unsigned int contextLen,
1037 unsigned char *out,
1038 unsigned int outLen);
1041 ** Return a new reference to the certificate that was most recently sent
1042 ** to the peer on this SSL/TLS connection, or NULL if none has been sent.
1044 SSL_IMPORT CERTCertificate * SSL_LocalCertificate(PRFileDesc *fd);
1046 /* Test an SSL configuration to see if SSL_BYPASS_PKCS11 can be turned on.
1047 ** Check the key exchange algorithm for each cipher in the list to see if
1048 ** a master secret key can be extracted after being derived with the mechanism
1049 ** required by the protocolmask argument. If the KEA will use keys from the
1050 ** specified cert make sure the extract operation is attempted from the slot
1051 ** where the private key resides.
1052 ** If MS can be extracted for all ciphers, (*pcanbypass) is set to TRUE and
1053 ** SECSuccess is returned. In all other cases but one (*pcanbypass) is
1054 ** set to FALSE and SECFailure is returned.
1055 ** In that last case Derive() has been called successfully but the MS is null,
1056 ** CanBypass sets (*pcanbypass) to FALSE and returns SECSuccess indicating the
1057 ** arguments were all valid but the slot cannot be bypassed.
1059 ** Note: A TRUE return code from CanBypass means "Your configuration will perform
1060 ** NO WORSE with the bypass enabled than without"; it does NOT mean that every
1061 ** cipher suite listed will work properly with the selected protocols.
1063 ** Caveat: If export cipher suites are included in the argument list Canbypass
1064 ** will return FALSE.
1067 /* protocol mask bits */
1068 #define SSL_CBP_SSL3 0x0001 /* test SSL v3 mechanisms */
1069 #define SSL_CBP_TLS1_0 0x0002 /* test TLS v1.0 mechanisms */
1071 SSL_IMPORT SECStatus SSL_CanBypass(CERTCertificate *cert,
1072 SECKEYPrivateKey *privKey,
1073 PRUint32 protocolmask,
1074 PRUint16 *ciphers, int nciphers,
1075 PRBool *pcanbypass, void *pwArg);
1078 ** Did the handshake with the peer negotiate the given extension?
1079 ** Output parameter valid only if function returns SECSuccess
1081 SSL_IMPORT SECStatus SSL_HandshakeNegotiatedExtension(PRFileDesc * socket,
1082 SSLExtensionType extId,
1083 PRBool *yes);
1085 SSL_IMPORT SECStatus SSL_HandshakeResumedSession(PRFileDesc *fd,
1086 PRBool *last_handshake_resumed);
1088 /* See SSL_SetClientChannelIDCallback for usage. If the callback returns
1089 * SECWouldBlock then SSL_RestartHandshakeAfterChannelIDReq should be called in
1090 * the future to restart the handshake. On SECSuccess, the callback must have
1091 * written a P-256, EC key pair to |*out_public_key| and |*out_private_key|. */
1092 typedef SECStatus (PR_CALLBACK *SSLClientChannelIDCallback)(
1093 void *arg,
1094 PRFileDesc *fd,
1095 SECKEYPublicKey **out_public_key,
1096 SECKEYPrivateKey **out_private_key);
1098 /* SSL_RestartHandshakeAfterChannelIDReq attempts to restart the handshake
1099 * after a ChannelID callback returned SECWouldBlock.
1101 * This function takes ownership of |channelIDPub| and |channelID|. */
1102 SSL_IMPORT SECStatus SSL_RestartHandshakeAfterChannelIDReq(
1103 PRFileDesc *fd,
1104 SECKEYPublicKey *channelIDPub,
1105 SECKEYPrivateKey *channelID);
1107 /* SSL_SetClientChannelIDCallback sets a callback function that will be called
1108 * once the server's ServerHello has been processed. This is only applicable to
1109 * a client socket and setting this callback causes the TLS Channel ID
1110 * extension to be advertised. */
1111 SSL_IMPORT SECStatus SSL_SetClientChannelIDCallback(
1112 PRFileDesc *fd,
1113 SSLClientChannelIDCallback callback,
1114 void *arg);
1117 ** How long should we wait before retransmitting the next flight of
1118 ** the DTLS handshake? Returns SECFailure if not DTLS or not in a
1119 ** handshake.
1121 SSL_IMPORT SECStatus DTLS_GetHandshakeTimeout(PRFileDesc *socket,
1122 PRIntervalTime *timeout);
1125 * Return a boolean that indicates whether the underlying library
1126 * will perform as the caller expects.
1128 * The only argument is a string, which should be the version
1129 * identifier of the NSS library. That string will be compared
1130 * against a string that represents the actual build version of
1131 * the SSL library.
1133 extern PRBool NSSSSL_VersionCheck(const char *importedVersion);
1136 * Returns a const string of the SSL library version.
1138 extern const char *NSSSSL_GetVersion(void);
1140 /* Restart an SSL connection that was paused to do asynchronous certificate
1141 * chain validation (when the auth certificate hook or bad cert handler
1142 * returned SECWouldBlock).
1144 * This function only works for non-blocking sockets; Do not use it for
1145 * blocking sockets. Currently, this function works only for the client role of
1146 * a connection; it does not work for the server role.
1148 * The application must call SSL_AuthCertificateComplete with 0 as the value of
1149 * the error parameter after it has successfully validated the peer's
1150 * certificate, in order to continue the SSL handshake.
1152 * The application may call SSL_AuthCertificateComplete with a non-zero value
1153 * for error (e.g. SEC_ERROR_REVOKED_CERTIFICATE) when certificate validation
1154 * fails, before it closes the connection. If the application does so, an
1155 * alert corresponding to the error (e.g. certificate_revoked) will be sent to
1156 * the peer. See the source code of the internal function
1157 * ssl3_SendAlertForCertError for the current mapping of error to alert. This
1158 * mapping may change in future versions of libssl.
1160 * This function will not complete the entire handshake. The application must
1161 * call SSL_ForceHandshake, PR_Recv, PR_Send, etc. after calling this function
1162 * to force the handshake to complete.
1164 * On the first handshake of a connection, libssl will wait for the peer's
1165 * certificate to be authenticated before calling the handshake callback,
1166 * sending a client certificate, sending any application data, or returning
1167 * any application data to the application. On subsequent (renegotiation)
1168 * handshakes, libssl will block the handshake unconditionally while the
1169 * certificate is being validated.
1171 * libssl may send and receive handshake messages while waiting for the
1172 * application to call SSL_AuthCertificateComplete, and it may call other
1173 * callbacks (e.g, the client auth data hook) before
1174 * SSL_AuthCertificateComplete has been called.
1176 * An application that uses this asynchronous mechanism will usually have lower
1177 * handshake latency if it has to do public key operations on the certificate
1178 * chain and/or CRL/OCSP/cert fetching during the authentication, especially if
1179 * it does so in parallel on another thread. However, if the application can
1180 * authenticate the peer's certificate quickly then it may be more efficient
1181 * to use the synchronous mechanism (i.e. returning SECFailure/SECSuccess
1182 * instead of SECWouldBlock from the authenticate certificate hook).
1184 * Be careful about converting an application from synchronous cert validation
1185 * to asynchronous certificate validation. A naive conversion is likely to
1186 * result in deadlocks; e.g. the application will wait in PR_Poll for network
1187 * I/O on the connection while all network I/O on the connection is blocked
1188 * waiting for this function to be called.
1190 * Returns SECFailure on failure, SECSuccess on success. Never returns
1191 * SECWouldBlock. Note that SSL_AuthCertificateComplete will (usually) return
1192 * SECSuccess; do not interpret the return value of SSL_AuthCertificateComplete
1193 * as an indicator of whether it is OK to continue using the connection. For
1194 * example, SSL_AuthCertificateComplete(fd, SEC_ERROR_REVOKED_CERTIFICATE) will
1195 * return SECSuccess (normally), but that does not mean that the application
1196 * should continue using the connection. If the application passes a non-zero
1197 * value for second argument (error), or if SSL_AuthCertificateComplete returns
1198 * anything other than SECSuccess, then the application should close the
1199 * connection.
1201 SSL_IMPORT SECStatus SSL_AuthCertificateComplete(PRFileDesc *fd,
1202 PRErrorCode error);
1203 SEC_END_PROTOS
1205 #endif /* __ssl_h_ */