kris/boringssl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
449c3c7b7b
boringssl/include/openssl/ssl.h

4464 lines
197 KiB
C
Raw Normal View History

Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
*
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
*
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
*
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
* 4. If you include any Windows specific code (or a derivative thereof) from
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
*
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
*
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
/* ====================================================================
* Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
* notice, this list of conditions and the following disclaimer.
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* openssl-core@openssl.org.
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
* This product includes cryptographic software written by Eric Young
* (eay@cryptsoft.com). This product includes software written by Tim
* Hudson (tjh@cryptsoft.com).
*
*/
/* ====================================================================
* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
* ECC cipher suite support in OpenSSL originally developed by
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
* SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
*/
/* ====================================================================
* Copyright 2005 Nokia. All rights reserved.
*
* The portions of the attached software ("Contribution") is developed by
* Nokia Corporation and is licensed pursuant to the OpenSSL open source
* license.
*
* The Contribution, originally written by Mika Kousa and Pasi Eronen of
* Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
* support (see RFC 4279) to OpenSSL.
*
* No patent licenses or other rights except those expressly stated in
* the OpenSSL open source license shall be deemed granted or received
* expressly, by implication, estoppel, or otherwise.
*
* No assurances are provided by Nokia that the Contribution does not
* infringe the patent or other intellectual property rights of any third
* party or that the license provides you with all the necessary rights
* to make use of the Contribution.
*
* THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
* ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
* SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
* OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
* OTHERWISE.
*/
Fix minor stylistic issues with ssl.h. Mostly stuff that doc.go was grumpy about. The main change is to move the version-specific headers to the bottom. Injecting them in the middle makes it seem as if the definitions above the #include and those below are somehow different, but it compiles fine with them at the bottom. (They have to be at the bottom because those headers depend on ssl.h.) Change-Id: Iaa4139d2f157c7a3fd0ea609b78ff11d2edfc7b0 Reviewed-on: https://boringssl-review.googlesource.com/4289 Reviewed-by: Adam Langley <agl@google.com>
2015-04-09 04:46:10 +01:00
#ifndef OPENSSL_HEADER_SSL_H
#define OPENSSL_HEADER_SSL_H
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
#include <openssl/base.h>
#include <openssl/bio.h>
#include <openssl/buf.h>
#include <openssl/hmac.h>
#include <openssl/lhash.h>
#include <openssl/pem.h>
Fix ssl3.h / ssl.h circular dependency. Like tls1.h, ssl3.h is now just a bundle of protocol constants. Hopefully we can opaquify this struct in due time, but for now it's still public. Change-Id: I68366eb233702e149c92e21297f70f8a4a45f060 Reviewed-on: https://boringssl-review.googlesource.com/6300 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 00:45:00 +01:00
#include <openssl/ssl3.h>
Convert reference counts in ssl/ Convert reference counts in ssl/ to use |CRYPTO_refcount_t|. Change-Id: I5d60f641b0c89b1ddfe38bfbd9d7285c60377f4c Reviewed-on: https://boringssl-review.googlesource.com/4773 Reviewed-by: Adam Langley <agl@google.com>
2015-05-15 21:08:38 +01:00
#include <openssl/thread.h>
Move remaining functions out of tls1.h. Now tls1.h is just a pile of protocol constants with no more circular dependency problem. I've preserved SSL_get_servername's behavior where it's simultaneously a lookup of handshake state and local configuration. I've removed it from SSL_get_servername_type. It got the logic wrong anyway with the order of the s->session check. (Searching through code, neither is used on the client, but the SSL_get_servername one is easy.) Change-Id: I61bb8fb0858b07d76a7835bffa6dc793812fb027 Reviewed-on: https://boringssl-review.googlesource.com/6298 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-17 18:48:04 +01:00
#include <openssl/tls1.h>
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
#include <openssl/x509.h>
Move the sys/time.h #include out of extern C. We shouldn't be wrapping system headers. Change-Id: I77498f4ec869797050b276eb764d892f73782f9f Reviewed-on: https://boringssl-review.googlesource.com/4282 Reviewed-by: Adam Langley <agl@google.com>
2015-04-08 04:20:51 +01:00
#if !defined(OPENSSL_WINDOWS)
#include <sys/time.h>
#endif
Compatibility changes for wpa_supplicant and OpenSSH. OpenSSH, especially, does some terrible things that mean that it needs the EVP_CIPHER structure to be exposed ☹. Damian is open to a better API to replace this, but only if OpenSSL agree too. Either way, it won't be happening soon. Change-Id: I393b7a6af6694d4d2fe9ebcccd40286eff4029bd Reviewed-on: https://boringssl-review.googlesource.com/4330 Reviewed-by: Adam Langley <agl@google.com>
2015-04-13 22:34:17 +01:00
/* wpa_supplicant expects to get the version functions from ssl.h */
#include <openssl/crypto.h>
Remove OPENSSL_timeval. With DTLSv1_get_timeout de-ctrl-ified, the type checker complains about OPENSSL_timeval. Existing callers all use the real timeval. Now that OPENSSL_timeval is not included in any public structs, simply forward-declare timeval itself in ssl.h and pull in winsock2.h in internal headers. Change-Id: Ieaf110e141578488048c28cdadb14881301a2ce1 Reviewed-on: https://boringssl-review.googlesource.com/4682 Reviewed-by: Adam Langley <agl@google.com>
2015-05-08 18:29:45 +01:00
/* Forward-declare struct timeval. On Windows, it is defined in winsock2.h and
* Windows headers define too many macros to be included in public headers.
* However, only a forward declaration is needed. */
struct timeval;
Fix minor stylistic issues with ssl.h. Mostly stuff that doc.go was grumpy about. The main change is to move the version-specific headers to the bottom. Injecting them in the middle makes it seem as if the definitions above the #include and those below are somehow different, but it compiles fine with them at the bottom. (They have to be at the bottom because those headers depend on ssl.h.) Change-Id: Iaa4139d2f157c7a3fd0ea609b78ff11d2edfc7b0 Reviewed-on: https://boringssl-review.googlesource.com/4289 Reviewed-by: Adam Langley <agl@google.com>
2015-04-09 04:46:10 +01:00
#if defined(__cplusplus)
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
extern "C" {
#endif
Start generating documentation for ssl.h. There's this giant "Underdocumented functions" section in the middle, but it doesn't look too silly once the "Deprecated methods" section is merged in with the other deprecated functions. Change-Id: Ib97d88b0f915f60e9790264474a9e4aa3e115382 Reviewed-on: https://boringssl-review.googlesource.com/4291 Reviewed-by: Adam Langley <agl@google.com>
2015-04-09 04:55:15 +01:00
/* SSL implementation. */
Document everything in ssl_ciph.c, now ssl_cipher.c. Just about everything depends on SSL_CIPHER. Move it to the top as the first section in ssl.h. Match the header order and the source file order and document everything. Also make a couple of minor style guide tweaks. Change-Id: I6a810dbe79238278ac480e5ced1447055715a79f Reviewed-on: https://boringssl-review.googlesource.com/4290 Reviewed-by: Adam Langley <agl@google.com>
2015-04-08 07:36:59 +01:00
/* Initialization. */
/* SSL_library_init initializes the crypto and SSL libraries and returns one. */
OPENSSL_EXPORT int SSL_library_init(void);
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL contexts.
*
* |SSL_CTX| objects manage shared state and configuration between multiple TLS
* or DTLS connections. Whether the connections are TLS or DTLS is selected by
* an |SSL_METHOD| on creation.
*
* |SSL_CTX| are reference-counted and may be shared by connections across
* multiple threads. Once shared, functions which change the |SSL_CTX|'s
* configuration may not be used. */
Document some core SSL_CTX and SSL methods. Current thought is to organize this by: - Core SSL_CTX APIs (creating, destroying) - Core SSL APIs (creating destroying, maybe handshake, read, write as well) - APIs to configure SSL_CTX/SSL, roughly grouped by feature. Probably options and modes are the first two sections. SSL_TXT_* constants can be part of documenting cipher suite configuration. - APIs to query state from SSL_CTX/SSL, roughly grouped by feature. (Or perhaps these should be folded into the configuration sections?) The functions themselves aren't reordered or reorganized to match the eventual header order yet. Though I did do the s -> ssl rename on the ones I've touched. Also formally deprecate SSL_clear. It would be a core SSL API except it's horrible. Change-Id: Ia7e4fdcb7bad4e9ccdee8cf8c3136dc63aaaa772 Reviewed-on: https://boringssl-review.googlesource.com/4784 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 16:43:13 +01:00
/* TLS_method is the |SSL_METHOD| used for TLS (and SSLv3) connections. */
OPENSSL_EXPORT const SSL_METHOD *TLS_method(void);
/* DTLS_method is the |SSL_METHOD| used for DTLS connections. */
OPENSSL_EXPORT const SSL_METHOD *DTLS_method(void);
/* SSL_CTX_new returns a newly-allocated |SSL_CTX| with default settings or NULL
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
* on error. */
Document some core SSL_CTX and SSL methods. Current thought is to organize this by: - Core SSL_CTX APIs (creating, destroying) - Core SSL APIs (creating destroying, maybe handshake, read, write as well) - APIs to configure SSL_CTX/SSL, roughly grouped by feature. Probably options and modes are the first two sections. SSL_TXT_* constants can be part of documenting cipher suite configuration. - APIs to query state from SSL_CTX/SSL, roughly grouped by feature. (Or perhaps these should be folded into the configuration sections?) The functions themselves aren't reordered or reorganized to match the eventual header order yet. Though I did do the s -> ssl rename on the ones I've touched. Also formally deprecate SSL_clear. It would be a core SSL API except it's horrible. Change-Id: Ia7e4fdcb7bad4e9ccdee8cf8c3136dc63aaaa772 Reviewed-on: https://boringssl-review.googlesource.com/4784 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 16:43:13 +01:00
OPENSSL_EXPORT SSL_CTX *SSL_CTX_new(const SSL_METHOD *method);
/* SSL_CTX_free releases memory associated with |ctx|. */
OPENSSL_EXPORT void SSL_CTX_free(SSL_CTX *ctx);
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL connections.
*
* An |SSL| object represents a single TLS or DTLS connection. Although the
* shared |SSL_CTX| is thread-safe, an |SSL| is not thread-safe and may only be
* used on one thread at a time. */
Document some core SSL_CTX and SSL methods. Current thought is to organize this by: - Core SSL_CTX APIs (creating, destroying) - Core SSL APIs (creating destroying, maybe handshake, read, write as well) - APIs to configure SSL_CTX/SSL, roughly grouped by feature. Probably options and modes are the first two sections. SSL_TXT_* constants can be part of documenting cipher suite configuration. - APIs to query state from SSL_CTX/SSL, roughly grouped by feature. (Or perhaps these should be folded into the configuration sections?) The functions themselves aren't reordered or reorganized to match the eventual header order yet. Though I did do the s -> ssl rename on the ones I've touched. Also formally deprecate SSL_clear. It would be a core SSL API except it's horrible. Change-Id: Ia7e4fdcb7bad4e9ccdee8cf8c3136dc63aaaa772 Reviewed-on: https://boringssl-review.googlesource.com/4784 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 16:43:13 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_new returns a newly-allocated |SSL| using |ctx| or NULL on error. The new
* connection inherits settings from |ctx| at the time of creation. Settings may
* also be individually configured on the connection.
Document some core SSL_CTX and SSL methods. Current thought is to organize this by: - Core SSL_CTX APIs (creating, destroying) - Core SSL APIs (creating destroying, maybe handshake, read, write as well) - APIs to configure SSL_CTX/SSL, roughly grouped by feature. Probably options and modes are the first two sections. SSL_TXT_* constants can be part of documenting cipher suite configuration. - APIs to query state from SSL_CTX/SSL, roughly grouped by feature. (Or perhaps these should be folded into the configuration sections?) The functions themselves aren't reordered or reorganized to match the eventual header order yet. Though I did do the s -> ssl rename on the ones I've touched. Also formally deprecate SSL_clear. It would be a core SSL API except it's horrible. Change-Id: Ia7e4fdcb7bad4e9ccdee8cf8c3136dc63aaaa772 Reviewed-on: https://boringssl-review.googlesource.com/4784 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 16:43:13 +01:00
*
* On creation, an |SSL| is not configured to be either a client or server. Call
* |SSL_set_connect_state| or |SSL_set_accept_state| to set this. */
OPENSSL_EXPORT SSL *SSL_new(SSL_CTX *ctx);
/* SSL_free releases memory associated with |ssl|. */
OPENSSL_EXPORT void SSL_free(SSL *ssl);
/* SSL_set_connect_state configures |ssl| to be a client. */
OPENSSL_EXPORT void SSL_set_connect_state(SSL *ssl);
/* SSL_set_accept_state configures |ssl| to be a server. */
OPENSSL_EXPORT void SSL_set_accept_state(SSL *ssl);
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
/* SSL_is_server returns one if |ssl| is configured as a server and zero
* otherwise. */
OPENSSL_EXPORT int SSL_is_server(SSL *ssl);
Document a bunch of core functions in ssl.h. Unfortunately, these are also some of the worst APIs in the SSL stack. I've tried to capture all the things they expose to the caller. 0 vs -1 is intentionally left unexpanded on for now. Upstream's documentation says 0 means transport EOF, which is a nice idea but isn't true. (A lot of random functions return 0 on error and pass it up to the caller.) https://crbug.com/466303 tracks fixing that. SSL_set_bio is intentionally documented to NOT be usable when they're already configured. The function tries to behave in this case and even with additional cases when |rbio| and/or |wbio| are unchanged, but this is buggy. For instance, this will explode: SSL_set_bio(ssl, bio1, bio1); SSL_set_bio(ssl, bio2, SSL_get_wbio(ssl)); As will this, though it's less clear this is part of the API contract due to SSL taking ownership. SSL_set_bio(ssl, bio1, bio2); SSL_set_bio(ssl, bio2, bio1); It also tries to handle ssl->bbio already existing, but I doubt it quite works. Hopefully we can drop ssl->bbio eventually. (Why is this so complicated...) Change-Id: I5f9f3043915bffc67e2ebd282813e04afbe076e6 Reviewed-on: https://boringssl-review.googlesource.com/5872 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:27:05 +01:00
/* SSL_set_bio configures |ssl| to read from |rbio| and write to |wbio|. |ssl|
* takes ownership of the two |BIO|s. If |rbio| and |wbio| are the same, |ssl|
* only takes ownership of one reference.
*
Document DTLS-specific retransmit and MTU functions. The caller obligations for retransmit are messy, so I've peppered a few other functions with mentions of it. There's only three functions, so they're lumped in with the other core functions. They're irrelevant for TLS, but important for DTLS. Change-Id: Ifc995390952eef81370b58276915dcbe4fc7e3b5 Reviewed-on: https://boringssl-review.googlesource.com/6093 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 16:14:36 +01:00
* In DTLS, if |rbio| is blocking, it must handle
* |BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT| control requests to set read timeouts.
*
Document a bunch of core functions in ssl.h. Unfortunately, these are also some of the worst APIs in the SSL stack. I've tried to capture all the things they expose to the caller. 0 vs -1 is intentionally left unexpanded on for now. Upstream's documentation says 0 means transport EOF, which is a nice idea but isn't true. (A lot of random functions return 0 on error and pass it up to the caller.) https://crbug.com/466303 tracks fixing that. SSL_set_bio is intentionally documented to NOT be usable when they're already configured. The function tries to behave in this case and even with additional cases when |rbio| and/or |wbio| are unchanged, but this is buggy. For instance, this will explode: SSL_set_bio(ssl, bio1, bio1); SSL_set_bio(ssl, bio2, SSL_get_wbio(ssl)); As will this, though it's less clear this is part of the API contract due to SSL taking ownership. SSL_set_bio(ssl, bio1, bio2); SSL_set_bio(ssl, bio2, bio1); It also tries to handle ssl->bbio already existing, but I doubt it quite works. Hopefully we can drop ssl->bbio eventually. (Why is this so complicated...) Change-Id: I5f9f3043915bffc67e2ebd282813e04afbe076e6 Reviewed-on: https://boringssl-review.googlesource.com/5872 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:27:05 +01:00
* Calling this function on an already-configured |ssl| is deprecated. */
OPENSSL_EXPORT void SSL_set_bio(SSL *ssl, BIO *rbio, BIO *wbio);
/* SSL_get_rbio returns the |BIO| that |ssl| reads from. */
OPENSSL_EXPORT BIO *SSL_get_rbio(const SSL *ssl);
/* SSL_get_wbio returns the |BIO| that |ssl| writes to. */
OPENSSL_EXPORT BIO *SSL_get_wbio(const SSL *ssl);
Document fd-based SSL APIs. Also clean up the code slightly. Change-Id: I066a389242c46cdc7d41b1ae9537c4b7716c92a2 Reviewed-on: https://boringssl-review.googlesource.com/6302 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 02:11:33 +01:00
/* SSL_get_fd calls |SSL_get_rfd|. */
OPENSSL_EXPORT int SSL_get_fd(const SSL *ssl);
/* SSL_get_rfd returns the file descriptor that |ssl| is configured to read
* from. If |ssl|'s read |BIO| is not configured or doesn't wrap a file
* descriptor then it returns -1. */
OPENSSL_EXPORT int SSL_get_rfd(const SSL *ssl);
/* SSL_get_wfd returns the file descriptor that |ssl| is configured to write
* to. If |ssl|'s write |BIO| is not configured or doesn't wrap a file
* descriptor then it returns -1. */
OPENSSL_EXPORT int SSL_get_wfd(const SSL *ssl);
/* SSL_set_wfd configures |ssl| to read from and write to |fd|. It returns one
* on success and zero on allocation error. The caller retains ownership of
* |fd|. */
OPENSSL_EXPORT int SSL_set_fd(SSL *ssl, int fd);
/* SSL_set_rfd configures |ssl| to read from |fd|. It returns one on success and
* zero on allocation error. The caller retains ownership of |fd|. */
OPENSSL_EXPORT int SSL_set_rfd(SSL *ssl, int fd);
/* SSL_set_wfd configures |ssl| to write to |fd|. It returns one on success and
* zero on allocation error. The caller retains ownership of |fd|. */
OPENSSL_EXPORT int SSL_set_wfd(SSL *ssl, int fd);
Document a bunch of core functions in ssl.h. Unfortunately, these are also some of the worst APIs in the SSL stack. I've tried to capture all the things they expose to the caller. 0 vs -1 is intentionally left unexpanded on for now. Upstream's documentation says 0 means transport EOF, which is a nice idea but isn't true. (A lot of random functions return 0 on error and pass it up to the caller.) https://crbug.com/466303 tracks fixing that. SSL_set_bio is intentionally documented to NOT be usable when they're already configured. The function tries to behave in this case and even with additional cases when |rbio| and/or |wbio| are unchanged, but this is buggy. For instance, this will explode: SSL_set_bio(ssl, bio1, bio1); SSL_set_bio(ssl, bio2, SSL_get_wbio(ssl)); As will this, though it's less clear this is part of the API contract due to SSL taking ownership. SSL_set_bio(ssl, bio1, bio2); SSL_set_bio(ssl, bio2, bio1); It also tries to handle ssl->bbio already existing, but I doubt it quite works. Hopefully we can drop ssl->bbio eventually. (Why is this so complicated...) Change-Id: I5f9f3043915bffc67e2ebd282813e04afbe076e6 Reviewed-on: https://boringssl-review.googlesource.com/5872 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:27:05 +01:00
/* SSL_do_handshake continues the current handshake. If there is none or the
* handshake has completed or False Started, it returns one. Otherwise, it
* returns <= 0. The caller should pass the value into |SSL_get_error| to
* determine how to proceed.
*
Document DTLS-specific retransmit and MTU functions. The caller obligations for retransmit are messy, so I've peppered a few other functions with mentions of it. There's only three functions, so they're lumped in with the other core functions. They're irrelevant for TLS, but important for DTLS. Change-Id: Ifc995390952eef81370b58276915dcbe4fc7e3b5 Reviewed-on: https://boringssl-review.googlesource.com/6093 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 16:14:36 +01:00
* In DTLS, if the read |BIO| is non-blocking, the caller must drive
* retransmissions. Whenever |SSL_get_error| signals |SSL_ERROR_WANT_READ|, use
* |DTLSv1_get_timeout| to determine the current timeout. If it expires before
* the next retry, call |DTLSv1_handle_timeout|. Note that DTLS handshake
* retransmissions use fresh sequence numbers, so it is not sufficient to replay
* packets at the transport.
*
Document a bunch of core functions in ssl.h. Unfortunately, these are also some of the worst APIs in the SSL stack. I've tried to capture all the things they expose to the caller. 0 vs -1 is intentionally left unexpanded on for now. Upstream's documentation says 0 means transport EOF, which is a nice idea but isn't true. (A lot of random functions return 0 on error and pass it up to the caller.) https://crbug.com/466303 tracks fixing that. SSL_set_bio is intentionally documented to NOT be usable when they're already configured. The function tries to behave in this case and even with additional cases when |rbio| and/or |wbio| are unchanged, but this is buggy. For instance, this will explode: SSL_set_bio(ssl, bio1, bio1); SSL_set_bio(ssl, bio2, SSL_get_wbio(ssl)); As will this, though it's less clear this is part of the API contract due to SSL taking ownership. SSL_set_bio(ssl, bio1, bio2); SSL_set_bio(ssl, bio2, bio1); It also tries to handle ssl->bbio already existing, but I doubt it quite works. Hopefully we can drop ssl->bbio eventually. (Why is this so complicated...) Change-Id: I5f9f3043915bffc67e2ebd282813e04afbe076e6 Reviewed-on: https://boringssl-review.googlesource.com/5872 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:27:05 +01:00
* TODO(davidben): Ensure 0 is only returned on transport EOF.
* https://crbug.com/466303. */
OPENSSL_EXPORT int SSL_do_handshake(SSL *ssl);
/* SSL_connect configures |ssl| as a client, if unconfigured, and calls
* |SSL_do_handshake|. */
OPENSSL_EXPORT int SSL_connect(SSL *ssl);
/* SSL_accept configures |ssl| as a server, if unconfigured, and calls
* |SSL_do_handshake|. */
OPENSSL_EXPORT int SSL_accept(SSL *ssl);
/* SSL_read reads up to |num| bytes from |ssl| into |buf|. It implicitly runs
* any pending handshakes, including renegotiations when enabled. On success, it
* returns the number of bytes read. Otherwise, it returns <= 0. The caller
* should pass the value into |SSL_get_error| to determine how to proceed.
*
* TODO(davidben): Ensure 0 is only returned on transport EOF.
* https://crbug.com/466303. */
OPENSSL_EXPORT int SSL_read(SSL *ssl, void *buf, int num);
/* SSL_peek behaves like |SSL_read| but does not consume any bytes returned. */
OPENSSL_EXPORT int SSL_peek(SSL *ssl, void *buf, int num);
Document a few more miscellaneous things. Change-Id: Ib4829bf9344341e3d4fe90c7cea66e217366fe97 Reviewed-on: https://boringssl-review.googlesource.com/6091 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 15:44:30 +01:00
/* SSL_pending returns the number of bytes available in |ssl|. It does not read
* from the transport. */
OPENSSL_EXPORT int SSL_pending(const SSL *ssl);
Document a bunch of core functions in ssl.h. Unfortunately, these are also some of the worst APIs in the SSL stack. I've tried to capture all the things they expose to the caller. 0 vs -1 is intentionally left unexpanded on for now. Upstream's documentation says 0 means transport EOF, which is a nice idea but isn't true. (A lot of random functions return 0 on error and pass it up to the caller.) https://crbug.com/466303 tracks fixing that. SSL_set_bio is intentionally documented to NOT be usable when they're already configured. The function tries to behave in this case and even with additional cases when |rbio| and/or |wbio| are unchanged, but this is buggy. For instance, this will explode: SSL_set_bio(ssl, bio1, bio1); SSL_set_bio(ssl, bio2, SSL_get_wbio(ssl)); As will this, though it's less clear this is part of the API contract due to SSL taking ownership. SSL_set_bio(ssl, bio1, bio2); SSL_set_bio(ssl, bio2, bio1); It also tries to handle ssl->bbio already existing, but I doubt it quite works. Hopefully we can drop ssl->bbio eventually. (Why is this so complicated...) Change-Id: I5f9f3043915bffc67e2ebd282813e04afbe076e6 Reviewed-on: https://boringssl-review.googlesource.com/5872 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:27:05 +01:00
/* SSL_write writes up to |num| bytes from |buf| into |ssl|. It implicitly runs
* any pending handshakes, including renegotiations when enabled. On success, it
* returns the number of bytes read. Otherwise, it returns <= 0. The caller
* should pass the value into |SSL_get_error| to determine how to proceed.
*
* A non-blocking |SSL_write| differs from non-blocking |write| in that a failed
* |SSL_write| still commits to the data passed in. When retrying, the caller
* must supply the original write buffer (or a larger one containing the
* original as a prefix). By default, retries will fail if they also do not
* reuse the same |buf| pointer. This may be relaxed with
* |SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER|, but the buffer contents still must be
* unchanged.
*
* By default, |SSL_write| will not return success until all |num| bytes are
* written. This may be relaxed with |SSL_MODE_ENABLE_PARTIAL_WRITE|. It allows
* |SSL_write| to complete with a partial result when only part of the input was
* written in a single record.
*
* TODO(davidben): Ensure 0 is only returned on transport EOF.
* https://crbug.com/466303. */
OPENSSL_EXPORT int SSL_write(SSL *ssl, const void *buf, int num);
/* SSL_shutdown shuts down |ssl|. On success, it completes in two stages. First,
* it returns 0 if |ssl| completed uni-directional shutdown; close_notify has
* been sent, but the peer's close_notify has not been received. Most callers
* may stop at this point. For bi-directional shutdown, call |SSL_shutdown|
* again. It returns 1 if close_notify has been both sent and received.
*
* If the peer's close_notify arrived first, the first stage is skipped.
* |SSL_shutdown| will return 1 once close_notify is sent and skip 0. Callers
* only interested in uni-directional shutdown must therefore allow for the
* first stage returning either 0 or 1.
*
* |SSL_shutdown| returns -1 on failure. The caller should pass the return value
* into |SSL_get_error| to determine how to proceed. If the underlying |BIO| is
* non-blocking, both stages may require retry.
*
* |SSL_shutdown| must be called to retain |ssl|'s session in the session
* cache. Use |SSL_CTX_set_quiet_shutdown| to configure |SSL_shutdown| to
* neither send nor wait for close_notify but still retain the session.
*
* TODO(davidben): Is there any point in the session cache interaction? Remove
* it? */
OPENSSL_EXPORT int SSL_shutdown(SSL *ssl);
Document a few more miscellaneous things. Change-Id: Ib4829bf9344341e3d4fe90c7cea66e217366fe97 Reviewed-on: https://boringssl-review.googlesource.com/6091 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 15:44:30 +01:00
/* SSL_CTX_set_quiet_shutdown sets quiet shutdown on |ctx| to |mode|. If
* enabled, |SSL_shutdown| will not send a close_notify alert or wait for one
* from the peer. It will instead synchronously return one. */
OPENSSL_EXPORT void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode);
/* SSL_CTX_get_quiet_shutdown returns whether quiet shutdown is enabled for
* |ctx|. */
OPENSSL_EXPORT int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx);
/* SSL_set_quiet_shutdown sets quiet shutdown on |ssl| to |mode|. If enabled,
* |SSL_shutdown| will not send a close_notify alert or wait for one from the
* peer. It will instead synchronously return one. */
OPENSSL_EXPORT void SSL_set_quiet_shutdown(SSL *ssl, int mode);
/* SSL_get_quiet_shutdown returns whether quiet shutdown is enabled for
* |ssl|. */
OPENSSL_EXPORT int SSL_get_quiet_shutdown(const SSL *ssl);
Document a bunch of core functions in ssl.h. Unfortunately, these are also some of the worst APIs in the SSL stack. I've tried to capture all the things they expose to the caller. 0 vs -1 is intentionally left unexpanded on for now. Upstream's documentation says 0 means transport EOF, which is a nice idea but isn't true. (A lot of random functions return 0 on error and pass it up to the caller.) https://crbug.com/466303 tracks fixing that. SSL_set_bio is intentionally documented to NOT be usable when they're already configured. The function tries to behave in this case and even with additional cases when |rbio| and/or |wbio| are unchanged, but this is buggy. For instance, this will explode: SSL_set_bio(ssl, bio1, bio1); SSL_set_bio(ssl, bio2, SSL_get_wbio(ssl)); As will this, though it's less clear this is part of the API contract due to SSL taking ownership. SSL_set_bio(ssl, bio1, bio2); SSL_set_bio(ssl, bio2, bio1); It also tries to handle ssl->bbio already existing, but I doubt it quite works. Hopefully we can drop ssl->bbio eventually. (Why is this so complicated...) Change-Id: I5f9f3043915bffc67e2ebd282813e04afbe076e6 Reviewed-on: https://boringssl-review.googlesource.com/5872 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:27:05 +01:00
/* SSL_get_error returns a |SSL_ERROR_*| value for the most recent operation on
* |ssl|. It should be called after an operation failed to determine. */
OPENSSL_EXPORT int SSL_get_error(const SSL *ssl, int ret_code);
/* SSL_ERROR_NONE indicates the operation succeeded. */
#define SSL_ERROR_NONE 0
/* SSL_ERROR_SSL indicates the operation failed within the library. The caller
* may inspect the error queue for more information. */
#define SSL_ERROR_SSL 1
/* SSL_ERROR_WANT_READ indicates the operation failed attempting to read from
* the transport. The caller may retry the operation when the transport is ready
Document DTLS-specific retransmit and MTU functions. The caller obligations for retransmit are messy, so I've peppered a few other functions with mentions of it. There's only three functions, so they're lumped in with the other core functions. They're irrelevant for TLS, but important for DTLS. Change-Id: Ifc995390952eef81370b58276915dcbe4fc7e3b5 Reviewed-on: https://boringssl-review.googlesource.com/6093 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 16:14:36 +01:00
* for reading.
*
* If signaled by a DTLS handshake, the caller must also call
* |DTLSv1_get_timeout| and |DTLSv1_handle_timeout| as appropriate. See
* |SSL_do_handshake|. */
Document a bunch of core functions in ssl.h. Unfortunately, these are also some of the worst APIs in the SSL stack. I've tried to capture all the things they expose to the caller. 0 vs -1 is intentionally left unexpanded on for now. Upstream's documentation says 0 means transport EOF, which is a nice idea but isn't true. (A lot of random functions return 0 on error and pass it up to the caller.) https://crbug.com/466303 tracks fixing that. SSL_set_bio is intentionally documented to NOT be usable when they're already configured. The function tries to behave in this case and even with additional cases when |rbio| and/or |wbio| are unchanged, but this is buggy. For instance, this will explode: SSL_set_bio(ssl, bio1, bio1); SSL_set_bio(ssl, bio2, SSL_get_wbio(ssl)); As will this, though it's less clear this is part of the API contract due to SSL taking ownership. SSL_set_bio(ssl, bio1, bio2); SSL_set_bio(ssl, bio2, bio1); It also tries to handle ssl->bbio already existing, but I doubt it quite works. Hopefully we can drop ssl->bbio eventually. (Why is this so complicated...) Change-Id: I5f9f3043915bffc67e2ebd282813e04afbe076e6 Reviewed-on: https://boringssl-review.googlesource.com/5872 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:27:05 +01:00
#define SSL_ERROR_WANT_READ 2
/* SSL_ERROR_WANT_READ indicates the operation failed attempting to write to
* the transport. The caller may retry the operation when the transport is ready
* for writing. */
#define SSL_ERROR_WANT_WRITE 3
/* SSL_ERROR_WANT_X509_LOOKUP indicates the operation failed in calling the
* |cert_cb| or |client_cert_cb|. The caller may retry the operation when the
* callback is ready to return a certificate or one has been configured
* externally.
*
* See also |SSL_CTX_set_cert_cb| and |SSL_CTX_set_client_cert_cb|. */
#define SSL_ERROR_WANT_X509_LOOKUP 4
/* SSL_ERROR_WANT_SYSCALL indicates the operation failed externally to the
* library. The caller should consult the system-specific error mechanism. This
* is typically |errno| but may be something custom if using a custom |BIO|. It
* may also be signaled if the transport returned EOF, in which case the
* operation's return value will be zero. */
#define SSL_ERROR_SYSCALL 5
/* SSL_ERROR_ZERO_RETURN indicates the operation failed because the connection
* was cleanly shut down with a close_notify alert. */
#define SSL_ERROR_ZERO_RETURN 6
/* SSL_ERROR_WANT_CONNECT indicates the operation failed attempting to connect
* the transport (the |BIO| signaled |BIO_RR_CONNECT|). The caller may retry the
* operation when the transport is ready. */
#define SSL_ERROR_WANT_CONNECT 7
/* SSL_ERROR_WANT_ACCEPT indicates the operation failed attempting to accept a
* connection from the transport (the |BIO| signaled |BIO_RR_ACCEPT|). The
* caller may retry the operation when the transport is ready.
*
* TODO(davidben): Remove this. It's used by accept BIOs which are bizarre. */
#define SSL_ERROR_WANT_ACCEPT 8
/* SSL_ERROR_WANT_CHANNEL_ID_LOOKUP indicates the operation failed looking up
* the Channel ID key. The caller may retry the operation when |channel_id_cb|
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
* is ready to return a key or one has been configured with
* |SSL_set1_tls_channel_id|.
Document a bunch of core functions in ssl.h. Unfortunately, these are also some of the worst APIs in the SSL stack. I've tried to capture all the things they expose to the caller. 0 vs -1 is intentionally left unexpanded on for now. Upstream's documentation says 0 means transport EOF, which is a nice idea but isn't true. (A lot of random functions return 0 on error and pass it up to the caller.) https://crbug.com/466303 tracks fixing that. SSL_set_bio is intentionally documented to NOT be usable when they're already configured. The function tries to behave in this case and even with additional cases when |rbio| and/or |wbio| are unchanged, but this is buggy. For instance, this will explode: SSL_set_bio(ssl, bio1, bio1); SSL_set_bio(ssl, bio2, SSL_get_wbio(ssl)); As will this, though it's less clear this is part of the API contract due to SSL taking ownership. SSL_set_bio(ssl, bio1, bio2); SSL_set_bio(ssl, bio2, bio1); It also tries to handle ssl->bbio already existing, but I doubt it quite works. Hopefully we can drop ssl->bbio eventually. (Why is this so complicated...) Change-Id: I5f9f3043915bffc67e2ebd282813e04afbe076e6 Reviewed-on: https://boringssl-review.googlesource.com/5872 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:27:05 +01:00
*
* See also |SSL_CTX_set_channel_id_cb|. */
#define SSL_ERROR_WANT_CHANNEL_ID_LOOKUP 9
/* SSL_ERROR_PENDING_SESSION indicates the operation failed because the session
* lookup callback indicated the session was unavailable. The caller may retry
* the operation when lookup has completed.
*
Document session cache functions. Also switch to the new variable names (SSL_CTX *ctx, SSL *ssl, SSL_SESSION *session) for all documented functions. Change-Id: I15e15a703b96af1727601108223c7ce3b0691f1d Reviewed-on: https://boringssl-review.googlesource.com/5882 Reviewed-by: Adam Langley <agl@google.com>
2015-09-14 06:40:10 +01:00
* See also |SSL_CTX_sess_set_get_cb| and |SSL_magic_pending_session_ptr|. */
Document a bunch of core functions in ssl.h. Unfortunately, these are also some of the worst APIs in the SSL stack. I've tried to capture all the things they expose to the caller. 0 vs -1 is intentionally left unexpanded on for now. Upstream's documentation says 0 means transport EOF, which is a nice idea but isn't true. (A lot of random functions return 0 on error and pass it up to the caller.) https://crbug.com/466303 tracks fixing that. SSL_set_bio is intentionally documented to NOT be usable when they're already configured. The function tries to behave in this case and even with additional cases when |rbio| and/or |wbio| are unchanged, but this is buggy. For instance, this will explode: SSL_set_bio(ssl, bio1, bio1); SSL_set_bio(ssl, bio2, SSL_get_wbio(ssl)); As will this, though it's less clear this is part of the API contract due to SSL taking ownership. SSL_set_bio(ssl, bio1, bio2); SSL_set_bio(ssl, bio2, bio1); It also tries to handle ssl->bbio already existing, but I doubt it quite works. Hopefully we can drop ssl->bbio eventually. (Why is this so complicated...) Change-Id: I5f9f3043915bffc67e2ebd282813e04afbe076e6 Reviewed-on: https://boringssl-review.googlesource.com/5872 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:27:05 +01:00
#define SSL_ERROR_PENDING_SESSION 11
/* SSL_ERROR_PENDING_CERTIFICATE indicates the operation failed because the
* early callback indicated certificate lookup was incomplete. The caller may
* retry the operation when lookup has completed. Note: when the operation is
* retried, the early callback will not be called a second time.
*
Document early callback functions. Also added a SSL_CTX_set_select_certificate_cb setter for select_certificate_cb so code needn't access SSL_CTX directly. Plus it serves as a convenient anchor for the documentation. Change-Id: I23755b910e1d77d4bea7bb9103961181dd3c5efe Reviewed-on: https://boringssl-review.googlesource.com/6291 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-17 17:28:18 +01:00
* See also |SSL_CTX_set_select_certificate_cb|. */
Document a bunch of core functions in ssl.h. Unfortunately, these are also some of the worst APIs in the SSL stack. I've tried to capture all the things they expose to the caller. 0 vs -1 is intentionally left unexpanded on for now. Upstream's documentation says 0 means transport EOF, which is a nice idea but isn't true. (A lot of random functions return 0 on error and pass it up to the caller.) https://crbug.com/466303 tracks fixing that. SSL_set_bio is intentionally documented to NOT be usable when they're already configured. The function tries to behave in this case and even with additional cases when |rbio| and/or |wbio| are unchanged, but this is buggy. For instance, this will explode: SSL_set_bio(ssl, bio1, bio1); SSL_set_bio(ssl, bio2, SSL_get_wbio(ssl)); As will this, though it's less clear this is part of the API contract due to SSL taking ownership. SSL_set_bio(ssl, bio1, bio2); SSL_set_bio(ssl, bio2, bio1); It also tries to handle ssl->bbio already existing, but I doubt it quite works. Hopefully we can drop ssl->bbio eventually. (Why is this so complicated...) Change-Id: I5f9f3043915bffc67e2ebd282813e04afbe076e6 Reviewed-on: https://boringssl-review.googlesource.com/5872 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:27:05 +01:00
#define SSL_ERROR_PENDING_CERTIFICATE 12
/* SSL_ERROR_WANT_PRIVATE_KEY_OPERATION indicates the operation failed because
* a private key operation was unfinished. The caller may retry the operation
* when the private key operation is complete.
*
* See also |SSL_set_private_key_method|. */
#define SSL_ERROR_WANT_PRIVATE_KEY_OPERATION 13
Document DTLS-specific retransmit and MTU functions. The caller obligations for retransmit are messy, so I've peppered a few other functions with mentions of it. There's only three functions, so they're lumped in with the other core functions. They're irrelevant for TLS, but important for DTLS. Change-Id: Ifc995390952eef81370b58276915dcbe4fc7e3b5 Reviewed-on: https://boringssl-review.googlesource.com/6093 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 16:14:36 +01:00
/* SSL_set_mtu sets the |ssl|'s MTU in DTLS to |mtu|. It returns one on success
* and zero on failure. */
OPENSSL_EXPORT int SSL_set_mtu(SSL *ssl, unsigned mtu);
/* DTLSv1_get_timeout queries the next DTLS handshake timeout. If there is a
* timeout in progress, it sets |*out| to the time remaining and returns one.
* Otherwise, it returns zero.
*
* When the timeout expires, call |DTLSv1_handle_timeout| to handle the
* retransmit behavior.
*
* NOTE: This function must be queried again whenever the handshake state
* machine changes, including when |DTLSv1_handle_timeout| is called. */
OPENSSL_EXPORT int DTLSv1_get_timeout(const SSL *ssl, struct timeval *out);
/* DTLSv1_handle_timeout is called when a DTLS handshake timeout expires. If no
* timeout had expired, it returns 0. Otherwise, it retransmits the previous
* flight of handshake messages and returns 1. If too many timeouts had expired
* without progress or an error occurs, it returns -1.
*
* NOTE: The caller's external timer should be compatible with the one |ssl|
* queries within some fudge factor. Otherwise, the call will be a no-op, but
* |DTLSv1_get_timeout| will return an updated timeout.
*
* WARNING: This function breaks the usual return value convention. */
OPENSSL_EXPORT int DTLSv1_handle_timeout(SSL *ssl);
Document some core SSL_CTX and SSL methods. Current thought is to organize this by: - Core SSL_CTX APIs (creating, destroying) - Core SSL APIs (creating destroying, maybe handshake, read, write as well) - APIs to configure SSL_CTX/SSL, roughly grouped by feature. Probably options and modes are the first two sections. SSL_TXT_* constants can be part of documenting cipher suite configuration. - APIs to query state from SSL_CTX/SSL, roughly grouped by feature. (Or perhaps these should be folded into the configuration sections?) The functions themselves aren't reordered or reorganized to match the eventual header order yet. Though I did do the s -> ssl rename on the ones I've touched. Also formally deprecate SSL_clear. It would be a core SSL API except it's horrible. Change-Id: Ia7e4fdcb7bad4e9ccdee8cf8c3136dc63aaaa772 Reviewed-on: https://boringssl-review.googlesource.com/4784 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 16:43:13 +01:00
Pull version, option, and mode APIs into their own sections. Change-Id: Ic243f09f80b90f3bf816d5491501b40b77018999 Reviewed-on: https://boringssl-review.googlesource.com/4791 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 20:31:07 +01:00
/* Protocol versions. */
Factor out the buffering and low-level record code. This begins decoupling the transport from the SSL state machine. The buffering logic is hidden behind an opaque API. Fields like ssl->packet and ssl->packet_length are gone. ssl3_get_record and dtls1_get_record now call low-level tls_open_record and dtls_open_record functions that unpack a single record independent of who owns the buffer. Both may be called in-place. This removes ssl->rstate which was redundant with the buffer length. Future work will push the buffer up the stack until it is above the handshake. Then we can expose SSL_open and SSL_seal APIs which act like *_open_record but return a slightly larger enum due to other events being possible. Likewise the handshake state machine will be detached from its buffer. The existing SSL_read, SSL_write, etc., APIs will be implemented on top of SSL_open, etc., combined with ssl_read_buffer_* and ssl_write_buffer_*. (Which is why ssl_read_buffer_extend still tries to abstract between TLS's and DTLS's fairly different needs.) The new buffering logic does not support read-ahead (removed previously) since it lacks a memmove on ssl_read_buffer_discard for TLS, but this could be added if desired. The old buffering logic wasn't quite right anyway; it tried to avoid the memmove in some cases and could get stuck too far into the buffer and not accept records. (The only time the memmove is optional is in DTLS or if enough of the record header is available to know that the entire next record would fit in the buffer.) The new logic also now actually decrypts the ciphertext in-place again, rather than almost in-place when there's an explicit nonce/IV. (That accidentally switched in https://boringssl-review.googlesource.com/#/c/4792/; see 3d59e04bce96474099ba76786a2337e99ae14505.) BUG=468889 Change-Id: I403c1626253c46897f47c7ae93aeab1064b767b2 Reviewed-on: https://boringssl-review.googlesource.com/5715 Reviewed-by: Adam Langley <agl@google.com>
2015-07-29 02:34:45 +01:00
#define DTLS1_VERSION_MAJOR 0xfe
Pull version, option, and mode APIs into their own sections. Change-Id: Ic243f09f80b90f3bf816d5491501b40b77018999 Reviewed-on: https://boringssl-review.googlesource.com/4791 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 20:31:07 +01:00
#define SSL3_VERSION_MAJOR 0x03
#define SSL3_VERSION 0x0300
#define TLS1_VERSION 0x0301
#define TLS1_1_VERSION 0x0302
#define TLS1_2_VERSION 0x0303
#define DTLS1_VERSION 0xfeff
#define DTLS1_2_VERSION 0xfefd
/* SSL_CTX_set_min_version sets the minimum protocol version for |ctx| to
* |version|. */
OPENSSL_EXPORT void SSL_CTX_set_min_version(SSL_CTX *ctx, uint16_t version);
/* SSL_CTX_set_max_version sets the maximum protocol version for |ctx| to
* |version|. */
OPENSSL_EXPORT void SSL_CTX_set_max_version(SSL_CTX *ctx, uint16_t version);
/* SSL_set_min_version sets the minimum protocol version for |ssl| to
* |version|. */
OPENSSL_EXPORT void SSL_set_min_version(SSL *ssl, uint16_t version);
/* SSL_set_max_version sets the maximum protocol version for |ssl| to
* |version|. */
OPENSSL_EXPORT void SSL_set_max_version(SSL *ssl, uint16_t version);
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
/* SSL_version returns the TLS or DTLS protocol version used by |ssl|, which is
* one of the |*_VERSION| values. (E.g. |TLS1_2_VERSION|.) Before the version
* is negotiated, the result is undefined. */
OPENSSL_EXPORT int SSL_version(const SSL *ssl);
Pull version, option, and mode APIs into their own sections. Change-Id: Ic243f09f80b90f3bf816d5491501b40b77018999 Reviewed-on: https://boringssl-review.googlesource.com/4791 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 20:31:07 +01:00
/* Options.
*
* Options configure protocol behavior. */
/* SSL_OP_LEGACY_SERVER_CONNECT allows initial connections to servers that don't
* support the renegotiation_info extension (RFC 5746). It is on by default. */
#define SSL_OP_LEGACY_SERVER_CONNECT 0x00000004L
/* SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER allows for record sizes |SSL3_RT_MAX_EXTRA|
* bytes above the maximum record size. */
#define SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER 0x00000020L
/* SSL_OP_TLS_D5_BUG accepts an RSAClientKeyExchange in TLS encoded as in SSL3
* (i.e. without a length prefix). */
#define SSL_OP_TLS_D5_BUG 0x00000100L
/* SSL_OP_ALL enables the above bug workarounds that are enabled by many
* consumers.
* TODO(davidben): Determine which of the remaining may be removed now. */
#define SSL_OP_ALL 0x00000BFFL
/* SSL_OP_NO_QUERY_MTU, in DTLS, disables querying the MTU from the underlying
* |BIO|. Instead, the MTU is configured with |SSL_set_mtu|. */
#define SSL_OP_NO_QUERY_MTU 0x00001000L
Document session cache functions. Also switch to the new variable names (SSL_CTX *ctx, SSL *ssl, SSL_SESSION *session) for all documented functions. Change-Id: I15e15a703b96af1727601108223c7ce3b0691f1d Reviewed-on: https://boringssl-review.googlesource.com/5882 Reviewed-by: Adam Langley <agl@google.com>
2015-09-14 06:40:10 +01:00
/* SSL_OP_NO_TICKET disables session ticket support (RFC 5077). */
Pull version, option, and mode APIs into their own sections. Change-Id: Ic243f09f80b90f3bf816d5491501b40b77018999 Reviewed-on: https://boringssl-review.googlesource.com/4791 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 20:31:07 +01:00
#define SSL_OP_NO_TICKET 0x00004000L
/* SSL_OP_CIPHER_SERVER_PREFERENCE configures servers to select ciphers and
* ECDHE curves according to the server's preferences instead of the
* client's. */
#define SSL_OP_CIPHER_SERVER_PREFERENCE 0x00400000L
/* SSL_CTX_set_options enables all options set in |options| (which should be one
* or more of the |SSL_OP_*| values, ORed together) in |ctx|. It returns a
* bitmask representing the resulting enabled options. */
OPENSSL_EXPORT uint32_t SSL_CTX_set_options(SSL_CTX *ctx, uint32_t options);
/* SSL_CTX_clear_options disables all options set in |options| (which should be
* one or more of the |SSL_OP_*| values, ORed together) in |ctx|. It returns a
* bitmask representing the resulting enabled options. */
OPENSSL_EXPORT uint32_t SSL_CTX_clear_options(SSL_CTX *ctx, uint32_t options);
/* SSL_CTX_get_options returns a bitmask of |SSL_OP_*| values that represent all
* the options enabled for |ctx|. */
OPENSSL_EXPORT uint32_t SSL_CTX_get_options(const SSL_CTX *ctx);
/* SSL_set_options enables all options set in |options| (which should be one or
* more of the |SSL_OP_*| values, ORed together) in |ssl|. It returns a bitmask
* representing the resulting enabled options. */
OPENSSL_EXPORT uint32_t SSL_set_options(SSL *ssl, uint32_t options);
/* SSL_clear_options disables all options set in |options| (which should be one
* or more of the |SSL_OP_*| values, ORed together) in |ssl|. It returns a
* bitmask representing the resulting enabled options. */
OPENSSL_EXPORT uint32_t SSL_clear_options(SSL *ssl, uint32_t options);
/* SSL_get_options returns a bitmask of |SSL_OP_*| values that represent all the
* options enabled for |ssl|. */
OPENSSL_EXPORT uint32_t SSL_get_options(const SSL *ssl);
/* Modes.
*
* Modes configure API behavior. */
/* SSL_MODE_ENABLE_PARTIAL_WRITE allows |SSL_write| to complete with a partial
* result when the only part of the input was written in a single record. */
#define SSL_MODE_ENABLE_PARTIAL_WRITE 0x00000001L
/* SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER allows retrying an incomplete |SSL_write|
* with a different buffer. However, |SSL_write| still assumes the buffer
* contents are unchanged. This is not the default to avoid the misconception
* that non-blocking |SSL_write| behaves like non-blocking |write|. */
#define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER 0x00000002L
/* SSL_MODE_NO_AUTO_CHAIN disables automatically building a certificate chain
* before sending certificates to the peer.
* TODO(davidben): Remove this behavior. https://crbug.com/486295. */
#define SSL_MODE_NO_AUTO_CHAIN 0x00000008L
/* SSL_MODE_ENABLE_FALSE_START allows clients to send application data before
* receipt of CCS and Finished. This mode enables full-handshakes to 'complete'
* in one RTT. See draft-bmoeller-tls-falsestart-01. */
#define SSL_MODE_ENABLE_FALSE_START 0x00000080L
/* SSL_MODE_CBC_RECORD_SPLITTING causes multi-byte CBC records in SSL 3.0 and
* TLS 1.0 to be split in two: the first record will contain a single byte and
* the second will contain the remainder. This effectively randomises the IV and
* prevents BEAST attacks. */
#define SSL_MODE_CBC_RECORD_SPLITTING 0x00000100L
/* SSL_MODE_NO_SESSION_CREATION will cause any attempts to create a session to
* fail with SSL_R_SESSION_MAY_NOT_BE_CREATED. This can be used to enforce that
* session resumption is used for a given SSL*. */
#define SSL_MODE_NO_SESSION_CREATION 0x00000200L
/* SSL_MODE_SEND_FALLBACK_SCSV sends TLS_FALLBACK_SCSV in the ClientHello.
* To be set only by applications that reconnect with a downgraded protocol
FALLBACK_SCSV is an RFC now. Update references. Change-Id: I56af31529cf6bfd00d3f0bb9b6281645ed134c5c Reviewed-on: https://boringssl-review.googlesource.com/5555 Reviewed-by: Adam Langley <agl@google.com>
2015-07-25 20:08:18 +01:00
* version; see RFC 7507 for details.
Pull version, option, and mode APIs into their own sections. Change-Id: Ic243f09f80b90f3bf816d5491501b40b77018999 Reviewed-on: https://boringssl-review.googlesource.com/4791 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 20:31:07 +01:00
*
* DO NOT ENABLE THIS if your application attempts a normal handshake. Only use
FALLBACK_SCSV is an RFC now. Update references. Change-Id: I56af31529cf6bfd00d3f0bb9b6281645ed134c5c Reviewed-on: https://boringssl-review.googlesource.com/5555 Reviewed-by: Adam Langley <agl@google.com>
2015-07-25 20:08:18 +01:00
* this in explicit fallback retries, following the guidance in RFC 7507. */
Pull version, option, and mode APIs into their own sections. Change-Id: Ic243f09f80b90f3bf816d5491501b40b77018999 Reviewed-on: https://boringssl-review.googlesource.com/4791 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 20:31:07 +01:00
#define SSL_MODE_SEND_FALLBACK_SCSV 0x00000400L
/* SSL_CTX_set_mode enables all modes set in |mode| (which should be one or more
* of the |SSL_MODE_*| values, ORed together) in |ctx|. It returns a bitmask
* representing the resulting enabled modes. */
OPENSSL_EXPORT uint32_t SSL_CTX_set_mode(SSL_CTX *ctx, uint32_t mode);
/* SSL_CTX_clear_mode disables all modes set in |mode| (which should be one or
* more of the |SSL_MODE_*| values, ORed together) in |ctx|. It returns a
* bitmask representing the resulting enabled modes. */
OPENSSL_EXPORT uint32_t SSL_CTX_clear_mode(SSL_CTX *ctx, uint32_t mode);
/* SSL_CTX_get_mode returns a bitmask of |SSL_MODE_*| values that represent all
* the modes enabled for |ssl|. */
OPENSSL_EXPORT uint32_t SSL_CTX_get_mode(const SSL_CTX *ctx);
/* SSL_set_mode enables all modes set in |mode| (which should be one or more of
* the |SSL_MODE_*| values, ORed together) in |ssl|. It returns a bitmask
* representing the resulting enabled modes. */
OPENSSL_EXPORT uint32_t SSL_set_mode(SSL *ssl, uint32_t mode);
/* SSL_clear_mode disables all modes set in |mode| (which should be one or more
* of the |SSL_MODE_*| values, ORed together) in |ssl|. It returns a bitmask
* representing the resulting enabled modes. */
OPENSSL_EXPORT uint32_t SSL_clear_mode(SSL *ssl, uint32_t mode);
/* SSL_get_mode returns a bitmask of |SSL_MODE_*| values that represent all the
* modes enabled for |ssl|. */
OPENSSL_EXPORT uint32_t SSL_get_mode(const SSL *ssl);
Implement asynchronous private key operations for client auth. This adds a new API, SSL_set_private_key_method, which allows the consumer to customize private key operations. For simplicity, it is incompatible with the multiple slots feature (which will hopefully go away) but does not, for now, break it. The new method is only routed up for the client for now. The server will require a decrypt hook as well for the plain RSA key exchange. BUG=347404 Change-Id: I35d69095c29134c34c2af88c613ad557d6957614 Reviewed-on: https://boringssl-review.googlesource.com/5049 Reviewed-by: Adam Langley <agl@google.com>
2015-05-29 22:11:21 +01:00
/* Configuring certificates and private keys.
*
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
* These functions configure the connection's leaf certificate, private key, and
* certificate chain. The certificate chain is ordered leaf to root (as sent on
* the wire) but does not include the leaf. Both client and server certificates
* use these functions.
*
* Certificates and keys may be configured before the handshake or dynamically
* in the early callback and certificate callback. */
Implement asynchronous private key operations for client auth. This adds a new API, SSL_set_private_key_method, which allows the consumer to customize private key operations. For simplicity, it is incompatible with the multiple slots feature (which will hopefully go away) but does not, for now, break it. The new method is only routed up for the client for now. The server will require a decrypt hook as well for the plain RSA key exchange. BUG=347404 Change-Id: I35d69095c29134c34c2af88c613ad557d6957614 Reviewed-on: https://boringssl-review.googlesource.com/5049 Reviewed-by: Adam Langley <agl@google.com>
2015-05-29 22:11:21 +01:00
Document APIs relating to configuring certificates and private keys. The APIs that are CTRL macros will be documented (and converted to functions) in a follow-up. Change-Id: I7d086db1768aa3c16e8d7775b0c818b72918f4c2 Reviewed-on: https://boringssl-review.googlesource.com/5354 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 00:38:46 +01:00
/* SSL_CTX_use_certificate sets |ctx|'s leaf certificate to |x509|. It returns
* one on success and zero on failure. */
OPENSSL_EXPORT int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x509);
/* SSL_use_certificate sets |ssl|'s leaf certificate to |x509|. It returns one
* on success and zero on failure. */
OPENSSL_EXPORT int SSL_use_certificate(SSL *ssl, X509 *x509);
/* SSL_CTX_use_PrivateKey sets |ctx|'s private key to |pkey|. It returns one on
* success and zero on failure. */
OPENSSL_EXPORT int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey);
/* SSL_use_PrivateKey sets |ssl|'s private key to |pkey|. It returns one on
* success and zero on failure. */
OPENSSL_EXPORT int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey);
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
/* SSL_CTX_set0_chain sets |ctx|'s certificate chain, excluding the leaf, to
* |chain|. On success, it returns one and takes ownership of |chain|.
* Otherwise, it returns zero. */
OPENSSL_EXPORT int SSL_CTX_set0_chain(SSL_CTX *ctx, STACK_OF(X509) *chain);
/* SSL_CTX_set1_chain sets |ctx|'s certificate chain, excluding the leaf, to
* |chain|. It returns one on success and zero on failure. The caller retains
* ownership of |chain| and may release it freely. */
OPENSSL_EXPORT int SSL_CTX_set1_chain(SSL_CTX *ctx, STACK_OF(X509) *chain);
/* SSL_set0_chain sets |ssl|'s certificate chain, excluding the leaf, to
* |chain|. On success, it returns one and takes ownership of |chain|.
* Otherwise, it returns zero. */
OPENSSL_EXPORT int SSL_set0_chain(SSL *ssl, STACK_OF(X509) *chain);
/* SSL_set1_chain sets |ssl|'s certificate chain, excluding the leaf, to
* |chain|. It returns one on success and zero on failure. The caller retains
* ownership of |chain| and may release it freely. */
OPENSSL_EXPORT int SSL_set1_chain(SSL *ssl, STACK_OF(X509) *chain);
/* SSL_CTX_add0_chain_cert appends |x509| to |ctx|'s certificate chain. On
* success, it returns one and takes ownership of |x509|. Otherwise, it returns
* zero. */
OPENSSL_EXPORT int SSL_CTX_add0_chain_cert(SSL_CTX *ctx, X509 *x509);
/* SSL_CTX_add1_chain_cert appends |x509| to |ctx|'s certificate chain. It
* returns one on success and zero on failure. The caller retains ownership of
* |x509| and may release it freely. */
OPENSSL_EXPORT int SSL_CTX_add1_chain_cert(SSL_CTX *ctx, X509 *x509);
/* SSL_add0_chain_cert appends |x509| to |ctx|'s certificate chain. On success,
* it returns one and takes ownership of |x509|. Otherwise, it returns zero. */
OPENSSL_EXPORT int SSL_add0_chain_cert(SSL *ssl, X509 *x509);
/* SSL_CTX_add_extra_chain_cert calls |SSL_CTX_add0_chain_cert|. */
OPENSSL_EXPORT int SSL_CTX_add_extra_chain_cert(SSL_CTX *ctx, X509 *x509);
/* SSL_add1_chain_cert appends |x509| to |ctx|'s certificate chain. It returns
* one on success and zero on failure. The caller retains ownership of |x509|
* and may release it freely. */
OPENSSL_EXPORT int SSL_add1_chain_cert(SSL *ssl, X509 *x509);
/* SSL_CTX_clear_chain_certs clears |ctx|'s certificate chain and returns
* one. */
OPENSSL_EXPORT int SSL_CTX_clear_chain_certs(SSL_CTX *ctx);
/* SSL_CTX_clear_extra_chain_certs calls |SSL_CTX_clear_chain_certs|. */
OPENSSL_EXPORT int SSL_CTX_clear_extra_chain_certs(SSL_CTX *ctx);
/* SSL_clear_chain_certs clears |ssl|'s certificate chain and returns one. */
OPENSSL_EXPORT int SSL_clear_chain_certs(SSL *ssl);
Document APIs relating to configuring certificates and private keys. The APIs that are CTRL macros will be documented (and converted to functions) in a follow-up. Change-Id: I7d086db1768aa3c16e8d7775b0c818b72918f4c2 Reviewed-on: https://boringssl-review.googlesource.com/5354 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 00:38:46 +01:00
/* SSL_CTX_set_cert_cb sets a callback that is called to select a certificate.
* The callback returns one on success, zero on internal error, and a negative
* number on failure or to pause the handshake. If the handshake is paused,
Better document the callbacks around client certificates. Deprecate the client_cert_cb variant since you can't really configure intermediates with it. (You might be able to by configuring the intermediates without the leaf or key and leaving the SSL stack to configure those, but that's really weird. cert_cb is simpler.) Also document the two functions the callbacks may use to query the CertificateRequest on the client. Change-Id: Iad6076266fd798cd74ea4e09978e7f5df5c8a670 Reviewed-on: https://boringssl-review.googlesource.com/6092 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 15:49:20 +01:00
* |SSL_get_error| will return |SSL_ERROR_WANT_X509_LOOKUP|.
*
* On the client, the callback may call |SSL_get0_certificate_types| and
* |SSL_get_client_CA_list| for information on the server's certificate
* request. */
Document APIs relating to configuring certificates and private keys. The APIs that are CTRL macros will be documented (and converted to functions) in a follow-up. Change-Id: I7d086db1768aa3c16e8d7775b0c818b72918f4c2 Reviewed-on: https://boringssl-review.googlesource.com/5354 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 00:38:46 +01:00
OPENSSL_EXPORT void SSL_CTX_set_cert_cb(SSL_CTX *ctx,
int (*cb)(SSL *ssl, void *arg),
void *arg);
/* SSL_set_cert_cb sets a callback that is called to select a certificate. The
* callback returns one on success, zero on internal error, and a negative
* number on failure or to pause the handshake. If the handshake is paused,
Better document the callbacks around client certificates. Deprecate the client_cert_cb variant since you can't really configure intermediates with it. (You might be able to by configuring the intermediates without the leaf or key and leaving the SSL stack to configure those, but that's really weird. cert_cb is simpler.) Also document the two functions the callbacks may use to query the CertificateRequest on the client. Change-Id: Iad6076266fd798cd74ea4e09978e7f5df5c8a670 Reviewed-on: https://boringssl-review.googlesource.com/6092 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 15:49:20 +01:00
* |SSL_get_error| will return |SSL_ERROR_WANT_X509_LOOKUP|.
*
* On the client, the callback may call |SSL_get0_certificate_types| and
* |SSL_get_client_CA_list| for information on the server's certificate
* request. */
Document APIs relating to configuring certificates and private keys. The APIs that are CTRL macros will be documented (and converted to functions) in a follow-up. Change-Id: I7d086db1768aa3c16e8d7775b0c818b72918f4c2 Reviewed-on: https://boringssl-review.googlesource.com/5354 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 00:38:46 +01:00
OPENSSL_EXPORT void SSL_set_cert_cb(SSL *ssl, int (*cb)(SSL *ssl, void *arg),
void *arg);
Better document the callbacks around client certificates. Deprecate the client_cert_cb variant since you can't really configure intermediates with it. (You might be able to by configuring the intermediates without the leaf or key and leaving the SSL stack to configure those, but that's really weird. cert_cb is simpler.) Also document the two functions the callbacks may use to query the CertificateRequest on the client. Change-Id: Iad6076266fd798cd74ea4e09978e7f5df5c8a670 Reviewed-on: https://boringssl-review.googlesource.com/6092 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 15:49:20 +01:00
/* SSL_get0_certificate_types, for a client, sets |*out_types| to an array
* containing the client certificate types requested by a server. It returns the
* length of the array.
*
* The behavior of this function is undefined except during the callbacks set by
* by |SSL_CTX_set_cert_cb| and |SSL_CTX_set_client_cert_cb| or when the
* handshake is paused because of them. */
OPENSSL_EXPORT size_t SSL_get0_certificate_types(SSL *ssl,
const uint8_t **out_types);
Document APIs relating to configuring certificates and private keys. The APIs that are CTRL macros will be documented (and converted to functions) in a follow-up. Change-Id: I7d086db1768aa3c16e8d7775b0c818b72918f4c2 Reviewed-on: https://boringssl-review.googlesource.com/5354 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 00:38:46 +01:00
/* SSL_certs_clear resets the private key, leaf certificate, and certificate
* chain of |ssl|. */
OPENSSL_EXPORT void SSL_certs_clear(SSL *ssl);
/* SSL_CTX_check_private_key returns one if the certificate and private key
* configured in |ctx| are consistent and zero otherwise. */
OPENSSL_EXPORT int SSL_CTX_check_private_key(const SSL_CTX *ctx);
/* SSL_check_private_key returns one if the certificate and private key
* configured in |ssl| are consistent and zero otherwise. */
OPENSSL_EXPORT int SSL_check_private_key(const SSL *ssl);
/* SSL_CTX_get0_certificate returns |ctx|'s leaf certificate. */
OPENSSL_EXPORT X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx);
/* SSL_get_certificate returns |ssl|'s leaf certificate. */
OPENSSL_EXPORT X509 *SSL_get_certificate(const SSL *ssl);
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
/* SSL_CTX_get0_privatekey returns |ctx|'s private key. */
OPENSSL_EXPORT EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx);
/* SSL_get_privatekey returns |ssl|'s private key. */
OPENSSL_EXPORT EVP_PKEY *SSL_get_privatekey(const SSL *ssl);
/* SSL_CTX_get0_chain_certs sets |*out_chain| to |ctx|'s certificate chain and
* returns one. */
OPENSSL_EXPORT int SSL_CTX_get0_chain_certs(const SSL_CTX *ctx,
STACK_OF(X509) **out_chain);
/* SSL_CTX_get_extra_chain_certs calls |SSL_CTX_get0_chain_certs|. */
OPENSSL_EXPORT int SSL_CTX_get_extra_chain_certs(const SSL_CTX *ctx,
STACK_OF(X509) **out_chain);
/* SSL_get0_chain_certs sets |*out_chain| to |ssl|'s certificate chain and
* returns one. */
OPENSSL_EXPORT int SSL_get0_chain_certs(const SSL *ssl,
STACK_OF(X509) **out_chain);
Add server-side support for Signed Certificate Timestamps. Change-Id: Ifa44fef160fc9d67771eed165f8fc277f28a0222 Reviewed-on: https://boringssl-review.googlesource.com/5840 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2015-09-09 13:44:55 +01:00
/* SSL_CTX_set_signed_cert_timestamp_list sets the list of signed certificate
* timestamps that is sent to clients that request it. The |list| argument must
* contain one or more SCT structures serialised as a SignedCertificateTimestamp
* List (see https://tools.ietf.org/html/rfc6962#section-3.3) – i.e. each SCT
* is prefixed by a big-endian, uint16 length and the concatenation of one or
* more such prefixed SCTs are themselves also prefixed by a uint16 length. It
* returns one on success and zero on error. The caller retains ownership of
* |list|. */
OPENSSL_EXPORT int SSL_CTX_set_signed_cert_timestamp_list(SSL_CTX *ctx,
const uint8_t *list,
size_t list_len);
Server-side OCSP stapling support. This is a simpler implementation than OpenSSL's, lacking responder IDs and request extensions support. This mirrors the client implementation already present. Change-Id: I54592b60e0a708bfb003d491c9250401403c9e69 Reviewed-on: https://boringssl-review.googlesource.com/5700 Reviewed-by: Adam Langley <agl@google.com>
2015-08-12 11:47:11 +01:00
/* SSL_CTX_set_ocsp_response sets the OCSP reponse that is sent to clients
* which request it. It returns one on success and zero on error. The caller
* retains ownership of |response|. */
OPENSSL_EXPORT int SSL_CTX_set_ocsp_response(SSL_CTX *ctx,
const uint8_t *response,
size_t response_len);
Adding more options for signing digest fallback. Allow configuring digest preferences for the private key. Some smartcards have limited support for signing digests, notably Windows CAPI keys and old Estonian smartcards. Chromium used the supports_digest hook in SSL_PRIVATE_KEY_METHOD to limit such keys to SHA1. However, detecting those keys was a heuristic, so some SHA256-capable keys authenticating to SHA256-only servers regressed in the switch to BoringSSL. Replace this mechanism with an API to configure digest preference order. This way heuristically-detected SHA1-only keys may be configured by Chromium as SHA1-preferring rather than SHA1-requiring. In doing so, clean up the shared_sigalgs machinery somewhat. BUG=468076 Change-Id: I996a2df213ae4d8b4062f0ab85b15262ca26f3c6 Reviewed-on: https://boringssl-review.googlesource.com/5755 Reviewed-by: Adam Langley <agl@google.com>
2015-09-04 17:41:04 +01:00
/* SSL_set_private_key_digest_prefs copies |num_digests| NIDs from |digest_nids|
* into |ssl|. These digests will be used, in decreasing order of preference,
* when signing with |ssl|'s private key. It returns one on success and zero on
* error. */
OPENSSL_EXPORT int SSL_set_private_key_digest_prefs(SSL *ssl,
const int *digest_nids,
size_t num_digests);
Document APIs relating to configuring certificates and private keys. The APIs that are CTRL macros will be documented (and converted to functions) in a follow-up. Change-Id: I7d086db1768aa3c16e8d7775b0c818b72918f4c2 Reviewed-on: https://boringssl-review.googlesource.com/5354 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 00:38:46 +01:00
/* Certificate and private key convenience functions. */
/* SSL_CTX_use_RSAPrivateKey sets |ctx|'s private key to |rsa|. It returns one
* on success and zero on failure. */
OPENSSL_EXPORT int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa);
/* SSL_use_RSAPrivateKey sets |ctx|'s private key to |rsa|. It returns one on
* success and zero on failure. */
OPENSSL_EXPORT int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa);
/* The following functions configure certificates or private keys but take as
* input DER-encoded structures. They return one on success and zero on
* failure. */
OPENSSL_EXPORT int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len,
const uint8_t *d);
OPENSSL_EXPORT int SSL_use_certificate_ASN1(SSL *ssl, const uint8_t *der,
int len);
OPENSSL_EXPORT int SSL_CTX_use_PrivateKey_ASN1(int pk, SSL_CTX *ctx,
const uint8_t *d, long len);
OPENSSL_EXPORT int SSL_use_PrivateKey_ASN1(int type, SSL *ssl,
const uint8_t *d, long len);
OPENSSL_EXPORT int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx,
Parse RSAPrivateKey with CBS. This removes the version field from RSA and instead handles versioning as part of parsing. (As a bonus, we now correctly limit multi-prime RSA to version 1 keys.) Most consumers are also converted. old_rsa_priv_{de,en}code are left alone for now. Those hooks are passed in parameters which match the old d2i/i2d pattern (they're only used in d2i_PrivateKey and i2d_PrivateKey). Include a test which, among other things, checks that public keys being serialized as private keys are handled properly. BUG=499653 Change-Id: Icdd5f0382c4a84f9c8867024f29756e1a306ba08 Reviewed-on: https://boringssl-review.googlesource.com/5273 Reviewed-by: Adam Langley <agl@google.com>
2015-06-27 19:56:25 +01:00
const uint8_t *der,
size_t der_len);
OPENSSL_EXPORT int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, const uint8_t *der,
size_t der_len);
Document APIs relating to configuring certificates and private keys. The APIs that are CTRL macros will be documented (and converted to functions) in a follow-up. Change-Id: I7d086db1768aa3c16e8d7775b0c818b72918f4c2 Reviewed-on: https://boringssl-review.googlesource.com/5354 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 00:38:46 +01:00
/* The following functions configure certificates or private keys but take as
* input files to read from. They return one on success and zero on failure. The
* |type| parameter is one of the |SSL_FILETYPE_*| values and determines whether
* the file's contents are read as PEM or DER. */
#define SSL_FILETYPE_ASN1 X509_FILETYPE_ASN1
#define SSL_FILETYPE_PEM X509_FILETYPE_PEM
OPENSSL_EXPORT int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx,
const char *file,
int type);
OPENSSL_EXPORT int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file,
int type);
OPENSSL_EXPORT int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file,
int type);
OPENSSL_EXPORT int SSL_use_certificate_file(SSL *ssl, const char *file,
int type);
OPENSSL_EXPORT int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file,
int type);
OPENSSL_EXPORT int SSL_use_PrivateKey_file(SSL *ssl, const char *file,
int type);
Fix several minor points noticed by Kenny. ∙ Some comments had the wrong function name at the beginning. ∙ Some ARM asm ended up with two #if defined(__arm__) lines – one from the .pl file and one inserted by the translation script. Change-Id: Ia8032cd09f06a899bf205feebc2d535a5078b521 Reviewed-on: https://boringssl-review.googlesource.com/6000 Reviewed-by: Adam Langley <agl@google.com>
2015-09-24 22:48:32 +01:00
/* SSL_CTX_use_certificate_chain_file configures certificates for |ctx|. It
* reads the contents of |file| as a PEM-encoded leaf certificate followed
* optionally by the certificate chain to send to the peer. It returns one on
* success and zero on failure. */
Document APIs relating to configuring certificates and private keys. The APIs that are CTRL macros will be documented (and converted to functions) in a follow-up. Change-Id: I7d086db1768aa3c16e8d7775b0c818b72918f4c2 Reviewed-on: https://boringssl-review.googlesource.com/5354 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 00:38:46 +01:00
OPENSSL_EXPORT int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx,
const char *file);
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
/* SSL_CTX_set_default_passwd_cb sets the password callback for PEM-based
* convenience functions called on |ctx|. */
OPENSSL_EXPORT void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx,
pem_password_cb *cb);
/* SSL_CTX_set_default_passwd_cb_userdata sets the userdata parameter for
* |ctx|'s password callback. */
OPENSSL_EXPORT void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx,
void *data);
Document APIs relating to configuring certificates and private keys. The APIs that are CTRL macros will be documented (and converted to functions) in a follow-up. Change-Id: I7d086db1768aa3c16e8d7775b0c818b72918f4c2 Reviewed-on: https://boringssl-review.googlesource.com/5354 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 00:38:46 +01:00
/* Custom private keys. */
Implement asynchronous private key operations for client auth. This adds a new API, SSL_set_private_key_method, which allows the consumer to customize private key operations. For simplicity, it is incompatible with the multiple slots feature (which will hopefully go away) but does not, for now, break it. The new method is only routed up for the client for now. The server will require a decrypt hook as well for the plain RSA key exchange. BUG=347404 Change-Id: I35d69095c29134c34c2af88c613ad557d6957614 Reviewed-on: https://boringssl-review.googlesource.com/5049 Reviewed-by: Adam Langley <agl@google.com>
2015-05-29 22:11:21 +01:00
enum ssl_private_key_result_t {
ssl_private_key_success,
ssl_private_key_retry,
ssl_private_key_failure,
};
/* SSL_PRIVATE_KEY_METHOD describes private key hooks. This is used to off-load
* signing operations to a custom, potentially asynchronous, backend. */
typedef struct ssl_private_key_method_st {
/* type returns either |EVP_PKEY_RSA| or |EVP_PKEY_EC| to denote the type of
* key used by |ssl|. */
int (*type)(SSL *ssl);
/* max_signature_len returns the maximum length of a signature signed by the
* key used by |ssl|. This must be a constant value for a given |ssl|. */
size_t (*max_signature_len)(SSL *ssl);
/* sign signs |in_len| bytes of digest from |in|. |md| is the hash function
* used to calculate |in|. On success, it returns |ssl_private_key_success|
* and writes at most |max_out| bytes of signature data to |out|. On failure,
* it returns |ssl_private_key_failure|. If the operation has not completed,
* it returns |ssl_private_key_retry|. |sign| should arrange for the
* high-level operation on |ssl| to be retried when the operation is
* completed. This will result in a call to |sign_complete|.
*
* If the key is an RSA key, implementations must use PKCS#1 padding. |in| is
* the digest itself, so the DigestInfo prefix, if any, must be prepended by
* |sign|. If |md| is |EVP_md5_sha1|, there is no prefix.
*
* It is an error to call |sign| while another private key operation is in
* progress on |ssl|. */
enum ssl_private_key_result_t (*sign)(SSL *ssl, uint8_t *out, size_t *out_len,
size_t max_out, const EVP_MD *md,
const uint8_t *in, size_t in_len);
/* sign_complete completes a pending |sign| operation. If the operation has
* completed, it returns |ssl_private_key_success| and writes the result to
* |out| as in |sign|. Otherwise, it returns |ssl_private_key_failure| on
* failure and |ssl_private_key_retry| if the operation is still in progress.
*
* |sign_complete| may be called arbitrarily many times before completion, but
* it is an error to call |sign_complete| if there is no pending |sign|
* operation in progress on |ssl|. */
enum ssl_private_key_result_t (*sign_complete)(SSL *ssl, uint8_t *out,
size_t *out_len, size_t max_out);
} SSL_PRIVATE_KEY_METHOD;
Adding more options for signing digest fallback. Allow configuring digest preferences for the private key. Some smartcards have limited support for signing digests, notably Windows CAPI keys and old Estonian smartcards. Chromium used the supports_digest hook in SSL_PRIVATE_KEY_METHOD to limit such keys to SHA1. However, detecting those keys was a heuristic, so some SHA256-capable keys authenticating to SHA256-only servers regressed in the switch to BoringSSL. Replace this mechanism with an API to configure digest preference order. This way heuristically-detected SHA1-only keys may be configured by Chromium as SHA1-preferring rather than SHA1-requiring. In doing so, clean up the shared_sigalgs machinery somewhat. BUG=468076 Change-Id: I996a2df213ae4d8b4062f0ab85b15262ca26f3c6 Reviewed-on: https://boringssl-review.googlesource.com/5755 Reviewed-by: Adam Langley <agl@google.com>
2015-09-04 17:41:04 +01:00
/* SSL_set_private_key_method configures a custom private key on |ssl|.
Fold away certificate slots mechanism. This allows us to remove the confusing EVP_PKEY argument to the SSL_PRIVATE_KEY_METHOD wrapper functions. It also simplifies some of the book-keeping around the CERT structure, as well as the API for configuring certificates themselves. The current one is a little odd as some functions automatically route to the slot while others affect the most recently touched slot. Others still (extra_certs) apply to all slots, making them not terribly useful. Consumers with complex needs should use cert_cb or the early callback (select_certificate_cb) to configure whatever they like based on the ClientHello. BUG=486295 Change-Id: Ice29ffeb867fa4959898b70dfc50fc00137f01f3 Reviewed-on: https://boringssl-review.googlesource.com/5351 Reviewed-by: Adam Langley <agl@google.com>
2015-07-05 16:54:09 +01:00
* |key_method| must remain valid for the lifetime of |ssl|. */
Implement asynchronous private key operations for client auth. This adds a new API, SSL_set_private_key_method, which allows the consumer to customize private key operations. For simplicity, it is incompatible with the multiple slots feature (which will hopefully go away) but does not, for now, break it. The new method is only routed up for the client for now. The server will require a decrypt hook as well for the plain RSA key exchange. BUG=347404 Change-Id: I35d69095c29134c34c2af88c613ad557d6957614 Reviewed-on: https://boringssl-review.googlesource.com/5049 Reviewed-by: Adam Langley <agl@google.com>
2015-05-29 22:11:21 +01:00
OPENSSL_EXPORT void SSL_set_private_key_method(
SSL *ssl, const SSL_PRIVATE_KEY_METHOD *key_method);
Move SSL_CIPHER section just above cipher suite configuration. Putting it at the top was probably a mistake? Even though SSL_CIPHER (like SSL_SESSION) doesn't depend on SSL, if you're reading through the header, SSL_CTX and SSL are the most important types. You could even use the library without touch cipher suite configs if you don't care since the default is decently reasonable, though it does include a lot of ciphers. (Hard to change that if we wanted to because DEFAULT is often used somewhat like ALL and then people subtract from it.) Change-Id: Ic9ddfc921858f7a4c141972fe0d1e465ca196b9d Reviewed-on: https://boringssl-review.googlesource.com/5963 Reviewed-by: Adam Langley <agl@google.com>
2015-09-20 17:18:11 +01:00
/* Cipher suites.
*
* |SSL_CIPHER| objects represent cipher suites. */
DECLARE_STACK_OF(SSL_CIPHER)
/* SSL_get_cipher_by_value returns the structure representing a TLS cipher
* suite based on its assigned number, or NULL if unknown. See
* https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-4. */
OPENSSL_EXPORT const SSL_CIPHER *SSL_get_cipher_by_value(uint16_t value);
/* SSL_CIPHER_get_id returns |cipher|'s id. It may be cast to a |uint16_t| to
* get the cipher suite value. */
OPENSSL_EXPORT uint32_t SSL_CIPHER_get_id(const SSL_CIPHER *cipher);
/* SSL_CIPHER_is_AES returns one if |cipher| uses AES (either GCM or CBC
* mode). */
OPENSSL_EXPORT int SSL_CIPHER_is_AES(const SSL_CIPHER *cipher);
/* SSL_CIPHER_has_MD5_HMAC returns one if |cipher| uses HMAC-MD5. */
OPENSSL_EXPORT int SSL_CIPHER_has_MD5_HMAC(const SSL_CIPHER *cipher);
/* SSL_CIPHER_is_AESGCM returns one if |cipher| uses AES-GCM. */
OPENSSL_EXPORT int SSL_CIPHER_is_AESGCM(const SSL_CIPHER *cipher);
/* SSL_CIPHER_is_CHACHA20POLY1305 returns one if |cipher| uses
* CHACHA20_POLY1305. */
OPENSSL_EXPORT int SSL_CIPHER_is_CHACHA20POLY1305(const SSL_CIPHER *cipher);
/* SSL_CIPHER_is_NULL returns one if |cipher| does not encrypt. */
OPENSSL_EXPORT int SSL_CIPHER_is_NULL(const SSL_CIPHER *cipher);
/* SSL_CIPHER_is_RC4 returns one if |cipher| uses RC4. */
OPENSSL_EXPORT int SSL_CIPHER_is_RC4(const SSL_CIPHER *cipher);
/* SSL_CIPHER_is_block_cipher returns one if |cipher| is a block cipher. */
OPENSSL_EXPORT int SSL_CIPHER_is_block_cipher(const SSL_CIPHER *cipher);
/* SSL_CIPHER_get_name returns the OpenSSL name of |cipher|. */
OPENSSL_EXPORT const char *SSL_CIPHER_get_name(const SSL_CIPHER *cipher);
/* SSL_CIPHER_get_kx_name returns a string that describes the key-exchange
* method used by |cipher|. For example, "ECDHE_ECDSA". */
OPENSSL_EXPORT const char *SSL_CIPHER_get_kx_name(const SSL_CIPHER *cipher);
/* SSL_CIPHER_get_rfc_name returns a newly-allocated string with the standard
* name for |cipher| or NULL on error. For example,
* "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256". The caller is responsible for
* calling |OPENSSL_free| on the result. */
OPENSSL_EXPORT char *SSL_CIPHER_get_rfc_name(const SSL_CIPHER *cipher);
/* SSL_CIPHER_get_bits returns the strength, in bits, of |cipher|. If
* |out_alg_bits| is not NULL, it writes the number of bits consumed by the
* symmetric algorithm to |*out_alg_bits|. */
OPENSSL_EXPORT int SSL_CIPHER_get_bits(const SSL_CIPHER *cipher,
int *out_alg_bits);
Document cipher suite configuration. The cipher suite rules could also be anchored on SSL_TXT_* if desired. I currently documented them in prose largely because SSL_TXT_* also defines protocol version strings and those are weird; SSL_TXT_TLSV1_1 isn't even a cipher rule. (And, in fact, those are the only SSL_TXT_* macros that we can't blindly remove. I found some code that #ifdef's the version SSL_TXT_* macros to decide if version-locked SSL_METHODs are available.) Also they clutter the header. I was thinking maybe we should dump a lot of the random constants into a separate undocumented header or perhaps just unexport them. I'm slightly torn on this though and could easily be convinced in the other direction. (Playing devil's advocate, anchoring on SSL_TXT_* means we're less likely to forget to document one so long as adding a SSL_TXT_* macro is the convention.) Change-Id: Ide2ae44db9d6d8f29c24943090c210da0108dc37 Reviewed-on: https://boringssl-review.googlesource.com/5962 Reviewed-by: Adam Langley <agl@google.com>
2015-09-20 17:17:03 +01:00
/* Cipher suite configuration.
*
* OpenSSL uses a mini-language to configure cipher suites. The language
* maintains an ordered list of enabled ciphers, along with an ordered list of
* disabled but available ciphers. Initially, all ciphers are disabled with a
* default ordering. The cipher string is then interpreted as a sequence of
* directives, separated by colons, each of which modifies this state.
*
* Most directives consist of a one character or empty opcode followed by a
* selector which matches a subset of available ciphers.
*
* Available opcodes are:
*
* The empty opcode enables and appends all matching disabled ciphers to the
* end of the enabled list. The newly appended ciphers are ordered relative to
* each other matching their order in the disabled list.
*
* |-| disables all matching enabled ciphers and prepends them to the disabled
* list, with relative order from the enabled list preserved. This means the
* most recently disabled ciphers get highest preference relative to other
* disabled ciphers if re-enabled.
*
* |+| moves all matching enabled ciphers to the end of the enabled list, with
* relative order preserved.
*
* |!| deletes all matching ciphers, enabled or not, from either list. Deleted
* ciphers will not matched by future operations.
*
* A selector may be a specific cipher (using the OpenSSL name for the cipher)
* or one or more rules separated by |+|. The final selector matches the
* intersection of each rule. For instance, |AESGCM+aECDSA| matches
* ECDSA-authenticated AES-GCM ciphers.
*
* Available cipher rules are:
*
* |ALL| matches all ciphers.
*
* |kRSA|, |kDHE|, |kECDHE|, and |kPSK| match ciphers using plain RSA, DHE,
* ECDHE, and plain PSK key exchanges, respectively. Note that ECDHE_PSK is
* matched by |kECDHE| and not |kPSK|.
*
* |aRSA|, |aECDSA|, and |aPSK| match ciphers authenticated by RSA, ECDSA, and
* a pre-shared key, respectively.
*
* |RSA|, |DHE|, |ECDHE|, |PSK|, |ECDSA|, and |PSK| are aliases for the
* corresponding |k*| or |a*| cipher rule. |RSA| is an alias for |kRSA|, not
* |aRSA|.
*
* |3DES|, |RC4|, |AES128|, |AES256|, |AES|, |AESGCM|, |CHACHA20| match
* ciphers whose bulk cipher use the corresponding encryption scheme. Note
* that |AES|, |AES128|, and |AES256| match both CBC and GCM ciphers.
*
* |MD5|, |SHA1|, |SHA256|, and |SHA384| match legacy cipher suites using the
* corresponding hash function in their MAC. AEADs are matched by none of
* these.
*
* |SHA| is an alias for |SHA1|.
*
* Although implemented, authentication-only ciphers match no rules and must be
* explicitly selected by name.
*
* Deprecated cipher rules:
*
* |kEDH|, |EDH|, |kEECDH|, and |EECDH| are legacy aliases for |kDHE|, |DHE|,
* |kECDHE|, and |ECDHE|, respectively.
*
* |MEDIUM| and |HIGH| match ciphers historically labeled by OpenSSL as
* 'medium' and 'high', respectively.
*
* |FIPS| matches ciphers historically FIPS-approved in OpenSSL.
*
* |SSLv3| and |TLSv1| match ciphers available in TLS 1.1 or earlier.
* |TLSv1_2| matches ciphers new in TLS 1.2. This is confusing and should not
* be used.
*
* Unknown rules silently match nothing.
*
* The special |@STRENGTH| directive will sort all enabled ciphers by strength.
*
* The |DEFAULT| directive, when appearing at the front of the string, expands
* to the default ordering of available ciphers.
*
* If configuring a server, one may also configure equal-preference groups to
* partially respect the client's preferences when
* |SSL_OP_CIPHER_SERVER_PREFERENCE| is enabled. Ciphers in an equal-preference
* group have equal priority and use the client order. This may be used to
* enforce that AEADs are preferred but select AES-GCM vs. ChaCha20-Poly1305
* based on client preferences. An equal-preference is specified with square
* brackets, combining multiple selectors separated by |. For example:
*
* [ECDHE-ECDSA-CHACHA20-POLY1305|ECDHE-ECDSA-AES128-GCM-SHA256]
*
* Once an equal-preference group is used, future directives must be
* opcode-less. */
/* SSL_DEFAULT_CIPHER_LIST is the default cipher suite configuration. It is
* substituted when a cipher string starts with 'DEFAULT'. */
#define SSL_DEFAULT_CIPHER_LIST "ALL"
/* SSL_CTX_set_cipher_list configures the cipher list for |ctx|, evaluating
* |str| as a cipher string. It returns one on success and zero on failure. */
OPENSSL_EXPORT int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str);
/* SSL_CTX_set_cipher_list configures the TLS 1.0+ cipher list for |ctx|,
* evaluating |str| as a cipher string. It returns one on success and zero on
* failure. If set, servers will use this cipher suite list for TLS 1.0 or
* higher. */
OPENSSL_EXPORT int SSL_CTX_set_cipher_list_tls10(SSL_CTX *ctx, const char *str);
/* SSL_CTX_set_cipher_list configures the TLS 1.1+ cipher list for |ctx|,
* evaluating |str| as a cipher string. It returns one on success and zero on
* failure. If set, servers will use this cipher suite list for TLS 1.1 or
* higher. */
OPENSSL_EXPORT int SSL_CTX_set_cipher_list_tls11(SSL_CTX *ctx, const char *str);
/* SSL_set_cipher_list configures the cipher list for |ssl|, evaluating |str| as
* a cipher string. It returns one on success and zero on failure. */
OPENSSL_EXPORT int SSL_set_cipher_list(SSL *ssl, const char *str);
/* SSL_get_ciphers returns the cipher list for |ssl|, in order of preference. If
* |SSL_CTX_set_cipher_list_tls10| or |SSL_CTX_set_cipher_list_tls11| has been
* used, the corresponding list for the current version is returned. */
OPENSSL_EXPORT STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *ssl);
Add SSL_get_tls_unique. SSL_get_tls_unique returns the tls-unique channel-binding value as defined in https://tools.ietf.org/html/rfc5929#section-3.1. Change-Id: Id9644328a7db8a91cf3ff0deee9dd6ce0d3e00ba Reviewed-on: https://boringssl-review.googlesource.com/4984 Reviewed-by: Adam Langley <agl@google.com>
2015-06-03 17:57:23 +01:00
/* Connection information. */
Move SSL_get_peer_* to Connection information. This is arguably more commonly queried connection information than the tls-unique. Change-Id: I1f080536153ba9f178af8e92cb43b03df37110b5 Reviewed-on: https://boringssl-review.googlesource.com/5874 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 06:03:54 +01:00
/* SSL_get_peer_certificate returns the peer's leaf certificate or NULL if the
* peer did not use certificates. The caller must call |X509_free| on the
* result to release it. */
OPENSSL_EXPORT X509 *SSL_get_peer_certificate(const SSL *ssl);
/* SSL_get_peer_cert_chain returns the peer's certificate chain or NULL if
* unavailable or the peer did not use certificates. For historical reasons,
* this may not be available if resuming a serialized |SSL_SESSION|. The caller
* does not take ownership of the result.
*
* WARNING: This function behaves differently between client and server. If
* |ssl| is a server, the returned chain does not include the leaf certificate.
* If a client, it does. */
OPENSSL_EXPORT STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *ssl);
Put OCSP and SCT accessors with SSL_get_peer_certificate. Grouping along two axes is weird. Doesn't hugely matter which one, but we should be consistent. Change-Id: I80fb04d3eff739c08fda29515ce81d101d8542cb Reviewed-on: https://boringssl-review.googlesource.com/6120 Reviewed-by: Adam Langley <agl@google.com>
2015-10-06 01:14:37 +01:00
/* SSL_get0_signed_cert_timestamp_list sets |*out| and |*out_len| to point to
* |*out_len| bytes of SCT information from the server. This is only valid if
* |ssl| is a client. The SCT information is a SignedCertificateTimestampList
* (including the two leading length bytes).
* See https://tools.ietf.org/html/rfc6962#section-3.3
* If no SCT was received then |*out_len| will be zero on return.
*
* WARNING: the returned data is not guaranteed to be well formed. */
OPENSSL_EXPORT void SSL_get0_signed_cert_timestamp_list(const SSL *ssl,
const uint8_t **out,
size_t *out_len);
/* SSL_get0_ocsp_response sets |*out| and |*out_len| to point to |*out_len|
* bytes of an OCSP response from the server. This is the DER encoding of an
* OCSPResponse type as defined in RFC 2560.
*
* WARNING: the returned data is not guaranteed to be well formed. */
OPENSSL_EXPORT void SSL_get0_ocsp_response(const SSL *ssl, const uint8_t **out,
size_t *out_len);
Add SSL_get_tls_unique. SSL_get_tls_unique returns the tls-unique channel-binding value as defined in https://tools.ietf.org/html/rfc5929#section-3.1. Change-Id: Id9644328a7db8a91cf3ff0deee9dd6ce0d3e00ba Reviewed-on: https://boringssl-review.googlesource.com/4984 Reviewed-by: Adam Langley <agl@google.com>
2015-06-03 17:57:23 +01:00
/* SSL_get_tls_unique writes at most |max_out| bytes of the tls-unique value
* for |ssl| to |out| and sets |*out_len| to the number of bytes written. It
* returns one on success or zero on error. In general |max_out| should be at
* least 12.
*
* This function will always fail if the initial handshake has not completed.
* The tls-unique value will change after a renegotiation but, since
* renegotiations can be initiated by the server at any point, the higher-level
* protocol must either leave them disabled or define states in which the
* tls-unique value can be read.
*
* The tls-unique value is defined by
* https://tools.ietf.org/html/rfc5929#section-3.1. Due to a weakness in the
* TLS protocol, tls-unique is broken for resumed connections unless the
* Extended Master Secret extension is negotiated. Thus this function will
* return zero if |ssl| performed session resumption unless EMS was used when
* negotiating the original session. */
OPENSSL_EXPORT int SSL_get_tls_unique(const SSL *ssl, uint8_t *out,
size_t *out_len, size_t max_out);
Add method to query Extended Master Secret support Change-Id: I4c285f4b3dd77f8fc7249c7504b5e4eb9b62959f Reviewed-on: https://boringssl-review.googlesource.com/5920 Reviewed-by: Adam Langley <agl@google.com>
2015-09-17 20:54:42 +01:00
/* SSL_get_extms_support returns one if the Extended Master Secret
* extension was negotiated. Otherwise, it returns zero. */
OPENSSL_EXPORT int SSL_get_extms_support(const SSL *ssl);
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
/* SSL_get_current_cipher returns the cipher used in the current outgoing
* connection state, or NULL if the null cipher is active. */
OPENSSL_EXPORT const SSL_CIPHER *SSL_get_current_cipher(const SSL *ssl);
/* SSL_session_reused returns one if |ssl| performed an abbreviated handshake
* and zero otherwise.
*
* TODO(davidben): Hammer down the semantics of this API while a handshake,
* initial or renego, is in progress. */
OPENSSL_EXPORT int SSL_session_reused(const SSL *ssl);
/* SSL_get_secure_renegotiation_support returns one if the peer supports secure
* renegotiation (RFC 5746) and zero otherwise. */
OPENSSL_EXPORT int SSL_get_secure_renegotiation_support(const SSL *ssl);
Move remaining functions out of tls1.h. Now tls1.h is just a pile of protocol constants with no more circular dependency problem. I've preserved SSL_get_servername's behavior where it's simultaneously a lookup of handshake state and local configuration. I've removed it from SSL_get_servername_type. It got the logic wrong anyway with the order of the s->session check. (Searching through code, neither is used on the client, but the SSL_get_servername one is easy.) Change-Id: I61bb8fb0858b07d76a7835bffa6dc793812fb027 Reviewed-on: https://boringssl-review.googlesource.com/6298 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-17 18:48:04 +01:00
/* SSL_export_keying_material exports a value derived from the master secret, as
* specified in RFC 5705. It writes |out_len| bytes to |out| given a label and
* optional context. (Since a zero length context is allowed, the |use_context|
* flag controls whether a context is included.)
*
* It returns one on success and zero otherwise. */
OPENSSL_EXPORT int SSL_export_keying_material(
SSL *ssl, uint8_t *out, size_t out_len, const char *label, size_t label_len,
const uint8_t *context, size_t context_len, int use_context);
Add SSL_get_tls_unique. SSL_get_tls_unique returns the tls-unique channel-binding value as defined in https://tools.ietf.org/html/rfc5929#section-3.1. Change-Id: Id9644328a7db8a91cf3ff0deee9dd6ce0d3e00ba Reviewed-on: https://boringssl-review.googlesource.com/4984 Reviewed-by: Adam Langley <agl@google.com>
2015-06-03 17:57:23 +01:00
Implement custom extensions. This change mirrors upstream's custom extension API because we have some internal users that depend on it. Change-Id: I408e442de0a55df7b05c872c953ff048cd406513 Reviewed-on: https://boringssl-review.googlesource.com/5471 Reviewed-by: Adam Langley <agl@google.com>
2015-07-31 02:10:13 +01:00
/* Custom extensions.
*
* The custom extension functions allow TLS extensions to be added to
* ClientHello and ServerHello messages. */
/* SSL_custom_ext_add_cb is a callback function that is called when the
* ClientHello (for clients) or ServerHello (for servers) is constructed. In
* the case of a server, this callback will only be called for a given
* extension if the ClientHello contained that extension – it's not possible to
* inject extensions into a ServerHello that the client didn't request.
*
* When called, |extension_value| will contain the extension number that is
* being considered for addition (so that a single callback can handle multiple
* extensions). If the callback wishes to include the extension, it must set
* |*out| to point to |*out_len| bytes of extension contents and return one. In
* this case, the corresponding |SSL_custom_ext_free_cb| callback will later be
* called with the value of |*out| once that data has been copied.
*
* If the callback does not wish to add an extension it must return zero.
*
* Alternatively, the callback can abort the connection by setting
* |*out_alert_value| to a TLS alert number and returning -1. */
typedef int (*SSL_custom_ext_add_cb)(SSL *ssl, unsigned extension_value,
const uint8_t **out, size_t *out_len,
int *out_alert_value, void *add_arg);
/* SSL_custom_ext_free_cb is a callback function that is called by OpenSSL iff
* an |SSL_custom_ext_add_cb| callback previously returned one. In that case,
* this callback is called and passed the |out| pointer that was returned by
* the add callback. This is to free any dynamically allocated data created by
* the add callback. */
typedef void (*SSL_custom_ext_free_cb)(SSL *ssl, unsigned extension_value,
const uint8_t *out, void *add_arg);
/* SSL_custom_ext_parse_cb is a callback function that is called by OpenSSL to
* parse an extension from the peer: that is from the ServerHello for a client
* and from the ClientHello for a server.
*
* When called, |extension_value| will contain the extension number and the
* contents of the extension are |contents_len| bytes at |contents|.
*
* The callback must return one to continue the handshake. Otherwise, if it
* returns zero, a fatal alert with value |*out_alert_value| is sent and the
* handshake is aborted. */
typedef int (*SSL_custom_ext_parse_cb)(SSL *ssl, unsigned extension_value,
const uint8_t *contents,
size_t contents_len,
int *out_alert_value, void *parse_arg);
/* SSL_extension_supported returns one iff OpenSSL internally handles
* extensions of type |extension_value|. This can be used to avoid registering
* custom extension handlers for extensions that a future version of OpenSSL
* may handle internally. */
OPENSSL_EXPORT int SSL_extension_supported(unsigned extension_value);
/* SSL_CTX_add_client_custom_ext registers callback functions for handling
* custom TLS extensions for client connections.
*
* If |add_cb| is NULL then an empty extension will be added in each
* ClientHello. Otherwise, see the comment for |SSL_custom_ext_add_cb| about
* this callback.
*
* The |free_cb| may be NULL if |add_cb| doesn't dynamically allocate data that
* needs to be freed.
*
* It returns one on success or zero on error. It's always an error to register
* callbacks for the same extension twice, or to register callbacks for an
* extension that OpenSSL handles internally. See |SSL_extension_supported| to
* discover, at runtime, which extensions OpenSSL handles internally. */
OPENSSL_EXPORT int SSL_CTX_add_client_custom_ext(
SSL_CTX *ctx, unsigned extension_value, SSL_custom_ext_add_cb add_cb,
SSL_custom_ext_free_cb free_cb, void *add_arg,
SSL_custom_ext_parse_cb parse_cb, void *parse_arg);
/* SSL_CTX_add_server_custom_ext is the same as
* |SSL_CTX_add_client_custom_ext|, but for server connections.
*
* Unlike on the client side, if |add_cb| is NULL no extension will be added.
* The |add_cb|, if any, will only be called if the ClientHello contained a
* matching extension. */
OPENSSL_EXPORT int SSL_CTX_add_server_custom_ext(
SSL_CTX *ctx, unsigned extension_value, SSL_custom_ext_add_cb add_cb,
SSL_custom_ext_free_cb free_cb, void *add_arg,
SSL_custom_ext_parse_cb parse_cb, void *parse_arg);
Document functions acting on an SSL_SESSION. Change-Id: I0b4386d1972af0ac10db397716de8161810a87f4 Reviewed-on: https://boringssl-review.googlesource.com/5877 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:07:33 +01:00
/* Sessions.
*
* An |SSL_SESSION| represents an SSL session that may be resumed in an
* abbreviated handshake. It is reference-counted and immutable. Once
* established, an |SSL_SESSION| may be shared by multiple |SSL| objects on
* different threads and must not be modified. */
Deprecated things are deprecated. Get them out of the way when reading through the header. Change-Id: Ied3f3601262e74570769cb7f858dcff4eff44813 Reviewed-on: https://boringssl-review.googlesource.com/5898 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 05:29:20 +01:00
DECLARE_LHASH_OF(SSL_SESSION)
More SSL_SESSION serialization functions. Change-Id: I2dd8d073521a230b2b0c4e74ec3d6eeb4899623e Reviewed-on: https://boringssl-review.googlesource.com/6303 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 03:15:37 +01:00
DECLARE_PEM_rw(SSL_SESSION, SSL_SESSION)
Deprecated things are deprecated. Get them out of the way when reading through the header. Change-Id: Ied3f3601262e74570769cb7f858dcff4eff44813 Reviewed-on: https://boringssl-review.googlesource.com/5898 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 05:29:20 +01:00
Document functions acting on an SSL_SESSION. Change-Id: I0b4386d1972af0ac10db397716de8161810a87f4 Reviewed-on: https://boringssl-review.googlesource.com/5877 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:07:33 +01:00
/* SSL_SESSION_new returns a newly-allocated blank |SSL_SESSION| or NULL on
* error. This may be useful in writing tests but otherwise should not be
* used outside the library. */
OPENSSL_EXPORT SSL_SESSION *SSL_SESSION_new(void);
/* SSL_SESSION_up_ref, if |session| is not NULL, increments the reference count
* of |session|. It then returns |session|. */
OPENSSL_EXPORT SSL_SESSION *SSL_SESSION_up_ref(SSL_SESSION *session);
/* SSL_SESSION_free decrements the reference count of |session|. If it reaches
* zero, all data referenced by |session| and |session| itself are released. */
OPENSSL_EXPORT void SSL_SESSION_free(SSL_SESSION *session);
/* SSL_SESSION_to_bytes serializes |in| into a newly allocated buffer and sets
* |*out_data| to that buffer and |*out_len| to its length. The caller takes
* ownership of the buffer and must call |OPENSSL_free| when done. It returns
* one on success and zero on error. */
const-correct a few SSL_SESSION functions. Change-Id: I64d1e29d1e414add4ae522fd9603c550d426a557 Reviewed-on: https://boringssl-review.googlesource.com/5881 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:48:12 +01:00
OPENSSL_EXPORT int SSL_SESSION_to_bytes(const SSL_SESSION *in,
uint8_t **out_data, size_t *out_len);
Document functions acting on an SSL_SESSION. Change-Id: I0b4386d1972af0ac10db397716de8161810a87f4 Reviewed-on: https://boringssl-review.googlesource.com/5877 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:07:33 +01:00
/* SSL_SESSION_to_bytes_for_ticket serializes |in|, but excludes the session
* identification information, namely the session ID and ticket. */
const-correct a few SSL_SESSION functions. Change-Id: I64d1e29d1e414add4ae522fd9603c550d426a557 Reviewed-on: https://boringssl-review.googlesource.com/5881 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:48:12 +01:00
OPENSSL_EXPORT int SSL_SESSION_to_bytes_for_ticket(const SSL_SESSION *in,
Document functions acting on an SSL_SESSION. Change-Id: I0b4386d1972af0ac10db397716de8161810a87f4 Reviewed-on: https://boringssl-review.googlesource.com/5877 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:07:33 +01:00
uint8_t **out_data,
size_t *out_len);
/* SSL_SESSION_from_bytes parses |in_len| bytes from |in| as an SSL_SESSION. It
* returns a newly-allocated |SSL_SESSION| on success or NULL on error. */
OPENSSL_EXPORT SSL_SESSION *SSL_SESSION_from_bytes(const uint8_t *in,
size_t in_len);
/* SSL_SESSION_get_version returns a string describing the TLS version |session|
* was established at. For example, "TLSv1.2" or "SSLv3". */
OPENSSL_EXPORT const char *SSL_SESSION_get_version(const SSL_SESSION *session);
/* SSL_SESSION_get_id returns a pointer to a buffer containg |session|'s session
* ID and sets |*out_len| to its length. */
OPENSSL_EXPORT const uint8_t *SSL_SESSION_get_id(const SSL_SESSION *session,
unsigned *out_len);
/* SSL_SESSION_get_time returns the time at which |session| was established in
* seconds since the UNIX epoch. */
OPENSSL_EXPORT long SSL_SESSION_get_time(const SSL_SESSION *session);
/* SSL_SESSION_get_timeout returns the lifetime of |session| in seconds. */
OPENSSL_EXPORT long SSL_SESSION_get_timeout(const SSL_SESSION *session);
/* SSL_SESSION_get_key_exchange_info returns a value that describes the
* strength of the asymmetric operation that provides confidentiality to
* |session|. Its interpretation depends on the operation used. See the
* documentation for this value in the |SSL_SESSION| structure. */
const-correct a few SSL_SESSION functions. Change-Id: I64d1e29d1e414add4ae522fd9603c550d426a557 Reviewed-on: https://boringssl-review.googlesource.com/5881 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:48:12 +01:00
OPENSSL_EXPORT uint32_t SSL_SESSION_get_key_exchange_info(
const SSL_SESSION *session);
Document functions acting on an SSL_SESSION. Change-Id: I0b4386d1972af0ac10db397716de8161810a87f4 Reviewed-on: https://boringssl-review.googlesource.com/5877 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:07:33 +01:00
/* SSL_SESSION_get0_peer return's the peer leaf certificate stored in
const-correct a few SSL_SESSION functions. Change-Id: I64d1e29d1e414add4ae522fd9603c550d426a557 Reviewed-on: https://boringssl-review.googlesource.com/5881 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:48:12 +01:00
* |session|.
*
* TODO(davidben): This should return a const X509 *. */
OPENSSL_EXPORT X509 *SSL_SESSION_get0_peer(const SSL_SESSION *session);
Document functions acting on an SSL_SESSION. Change-Id: I0b4386d1972af0ac10db397716de8161810a87f4 Reviewed-on: https://boringssl-review.googlesource.com/5877 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:07:33 +01:00
/* SSL_SESSION_set_time sets |session|'s creation time to |time| and returns
* |time|. This function may be useful in writing tests but otherwise should not
* be used. */
OPENSSL_EXPORT long SSL_SESSION_set_time(SSL_SESSION *session, long time);
Fix several minor points noticed by Kenny. ∙ Some comments had the wrong function name at the beginning. ∙ Some ARM asm ended up with two #if defined(__arm__) lines – one from the .pl file and one inserted by the translation script. Change-Id: Ia8032cd09f06a899bf205feebc2d535a5078b521 Reviewed-on: https://boringssl-review.googlesource.com/6000 Reviewed-by: Adam Langley <agl@google.com>
2015-09-24 22:48:32 +01:00
/* SSL_SESSION_set_timeout sets |session|'s timeout to |timeout| and returns
* one. This function may be useful in writing tests but otherwise should not
* be used. */
Document functions acting on an SSL_SESSION. Change-Id: I0b4386d1972af0ac10db397716de8161810a87f4 Reviewed-on: https://boringssl-review.googlesource.com/5877 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:07:33 +01:00
OPENSSL_EXPORT long SSL_SESSION_set_timeout(SSL_SESSION *session, long timeout);
/* SSL_SESSION_set1_id_context sets |session|'s session ID context (see
* |SSL_CTX_set_session_id_context|) to |sid_ctx|. It returns one on success and
* zero on error. This function may be useful in writing tests but otherwise
* should not be used. */
OPENSSL_EXPORT int SSL_SESSION_set1_id_context(SSL_SESSION *session,
const uint8_t *sid_ctx,
unsigned sid_ctx_len);
Document session cache functions. Also switch to the new variable names (SSL_CTX *ctx, SSL *ssl, SSL_SESSION *session) for all documented functions. Change-Id: I15e15a703b96af1727601108223c7ce3b0691f1d Reviewed-on: https://boringssl-review.googlesource.com/5882 Reviewed-by: Adam Langley <agl@google.com>
2015-09-14 06:40:10 +01:00
/* Session caching.
*
* Session caching allows clients to reconnect to a server based on saved
* parameters from a previous connection.
*
* For a server, the library implements a built-in internal session cache as an
* in-memory hash table. One may also register callbacks to implement a custom
* external session cache. An external cache may be used in addition to or
* instead of the internal one. Use |SSL_CTX_set_session_cache_mode| to toggle
* the internal cache.
*
* For a client, the only option is an external session cache. Prior to
* handshaking, the consumer should look up a session externally (keyed, for
* instance, by hostname) and use |SSL_set_session| to configure which session
* to offer. The callbacks may be used to determine when new sessions are
* available.
*
* Note that offering or accepting a session short-circuits most parameter
* negotiation. Resuming sessions across different configurations may result in
* surprising behavor. So, for instance, a client implementing a version
* fallback should shard its session cache by maximum protocol version. */
/* SSL_SESS_CACHE_OFF disables all session caching. */
#define SSL_SESS_CACHE_OFF 0x0000
/* SSL_SESS_CACHE_CLIENT enables session caching for a client.
*
* TODO(davidben): The internal cache is useless on the client. Always act as if
* SSL_SESS_CACHE_NO_INTERNAL is set. https://crbug.com/531194. Also see TODO
* attached to |SSL_CTX_sess_set_new_cb|. */
#define SSL_SESS_CACHE_CLIENT 0x0001
/* SSL_SESS_CACHE_SERVER enables session caching for a server. */
#define SSL_SESS_CACHE_SERVER 0x0002
/* SSL_SESS_CACHE_SERVER enables session caching for both client and server. */
#define SSL_SESS_CACHE_BOTH (SSL_SESS_CACHE_CLIENT | SSL_SESS_CACHE_SERVER)
/* SSL_SESS_CACHE_NO_AUTO_CLEAR disables automatically calling
* |SSL_CTX_flush_sessions| every 255 connections. */
#define SSL_SESS_CACHE_NO_AUTO_CLEAR 0x0080
/* SSL_SESS_CACHE_NO_INTERNAL_LOOKUP disables looking up a session from the
* internal session cache. */
#define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP 0x0100
/* SSL_SESS_CACHE_NO_INTERNAL_STORE disables storing sessions in the internal
* session cache. */
#define SSL_SESS_CACHE_NO_INTERNAL_STORE 0x0200
/* SSL_SESS_CACHE_NO_INTERNAL disables the internal session cache. */
#define SSL_SESS_CACHE_NO_INTERNAL \
(SSL_SESS_CACHE_NO_INTERNAL_LOOKUP | SSL_SESS_CACHE_NO_INTERNAL_STORE)
/* SSL_CTX_set_session_cache_mode sets the session cache mode bits for |ctx| to
* |mode|. It returns the previous value. */
OPENSSL_EXPORT int SSL_CTX_set_session_cache_mode(SSL_CTX *ctx, int mode);
/* SSL_CTX_get_session_cache_mode returns the session cache mode bits for
* |ctx| */
OPENSSL_EXPORT int SSL_CTX_get_session_cache_mode(const SSL_CTX *ctx);
Fix SSL_set_session documentation comment. I put an extra space in there. Also document ownership and return value. Change-Id: I0635423be7774a7db54dbf638cc548d291121529 Reviewed-on: https://boringssl-review.googlesource.com/6010 Reviewed-by: Adam Langley <agl@google.com>
2015-09-25 04:56:37 +01:00
/* SSL_set_session, for a client, configures |ssl| to offer to resume |session|
* in the initial handshake and returns one. The caller retains ownership of
* |session|. */
Document session cache functions. Also switch to the new variable names (SSL_CTX *ctx, SSL *ssl, SSL_SESSION *session) for all documented functions. Change-Id: I15e15a703b96af1727601108223c7ce3b0691f1d Reviewed-on: https://boringssl-review.googlesource.com/5882 Reviewed-by: Adam Langley <agl@google.com>
2015-09-14 06:40:10 +01:00
OPENSSL_EXPORT int SSL_set_session(SSL *ssl, SSL_SESSION *session);
/* SSL_get_session returns a non-owning pointer to |ssl|'s session. Prior to the
* initial handshake beginning, this is the session to be offered, set by
* |SSL_set_session|. After a handshake has finished, this is the currently
* active session. Its behavior is undefined while a handshake is progress. */
OPENSSL_EXPORT SSL_SESSION *SSL_get_session(const SSL *ssl);
/* SSL_get0_session is an alias for |SSL_get_session|. */
#define SSL_get0_session SSL_get_session
/* SSL_get1_session acts like |SSL_get_session| but returns a new reference to
* the session. */
OPENSSL_EXPORT SSL_SESSION *SSL_get1_session(SSL *ssl);
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
/* SSL_DEFAULT_SESSION_TIMEOUT is the default lifetime, in seconds, of a
* session. */
#define SSL_DEFAULT_SESSION_TIMEOUT (2 * 60 * 60)
/* SSL_CTX_set_timeout sets the lifetime, in seconds, of sessions created in
* |ctx| to |timeout|. */
Document session cache functions. Also switch to the new variable names (SSL_CTX *ctx, SSL *ssl, SSL_SESSION *session) for all documented functions. Change-Id: I15e15a703b96af1727601108223c7ce3b0691f1d Reviewed-on: https://boringssl-review.googlesource.com/5882 Reviewed-by: Adam Langley <agl@google.com>
2015-09-14 06:40:10 +01:00
OPENSSL_EXPORT long SSL_CTX_set_timeout(SSL_CTX *ctx, long timeout);
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
/* SSL_CTX_get_timeout returns the lifetime, in seconds, of sessions created in
* |ctx|. */
Document session cache functions. Also switch to the new variable names (SSL_CTX *ctx, SSL *ssl, SSL_SESSION *session) for all documented functions. Change-Id: I15e15a703b96af1727601108223c7ce3b0691f1d Reviewed-on: https://boringssl-review.googlesource.com/5882 Reviewed-by: Adam Langley <agl@google.com>
2015-09-14 06:40:10 +01:00
OPENSSL_EXPORT long SSL_CTX_get_timeout(const SSL_CTX *ctx);
/* SSL_CTX_set_session_id_context sets |ctx|'s session ID context to |sid_ctx|.
* It returns one on success and zero on error. The session ID context is an
* application-defined opaque byte string. A session will not be used in a
* connection without a matching session ID context.
*
* For a server, if |SSL_VERIFY_PEER| is enabled, it is an error to not set a
* session ID context.
*
* TODO(davidben): Is that check needed? That seems a special case of taking
* care not to cross-resume across configuration changes, and this is only
* relevant if a server requires client auth. */
OPENSSL_EXPORT int SSL_CTX_set_session_id_context(SSL_CTX *ctx,
const uint8_t *sid_ctx,
unsigned sid_ctx_len);
/* SSL_set_session_id_context sets |ssl|'s session ID context to |sid_ctx|. It
* returns one on success and zero on error. See also
* |SSL_CTX_set_session_id_context|. */
OPENSSL_EXPORT int SSL_set_session_id_context(SSL *ssl, const uint8_t *sid_ctx,
unsigned sid_ctx_len);
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
/* SSL_SESSION_CACHE_MAX_SIZE_DEFAULT is the default maximum size of a session
* cache. */
#define SSL_SESSION_CACHE_MAX_SIZE_DEFAULT (1024 * 20)
Document session cache functions. Also switch to the new variable names (SSL_CTX *ctx, SSL *ssl, SSL_SESSION *session) for all documented functions. Change-Id: I15e15a703b96af1727601108223c7ce3b0691f1d Reviewed-on: https://boringssl-review.googlesource.com/5882 Reviewed-by: Adam Langley <agl@google.com>
2015-09-14 06:40:10 +01:00
/* SSL_CTX_sess_set_cache_size sets the maximum size of |ctx|'s internal session
* cache to |size|. It returns the previous value. */
OPENSSL_EXPORT unsigned long SSL_CTX_sess_set_cache_size(SSL_CTX *ctx,
unsigned long size);
/* SSL_CTX_sess_get_cache_size returns the maximum size of |ctx|'s internal
* session cache. */
OPENSSL_EXPORT unsigned long SSL_CTX_sess_get_cache_size(const SSL_CTX *ctx);
/* SSL_CTX_sessions returns |ctx|'s internal session cache. */
OPENSSL_EXPORT LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx);
/* SSL_CTX_sess_number returns the number of sessions in |ctx|'s internal
* session cache. */
OPENSSL_EXPORT size_t SSL_CTX_sess_number(const SSL_CTX *ctx);
/* SSL_CTX_add_session inserts |session| into |ctx|'s internal session cache. It
* returns one on success and zero on error or if |ctx| already included a
* session with that session ID. The caller retains its reference to
* |session|. */
OPENSSL_EXPORT int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *session);
/* SSL_CTX_remove_session removes |session| from |ctx|'s internal session cache.
* It returns one on success and zero on error or if no session with a matching
* ID was found. */
OPENSSL_EXPORT int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *session);
/* SSL_CTX_flush_sessions removes all sessions from |ctx| which have expired as
* of time |time|. If |time| is zero, all sessions are removed. */
OPENSSL_EXPORT void SSL_CTX_flush_sessions(SSL_CTX *ctx, long time);
/* SSL_CTX_sess_set_new_cb sets the callback to be called when a new session is
* established and ready to be cached. If the session cache is disabled (the
* appropriate one of |SSL_SESS_CACHE_CLIENT| or |SSL_SESS_CACHE_SERVER| is
* unset), the callback is not called.
*
* The callback is passed a reference to |session|. It returns one if it takes
* ownership and zero otherwise.
*
* Note: For a client, the callback may be called on abbreviated handshakes if a
* ticket is renewed. Further, it may not be called until some time after
* |SSL_do_handshake| or |SSL_connect| completes if False Start is enabled. Thus
* it's recommended to use this callback over checking |SSL_session_reused| on
* handshake completion.
*
* TODO(davidben): Conditioning callbacks on |SSL_SESS_CACHE_CLIENT| or
* |SSL_SESS_CACHE_SERVER| doesn't make any sense when one could just as easily
* not supply the callbacks. Removing that condition and the client internal
* cache would simplify things. */
OPENSSL_EXPORT void SSL_CTX_sess_set_new_cb(
SSL_CTX *ctx, int (*new_session_cb)(SSL *ssl, SSL_SESSION *session));
/* SSL_CTX_sess_get_new_cb returns the callback set by
* |SSL_CTX_sess_set_new_cb|. */
OPENSSL_EXPORT int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx))(
SSL *ssl, SSL_SESSION *session);
/* SSL_CTX_sess_set_remove_cb sets a callback which is called when a session is
* removed from the internal session cache.
*
* TODO(davidben): What is the point of this callback? It seems useless since it
* only fires on sessions in the internal cache. */
OPENSSL_EXPORT void SSL_CTX_sess_set_remove_cb(
SSL_CTX *ctx,
void (*remove_session_cb)(SSL_CTX *ctx, SSL_SESSION *session));
/* SSL_CTX_sess_get_remove_cb returns the callback set by
* |SSL_CTX_sess_set_remove_cb|. */
OPENSSL_EXPORT void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx))(
SSL_CTX *ctx, SSL_SESSION *session);
/* SSL_CTX_sess_set_get_cb sets a callback to look up a session by ID for a
* server. The callback is passed the session ID and should return a matching
* |SSL_SESSION| or NULL if not found. It should set |*out_copy| to zero and
* return a new reference to the session. This callback is not used for a
* client.
*
* For historical reasons, if |*out_copy| is set to one (default), the SSL
* library will take a new reference to the returned |SSL_SESSION|, expecting
* the callback to return a non-owning pointer. This is not recommended. If
* |ctx| and thus the callback is used on multiple threads, the session may be
* removed and invalidated before the SSL library calls |SSL_SESSION_up_ref|,
* whereas the callback may synchronize internally.
*
* To look up a session asynchronously, the callback may return
* |SSL_magic_pending_session_ptr|. See the documentation for that function and
* |SSL_ERROR_PENDING_SESSION|.
*
* If the internal session cache is enabled, the callback is only consulted if
Document that SSL_CTX_sess_set_get_cb's id parameter should be const. See also upstream's bf0fc41266f17311c5db1e0541d3dd12eb27deb6. Change-Id: Ib692b0ad608f2e3291f2aeab2ad98a7e177d5851 Reviewed-on: https://boringssl-review.googlesource.com/6150 Reviewed-by: Adam Langley <agl@google.com>
2015-10-07 14:36:23 +01:00
* the internal cache does not return a match.
*
* The callback's |id| parameter is not const for historical reasons, but the
* contents may not be modified. */
Document session cache functions. Also switch to the new variable names (SSL_CTX *ctx, SSL *ssl, SSL_SESSION *session) for all documented functions. Change-Id: I15e15a703b96af1727601108223c7ce3b0691f1d Reviewed-on: https://boringssl-review.googlesource.com/5882 Reviewed-by: Adam Langley <agl@google.com>
2015-09-14 06:40:10 +01:00
OPENSSL_EXPORT void SSL_CTX_sess_set_get_cb(
SSL_CTX *ctx,
SSL_SESSION *(*get_session_cb)(SSL *ssl, uint8_t *id, int id_len,
int *out_copy));
/* SSL_CTX_sess_get_get_cb returns the callback set by
* |SSL_CTX_sess_set_get_cb|. */
OPENSSL_EXPORT SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx))(
SSL *ssl, uint8_t *id, int id_len, int *out_copy);
/* SSL_magic_pending_session_ptr returns a magic |SSL_SESSION|* which indicates
* that the session isn't currently unavailable. |SSL_get_error| will then
* return |SSL_ERROR_PENDING_SESSION| and the handshake can be retried later
* when the lookup has completed. */
OPENSSL_EXPORT SSL_SESSION *SSL_magic_pending_session_ptr(void);
/* GEN_SESSION_CB is a callback to generate session IDs for |ssl|. It returns
* one on success and zero on error. On success, the generated ID is written to
* |id| and |*id_len| set to the length. On entry, |*id_len| is the maximum
* length of the ID, but the callback may shorten it if desired. It is an error
* for the callback to set the size to zero.
*
* Callbacks may use |SSL_has_matching_session_id| to check that the generated
* ID is unique. */
typedef int (*GEN_SESSION_CB)(const SSL *ssl, uint8_t *id, unsigned *id_len);
/* SSL_CTX_set_generate_session_id sets the session ID callback of |ctx| to
* |cb| and returns one. It will be called on the server when establishing a new
* session. */
OPENSSL_EXPORT int SSL_CTX_set_generate_session_id(SSL_CTX *ctx,
GEN_SESSION_CB cb);
/* SSL_set_generate_session_id sets the session ID callback of |ssl| to |cb| and
* returns one. It will be called on the server when establishing a new
* session. */
OPENSSL_EXPORT int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb);
/* SSL_has_matching_session_id returns one if |ssl|'s session cache has a
* session of value |id| and zero otherwise. */
OPENSSL_EXPORT int SSL_has_matching_session_id(const SSL *ssl,
const uint8_t *id,
unsigned id_len);
/* Session tickets.
*
* Session tickets, from RFC 5077, allow session resumption without server-side
* state. Session tickets are supported in by default but may be disabled with
* |SSL_OP_NO_TICKET|.
*
* On the client, ticket-based sessions use the same APIs as ID-based tickets.
* Callers do not need to handle them differently.
*
* On the server, tickets are encrypted and authenticated with a secret key. By
* default, an |SSL_CTX| generates a key on creation. Tickets are minted and
* processed transparently. The following functions may be used to configure a
* persistent key or implement more custom behavior. */
Move the session ticket functions to ssl.h. Having them spread between ssl.h and tls1.h isn't terribly enlightening. Change-Id: I5fec4b8e5260312b22bcef21bd4db7a8a8149ad8 Reviewed-on: https://boringssl-review.googlesource.com/5234 Reviewed-by: Adam Langley <agl@google.com>
2015-06-25 22:35:11 +01:00
/* SSL_CTX_get_tlsext_ticket_keys writes |ctx|'s session ticket key material to
* |len| bytes of |out|. It returns one on success and zero if |len| is not
* 48. If |out| is NULL, it returns 48 instead. */
OPENSSL_EXPORT int SSL_CTX_get_tlsext_ticket_keys(SSL_CTX *ctx, void *out,
size_t len);
/* SSL_CTX_set_tlsext_ticket_keys sets |ctx|'s session ticket key material to
* |len| bytes of |in|. It returns one on success and zero if |len| is not
* 48. If |in| is NULL, it returns 48 instead. */
OPENSSL_EXPORT int SSL_CTX_set_tlsext_ticket_keys(SSL_CTX *ctx, const void *in,
size_t len);
Cleanup ticket processing and session lookup. Use more sensible variable names. Also move some work between the helpers and s3_srvr.c a little; the session lookup functions now only return a new session. Whether to send a ticket is now an additional output to avoid the enum explosion around renewal. The actual SSL state is not modified. This is somewhat cleaner as s3_srvr.c may still reject a session for other reasons, so we avoid setting ssl->session and ssl->verify_result to a session that wouldn't be used. (They get fixed up in ssl_get_new_session, so it didn't actually matter.) Change-Id: Ib52fabbe993b5e2b7408395a02cdea3dee66df7b Reviewed-on: https://boringssl-review.googlesource.com/5235 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 20:34:50 +01:00
/* SSL_TICKET_KEY_NAME_LEN is the length of the key name prefix of a session
* ticket. */
#define SSL_TICKET_KEY_NAME_LEN 16
Move the session ticket functions to ssl.h. Having them spread between ssl.h and tls1.h isn't terribly enlightening. Change-Id: I5fec4b8e5260312b22bcef21bd4db7a8a8149ad8 Reviewed-on: https://boringssl-review.googlesource.com/5234 Reviewed-by: Adam Langley <agl@google.com>
2015-06-25 22:35:11 +01:00
/* SSL_CTX_set_tlsext_ticket_key_cb sets the ticket callback to |callback| and
* returns one. |callback| will be called when encrypting a new ticket and when
* decrypting a ticket from the client.
*
* In both modes, |ctx| and |hmac_ctx| will already have been initialized with
* |EVP_CIPHER_CTX_init| and |HMAC_CTX_init|, respectively. |callback|
* configures |hmac_ctx| with an HMAC digest and key, and configures |ctx|
* for encryption or decryption, based on the mode.
*
* When encrypting a new ticket, |encrypt| will be one. It writes a public
* 16-byte key name to |key_name| and a fresh IV to |iv|. The output IV length
* must match |EVP_CIPHER_CTX_iv_length| of the cipher selected. In this mode,
* |callback| returns 1 on success and -1 on error.
*
* When decrypting a ticket, |encrypt| will be zero. |key_name| will point to a
* 16-byte key name and |iv| points to an IV. The length of the IV consumed must
* match |EVP_CIPHER_CTX_iv_length| of the cipher selected. In this mode,
* |callback| returns -1 to abort the handshake, 0 if decrypting the ticket
* failed, and 1 or 2 on success. If it returns 2, the ticket will be renewed.
* This may be used to re-key the ticket.
*
* WARNING: |callback| wildly breaks the usual return value convention and is
* called in two different modes. */
OPENSSL_EXPORT int SSL_CTX_set_tlsext_ticket_key_cb(
SSL_CTX *ctx, int (*callback)(SSL *ssl, uint8_t *key_name, uint8_t *iv,
EVP_CIPHER_CTX *ctx, HMAC_CTX *hmac_ctx,
int encrypt));
ECDHE and DHE functions get grouped into sections. All these functions were already documented, just not grouped. I put these above DTLS-SRTP and PSK as they're considerably less niche of features. Change-Id: I610892ce9763fe0da4f65ec87e5c7aaecb10388b Reviewed-on: https://boringssl-review.googlesource.com/5895 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 04:49:00 +01:00
/* Elliptic curve Diffie-Hellman.
*
* Cipher suites using an ECDHE key exchange perform Diffie-Hellman over an
* elliptic curve negotiated by both endpoints. See RFC 4492. Only named curves
* are supported. ECDHE is always enabled, but the curve preferences may be
* configured with these functions.
*
* A client may use |SSL_SESSION_get_key_exchange_info| to determine the curve
* selected. */
/* SSL_CTX_set1_curves sets the preferred curves for |ctx| to be |curves|. Each
* element of |curves| should be a curve nid. It returns one on success and
* zero on failure. */
OPENSSL_EXPORT int SSL_CTX_set1_curves(SSL_CTX *ctx, const int *curves,
size_t curves_len);
/* SSL_set1_curves sets the preferred curves for |ssl| to be |curves|. Each
* element of |curves| should be a curve nid. It returns one on success and
* zero on failure. */
OPENSSL_EXPORT int SSL_set1_curves(SSL *ssl, const int *curves,
size_t curves_len);
/* SSL_CTX_set_tmp_ecdh configures |ctx| to use the curve from |ecdh| as the
* curve for ephemeral ECDH keys. For historical reasons, this API expects an
* |EC_KEY|, but only the curve is used. It returns one on success and zero on
* error. If unset, an appropriate curve will be chosen based on curve
* preferences. (This is recommended.) */
OPENSSL_EXPORT int SSL_CTX_set_tmp_ecdh(SSL_CTX *ctx, const EC_KEY *ec_key);
/* SSL_set_tmp_ecdh configures |ssl| to use the curve from |ecdh| as the curve
* for ephemeral ECDH keys. For historical reasons, this API expects an
* |EC_KEY|, but only the curve is used. It returns one on success and zero on
* error. If unset, an appropriate curve will be chosen based on curve
* preferences. (This is recommended.) */
OPENSSL_EXPORT int SSL_set_tmp_ecdh(SSL *ssl, const EC_KEY *ec_key);
/* SSL_CTX_set_tmp_ecdh_callback configures |ctx| to use |callback| to determine
* the curve for ephemeral ECDH keys. |callback| should ignore |is_export| and
* |keylength| and return an |EC_KEY| of the selected curve or NULL on
* error. Only the curve is used, so the |EC_KEY| needn't have a generated
* keypair.
*
* If the callback is unset, an appropriate curve will be chosen based on curve
* preferences. (This is recommended.)
*
* WARNING: The caller does not take ownership of the resulting |EC_KEY|, so
* |callback| must save and release the object elsewhere. */
OPENSSL_EXPORT void SSL_CTX_set_tmp_ecdh_callback(
SSL_CTX *ctx, EC_KEY *(*callback)(SSL *ssl, int is_export, int keylength));
/* SSL_set_tmp_ecdh_callback configures |ssl| to use |callback| to determine the
* curve for ephemeral ECDH keys. |callback| should ignore |is_export| and
* |keylength| and return an |EC_KEY| of the selected curve or NULL on
* error. Only the curve is used, so the |EC_KEY| needn't have a generated
* keypair.
*
* If the callback is unset, an appropriate curve will be chosen based on curve
* preferences. (This is recommended.)
*
* WARNING: The caller does not take ownership of the resulting |EC_KEY|, so
* |callback| must save and release the object elsewhere. */
OPENSSL_EXPORT void SSL_set_tmp_ecdh_callback(
SSL *ssl, EC_KEY *(*callback)(SSL *ssl, int is_export, int keylength));
/* SSL_get_curve_name returns a human-readable name for the elliptic curve
* specified by the given TLS curve id, or NULL if the curve if unknown. */
Document certificate verification functions in SSL. Or at least group them together and make a passing attempt to document them. The legacy X.509 stack itself remains largely untouched and most of the parameters have to do with it. Change-Id: I9e11e2ad1bbeef53478c787344398c0d8d1b3876 Reviewed-on: https://boringssl-review.googlesource.com/5942 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 18:04:22 +01:00
OPENSSL_EXPORT const char *SSL_get_curve_name(uint16_t curve_id);
ECDHE and DHE functions get grouped into sections. All these functions were already documented, just not grouped. I put these above DTLS-SRTP and PSK as they're considerably less niche of features. Change-Id: I610892ce9763fe0da4f65ec87e5c7aaecb10388b Reviewed-on: https://boringssl-review.googlesource.com/5895 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 04:49:00 +01:00
/* Multiplicative Diffie-Hellman.
*
* Cipher suites using a DHE key exchange perform Diffie-Hellman over a
* multiplicative group selected by the server. These ciphers are disabled for a
* server unless a group is chosen with one of these functions.
*
* A client may use |SSL_SESSION_get_key_exchange_info| to determine the size of
* the selected group's prime, but note that servers may select degenerate
* groups. */
/* SSL_CTX_set_tmp_dh configures |ctx| to use the group from |dh| as the group
* for DHE. Only the group is used, so |dh| needn't have a keypair. It returns
* one on success and zero on error. */
OPENSSL_EXPORT int SSL_CTX_set_tmp_dh(SSL_CTX *ctx, const DH *dh);
/* SSL_set_tmp_dh configures |ssl| to use the group from |dh| as the group for
* DHE. Only the group is used, so |dh| needn't have a keypair. It returns one
* on success and zero on error. */
OPENSSL_EXPORT int SSL_set_tmp_dh(SSL *ssl, const DH *dh);
/* SSL_CTX_set_tmp_dh_callback configures |ctx| to use |callback| to determine
* the group for DHE ciphers. |callback| should ignore |is_export| and
* |keylength| and return a |DH| of the selected group or NULL on error. Only
* the parameters are used, so the |DH| needn't have a generated keypair.
*
* WARNING: The caller does not take ownership of the resulting |DH|, so
* |callback| must save and release the object elsewhere. */
OPENSSL_EXPORT void SSL_CTX_set_tmp_dh_callback(
SSL_CTX *ctx, DH *(*callback)(SSL *ssl, int is_export, int keylength));
/* SSL_set_tmp_dh_callback configures |ssl| to use |callback| to determine the
* group for DHE ciphers. |callback| should ignore |is_export| and |keylength|
* and return a |DH| of the selected group or NULL on error. Only the
* parameters are used, so the |DH| needn't have a generated keypair.
*
* WARNING: The caller does not take ownership of the resulting |DH|, so
* |callback| must save and release the object elsewhere. */
OPENSSL_EXPORT void SSL_set_tmp_dh_callback(SSL *ssl,
DH *(*dh)(SSL *ssl, int is_export,
int keylength));
Document certificate verification functions in SSL. Or at least group them together and make a passing attempt to document them. The legacy X.509 stack itself remains largely untouched and most of the parameters have to do with it. Change-Id: I9e11e2ad1bbeef53478c787344398c0d8d1b3876 Reviewed-on: https://boringssl-review.googlesource.com/5942 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 18:04:22 +01:00
/* Certificate verification.
*
* SSL may authenticate either endpoint with an X.509 certificate. Typically
* this is used to authenticate the server to the client. These functions
* configure certificate verification.
*
* WARNING: By default, certificate verification errors on a client are not
* fatal. See |SSL_VERIFY_NONE| This may be configured with
* |SSL_CTX_set_verify|.
*
* By default clients are anonymous but a server may request a certificate from
* the client by setting |SSL_VERIFY_PEER|.
*
* Many of these functions use OpenSSL's legacy X.509 stack which is
* underdocumented and deprecated, but the replacement isn't ready yet. For
* now, consumers may use the existing stack or bypass it by performing
* certificate verification externally. This may be done with
* |SSL_CTX_set_cert_verify_callback| or by extracting the chain with
* |SSL_get_peer_cert_chain| after the handshake. In the future, functions will
OCSP stapling and SCT extensions go under certificate verification. This mirrors how the server halves fall under configuring certificates. Change-Id: I9bde85eecfaff6487eeb887c88cb8bb0c36b83d8 Reviewed-on: https://boringssl-review.googlesource.com/5961 Reviewed-by: Adam Langley <agl@google.com>
2015-09-20 05:00:28 +01:00
* be added to use the SSL stack without dependency on any part of the legacy
* X.509 and ASN.1 stack.
*
* To augment certificate verification, a client may also enable OCSP stapling
* (RFC 6066) and Certificate Transparency (RFC 6962) extensions. */
Document certificate verification functions in SSL. Or at least group them together and make a passing attempt to document them. The legacy X.509 stack itself remains largely untouched and most of the parameters have to do with it. Change-Id: I9e11e2ad1bbeef53478c787344398c0d8d1b3876 Reviewed-on: https://boringssl-review.googlesource.com/5942 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 18:04:22 +01:00
/* SSL_VERIFY_NONE, on a client, verifies the server certificate but does not
* make errors fatal. The result may be checked with |SSL_get_verify_result|. On
* a server it does not request a client certificate. This is the default. */
#define SSL_VERIFY_NONE 0x00
/* SSL_VERIFY_PEER, on a client, makes server certificate errors fatal. On a
* server it requests a client certificate and makes errors fatal. However,
* anonymous clients are still allowed. See
* |SSL_VERIFY_FAIL_IF_NO_PEER_CERT|. */
#define SSL_VERIFY_PEER 0x01
/* SSL_VERIFY_FAIL_IF_NO_PEER_CERT configures a server to reject connections if
* the client declines to send a certificate. Otherwise |SSL_VERIFY_PEER| still
* allows anonymous clients. */
#define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02
/* SSL_VERIFY_PEER_IF_NO_OBC configures a server to request a client certificate
* if and only if Channel ID is not negotiated. */
#define SSL_VERIFY_PEER_IF_NO_OBC 0x04
/* SSL_CTX_set_verify configures certificate verification behavior. |mode| is
* one of the |SSL_VERIFY_*| values defined above. |callback|, if not NULL, is
* used to customize certificate verification. See the behavior of
* |X509_STORE_CTX_set_verify_cb|.
*
* The callback may use |SSL_get_ex_data_X509_STORE_CTX_idx| with
* |X509_STORE_CTX_get_ex_data| to look up the |SSL| from |store_ctx|. */
OPENSSL_EXPORT void SSL_CTX_set_verify(
SSL_CTX *ctx, int mode, int (*callback)(int ok, X509_STORE_CTX *store_ctx));
/* SSL_set_verify configures certificate verification behavior. |mode| is one of
* the |SSL_VERIFY_*| values defined above. |callback|, if not NULL, is used to
* customize certificate verification. See the behavior of
* |X509_STORE_CTX_set_verify_cb|.
*
* The callback may use |SSL_get_ex_data_X509_STORE_CTX_idx| with
* |X509_STORE_CTX_get_ex_data| to look up the |SSL| from |store_ctx|. */
OPENSSL_EXPORT void SSL_set_verify(SSL *ssl, int mode,
int (*callback)(int ok,
X509_STORE_CTX *store_ctx));
/* SSL_CTX_get_verify_mode returns |ctx|'s verify mode, set by
* |SSL_CTX_set_verify|. */
OPENSSL_EXPORT int SSL_CTX_get_verify_mode(const SSL_CTX *ctx);
/* SSL_get_verify_mode returns |ssl|'s verify mode, set by |SSL_CTX_set_verify|
* or |SSL_set_verify|. */
OPENSSL_EXPORT int SSL_get_verify_mode(const SSL *ssl);
/* SSL_CTX_get_verify_callback returns the callback set by
* |SSL_CTX_set_verify|. */
OPENSSL_EXPORT int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(
int ok, X509_STORE_CTX *store_ctx);
/* SSL_get_verify_callback returns the callback set by |SSL_CTX_set_verify| or
* |SSL_set_verify|. */
OPENSSL_EXPORT int (*SSL_get_verify_callback(const SSL *ssl))(
int ok, X509_STORE_CTX *store_ctx);
/* SSL_CTX_set_verify_depth sets the maximum depth of a certificate chain
* accepted in verification. This number does not include the leaf, so a depth
* of 1 allows the leaf and one CA certificate. */
OPENSSL_EXPORT void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth);
/* SSL_set_verify_depth sets the maximum depth of a certificate chain accepted
* in verification. This number does not include the leaf, so a depth of 1
* allows the leaf and one CA certificate. */
OPENSSL_EXPORT void SSL_set_verify_depth(SSL *ssl, int depth);
/* SSL_CTX_get_verify_depth returns the maximum depth of a certificate accepted
* in verification. */
OPENSSL_EXPORT int SSL_CTX_get_verify_depth(const SSL_CTX *ctx);
/* SSL_get_verify_depth returns the maximum depth of a certificate accepted in
* verification. */
OPENSSL_EXPORT int SSL_get_verify_depth(const SSL *ssl);
/* SSL_CTX_set1_param sets verification parameters from |param|. It returns one
* on success and zero on failure. The caller retains ownership of |param|. */
OPENSSL_EXPORT int SSL_CTX_set1_param(SSL_CTX *ctx,
const X509_VERIFY_PARAM *param);
/* SSL_set1_param sets verification parameters from |param|. It returns one on
* success and zero on failure. The caller retains ownership of |param|. */
OPENSSL_EXPORT int SSL_set1_param(SSL *ssl,
const X509_VERIFY_PARAM *param);
/* SSL_CTX_get0_param returns |ctx|'s |X509_VERIFY_PARAM| for certificate
* verification. The caller must not release the returned pointer but may call
* functions on it to configure it. */
OPENSSL_EXPORT X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx);
/* SSL_get0_param returns |ssl|'s |X509_VERIFY_PARAM| for certificate
* verification. The caller must not release the returned pointer but may call
* functions on it to configure it. */
OPENSSL_EXPORT X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl);
/* SSL_CTX_set_purpose sets |ctx|'s |X509_VERIFY_PARAM|'s 'purpose' parameter to
* |purpose|. It returns one on success and zero on error. */
OPENSSL_EXPORT int SSL_CTX_set_purpose(SSL_CTX *ctx, int purpose);
/* SSL_set_purpose sets |ssl|'s |X509_VERIFY_PARAM|'s 'purpose' parameter to
* |purpose|. It returns one on success and zero on error. */
OPENSSL_EXPORT int SSL_set_purpose(SSL *ssl, int purpose);
/* SSL_CTX_set_trust sets |ctx|'s |X509_VERIFY_PARAM|'s 'trust' parameter to
* |trust|. It returns one on success and zero on error. */
OPENSSL_EXPORT int SSL_CTX_set_trust(SSL_CTX *ctx, int trust);
/* SSL_set_trust sets |ssl|'s |X509_VERIFY_PARAM|'s 'trust' parameter to
* |trust|. It returns one on success and zero on error. */
OPENSSL_EXPORT int SSL_set_trust(SSL *ssl, int trust);
/* SSL_CTX_set_cert_store sets |ctx|'s certificate store to |store|. It takes
* ownership of |store|. The store is used for certificate verification.
*
* The store is also used for the auto-chaining feature, but this is deprecated.
* See also |SSL_MODE_NO_AUTO_CHAIN|. */
OPENSSL_EXPORT void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store);
/* SSL_CTX_get_cert_store returns |ctx|'s certificate store. */
OPENSSL_EXPORT X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx);
/* SSL_CTX_set_default_verify_paths loads the OpenSSL system-default trust
* anchors into |ctx|'s store. It returns one on success and zero on failure. */
OPENSSL_EXPORT int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx);
/* SSL_CTX_load_verify_locations loads trust anchors into |ctx|'s store from
* |ca_file| and |ca_dir|, either of which may be NULL. If |ca_file| is passed,
* it is opened and PEM-encoded CA certificates are read. If |ca_dir| is passed,
* it is treated as a directory in OpenSSL's hashed directory format. It returns
* one on success and zero on failure.
*
* See
* https://www.openssl.org/docs/manmaster/ssl/SSL_CTX_load_verify_locations.html
* for documentation on the directory format. */
OPENSSL_EXPORT int SSL_CTX_load_verify_locations(SSL_CTX *ctx,
const char *ca_file,
const char *ca_dir);
/* SSL_get_verify_result returns the result of certificate verification. It is
* either |X509_V_OK| or a |X509_V_ERR_*| value. */
OPENSSL_EXPORT long SSL_get_verify_result(const SSL *ssl);
/* SSL_set_verify_result overrides the result of certificate verification. */
OPENSSL_EXPORT void SSL_set_verify_result(SSL *ssl, long result);
/* SSL_get_ex_data_X509_STORE_CTX_idx returns the ex_data index used to look up
* the |SSL| associated with an |X509_STORE_CTX| in the verify callback. */
OPENSSL_EXPORT int SSL_get_ex_data_X509_STORE_CTX_idx(void);
/* SSL_CTX_set_cert_verify_callback sets a custom callback to be called on
* certificate verification rather than |X509_verify_cert|. |store_ctx| contains
* the verification parameters. The callback should return one on success and
* zero on fatal error. It may use |X509_STORE_CTX_set_error| to set a
* verification result.
*
* The callback may use either the |arg| parameter or
* |SSL_get_ex_data_X509_STORE_CTX_idx| to recover the associated |SSL|
* object. */
OPENSSL_EXPORT void SSL_CTX_set_cert_verify_callback(
SSL_CTX *ctx, int (*callback)(X509_STORE_CTX *store_ctx, void *arg),
void *arg);
OCSP stapling and SCT extensions go under certificate verification. This mirrors how the server halves fall under configuring certificates. Change-Id: I9bde85eecfaff6487eeb887c88cb8bb0c36b83d8 Reviewed-on: https://boringssl-review.googlesource.com/5961 Reviewed-by: Adam Langley <agl@google.com>
2015-09-20 05:00:28 +01:00
/* SSL_enable_signed_cert_timestamps causes |ssl| (which must be the client end
* of a connection) to request SCTs from the server. See
Put OCSP and SCT accessors with SSL_get_peer_certificate. Grouping along two axes is weird. Doesn't hugely matter which one, but we should be consistent. Change-Id: I80fb04d3eff739c08fda29515ce81d101d8542cb Reviewed-on: https://boringssl-review.googlesource.com/6120 Reviewed-by: Adam Langley <agl@google.com>
2015-10-06 01:14:37 +01:00
* https://tools.ietf.org/html/rfc6962. It returns one.
*
* Call |SSL_get0_signed_cert_timestamp_list| to recover the SCT after the
* handshake. */
OCSP stapling and SCT extensions go under certificate verification. This mirrors how the server halves fall under configuring certificates. Change-Id: I9bde85eecfaff6487eeb887c88cb8bb0c36b83d8 Reviewed-on: https://boringssl-review.googlesource.com/5961 Reviewed-by: Adam Langley <agl@google.com>
2015-09-20 05:00:28 +01:00
OPENSSL_EXPORT int SSL_enable_signed_cert_timestamps(SSL *ssl);
/* SSL_CTX_enable_signed_cert_timestamps enables SCT requests on all client SSL
Put OCSP and SCT accessors with SSL_get_peer_certificate. Grouping along two axes is weird. Doesn't hugely matter which one, but we should be consistent. Change-Id: I80fb04d3eff739c08fda29515ce81d101d8542cb Reviewed-on: https://boringssl-review.googlesource.com/6120 Reviewed-by: Adam Langley <agl@google.com>
2015-10-06 01:14:37 +01:00
* objects created from |ctx|.
OCSP stapling and SCT extensions go under certificate verification. This mirrors how the server halves fall under configuring certificates. Change-Id: I9bde85eecfaff6487eeb887c88cb8bb0c36b83d8 Reviewed-on: https://boringssl-review.googlesource.com/5961 Reviewed-by: Adam Langley <agl@google.com>
2015-09-20 05:00:28 +01:00
*
Put OCSP and SCT accessors with SSL_get_peer_certificate. Grouping along two axes is weird. Doesn't hugely matter which one, but we should be consistent. Change-Id: I80fb04d3eff739c08fda29515ce81d101d8542cb Reviewed-on: https://boringssl-review.googlesource.com/6120 Reviewed-by: Adam Langley <agl@google.com>
2015-10-06 01:14:37 +01:00
* Call |SSL_get0_signed_cert_timestamp_list| to recover the SCT after the
* handshake. */
OPENSSL_EXPORT void SSL_CTX_enable_signed_cert_timestamps(SSL_CTX *ctx);
OCSP stapling and SCT extensions go under certificate verification. This mirrors how the server halves fall under configuring certificates. Change-Id: I9bde85eecfaff6487eeb887c88cb8bb0c36b83d8 Reviewed-on: https://boringssl-review.googlesource.com/5961 Reviewed-by: Adam Langley <agl@google.com>
2015-09-20 05:00:28 +01:00
/* SSL_enable_ocsp_stapling causes |ssl| (which must be the client end of a
* connection) to request a stapled OCSP response from the server. It returns
Put OCSP and SCT accessors with SSL_get_peer_certificate. Grouping along two axes is weird. Doesn't hugely matter which one, but we should be consistent. Change-Id: I80fb04d3eff739c08fda29515ce81d101d8542cb Reviewed-on: https://boringssl-review.googlesource.com/6120 Reviewed-by: Adam Langley <agl@google.com>
2015-10-06 01:14:37 +01:00
* one.
*
* Call |SSL_get0_ocsp_response| to recover the OCSP response after the
* handshake. */
OCSP stapling and SCT extensions go under certificate verification. This mirrors how the server halves fall under configuring certificates. Change-Id: I9bde85eecfaff6487eeb887c88cb8bb0c36b83d8 Reviewed-on: https://boringssl-review.googlesource.com/5961 Reviewed-by: Adam Langley <agl@google.com>
2015-09-20 05:00:28 +01:00
OPENSSL_EXPORT int SSL_enable_ocsp_stapling(SSL *ssl);
/* SSL_CTX_enable_ocsp_stapling enables OCSP stapling on all client SSL objects
Put OCSP and SCT accessors with SSL_get_peer_certificate. Grouping along two axes is weird. Doesn't hugely matter which one, but we should be consistent. Change-Id: I80fb04d3eff739c08fda29515ce81d101d8542cb Reviewed-on: https://boringssl-review.googlesource.com/6120 Reviewed-by: Adam Langley <agl@google.com>
2015-10-06 01:14:37 +01:00
* created from |ctx|.
OCSP stapling and SCT extensions go under certificate verification. This mirrors how the server halves fall under configuring certificates. Change-Id: I9bde85eecfaff6487eeb887c88cb8bb0c36b83d8 Reviewed-on: https://boringssl-review.googlesource.com/5961 Reviewed-by: Adam Langley <agl@google.com>
2015-09-20 05:00:28 +01:00
*
Put OCSP and SCT accessors with SSL_get_peer_certificate. Grouping along two axes is weird. Doesn't hugely matter which one, but we should be consistent. Change-Id: I80fb04d3eff739c08fda29515ce81d101d8542cb Reviewed-on: https://boringssl-review.googlesource.com/6120 Reviewed-by: Adam Langley <agl@google.com>
2015-10-06 01:14:37 +01:00
* Call |SSL_get0_ocsp_response| to recover the OCSP response after the
* handshake. */
OPENSSL_EXPORT void SSL_CTX_enable_ocsp_stapling(SSL_CTX *ctx);
OCSP stapling and SCT extensions go under certificate verification. This mirrors how the server halves fall under configuring certificates. Change-Id: I9bde85eecfaff6487eeb887c88cb8bb0c36b83d8 Reviewed-on: https://boringssl-review.googlesource.com/5961 Reviewed-by: Adam Langley <agl@google.com>
2015-09-20 05:00:28 +01:00
Document certificate verification functions in SSL. Or at least group them together and make a passing attempt to document them. The legacy X.509 stack itself remains largely untouched and most of the parameters have to do with it. Change-Id: I9e11e2ad1bbeef53478c787344398c0d8d1b3876 Reviewed-on: https://boringssl-review.googlesource.com/5942 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 18:04:22 +01:00
/* Client certificate CA list.
*
* When requesting a client certificate, a server may advertise a list of
* certificate authorities which are accepted. These functions may be used to
* configure this list. */
/* SSL_set_client_CA_list sets |ssl|'s client certificate CA list to
* |name_list|. It takes ownership of |name_list|. */
OPENSSL_EXPORT void SSL_set_client_CA_list(SSL *ssl,
STACK_OF(X509_NAME) *name_list);
/* SSL_CTX_set_client_CA_list sets |ctx|'s client certificate CA list to
* |name_list|. It takes ownership of |name_list|. */
OPENSSL_EXPORT void SSL_CTX_set_client_CA_list(SSL_CTX *ctx,
STACK_OF(X509_NAME) *name_list);
Better document the callbacks around client certificates. Deprecate the client_cert_cb variant since you can't really configure intermediates with it. (You might be able to by configuring the intermediates without the leaf or key and leaving the SSL stack to configure those, but that's really weird. cert_cb is simpler.) Also document the two functions the callbacks may use to query the CertificateRequest on the client. Change-Id: Iad6076266fd798cd74ea4e09978e7f5df5c8a670 Reviewed-on: https://boringssl-review.googlesource.com/6092 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 15:49:20 +01:00
/* SSL_get_client_CA_list returns |ssl|'s client certificate CA list. If |ssl|
* has not been configured as a client, this is the list configured by
* |SSL_CTX_set_client_CA_list|.
*
* If configured as a client, it returns the client certificate CA list sent by
* the server. In this mode, the behavior is undefined except during the
* callbacks set by |SSL_CTX_set_cert_cb| and |SSL_CTX_set_client_cert_cb| or
* when the handshake is paused because of them. */
Document certificate verification functions in SSL. Or at least group them together and make a passing attempt to document them. The legacy X.509 stack itself remains largely untouched and most of the parameters have to do with it. Change-Id: I9e11e2ad1bbeef53478c787344398c0d8d1b3876 Reviewed-on: https://boringssl-review.googlesource.com/5942 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 18:04:22 +01:00
OPENSSL_EXPORT STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *ssl);
/* SSL_CTX_get_client_CA_list returns |ctx|'s client certificate CA list. */
OPENSSL_EXPORT STACK_OF(X509_NAME) *
SSL_CTX_get_client_CA_list(const SSL_CTX *ctx);
/* SSL_add_client_CA appends |x509|'s subject to the client certificate CA list.
* It returns one on success or zero on error. The caller retains ownership of
* |x509|. */
OPENSSL_EXPORT int SSL_add_client_CA(SSL *ssl, X509 *x509);
/* SSL_CTX_add_client_CA appends |x509|'s subject to the client certificate CA
* list. It returns one on success or zero on error. The caller retains
* ownership of |x509|. */
OPENSSL_EXPORT int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x509);
/* SSL_load_client_CA_file opens |file| and reads PEM-encoded certificates from
* it. It returns a newly-allocated stack of the certificate subjects or NULL
* on error. */
OPENSSL_EXPORT STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file);
/* SSL_dup_CA_list makes a deep copy of |list|. It returns the new list on
* success or NULL on allocation error. */
OPENSSL_EXPORT STACK_OF(X509_NAME) *SSL_dup_CA_list(STACK_OF(X509_NAME) *list);
/* SSL_add_file_cert_subjects_to_stack behaves like |SSL_load_client_CA_file|
* but appends the result to |out|. It returns one on success or zero on
* error. */
OPENSSL_EXPORT int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *out,
const char *file);
/* SSL_add_dir_cert_subjects_to_stack lists files in directory |dir|. It calls
* |SSL_add_file_cert_subjects_to_stack| on each file and returns one on success
* or zero on error. */
OPENSSL_EXPORT int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *out,
const char *dir);
Move remaining functions out of tls1.h. Now tls1.h is just a pile of protocol constants with no more circular dependency problem. I've preserved SSL_get_servername's behavior where it's simultaneously a lookup of handshake state and local configuration. I've removed it from SSL_get_servername_type. It got the logic wrong anyway with the order of the s->session check. (Searching through code, neither is used on the client, but the SSL_get_servername one is easy.) Change-Id: I61bb8fb0858b07d76a7835bffa6dc793812fb027 Reviewed-on: https://boringssl-review.googlesource.com/6298 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-17 18:48:04 +01:00
/* Server name indication.
*
* The server_name extension (RFC 3546) allows the client to advertise the name
* of the server it is connecting to. This is used in virtual hosting
* deployments to select one of a several certificates on a single IP. Only the
* host_name name type is supported. */
#define TLSEXT_NAMETYPE_host_name 0
/* SSL_set_tlsext_host_name, for a client, configures |ssl| to advertise |name|
* in the server_name extension. It returns one on success and zero on error. */
OPENSSL_EXPORT int SSL_set_tlsext_host_name(SSL *ssl, const char *name);
/* SSL_get_servername, for a server, returns the hostname supplied by the
* client or NULL if there was none. The |type| argument must be
* |TLSEXT_NAMETYPE_host_name|. */
OPENSSL_EXPORT const char *SSL_get_servername(const SSL *ssl, const int type);
/* SSL_get_servername_type, for a server, returns |TLSEXT_NAMETYPE_host_name|
* if the client sent a hostname and -1 otherwise. */
OPENSSL_EXPORT int SSL_get_servername_type(const SSL *ssl);
/* SSL_CTX_set_tlsext_servername_callback configures |callback| to be called on
* the server after ClientHello extensions have been parsed and returns one.
* The callback may use |SSL_get_servername| to examine the server_name extension
* and returns a |SSL_TLSEXT_ERR_*| value. The value of |arg| may be set by
* calling |SSL_CTX_set_tlsext_servername_arg|.
*
* If the callback returns |SSL_TLSEXT_ERR_NOACK|, the server_name extension is
* not acknowledged in the ServerHello. If the return value is
* |SSL_TLSEXT_ERR_ALERT_FATAL| or |SSL_TLSEXT_ERR_ALERT_WARNING| then
* |*out_alert| must be set to the alert value to send. */
OPENSSL_EXPORT int SSL_CTX_set_tlsext_servername_callback(
SSL_CTX *ctx, int (*callback)(SSL *ssl, int *out_alert, void *arg));
/* SSL_CTX_set_tlsext_servername_arg sets the argument to the servername
* callback and returns one. See |SSL_CTX_set_tlsext_servername_callback|. */
OPENSSL_EXPORT int SSL_CTX_set_tlsext_servername_arg(SSL_CTX *ctx, void *arg);
/* SSL_TLSEXT_ERR_* are values returned by some extension-related callbacks. */
#define SSL_TLSEXT_ERR_OK 0
#define SSL_TLSEXT_ERR_ALERT_WARNING 1
#define SSL_TLSEXT_ERR_ALERT_FATAL 2
#define SSL_TLSEXT_ERR_NOACK 3
Group ALPN functions into their own section. These were already documented, though some of the documentation was expanded on slightly. Change-Id: I04c6276a83a64a03ab9cce9b9c94d4dea9ddf638 Reviewed-on: https://boringssl-review.googlesource.com/5896 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 05:10:19 +01:00
/* Application-layer protocol negotation.
*
* The ALPN extension (RFC 7301) allows negotiating different application-layer
* protocols over a single port. This is used, for example, to negotiate
* HTTP/2. */
/* SSL_CTX_set_alpn_protos sets the client ALPN protocol list on |ctx| to
* |protos|. |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
* length-prefixed strings). It returns zero on success and one on failure.
* Configuring this list enables ALPN on a client.
*
* WARNING: this function is dangerous because it breaks the usual return value
* convention. */
OPENSSL_EXPORT int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const uint8_t *protos,
unsigned protos_len);
/* SSL_set_alpn_protos sets the client ALPN protocol list on |ssl| to |protos|.
* |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
* length-prefixed strings). It returns zero on success and one on failure.
* Configuring this list enables ALPN on a client.
*
* WARNING: this function is dangerous because it breaks the usual return value
* convention. */
OPENSSL_EXPORT int SSL_set_alpn_protos(SSL *ssl, const uint8_t *protos,
unsigned protos_len);
/* SSL_CTX_set_alpn_select_cb sets a callback function on |ctx| that is called
* during ClientHello processing in order to select an ALPN protocol from the
* client's list of offered protocols. Configuring this callback enables ALPN on
* a server.
*
* The callback is passed a wire-format (i.e. a series of non-empty, 8-bit
* length-prefixed strings) ALPN protocol list in |in|. It should set |*out| and
* |*out_len| to the selected protocol and return |SSL_TLSEXT_ERR_OK| on
* success. It does not pass ownership of the buffer. Otherwise, it should
* return |SSL_TLSEXT_ERR_NOACK|. Other |SSL_TLSEXT_ERR_*| values are
* unimplemented and will be treated as |SSL_TLSEXT_ERR_NOACK|. */
OPENSSL_EXPORT void SSL_CTX_set_alpn_select_cb(
SSL_CTX *ctx, int (*cb)(SSL *ssl, const uint8_t **out, uint8_t *out_len,
const uint8_t *in, unsigned in_len, void *arg),
void *arg);
/* SSL_get0_alpn_selected gets the selected ALPN protocol (if any) from |ssl|.
* On return it sets |*out_data| to point to |*out_len| bytes of protocol name
* (not including the leading length-prefix byte). If the server didn't respond
* with a negotiated protocol then |*out_len| will be zero. */
OPENSSL_EXPORT void SSL_get0_alpn_selected(const SSL *ssl,
const uint8_t **out_data,
unsigned *out_len);
Group NPN functions in their own section. Existing documentation was moved to the header, very slightly tweaked. Change-Id: Ife3c2351e2d7e6a335854284f996918039414446 Reviewed-on: https://boringssl-review.googlesource.com/5897 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 05:25:52 +01:00
/* Next protocol negotiation.
*
* The NPN extension (draft-agl-tls-nextprotoneg-03) is the predecessor to ALPN
* and deprecated in favor of it. */
/* SSL_CTX_set_next_protos_advertised_cb sets a callback that is called when a
* TLS server needs a list of supported protocols for Next Protocol
* Negotiation. The returned list must be in wire format. The list is returned
* by setting |*out| to point to it and |*out_len| to its length. This memory
* will not be modified, but one should assume that |ssl| keeps a reference to
* it.
*
* The callback should return |SSL_TLSEXT_ERR_OK| if it wishes to advertise.
* Otherwise, no such extension will be included in the ServerHello. */
OPENSSL_EXPORT void SSL_CTX_set_next_protos_advertised_cb(
SSL_CTX *ctx,
int (*cb)(SSL *ssl, const uint8_t **out, unsigned *out_len, void *arg),
void *arg);
/* SSL_CTX_set_next_proto_select_cb sets a callback that is called when a client
* needs to select a protocol from the server's provided list. |*out| must be
* set to point to the selected protocol (which may be within |in|). The length
* of the protocol name must be written into |*out_len|. The server's advertised
* protocols are provided in |in| and |in_len|. The callback can assume that
* |in| is syntactically valid.
*
* The client must select a protocol. It is fatal to the connection if this
* callback returns a value other than |SSL_TLSEXT_ERR_OK|.
*
* Configuring this callback enables NPN on a client. */
OPENSSL_EXPORT void SSL_CTX_set_next_proto_select_cb(
SSL_CTX *ctx, int (*cb)(SSL *ssl, uint8_t **out, uint8_t *out_len,
const uint8_t *in, unsigned in_len, void *arg),
void *arg);
/* SSL_get0_next_proto_negotiated sets |*out_data| and |*out_len| to point to
* the client's requested protocol for this connection. If the client didn't
* request any protocol, then |*out_data| is set to NULL.
*
* Note that the client can request any protocol it chooses. The value returned
* from this function need not be a member of the list of supported protocols
* provided by the server. */
OPENSSL_EXPORT void SSL_get0_next_proto_negotiated(const SSL *ssl,
const uint8_t **out_data,
unsigned *out_len);
/* SSL_select_next_proto implements the standard protocol selection. It is
* expected that this function is called from the callback set by
* |SSL_CTX_set_next_proto_select_cb|.
*
* The protocol data is assumed to be a vector of 8-bit, length prefixed byte
* strings. The length byte itself is not included in the length. A byte
* string of length 0 is invalid. No byte string may be truncated.
*
* The current, but experimental algorithm for selecting the protocol is:
*
* 1) If the server doesn't support NPN then this is indicated to the
* callback. In this case, the client application has to abort the connection
* or have a default application level protocol.
*
* 2) If the server supports NPN, but advertises an empty list then the
* client selects the first protcol in its list, but indicates via the
* API that this fallback case was enacted.
*
* 3) Otherwise, the client finds the first protocol in the server's list
* that it supports and selects this protocol. This is because it's
* assumed that the server has better information about which protocol
* a client should use.
*
* 4) If the client doesn't support any of the server's advertised
* protocols, then this is treated the same as case 2.
*
* It returns either |OPENSSL_NPN_NEGOTIATED| if a common protocol was found, or
* |OPENSSL_NPN_NO_OVERLAP| if the fallback case was reached. */
OPENSSL_EXPORT int SSL_select_next_proto(uint8_t **out, uint8_t *out_len,
const uint8_t *server,
unsigned server_len,
const uint8_t *client,
unsigned client_len);
#define OPENSSL_NPN_UNSUPPORTED 0
#define OPENSSL_NPN_NEGOTIATED 1
#define OPENSSL_NPN_NO_OVERLAP 2
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
/* Channel ID.
*
* See draft-balfanz-tls-channelid-01. */
/* SSL_CTX_enable_tls_channel_id either configures a TLS server to accept TLS
* Channel IDs from clients, or configures a client to send TLS Channel IDs to
* a server. It returns one. */
OPENSSL_EXPORT int SSL_CTX_enable_tls_channel_id(SSL_CTX *ctx);
/* SSL_enable_tls_channel_id either configures a TLS server to accept TLS
* Channel IDs from clients, or configures a client to send TLS Channel IDs to
* server. It returns one. */
OPENSSL_EXPORT int SSL_enable_tls_channel_id(SSL *ssl);
/* SSL_CTX_set1_tls_channel_id configures a TLS client to send a TLS Channel ID
* to compatible servers. |private_key| must be a P-256 EC key. It returns one
* on success and zero on error. */
OPENSSL_EXPORT int SSL_CTX_set1_tls_channel_id(SSL_CTX *ctx,
EVP_PKEY *private_key);
/* SSL_set1_tls_channel_id configures a TLS client to send a TLS Channel ID to
* compatible servers. |private_key| must be a P-256 EC key. It returns one on
* success and zero on error. */
OPENSSL_EXPORT int SSL_set1_tls_channel_id(SSL *ssl, EVP_PKEY *private_key);
/* SSL_get_tls_channel_id gets the client's TLS Channel ID from a server |SSL*|
* and copies up to the first |max_out| bytes into |out|. The Channel ID
* consists of the client's P-256 public key as an (x,y) pair where each is a
* 32-byte, big-endian field element. It returns 0 if the client didn't offer a
* Channel ID and the length of the complete Channel ID otherwise. */
OPENSSL_EXPORT size_t SSL_get_tls_channel_id(SSL *ssl, uint8_t *out,
size_t max_out);
/* SSL_CTX_set_channel_id_cb sets a callback to be called when a TLS Channel ID
* is requested. The callback may set |*out_pkey| to a key, passing a reference
* to the caller. If none is returned, the handshake will pause and
* |SSL_get_error| will return |SSL_ERROR_WANT_CHANNEL_ID_LOOKUP|.
*
* See also |SSL_ERROR_WANT_CHANNEL_ID_LOOKUP|. */
OPENSSL_EXPORT void SSL_CTX_set_channel_id_cb(
SSL_CTX *ctx, void (*channel_id_cb)(SSL *ssl, EVP_PKEY **out_pkey));
/* SSL_CTX_get_channel_id_cb returns the callback set by
* |SSL_CTX_set_channel_id_cb|. */
OPENSSL_EXPORT void (*SSL_CTX_get_channel_id_cb(SSL_CTX *ctx))(
SSL *ssl, EVP_PKEY **out_pkey);
Fold srtp.h into ssl.h. This gets the documentation into the ssl.h documentation, and removes one of the circularly-dependent headers hanging off ssl.h. Also fixes some typos; there were a few instances of "SSL *ctx". Change-Id: I2a41c6f518f4780af84d468ed220fe7b0b8eb0d3 Reviewed-on: https://boringssl-review.googlesource.com/5883 Reviewed-by: Adam Langley <agl@google.com>
2015-09-14 06:54:44 +01:00
/* DTLS-SRTP.
*
* See RFC 5764. */
/* An SRTP_PROTECTION_PROFILE is an SRTP profile for use with the use_srtp
* extension. */
struct srtp_protection_profile_st {
const char *name;
unsigned long id;
} /* SRTP_PROTECTION_PROFILE */;
DECLARE_STACK_OF(SRTP_PROTECTION_PROFILE)
/* SRTP_* define constants for SRTP profiles. */
#define SRTP_AES128_CM_SHA1_80 0x0001
#define SRTP_AES128_CM_SHA1_32 0x0002
#define SRTP_AES128_F8_SHA1_80 0x0003
#define SRTP_AES128_F8_SHA1_32 0x0004
#define SRTP_NULL_SHA1_80 0x0005
#define SRTP_NULL_SHA1_32 0x0006
/* SSL_CTX_set_srtp_profiles enables SRTP for all SSL objects created from
* |ctx|. |profile| contains a colon-separated list of profile names. It returns
* one on success and zero on failure. */
OPENSSL_EXPORT int SSL_CTX_set_srtp_profiles(SSL_CTX *ctx,
const char *profiles);
/* SSL_set_srtp_profiles enables SRTP for |ssl|. |profile| contains a
* colon-separated list of profile names. It returns one on success and zero on
* failure. */
OPENSSL_EXPORT int SSL_set_srtp_profiles(SSL *ssl, const char *profiles);
/* SSL_get_srtp_profiles returns the SRTP profiles supported by |ssl|. */
OPENSSL_EXPORT STACK_OF(SRTP_PROTECTION_PROFILE) *SSL_get_srtp_profiles(
SSL *ssl);
/* SSL_get_selected_srtp_profile returns the selected SRTP profile, or NULL if
* SRTP was not negotiated. */
OPENSSL_EXPORT const SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(
SSL *ssl);
Document PSK functions in ssl.h. Change-Id: Iac58d28570d429236de1d2bc40b631e252b8e710 Reviewed-on: https://boringssl-review.googlesource.com/5893 Reviewed-by: Adam Langley <agl@google.com>
2015-09-15 13:05:54 +01:00
/* Pre-shared keys.
*
* Connections may be configured with PSK (Pre-Shared Key) cipher suites. These
* authenticate using out-of-band pre-shared keys rather than certificates. See
* RFC 4279.
*
* This implementation uses NUL-terminated C strings for identities and identity
* hints, so values with a NUL character are not supported. (RFC 4279 does not
* specify the format of an identity.) */
/* PSK_MAX_IDENTITY_LEN is the maximum supported length of a PSK identity,
* excluding the NUL terminator. */
#define PSK_MAX_IDENTITY_LEN 128
/* PSK_MAX_PSK_LEN is the maximum supported length of a pre-shared key. */
#define PSK_MAX_PSK_LEN 256
/* SSL_CTX_set_psk_client_callback sets the callback to be called when PSK is
* negotiated on the client. This callback must be set to enable PSK cipher
* suites on the client.
*
* The callback is passed the identity hint in |hint| or NULL if none was
* provided. It should select a PSK identity and write the identity and the
* corresponding PSK to |identity| and |psk|, respectively. The identity is
* written as a NUL-terminated C string of length (excluding the NUL terminator)
* at most |max_identity_len|. The PSK's length must be at most |max_psk_len|.
* The callback returns the length of the PSK or 0 if no suitable identity was
* found. */
OPENSSL_EXPORT void SSL_CTX_set_psk_client_callback(
SSL_CTX *ctx,
unsigned (*psk_client_callback)(
SSL *ssl, const char *hint, char *identity,
unsigned max_identity_len, uint8_t *psk, unsigned max_psk_len));
/* SSL_set_psk_client_callback sets the callback to be called when PSK is
* negotiated on the client. This callback must be set to enable PSK cipher
* suites on the client. See also |SSL_CTX_set_psk_client_callback|. */
OPENSSL_EXPORT void SSL_set_psk_client_callback(
SSL *ssl, unsigned (*psk_client_callback)(SSL *ssl, const char *hint,
char *identity,
unsigned max_identity_len,
uint8_t *psk,
unsigned max_psk_len));
/* SSL_CTX_set_psk_server_callback sets the callback to be called when PSK is
* negotiated on the server. This callback must be set to enable PSK cipher
* suites on the server.
*
* The callback is passed the identity in |identity|. It should write a PSK of
* length at most |max_psk_len| to |psk| and return the number of bytes written
* or zero if the PSK identity is unknown. */
OPENSSL_EXPORT void SSL_CTX_set_psk_server_callback(
SSL_CTX *ctx,
unsigned (*psk_server_callback)(SSL *ssl, const char *identity,
uint8_t *psk,
unsigned max_psk_len));
/* SSL_set_psk_server_callback sets the callback to be called when PSK is
* negotiated on the server. This callback must be set to enable PSK cipher
* suites on the server. See also |SSL_CTX_set_psk_server_callback|. */
OPENSSL_EXPORT void SSL_set_psk_server_callback(
SSL *ssl,
unsigned (*psk_server_callback)(SSL *ssl, const char *identity,
uint8_t *psk,
unsigned max_psk_len));
/* SSL_CTX_use_psk_identity_hint configures server connections to advertise an
* identity hint of |identity_hint|. It returns one on success and zero on
* error. */
OPENSSL_EXPORT int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx,
const char *identity_hint);
/* SSL_use_psk_identity_hint configures server connections to advertise an
* identity hint of |identity_hint|. It returns one on success and zero on
* error. */
OPENSSL_EXPORT int SSL_use_psk_identity_hint(SSL *ssl,
const char *identity_hint);
/* SSL_get_psk_identity_hint returns the PSK identity hint advertised for |ssl|
* or NULL if there is none. */
OPENSSL_EXPORT const char *SSL_get_psk_identity_hint(const SSL *ssl);
/* SSL_get_psk_identity, after the handshake completes, returns the PSK identity
* that was negotiated by |ssl| or NULL if PSK was not used. */
OPENSSL_EXPORT const char *SSL_get_psk_identity(const SSL *ssl);
Document alert handling. SSL_alert_desc_string_long was kept in the undeprecated bucket and one missing alert was added. We have some uses and it's not completely ridiculous for logging purposes. The two-character one is ridiculous though and gets turned into a stub that returns a constant string ("!" or "!!") because M2Crypto expects it. Change-Id: Iaf8794b5d953630216278536236c7113655180af Reviewed-on: https://boringssl-review.googlesource.com/6297 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-17 18:26:57 +01:00
/* Alerts.
*
* TLS and SSL 3.0 use alerts to signal error conditions. Alerts have a type
* (warning or fatal) and description. OpenSSL internally handles fatal alerts
* with dedicated error codes (see |SSL_AD_REASON_OFFSET|). Except for
* close_notify, warning alerts are silently ignored and may only be surfaced
* with |SSL_CTX_set_info_callback|. */
/* SSL_AD_REASON_OFFSET is the offset between error reasons and |SSL_AD_*|
* values. Any error code under |ERR_LIB_SSL| with an error reason above this
* value corresponds to an alert description. Consumers may add or subtract
* |SSL_AD_REASON_OFFSET| to convert between them.
*
* make_errors.go reserves error codes above 1000 for manually-assigned errors.
* This value must be kept in sync with reservedReasonCode in make_errors.h */
#define SSL_AD_REASON_OFFSET 1000
/* SSL_AD_* are alert descriptions for SSL 3.0 and TLS. */
#define SSL_AD_CLOSE_NOTIFY SSL3_AD_CLOSE_NOTIFY
#define SSL_AD_UNEXPECTED_MESSAGE SSL3_AD_UNEXPECTED_MESSAGE
#define SSL_AD_BAD_RECORD_MAC SSL3_AD_BAD_RECORD_MAC
#define SSL_AD_DECRYPTION_FAILED TLS1_AD_DECRYPTION_FAILED
#define SSL_AD_RECORD_OVERFLOW TLS1_AD_RECORD_OVERFLOW
#define SSL_AD_DECOMPRESSION_FAILURE SSL3_AD_DECOMPRESSION_FAILURE
#define SSL_AD_HANDSHAKE_FAILURE SSL3_AD_HANDSHAKE_FAILURE
#define SSL_AD_NO_CERTIFICATE SSL3_AD_NO_CERTIFICATE /* Not used in TLS */
#define SSL_AD_BAD_CERTIFICATE SSL3_AD_BAD_CERTIFICATE
#define SSL_AD_UNSUPPORTED_CERTIFICATE SSL3_AD_UNSUPPORTED_CERTIFICATE
#define SSL_AD_CERTIFICATE_REVOKED SSL3_AD_CERTIFICATE_REVOKED
#define SSL_AD_CERTIFICATE_EXPIRED SSL3_AD_CERTIFICATE_EXPIRED
#define SSL_AD_CERTIFICATE_UNKNOWN SSL3_AD_CERTIFICATE_UNKNOWN
#define SSL_AD_ILLEGAL_PARAMETER SSL3_AD_ILLEGAL_PARAMETER
#define SSL_AD_UNKNOWN_CA TLS1_AD_UNKNOWN_CA
#define SSL_AD_ACCESS_DENIED TLS1_AD_ACCESS_DENIED
#define SSL_AD_DECODE_ERROR TLS1_AD_DECODE_ERROR
#define SSL_AD_DECRYPT_ERROR TLS1_AD_DECRYPT_ERROR
#define SSL_AD_EXPORT_RESTRICTION TLS1_AD_EXPORT_RESTRICTION
#define SSL_AD_PROTOCOL_VERSION TLS1_AD_PROTOCOL_VERSION
#define SSL_AD_INSUFFICIENT_SECURITY TLS1_AD_INSUFFICIENT_SECURITY
#define SSL_AD_INTERNAL_ERROR TLS1_AD_INTERNAL_ERROR
#define SSL_AD_USER_CANCELLED TLS1_AD_USER_CANCELLED
#define SSL_AD_NO_RENEGOTIATION TLS1_AD_NO_RENEGOTIATION
#define SSL_AD_UNSUPPORTED_EXTENSION TLS1_AD_UNSUPPORTED_EXTENSION
#define SSL_AD_CERTIFICATE_UNOBTAINABLE TLS1_AD_CERTIFICATE_UNOBTAINABLE
#define SSL_AD_UNRECOGNIZED_NAME TLS1_AD_UNRECOGNIZED_NAME
#define SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE \
TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE
#define SSL_AD_BAD_CERTIFICATE_HASH_VALUE TLS1_AD_BAD_CERTIFICATE_HASH_VALUE
#define SSL_AD_UNKNOWN_PSK_IDENTITY TLS1_AD_UNKNOWN_PSK_IDENTITY
#define SSL_AD_INAPPROPRIATE_FALLBACK SSL3_AD_INAPPROPRIATE_FALLBACK
/* SSL_alert_type_string_long returns a string description of |value| as an
* alert type (warning or fatal). */
OPENSSL_EXPORT const char *SSL_alert_type_string_long(int value);
/* SSL_alert_desc_string_long returns a string description of |value| as an
* alert description or "unknown" if unknown. */
OPENSSL_EXPORT const char *SSL_alert_desc_string_long(int value);
Move ex_data functions in ssl.h to a section. Change-Id: Ie3b7c1956cc9d62091f649d0e621d84fce1d26ec Reviewed-on: https://boringssl-review.googlesource.com/5879 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 19:20:58 +01:00
/* ex_data functions.
*
* See |ex_data.h| for details. */
OPENSSL_EXPORT int SSL_set_ex_data(SSL *ssl, int idx, void *data);
OPENSSL_EXPORT void *SSL_get_ex_data(const SSL *ssl, int idx);
OPENSSL_EXPORT int SSL_get_ex_new_index(long argl, void *argp,
CRYPTO_EX_new *new_func,
CRYPTO_EX_dup *dup_func,
CRYPTO_EX_free *free_func);
OPENSSL_EXPORT int SSL_SESSION_set_ex_data(SSL_SESSION *session, int idx,
void *data);
OPENSSL_EXPORT void *SSL_SESSION_get_ex_data(const SSL_SESSION *session,
int idx);
OPENSSL_EXPORT int SSL_SESSION_get_ex_new_index(long argl, void *argp,
CRYPTO_EX_new *new_func,
CRYPTO_EX_dup *dup_func,
CRYPTO_EX_free *free_func);
OPENSSL_EXPORT int SSL_CTX_set_ex_data(SSL_CTX *ctx, int idx, void *data);
OPENSSL_EXPORT void *SSL_CTX_get_ex_data(const SSL_CTX *ctx, int idx);
OPENSSL_EXPORT int SSL_CTX_get_ex_new_index(long argl, void *argp,
CRYPTO_EX_new *new_func,
CRYPTO_EX_dup *dup_func,
CRYPTO_EX_free *free_func);
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
/* Obscure functions. */
/* SSL_get_rc4_state sets |*read_key| and |*write_key| to the RC4 states for
* the read and write directions. It returns one on success or zero if |ssl|
* isn't using an RC4-based cipher suite. */
OPENSSL_EXPORT int SSL_get_rc4_state(const SSL *ssl, const RC4_KEY **read_key,
const RC4_KEY **write_key);
/* SSL_get_structure_sizes returns the sizes of the SSL, SSL_CTX and
* SSL_SESSION structures so that a test can ensure that outside code agrees on
* these values. */
OPENSSL_EXPORT void SSL_get_structure_sizes(size_t *ssl_size,
size_t *ssl_ctx_size,
size_t *ssl_session_size);
Move a few more functions to the catch-all 'obscure' bucket. Change-Id: I493f26561db2bc8510963a0da5032a758bb1f3ef Reviewed-on: https://boringssl-review.googlesource.com/5960 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 21:23:06 +01:00
/* SSL_CTX_set_msg_callback installs |cb| as the message callback for |ctx|.
* This callback will be called when sending or receiving low-level record
* headers, complete handshake messages, ChangeCipherSpec, and alerts.
* |write_p| is one for outgoing messages and zero for incoming messages.
*
* For each record header, |cb| is called with |version| = 0 and |content_type|
* = |SSL3_RT_HEADER|. The |len| bytes from |buf| contain the header. Note that
* this does not include the record body. If the record is sealed, the length
* in the header is the length of the ciphertext.
*
* For each handshake message, ChangeCipherSpec, and alert, |version| is the
* protocol version and |content_type| is the corresponding record type. The
* |len| bytes from |buf| contain the handshake message, one-byte
* ChangeCipherSpec body, and two-byte alert, respectively. */
OPENSSL_EXPORT void SSL_CTX_set_msg_callback(
SSL_CTX *ctx, void (*cb)(int write_p, int version, int content_type,
const void *buf, size_t len, SSL *ssl, void *arg));
/* SSL_CTX_set_msg_callback_arg sets the |arg| parameter of the message
* callback. */
OPENSSL_EXPORT void SSL_CTX_set_msg_callback_arg(SSL_CTX *ctx, void *arg);
/* SSL_set_msg_callback installs |cb| as the message callback of |ssl|. See
* |SSL_CTX_set_msg_callback| for when this callback is called. */
OPENSSL_EXPORT void SSL_set_msg_callback(
SSL *ssl, void (*cb)(int write_p, int version, int content_type,
const void *buf, size_t len, SSL *ssl, void *arg));
/* SSL_set_msg_callback_arg sets the |arg| parameter of the message callback. */
OPENSSL_EXPORT void SSL_set_msg_callback_arg(SSL *ssl, void *arg);
/* SSL_CTX_set_keylog_bio sets configures all SSL objects attached to |ctx| to
* log session material to |keylog_bio|. This is intended for debugging use
* with tools like Wireshark. |ctx| takes ownership of |keylog_bio|.
*
* The format is described in
* https://developer.mozilla.org/en-US/docs/Mozilla/Projects/NSS/Key_Log_Format. */
OPENSSL_EXPORT void SSL_CTX_set_keylog_bio(SSL_CTX *ctx, BIO *keylog_bio);
Add SSL_set_renegotiate_mode. Add a slightly richer API. Notably, one can configure ssl_renegotiate_once to only accept the first renego. Also, this API doesn't repeat the mistake I made with SSL_set_reject_peer_renegotiations which is super-confusing with the negation. Change-Id: I7eb5d534e3e6c553b641793f4677fe5a56451c71 Reviewed-on: https://boringssl-review.googlesource.com/6221 Reviewed-by: Adam Langley <agl@google.com>
2015-10-13 00:54:18 +01:00
enum ssl_renegotiate_mode_t {
ssl_renegotiate_never = 0,
ssl_renegotiate_once,
ssl_renegotiate_freely,
};
/* SSL_set_renegotiate_mode configures how |ssl|, a client, reacts to
* renegotiation attempts by a server. If |ssl| is a server, peer-initiated
* renegotiations are *always* rejected and this function does nothing.
*
* The renegotiation mode defaults to |ssl_renegotiate_never|, but may be set
* at any point in a connection's lifetime. Set it to |ssl_renegotiate_once| to
* allow one renegotiation and |ssl_renegotiate_freely| to allow all
* renegotiations.
*
* There is no support in BoringSSL for initiating renegotiations as a client
* or server. */
OPENSSL_EXPORT void SSL_set_renegotiate_mode(SSL *ssl,
enum ssl_renegotiate_mode_t mode);
Move a few more functions to the catch-all 'obscure' bucket. Change-Id: I493f26561db2bc8510963a0da5032a758bb1f3ef Reviewed-on: https://boringssl-review.googlesource.com/5960 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 21:23:06 +01:00
Put renego functions together. Change-Id: I3bfbf90a790a10e4464e0e39bbd7c0c2bee9fe35 Reviewed-on: https://boringssl-review.googlesource.com/6301 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 00:47:13 +01:00
/* SSL_renegotiate_pending returns one if |ssl| is in the middle of a
* renegotiation. */
OPENSSL_EXPORT int SSL_renegotiate_pending(SSL *ssl);
/* SSL_total_renegotiations returns the total number of renegotiation handshakes
* peformed by |ssl|. This includes the pending renegotiation, if any. */
OPENSSL_EXPORT int SSL_total_renegotiations(const SSL *ssl);
Document a few more miscellaneous things. Change-Id: Ib4829bf9344341e3d4fe90c7cea66e217366fe97 Reviewed-on: https://boringssl-review.googlesource.com/6091 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 15:44:30 +01:00
/* SSL_MAX_CERT_LIST_DEFAULT is the default maximum length, in bytes, of a peer
* certificate chain. */
#define SSL_MAX_CERT_LIST_DEFAULT 1024 * 100
/* SSL_CTX_get_max_cert_list returns the maximum length, in bytes, of a peer
* certificate chain accepted by |ctx|. */
OPENSSL_EXPORT size_t SSL_CTX_get_max_cert_list(const SSL_CTX *ctx);
/* SSL_CTX_set_max_cert_list sets the maximum length, in bytes, of a peer
* certificate chain to |max_cert_list|. This affects how much memory may be
* consumed during the handshake. */
OPENSSL_EXPORT void SSL_CTX_set_max_cert_list(SSL_CTX *ctx,
size_t max_cert_list);
/* SSL_get_max_cert_list returns the maximum length, in bytes, of a peer
* certificate chain accepted by |ssl|. */
OPENSSL_EXPORT size_t SSL_get_max_cert_list(const SSL *ssl);
/* SSL_set_max_cert_list sets the maximum length, in bytes, of a peer
* certificate chain to |max_cert_list|. This affects how much memory may be
* consumed during the handshake. */
OPENSSL_EXPORT void SSL_set_max_cert_list(SSL *ssl, size_t max_cert_list);
/* SSL_CTX_set_max_send_fragment sets the maximum length, in bytes, of records
* sent by |ctx|. Beyond this length, handshake messages and application data
* will be split into multiple records. */
OPENSSL_EXPORT void SSL_CTX_set_max_send_fragment(SSL_CTX *ctx,
size_t max_send_fragment);
/* SSL_set_max_send_fragment sets the maximum length, in bytes, of records
* sent by |ssl|. Beyond this length, handshake messages and application data
* will be split into multiple records. */
OPENSSL_EXPORT void SSL_set_max_send_fragment(SSL *ssl,
size_t max_send_fragment);
Add use counters for SSL_OP_TLS_D5_BUG and SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER. These are theh two remaining quirks (SSL_OP_LEGACY_SERVER_CONNECT aside). Add counters so we can determine whether there are still clients that trip up these cases. Change-Id: I7e92f42f3830c1df675445ec15a852e5659eb499 Reviewed-on: https://boringssl-review.googlesource.com/6290 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-17 03:45:17 +01:00
/* OPENSSL_get_big_buffer_use_count returns the total number of invalid TLS
* records that were accepted because of |SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER|.
*
* TODO(davidben): Remove this when (hopefully!) the quirk is demonstrated to be
* unnecessary. */
OPENSSL_EXPORT uint64_t OPENSSL_get_big_buffer_use_count(void);
/* OPENSSL_get_d5_bug_use_count returns the total number of invalid RSA
* ClientKeyExchanges that were accepted because of |SSL_OP_TLS_D5_BUG|.
*
* TODO(davidben): Remove this when (hopefully!) the quirk is demonstrated to be
* unnecessary. */
OPENSSL_EXPORT uint64_t OPENSSL_get_d5_bug_use_count(void);
Document early callback functions. Also added a SSL_CTX_set_select_certificate_cb setter for select_certificate_cb so code needn't access SSL_CTX directly. Plus it serves as a convenient anchor for the documentation. Change-Id: I23755b910e1d77d4bea7bb9103961181dd3c5efe Reviewed-on: https://boringssl-review.googlesource.com/6291 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-17 17:28:18 +01:00
/* ssl_early_callback_ctx is passed to certain callbacks that are called very
* early on during the server handshake. At this point, much of the SSL* hasn't
* been filled out and only the ClientHello can be depended on. */
struct ssl_early_callback_ctx {
SSL *ssl;
const uint8_t *client_hello;
size_t client_hello_len;
const uint8_t *session_id;
size_t session_id_len;
const uint8_t *cipher_suites;
size_t cipher_suites_len;
const uint8_t *compression_methods;
size_t compression_methods_len;
const uint8_t *extensions;
size_t extensions_len;
};
/* SSL_early_callback_ctx_extension_get searches the extensions in |ctx| for an
* extension of the given type. If not found, it returns zero. Otherwise it
* sets |out_data| to point to the extension contents (not including the type
* and length bytes), sets |out_len| to the length of the extension contents
* and returns one. */
OPENSSL_EXPORT int SSL_early_callback_ctx_extension_get(
const struct ssl_early_callback_ctx *ctx, uint16_t extension_type,
const uint8_t **out_data, size_t *out_len);
/* SSL_CTX_set_select_certificate_cb sets a callback that is called before most
* ClientHello processing and before the decision whether to resume a session
* is made. The callback may inspect the ClientHello and configure the
* connection. It may then return one to continue the handshake or zero to
* pause the handshake to perform an asynchronous operation. If paused,
* |SSL_get_error| will return |SSL_ERROR_PENDING_CERTIFICATE|.
*
* Note: The |ssl_early_callback_ctx| is only valid for the duration of the
* callback and is not valid while the handshake is paused. Further, unlike with
* most callbacks, when the handshake loop is resumed, it will not call the
* callback a second time. The caller must finish reconfiguring the connection
* before resuming the handshake. */
OPENSSL_EXPORT void SSL_CTX_set_select_certificate_cb(
SSL_CTX *ctx, int (*cb)(const struct ssl_early_callback_ctx *));
/* SSL_CTX_set_dos_protection_cb sets a callback that is called once the
* resumption decision for a ClientHello has been made. It can return one to
* allow the handshake to continue or zero to cause the handshake to abort. */
OPENSSL_EXPORT void SSL_CTX_set_dos_protection_cb(
SSL_CTX *ctx, int (*cb)(const struct ssl_early_callback_ctx *));
Document the info callback. This callback is some combination of arguably useful stuff (bracket handshakes, alerts) and completely insane things (find out when the state machine advances). Deprecate the latter. Change-Id: Ibea5b32cb360b767b0f45b302fd5f1fe17850593 Reviewed-on: https://boringssl-review.googlesource.com/6305 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 03:51:17 +01:00
/* SSL_ST_* are possible values for |SSL_state| and the bitmasks that make them
* up. */
#define SSL_ST_CONNECT 0x1000
#define SSL_ST_ACCEPT 0x2000
#define SSL_ST_MASK 0x0FFF
#define SSL_ST_INIT (SSL_ST_CONNECT | SSL_ST_ACCEPT)
#define SSL_ST_OK 0x03
#define SSL_ST_RENEGOTIATE (0x04 | SSL_ST_INIT)
/* SSL_CB_* are possible values for the |type| parameter in the info
* callback and the bitmasks that make them up. */
#define SSL_CB_LOOP 0x01
#define SSL_CB_EXIT 0x02
#define SSL_CB_READ 0x04
#define SSL_CB_WRITE 0x08
#define SSL_CB_ALERT 0x4000
#define SSL_CB_READ_ALERT (SSL_CB_ALERT | SSL_CB_READ)
#define SSL_CB_WRITE_ALERT (SSL_CB_ALERT | SSL_CB_WRITE)
#define SSL_CB_ACCEPT_LOOP (SSL_ST_ACCEPT | SSL_CB_LOOP)
#define SSL_CB_ACCEPT_EXIT (SSL_ST_ACCEPT | SSL_CB_EXIT)
#define SSL_CB_CONNECT_LOOP (SSL_ST_CONNECT | SSL_CB_LOOP)
#define SSL_CB_CONNECT_EXIT (SSL_ST_CONNECT | SSL_CB_EXIT)
#define SSL_CB_HANDSHAKE_START 0x10
#define SSL_CB_HANDSHAKE_DONE 0x20
/* SSL_set_info_callback configures a callback to be run when various events
* occur during a connection's lifetime. The |type| argumentj determines the
* type of event and the meaning of the |value| argument. Callbacks must ignore
* unexpected |type| values.
*
* |SSL_CB_READ_ALERT| is signaled for each alert received, warning or fatal.
* The |value| argument is a 16-bit value where the alert level (either
* |SSL3_AL_WARNING| or |SSL3_AL_FATAL|) is in the most-significant eight bits and
* the alert type (one of |SSL_AD_*|) is in the least-significant eight.
*
* |SSL_CB_WRITE_ALERT| is signaled for each alert sent. The |value| argument
* is constructed as with |SSL_CB_READ_ALERT|.
*
* |SSL_CB_HANDSHAKE_START| is signaled when a handshake begins. The |value|
* argument is always one.
*
* |SSL_CB_HANDSHAKE_DONE| is signaled when a handshake completes successfully.
* The |value| argument is always one. If a handshake False Starts, this event
* may be used to determine when the Finished message is received.
*
* The following event types expose implementation details of the handshake
* state machine. Consuming them is deprecated.
*
* |SSL_CB_ACCEPT_LOOP| (respectively, |SSL_CB_CONNECT_LOOP|) is signaled when
* a server (respectively, client) handshake progresses. The |value| argument
* is always one. For the duration of the callback, |SSL_state| will return the
* previous state.
*
* |SSL_CB_ACCEPT_EXIT| (respectively, |SSL_CB_CONNECT_EXIT|) is signaled when
* a server (respectively, client) handshake completes, fails, or is paused.
* The |value| argument is one if the handshake succeeded and <= 0
* otherwise. */
OPENSSL_EXPORT void SSL_CTX_set_info_callback(
SSL_CTX *ctx, void (*cb)(const SSL *ssl, int type, int value));
/* SSL_CTX_get_info_callback returns the callback set by
* |SSL_CTX_set_info_callback|. */
OPENSSL_EXPORT void (*SSL_CTX_get_info_callback(SSL_CTX *ctx))(const SSL *ssl,
int type,
int value);
/* SSL_set_info_callback configures a callback to be run at various events
* during a connection's lifetime. See |SSL_CTX_set_info_callback|. */
OPENSSL_EXPORT void SSL_set_info_callback(
SSL *ssl, void (*cb)(const SSL *ssl, int type, int value));
/* SSL_get_info_callback returns the callback set by |SSL_set_info_callback|. */
OPENSSL_EXPORT void (*SSL_get_info_callback(const SSL *ssl))(const SSL *ssl,
int type,
int value);
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
Document everything in ssl_ciph.c, now ssl_cipher.c. Just about everything depends on SSL_CIPHER. Move it to the top as the first section in ssl.h. Match the header order and the source file order and document everything. Also make a couple of minor style guide tweaks. Change-Id: I6a810dbe79238278ac480e5ced1447055715a79f Reviewed-on: https://boringssl-review.googlesource.com/4290 Reviewed-by: Adam Langley <agl@google.com>
2015-04-08 07:36:59 +01:00
/* Underdocumented functions.
*
* Functions below here haven't been touched up and may be underdocumented. */
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
/* Used in SSL_set_shutdown()/SSL_get_shutdown(); */
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
#define SSL_SENT_SHUTDOWN 1
#define SSL_RECEIVED_SHUTDOWN 2
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Is the SSL_connection established? */
#define SSL_get_state(a) SSL_state(a)
#define SSL_is_init_finished(a) (SSL_state(a) == SSL_ST_OK)
#define SSL_in_init(a) (SSL_state(a) & SSL_ST_INIT)
#define SSL_in_connect_init(a) (SSL_state(a) & SSL_ST_CONNECT)
#define SSL_in_accept_init(a) (SSL_state(a) & SSL_ST_ACCEPT)
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_in_false_start returns one if |s| has a pending unfinished handshake that
* is in False Start. |SSL_write| may be called at this point without waiting
* for the peer, but |SSL_read| will require the handshake to be completed. */
OPENSSL_EXPORT int SSL_in_false_start(const SSL *s);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Clean up ssl_stat.c slightly. (Documentation/deprecation will come in later commits.) Change-Id: I3aba26e32b2e47a1afb5cedd44d09115fc193bce Reviewed-on: https://boringssl-review.googlesource.com/6296 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-17 18:05:27 +01:00
OPENSSL_EXPORT const char *SSL_state_string(const SSL *ssl);
OPENSSL_EXPORT const char *SSL_state_string_long(const SSL *ssl);
Implement client side of TLS signed certificate stamps extension. https://crbug.com/389420 and 3.3 in rfc6962. Change-Id: Ib22bcd4e4bde5a314ed33e123e19a76cdb714da4 Reviewed-on: https://boringssl-review.googlesource.com/1491 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-08-14 13:42:37 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
OPENSSL_EXPORT void SSL_set_shutdown(SSL *ssl, int mode);
OPENSSL_EXPORT int SSL_get_shutdown(const SSL *ssl);
OPENSSL_EXPORT SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl);
OPENSSL_EXPORT SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx);
OPENSSL_EXPORT int SSL_state(const SSL *ssl);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Deprecated functions. */
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Add SSL_set_renegotiate_mode. Add a slightly richer API. Notably, one can configure ssl_renegotiate_once to only accept the first renego. Also, this API doesn't repeat the mistake I made with SSL_set_reject_peer_renegotiations which is super-confusing with the negation. Change-Id: I7eb5d534e3e6c553b641793f4677fe5a56451c71 Reviewed-on: https://boringssl-review.googlesource.com/6221 Reviewed-by: Adam Langley <agl@google.com>
2015-10-13 00:54:18 +01:00
/* SSL_set_reject_peer_renegotiations calls |SSL_set_renegotiate_mode| with
* |ssl_never_renegotiate| if |reject| is one and |ssl_renegotiate_freely| if
* zero. */
OPENSSL_EXPORT void SSL_set_reject_peer_renegotiations(SSL *ssl, int reject);
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CIPHER_description writes a description of |cipher| into |buf| and
* returns |buf|. If |buf| is NULL, it returns a newly allocated string, to be
* freed with |OPENSSL_free|, or NULL on error.
*
* The description includes a trailing newline and has the form:
* AES128-SHA SSLv3 Kx=RSA Au=RSA Enc=AES(128) Mac=SHA1
*
* Consider |SSL_CIPHER_get_name| or |SSL_CIPHER_get_rfc_name| instead. */
OPENSSL_EXPORT const char *SSL_CIPHER_description(const SSL_CIPHER *cipher,
char *buf, int len);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CIPHER_get_version returns the string "TLSv1/SSLv3". */
OPENSSL_EXPORT const char *SSL_CIPHER_get_version(const SSL_CIPHER *cipher);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Deprecated things are deprecated. Get them out of the way when reading through the header. Change-Id: Ied3f3601262e74570769cb7f858dcff4eff44813 Reviewed-on: https://boringssl-review.googlesource.com/5898 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 05:29:20 +01:00
typedef void COMP_METHOD;
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_COMP_get_compression_methods returns NULL. */
OPENSSL_EXPORT COMP_METHOD *SSL_COMP_get_compression_methods(void);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_COMP_add_compression_method returns one. */
OPENSSL_EXPORT int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_COMP_get_name returns NULL. */
OPENSSL_EXPORT const char *SSL_COMP_get_name(const COMP_METHOD *comp);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSLv23_method calls |TLS_method|. */
OPENSSL_EXPORT const SSL_METHOD *SSLv23_method(void);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Version-specific methods behave exactly like |TLS_method| and |DTLS_method|
* except they also call |SSL_CTX_set_min_version| and |SSL_CTX_set_max_version|
* to lock connections to that protocol version. */
OPENSSL_EXPORT const SSL_METHOD *SSLv3_method(void);
OPENSSL_EXPORT const SSL_METHOD *TLSv1_method(void);
OPENSSL_EXPORT const SSL_METHOD *TLSv1_1_method(void);
OPENSSL_EXPORT const SSL_METHOD *TLSv1_2_method(void);
OPENSSL_EXPORT const SSL_METHOD *DTLSv1_method(void);
OPENSSL_EXPORT const SSL_METHOD *DTLSv1_2_method(void);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Client- and server-specific methods call their corresponding generic
* methods. */
OPENSSL_EXPORT const SSL_METHOD *SSLv23_server_method(void);
OPENSSL_EXPORT const SSL_METHOD *SSLv23_client_method(void);
OPENSSL_EXPORT const SSL_METHOD *SSLv3_server_method(void);
OPENSSL_EXPORT const SSL_METHOD *SSLv3_client_method(void);
OPENSSL_EXPORT const SSL_METHOD *TLSv1_server_method(void);
OPENSSL_EXPORT const SSL_METHOD *TLSv1_client_method(void);
OPENSSL_EXPORT const SSL_METHOD *TLSv1_1_server_method(void);
OPENSSL_EXPORT const SSL_METHOD *TLSv1_1_client_method(void);
OPENSSL_EXPORT const SSL_METHOD *TLSv1_2_server_method(void);
OPENSSL_EXPORT const SSL_METHOD *TLSv1_2_client_method(void);
OPENSSL_EXPORT const SSL_METHOD *DTLS_server_method(void);
OPENSSL_EXPORT const SSL_METHOD *DTLS_client_method(void);
OPENSSL_EXPORT const SSL_METHOD *DTLSv1_server_method(void);
OPENSSL_EXPORT const SSL_METHOD *DTLSv1_client_method(void);
OPENSSL_EXPORT const SSL_METHOD *DTLSv1_2_server_method(void);
OPENSSL_EXPORT const SSL_METHOD *DTLSv1_2_client_method(void);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_clear resets |ssl| to allow another connection and returns one on success
* or zero on failure. It returns most configuration state but releases memory
* associated with the current connection.
*
* Free |ssl| and create a new one instead. */
OPENSSL_EXPORT int SSL_clear(SSL *ssl);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_set_tmp_rsa_callback does nothing. */
OPENSSL_EXPORT void SSL_CTX_set_tmp_rsa_callback(
SSL_CTX *ctx, RSA *(*cb)(SSL *ssl, int is_export, int keylength));
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_set_tmp_rsa_callback does nothing. */
OPENSSL_EXPORT void SSL_set_tmp_rsa_callback(SSL *ssl,
RSA *(*cb)(SSL *ssl, int is_export,
int keylength));
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_sess_connect returns zero. */
OPENSSL_EXPORT int SSL_CTX_sess_connect(const SSL_CTX *ctx);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_sess_connect_good returns zero. */
OPENSSL_EXPORT int SSL_CTX_sess_connect_good(const SSL_CTX *ctx);
Add SSL_set_reject_peer_renegotiations. This causes any unexpected handshake records to be met with a fatal no_renegotiation alert. In addition, restore the redundant version sanity-checks in the handshake state machines. Some code would zero the version field as a hacky way to break the handshake on renego. Those will be removed when switching to this API. The spec allows for a non-fatal no_renegotiation alert, but ssl3_read_bytes makes it difficult to find the end of a ClientHello and skip it entirely. Given that OpenSSL goes out of its way to map non-fatal no_renegotiation alerts to fatal ones, this seems probably fine. This avoids needing to account for another source of the library consuming an unbounded number of bytes without returning data up. Change-Id: Ie5050d9c9350c29cfe32d03a3c991bdc1da9e0e4 Reviewed-on: https://boringssl-review.googlesource.com/4300 Reviewed-by: Adam Langley <agl@google.com>
2015-04-09 00:16:58 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_sess_connect_renegotiate returns zero. */
OPENSSL_EXPORT int SSL_CTX_sess_connect_renegotiate(const SSL_CTX *ctx);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_sess_accept returns zero. */
OPENSSL_EXPORT int SSL_CTX_sess_accept(const SSL_CTX *ctx);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_sess_accept_renegotiate returns zero. */
OPENSSL_EXPORT int SSL_CTX_sess_accept_renegotiate(const SSL_CTX *ctx);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_sess_accept_good returns zero. */
OPENSSL_EXPORT int SSL_CTX_sess_accept_good(const SSL_CTX *ctx);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_sess_hits returns zero. */
OPENSSL_EXPORT int SSL_CTX_sess_hits(const SSL_CTX *ctx);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_sess_cb_hits returns zero. */
OPENSSL_EXPORT int SSL_CTX_sess_cb_hits(const SSL_CTX *ctx);
Revise SSL_cutthrough_complete and SSL_in_init. This makes the following changes: - SSL_cutthrough_complete no longer rederives whether cutthrough happened and just maintains a handshake bit. - SSL_in_init no longer returns true if we are False Starting but haven't completed the handshake. That logic was awkward as it depended on querying in_read_app_data to force SSL_read to flush the entire handshake. Defaulting SSL_in_init to continue querying the full handshake and special-casing SSL_write is better. E.g. the check in bidirectional SSL_shutdown wants to know if we're in a handshake. No internal consumer of SSL_MODE_HANDSHAKE_CUTTHROUGH ever queries SSL_in_init directly. - in_read_app_data is gone now that the final use is dead. Change-Id: I05211a116d684054dfef53075cd277b1b30623b5 Reviewed-on: https://boringssl-review.googlesource.com/3336 Reviewed-by: Adam Langley <agl@google.com>
2015-02-09 05:01:31 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_sess_misses returns zero. */
OPENSSL_EXPORT int SSL_CTX_sess_misses(const SSL_CTX *ctx);
Rename cutthrough to False Start. False Start is the name it's known by now. Deprecate the old API and expose new ones with the new name. Change-Id: I32d307027e178fd7d9c0069686cc046f75fdbf6f Reviewed-on: https://boringssl-review.googlesource.com/3481 Reviewed-by: Adam Langley <agl@google.com>
2015-02-17 00:16:46 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_sess_timeouts returns zero. */
OPENSSL_EXPORT int SSL_CTX_sess_timeouts(const SSL_CTX *ctx);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_sess_cache_full returns zero. */
OPENSSL_EXPORT int SSL_CTX_sess_cache_full(const SSL_CTX *ctx);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_cutthrough_complete calls |SSL_in_false_start|. */
OPENSSL_EXPORT int SSL_cutthrough_complete(const SSL *s);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_num_renegotiations calls |SSL_total_renegotiations|. */
OPENSSL_EXPORT int SSL_num_renegotiations(const SSL *ssl);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_need_tmp_RSA returns zero. */
OPENSSL_EXPORT int SSL_CTX_need_tmp_RSA(const SSL_CTX *ctx);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_need_tmp_RSA returns zero. */
OPENSSL_EXPORT int SSL_need_tmp_RSA(const SSL *ssl);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_set_tmp_rsa returns one. */
OPENSSL_EXPORT int SSL_CTX_set_tmp_rsa(SSL_CTX *ctx, const RSA *rsa);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_set_tmp_rsa returns one. */
OPENSSL_EXPORT int SSL_set_tmp_rsa(SSL *ssl, const RSA *rsa);
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SSL_CTX_get_read_ahead returns zero. */
OPENSSL_EXPORT int SSL_CTX_get_read_ahead(const SSL_CTX *ctx);
/* SSL_CTX_set_read_ahead does nothing. */
OPENSSL_EXPORT void SSL_CTX_set_read_ahead(SSL_CTX *ctx, int yes);
/* SSL_get_read_ahead returns zero. */
OPENSSL_EXPORT int SSL_get_read_ahead(const SSL *s);
/* SSL_set_read_ahead does nothing. */
OPENSSL_EXPORT void SSL_set_read_ahead(SSL *s, int yes);
/* SSL_renegotiate put an error on the error queue and returns zero. */
OPENSSL_EXPORT int SSL_renegotiate(SSL *ssl);
/* SSL_set_state does nothing. */
OPENSSL_EXPORT void SSL_set_state(SSL *ssl, int state);
/* SSL_MODE_HANDSHAKE_CUTTHROUGH is the same as SSL_MODE_ENABLE_FALSE_START. */
#define SSL_MODE_HANDSHAKE_CUTTHROUGH SSL_MODE_ENABLE_FALSE_START
/* i2d_SSL_SESSION serializes |in| to the bytes pointed to by |*pp|. On success,
* it returns the number of bytes written and advances |*pp| by that many bytes.
* On failure, it returns -1. If |pp| is NULL, no bytes are written and only the
* length is returned.
Document DTLS timeout API and add current_time_cb hook. This is so the tests needn't be sensitive to the clock. It is, unfortunately, a test-only hook, but the DTLS retransmit/timeout logic more-or-less requires it currently. Use this hook to, for now, freeze the clock at zero. This makes the tests deterministic. It might be worth designing a saner API in the future. The current one, notably, requires that the caller's clock be compatible with the one we internally use. It's also not clear whether the caller needs to call DTLSv1_handle_timeout or can just rely on the state machine doing it internally (as it does do). But mock clocks are relatively tame and WebRTC wants to compile against upstream OpenSSL for now, so we're limited in how much new API we can build. Change-Id: I7aad51570596f69275ed0fc1a8892393e4b7ba13 Reviewed-on: https://boringssl-review.googlesource.com/3210 Reviewed-by: Adam Langley <agl@google.com>
2015-01-26 05:22:12 +00:00
*
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
* Use |SSL_SESSION_to_bytes| instead. */
OPENSSL_EXPORT int i2d_SSL_SESSION(SSL_SESSION *in, uint8_t **pp);
Document DTLS timeout API and add current_time_cb hook. This is so the tests needn't be sensitive to the clock. It is, unfortunately, a test-only hook, but the DTLS retransmit/timeout logic more-or-less requires it currently. Use this hook to, for now, freeze the clock at zero. This makes the tests deterministic. It might be worth designing a saner API in the future. The current one, notably, requires that the caller's clock be compatible with the one we internally use. It's also not clear whether the caller needs to call DTLSv1_handle_timeout or can just rely on the state machine doing it internally (as it does do). But mock clocks are relatively tame and WebRTC wants to compile against upstream OpenSSL for now, so we're limited in how much new API we can build. Change-Id: I7aad51570596f69275ed0fc1a8892393e4b7ba13 Reviewed-on: https://boringssl-review.googlesource.com/3210 Reviewed-by: Adam Langley <agl@google.com>
2015-01-26 05:22:12 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* d2i_SSL_SESSION parses a serialized session from the |length| bytes pointed
* to by |*pp|. It returns the new |SSL_SESSION| and advances |*pp| by the
* number of bytes consumed on success and NULL on failure. The caller takes
* ownership of the new session and must call |SSL_SESSION_free| when done.
Document DTLS timeout API and add current_time_cb hook. This is so the tests needn't be sensitive to the clock. It is, unfortunately, a test-only hook, but the DTLS retransmit/timeout logic more-or-less requires it currently. Use this hook to, for now, freeze the clock at zero. This makes the tests deterministic. It might be worth designing a saner API in the future. The current one, notably, requires that the caller's clock be compatible with the one we internally use. It's also not clear whether the caller needs to call DTLSv1_handle_timeout or can just rely on the state machine doing it internally (as it does do). But mock clocks are relatively tame and WebRTC wants to compile against upstream OpenSSL for now, so we're limited in how much new API we can build. Change-Id: I7aad51570596f69275ed0fc1a8892393e4b7ba13 Reviewed-on: https://boringssl-review.googlesource.com/3210 Reviewed-by: Adam Langley <agl@google.com>
2015-01-26 05:22:12 +00:00
*
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
* If |a| is non-NULL, |*a| is released and set the new |SSL_SESSION|.
Promote all dtls1_ctrl hooks to functions. BUG=404754 Change-Id: I5f11485fbafa07cddcf2612e2f616f90bf7c722d Reviewed-on: https://boringssl-review.googlesource.com/4554 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:44:18 +01:00
*
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
* Use |SSL_SESSION_from_bytes| instead. */
OPENSSL_EXPORT SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const uint8_t **pp,
long length);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
More SSL_SESSION serialization functions. Change-Id: I2dd8d073521a230b2b0c4e74ec3d6eeb4899623e Reviewed-on: https://boringssl-review.googlesource.com/6303 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 03:15:37 +01:00
/* i2d_SSL_SESSION_bio serializes |session| and writes the result to |bio|. It
* returns the number of bytes written on success and <= 0 on error. */
OPENSSL_EXPORT int i2d_SSL_SESSION_bio(BIO *bio, const SSL_SESSION *session);
/* d2i_SSL_SESSION_bio reads a serialized |SSL_SESSION| from |bio| and returns a
* newly-allocated |SSL_SESSION| or NULL on error. If |out| is not NULL, it also
* frees |*out| and sets |*out| to the new |SSL_SESSION|. */
OPENSSL_EXPORT SSL_SESSION *d2i_SSL_SESSION_bio(BIO *bio, SSL_SESSION **out);
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* ERR_load_SSL_strings does nothing. */
OPENSSL_EXPORT void ERR_load_SSL_strings(void);
/* SSL_load_error_strings does nothing. */
OPENSSL_EXPORT void SSL_load_error_strings(void);
Fold srtp.h into ssl.h. This gets the documentation into the ssl.h documentation, and removes one of the circularly-dependent headers hanging off ssl.h. Also fixes some typos; there were a few instances of "SSL *ctx". Change-Id: I2a41c6f518f4780af84d468ed220fe7b0b8eb0d3 Reviewed-on: https://boringssl-review.googlesource.com/5883 Reviewed-by: Adam Langley <agl@google.com>
2015-09-14 06:54:44 +01:00
/* SSL_CTX_set_tlsext_use_srtp calls |SSL_CTX_set_srtp_profiles|. It returns
* zero on success and one on failure.
*
* WARNING: this function is dangerous because it breaks the usual return value
* convention. Use |SSL_CTX_set_srtp_profiles| instead. */
OPENSSL_EXPORT int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx,
const char *profiles);
/* SSL_set_tlsext_use_srtp calls |SSL_set_srtp_profiles|. It returns zero on
* success and one on failure.
*
* WARNING: this function is dangerous because it breaks the usual return value
* convention. Use |SSL_set_srtp_profiles| instead. */
OPENSSL_EXPORT int SSL_set_tlsext_use_srtp(SSL *ssl, const char *profiles);
Deprecated things are deprecated. Get them out of the way when reading through the header. Change-Id: Ied3f3601262e74570769cb7f858dcff4eff44813 Reviewed-on: https://boringssl-review.googlesource.com/5898 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 05:29:20 +01:00
/* SSL_get_current_compression returns NULL. */
OPENSSL_EXPORT const COMP_METHOD *SSL_get_current_compression(SSL *s);
/* SSL_get_current_expansion returns NULL. */
OPENSSL_EXPORT const COMP_METHOD *SSL_get_current_expansion(SSL *s);
#define SSL_set_app_data(s, arg) (SSL_set_ex_data(s, 0, (char *)arg))
#define SSL_get_app_data(s) (SSL_get_ex_data(s, 0))
#define SSL_SESSION_set_app_data(s, a) \
(SSL_SESSION_set_ex_data(s, 0, (char *)a))
#define SSL_SESSION_get_app_data(s) (SSL_SESSION_get_ex_data(s, 0))
#define SSL_CTX_get_app_data(ctx) (SSL_CTX_get_ex_data(ctx, 0))
#define SSL_CTX_set_app_data(ctx, arg) \
(SSL_CTX_set_ex_data(ctx, 0, (char *)arg))
#define OpenSSL_add_ssl_algorithms() SSL_library_init()
#define SSLeay_add_ssl_algorithms() SSL_library_init()
#define SSL_get_cipher(ssl) SSL_CIPHER_get_name(SSL_get_current_cipher(ssl))
#define SSL_get_cipher_bits(ssl, out_alg_bits) \
SSL_CIPHER_get_bits(SSL_get_current_cipher(ssl), out_alg_bits)
#define SSL_get_cipher_version(ssl) \
SSL_CIPHER_get_version(SSL_get_current_cipher(ssl))
#define SSL_get_cipher_name(ssl) \
SSL_CIPHER_get_name(SSL_get_current_cipher(ssl))
#define SSL_get_time(session) SSL_SESSION_get_time(session)
#define SSL_set_time(session, time) SSL_SESSION_set_time((session), (time))
#define SSL_get_timeout(session) SSL_SESSION_get_timeout(session)
#define SSL_set_timeout(session, timeout) \
SSL_SESSION_set_timeout((session), (timeout))
typedef struct ssl_comp_st SSL_COMP;
struct ssl_comp_st {
int id;
const char *name;
char *method;
};
DECLARE_STACK_OF(SSL_COMP)
/* The following flags toggle individual protocol versions. This is deprecated.
* Use |SSL_CTX_set_min_version| and |SSL_CTX_set_max_version| instead. */
#define SSL_OP_NO_SSLv3 0x02000000L
#define SSL_OP_NO_TLSv1 0x04000000L
#define SSL_OP_NO_TLSv1_2 0x08000000L
#define SSL_OP_NO_TLSv1_1 0x10000000L
#define SSL_OP_NO_DTLSv1 SSL_OP_NO_TLSv1
#define SSL_OP_NO_DTLSv1_2 SSL_OP_NO_TLSv1_2
/* The following flags do nothing and are included only to make it easier to
* compile code with BoringSSL. */
Banish more deprecated flags to the bottom. Change-Id: I7959fc65afae8860804ab9f038e3b5a9c2c8ec7b Reviewed-on: https://boringssl-review.googlesource.com/5943 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 18:29:36 +01:00
#define SSL_MODE_AUTO_RETRY 0
#define SSL_MODE_RELEASE_BUFFERS 0
#define SSL_MODE_SEND_CLIENTHELLO_TIME 0
#define SSL_MODE_SEND_SERVERHELLO_TIME 0
Deprecated things are deprecated. Get them out of the way when reading through the header. Change-Id: Ied3f3601262e74570769cb7f858dcff4eff44813 Reviewed-on: https://boringssl-review.googlesource.com/5898 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 05:29:20 +01:00
#define SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION 0
#define SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS 0
#define SSL_OP_EPHEMERAL_RSA 0
#define SSL_OP_MICROSOFT_SESS_ID_BUG 0
#define SSL_OP_MSIE_SSLV2_RSA_PADDING 0
#define SSL_OP_NETSCAPE_CA_DN_BUG 0
#define SSL_OP_NETSCAPE_CHALLENGE_BUG 0
#define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG 0
#define SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG 0
#define SSL_OP_NO_COMPRESSION 0
#define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION 0
#define SSL_OP_NO_SSLv2 0
#define SSL_OP_PKCS1_CHECK_1 0
#define SSL_OP_PKCS1_CHECK_2 0
#define SSL_OP_SINGLE_DH_USE 0
#define SSL_OP_SINGLE_ECDH_USE 0
#define SSL_OP_SSLEAY_080_CLIENT_DH_BUG 0
#define SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG 0
#define SSL_OP_TLS_BLOCK_PADDING_BUG 0
#define SSL_OP_TLS_ROLLBACK_BUG 0
Document certificate verification functions in SSL. Or at least group them together and make a passing attempt to document them. The legacy X.509 stack itself remains largely untouched and most of the parameters have to do with it. Change-Id: I9e11e2ad1bbeef53478c787344398c0d8d1b3876 Reviewed-on: https://boringssl-review.googlesource.com/5942 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 18:04:22 +01:00
#define SSL_VERIFY_CLIENT_ONCE 0
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
/* SSL_cache_hit calls |SSL_session_resumed|. */
OPENSSL_EXPORT int SSL_cache_hit(SSL *ssl);
/* SSL_get_default_timeout returns |SSL_DEFAULT_SESSION_TIMEOUT|. */
OPENSSL_EXPORT long SSL_get_default_timeout(const SSL *ssl);
/* SSL_get_version returns a string describing the TLS version used by |ssl|.
* For example, "TLSv1.2" or "SSLv3". */
OPENSSL_EXPORT const char *SSL_get_version(const SSL *ssl);
Document cipher suite configuration. The cipher suite rules could also be anchored on SSL_TXT_* if desired. I currently documented them in prose largely because SSL_TXT_* also defines protocol version strings and those are weird; SSL_TXT_TLSV1_1 isn't even a cipher rule. (And, in fact, those are the only SSL_TXT_* macros that we can't blindly remove. I found some code that #ifdef's the version SSL_TXT_* macros to decide if version-locked SSL_METHODs are available.) Also they clutter the header. I was thinking maybe we should dump a lot of the random constants into a separate undocumented header or perhaps just unexport them. I'm slightly torn on this though and could easily be convinced in the other direction. (Playing devil's advocate, anchoring on SSL_TXT_* means we're less likely to forget to document one so long as adding a SSL_TXT_* macro is the convention.) Change-Id: Ide2ae44db9d6d8f29c24943090c210da0108dc37 Reviewed-on: https://boringssl-review.googlesource.com/5962 Reviewed-by: Adam Langley <agl@google.com>
2015-09-20 17:17:03 +01:00
/* SSL_get_cipher_list returns the name of the |n|th cipher in the output of
* |SSL_get_ciphers| or NULL if out of range. Use |SSL_get_ciphers| insteads. */
OPENSSL_EXPORT const char *SSL_get_cipher_list(const SSL *ssl, int n);
Better document the callbacks around client certificates. Deprecate the client_cert_cb variant since you can't really configure intermediates with it. (You might be able to by configuring the intermediates without the leaf or key and leaving the SSL stack to configure those, but that's really weird. cert_cb is simpler.) Also document the two functions the callbacks may use to query the CertificateRequest on the client. Change-Id: Iad6076266fd798cd74ea4e09978e7f5df5c8a670 Reviewed-on: https://boringssl-review.googlesource.com/6092 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 15:49:20 +01:00
/* SSL_CTX_set_client_cert_cb sets a callback which is called on the client if
* the server requests a client certificate and none is configured. On success,
* the callback should return one and set |*out_x509| to |*out_pkey| to a leaf
* certificate and private key, respectively, passing ownership. It should
* return zero to send no certificate and -1 to fail or pause the handshake. If
* the handshake is paused, |SSL_get_error| will return
* |SSL_ERROR_WANT_X509_LOOKUP|.
*
* The callback may call |SSL_get0_certificate_types| and
* |SSL_get_client_CA_list| for information on the server's certificate request.
*
* Use |SSL_CTX_set_cert_cb| instead. Configuring intermediate certificates with
* this function is confusing. */
OPENSSL_EXPORT void SSL_CTX_set_client_cert_cb(
SSL_CTX *ctx,
int (*client_cert_cb)(SSL *ssl, X509 **out_x509, EVP_PKEY **out_pkey));
/* SSL_CTX_get_client_cert_cb returns the callback set by
* |SSL_CTX_set_client_cert_cb|. */
OPENSSL_EXPORT int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx))(
SSL *ssl, X509 **out_x509, EVP_PKEY **out_pkey);
Deprecate SSL_want*. This is redundant with SSL_get_error. Neither is very good API, but SSL_get_error is more common. SSL_get_error also takes a return code which makes it harder to accidentally call it at some a point other than immediately after an operation. (Any other point is confusing since you can have SSL_read and SSL_write operations going on in parallel and they'll get mixed up.) Change-Id: I5818527c30daac28edb552c6c550c05c8580292d Reviewed-on: https://boringssl-review.googlesource.com/6294 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-17 17:43:36 +01:00
#define SSL_NOTHING 1
#define SSL_WRITING 2
#define SSL_READING 3
#define SSL_X509_LOOKUP 4
#define SSL_CHANNEL_ID_LOOKUP 5
#define SSL_PENDING_SESSION 7
#define SSL_CERTIFICATE_SELECTION_PENDING 8
#define SSL_PRIVATE_KEY_OPERATION 9
/* SSL_want returns one of the above values to determine what the most recent
* operation on |ssl| was blocked on. Use |SSL_get_error| instead. */
OPENSSL_EXPORT int SSL_want(const SSL *ssl);
#define SSL_want_nothing(ssl) (SSL_want(ssl) == SSL_NOTHING)
#define SSL_want_read(ssl) (SSL_want(ssl) == SSL_READING)
#define SSL_want_write(ssl) (SSL_want(ssl) == SSL_WRITING)
#define SSL_want_x509_lookup(ssl) (SSL_want(ssl) == SSL_X509_LOOKUP)
#define SSL_want_channel_id_lookup(ssl) (SSL_want(ssl) == SSL_CHANNEL_ID_LOOKUP)
#define SSL_want_session(ssl) (SSL_want(ssl) == SSL_PENDING_SESSION)
#define SSL_want_certificate(ssl) \
(SSL_want(ssl) == SSL_CERTIFICATE_SELECTION_PENDING)
#define SSL_want_private_key_operation(ssl) \
(SSL_want(ssl) == SSL_PRIVATE_KEY_OPERATION)
Deprecate SSL_get_(peer_)finished. The only reason you'd want it is to tls_unique, and we have a better API for that. (It has one caller and that is indeed what that caller uses it for.) Change-Id: I39f8e353f56f18becb63dd6f7205ad31f4192bfd Reviewed-on: https://boringssl-review.googlesource.com/6295 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-17 17:51:52 +01:00
/* SSL_get_finished writes up to |count| bytes of the Finished message sent by
* |ssl| to |buf|. It returns the total untruncated length or zero if none has
* been sent yet.
*
* Use |SSL_get_tls_unique| instead. */
OPENSSL_EXPORT size_t SSL_get_finished(const SSL *ssl, void *buf, size_t count);
/* SSL_get_peer_finished writes up to |count| bytes of the Finished message
* received from |ssl|'s peer to |buf|. It returns the total untruncated length
* or zero if none has been received yet.
*
* Use |SSL_get_tls_unique| instead. */
OPENSSL_EXPORT size_t SSL_get_peer_finished(const SSL *ssl, void *buf,
size_t count);
Document alert handling. SSL_alert_desc_string_long was kept in the undeprecated bucket and one missing alert was added. We have some uses and it's not completely ridiculous for logging purposes. The two-character one is ridiculous though and gets turned into a stub that returns a constant string ("!" or "!!") because M2Crypto expects it. Change-Id: Iaf8794b5d953630216278536236c7113655180af Reviewed-on: https://boringssl-review.googlesource.com/6297 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-17 18:26:57 +01:00
/* SSL_alert_type_string returns "!". Use |SSL_alert_type_string_long|
* instead. */
OPENSSL_EXPORT const char *SSL_alert_type_string(int value);
/* SSL_alert_desc_string returns "!!". Use |SSL_alert_desc_string_long|
* instead. */
OPENSSL_EXPORT const char *SSL_alert_desc_string(int value);
Deprecate all the string macros. They're really not all that helpful, considering they're each used exactly once. They're also confusing as it is ALMOST the case that SSL_TXT_FOO expands to "FOO", but SSL_TXT_AES_GCM expand "AESGCM" and the protocol versions have lowercase v's and dots. Change-Id: If78ad8edb0c024819219f61675c60c2a7f3a36b0 Reviewed-on: https://boringssl-review.googlesource.com/6307 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 03:59:59 +01:00
/* SSL_TXT_* expand to strings. */
#define SSL_TXT_MEDIUM "MEDIUM"
#define SSL_TXT_HIGH "HIGH"
#define SSL_TXT_FIPS "FIPS"
#define SSL_TXT_kRSA "kRSA"
#define SSL_TXT_kDHE "kDHE"
#define SSL_TXT_kEDH "kEDH"
#define SSL_TXT_kECDHE "kECDHE"
#define SSL_TXT_kEECDH "kEECDH"
#define SSL_TXT_kPSK "kPSK"
#define SSL_TXT_aRSA "aRSA"
#define SSL_TXT_aECDSA "aECDSA"
#define SSL_TXT_aPSK "aPSK"
#define SSL_TXT_DH "DH"
#define SSL_TXT_DHE "DHE"
#define SSL_TXT_EDH "EDH"
#define SSL_TXT_RSA "RSA"
#define SSL_TXT_ECDH "ECDH"
#define SSL_TXT_ECDHE "ECDHE"
#define SSL_TXT_EECDH "EECDH"
#define SSL_TXT_ECDSA "ECDSA"
#define SSL_TXT_PSK "PSK"
#define SSL_TXT_3DES "3DES"
#define SSL_TXT_RC4 "RC4"
#define SSL_TXT_AES128 "AES128"
#define SSL_TXT_AES256 "AES256"
#define SSL_TXT_AES "AES"
#define SSL_TXT_AES_GCM "AESGCM"
#define SSL_TXT_CHACHA20 "CHACHA20"
#define SSL_TXT_MD5 "MD5"
#define SSL_TXT_SHA1 "SHA1"
#define SSL_TXT_SHA "SHA"
#define SSL_TXT_SHA256 "SHA256"
#define SSL_TXT_SHA384 "SHA384"
#define SSL_TXT_SSLV3 "SSLv3"
#define SSL_TXT_TLSV1 "TLSv1"
#define SSL_TXT_TLSV1_1 "TLSv1.1"
#define SSL_TXT_TLSV1_2 "TLSv1.2"
#define SSL_TXT_ALL "ALL"
#define SSL_TXT_CMPDEF "COMPLEMENTOFDEFAULT"
Private (and deprecated) types. Change-Id: Ia66e485cb2de45c9fb0a1ecd9a703863ad24d9c9 Reviewed-on: https://boringssl-review.googlesource.com/6308 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 04:13:21 +01:00
typedef struct ssl_conf_ctx_st SSL_CONF_CTX;
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Private structures.
Promote a few more macros. Next batch. Mostly a bunch of deprecated things. This switches SSL_CTX_set_tmp_rsa from always failing to always succeeding. The latter is probably a safer behavior; a consumer may defensively set a temporary RSA key. We'll successfully "set it" and just never use the result. Change-Id: Idd3d6bf4fc1a20bc9a26605bb9c77c9f799f993c Reviewed-on: https://boringssl-review.googlesource.com/4566 Reviewed-by: Adam Langley <agl@google.com>
2015-04-27 05:28:56 +01:00
*
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
* This structures are exposed for historical reasons, but access to them is
* deprecated. */
Promote a few more macros. Next batch. Mostly a bunch of deprecated things. This switches SSL_CTX_set_tmp_rsa from always failing to always succeeding. The latter is probably a safer behavior; a consumer may defensively set a temporary RSA key. We'll successfully "set it" and just never use the result. Change-Id: Idd3d6bf4fc1a20bc9a26605bb9c77c9f799f993c Reviewed-on: https://boringssl-review.googlesource.com/4566 Reviewed-by: Adam Langley <agl@google.com>
2015-04-27 05:28:56 +01:00
Private (and deprecated) types. Change-Id: Ia66e485cb2de45c9fb0a1ecd9a703863ad24d9c9 Reviewed-on: https://boringssl-review.googlesource.com/6308 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 04:13:21 +01:00
typedef struct ssl_protocol_method_st SSL_PROTOCOL_METHOD;
typedef struct ssl3_enc_method SSL3_ENC_METHOD;
typedef struct ssl_aead_ctx_st SSL_AEAD_CTX;
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
struct ssl_cipher_st {
/* name is the OpenSSL name for the cipher. */
const char *name;
/* id is the cipher suite value bitwise OR-d with 0x03000000. */
uint32_t id;
Promote a few more macros. Next batch. Mostly a bunch of deprecated things. This switches SSL_CTX_set_tmp_rsa from always failing to always succeeding. The latter is probably a safer behavior; a consumer may defensively set a temporary RSA key. We'll successfully "set it" and just never use the result. Change-Id: Idd3d6bf4fc1a20bc9a26605bb9c77c9f799f993c Reviewed-on: https://boringssl-review.googlesource.com/4566 Reviewed-by: Adam Langley <agl@google.com>
2015-04-27 05:28:56 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* The following are internal fields. See ssl/internal.h for their values. */
Promote set_tmp_dh and set_tmp_ecdh to functions. BUG=404754 Change-Id: I7c75dd88fe9338b1d3b90745f742d15d6b84775a Reviewed-on: https://boringssl-review.googlesource.com/4568 Reviewed-by: Adam Langley <agl@google.com>
2015-04-28 05:05:35 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
uint32_t algorithm_mkey;
uint32_t algorithm_auth;
uint32_t algorithm_enc;
uint32_t algorithm_mac;
uint32_t algorithm_ssl;
uint32_t algo_strength;
uint32_t algorithm_prf;
Promote set_tmp_dh and set_tmp_ecdh to functions. BUG=404754 Change-Id: I7c75dd88fe9338b1d3b90745f742d15d6b84775a Reviewed-on: https://boringssl-review.googlesource.com/4568 Reviewed-by: Adam Langley <agl@google.com>
2015-04-28 05:05:35 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* strength_bits is the strength of the cipher in bits. */
int strength_bits;
/* alg_bits is the number of bits of key material used by the algorithm. */
int alg_bits;
};
Promote set_tmp_dh and set_tmp_ecdh to functions. BUG=404754 Change-Id: I7c75dd88fe9338b1d3b90745f742d15d6b84775a Reviewed-on: https://boringssl-review.googlesource.com/4568 Reviewed-by: Adam Langley <agl@google.com>
2015-04-28 05:05:35 +01:00
Private constants are private. Change-Id: Id20fcf357d4a0fc28734a7f2ea1fe077d4b34f1e Reviewed-on: https://boringssl-review.googlesource.com/6306 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 03:53:31 +01:00
#define SSL_MAX_SSL_SESSION_ID_LENGTH 32
#define SSL_MAX_SID_CTX_LENGTH 32
#define SSL_MAX_MASTER_KEY_LENGTH 48
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
struct ssl_session_st {
int ssl_version; /* what ssl version session info is being kept in here? */
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
int master_key_length;
uint8_t master_key[SSL_MAX_MASTER_KEY_LENGTH];
/* session_id - valid? */
unsigned int session_id_length;
uint8_t session_id[SSL_MAX_SSL_SESSION_ID_LENGTH];
/* this is used to determine whether the session is being reused in
* the appropriate context. It is up to the application to set this,
* via SSL_new */
unsigned int sid_ctx_length;
uint8_t sid_ctx[SSL_MAX_SID_CTX_LENGTH];
Promote channel ID macros to proper functions. BUG=404754 Change-Id: I002d4602720e207f92a985d90f0d58e89562affa Reviewed-on: https://boringssl-review.googlesource.com/4569 Reviewed-by: Adam Langley <agl@google.com>
2015-04-28 05:19:50 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
char *psk_identity;
/* Used to indicate that session resumption is not allowed. Applications can
* also set this bit for a new session via not_resumable_session_cb to
* disable session caching and tickets. */
int not_resumable;
Promote channel ID macros to proper functions. BUG=404754 Change-Id: I002d4602720e207f92a985d90f0d58e89562affa Reviewed-on: https://boringssl-review.googlesource.com/4569 Reviewed-by: Adam Langley <agl@google.com>
2015-04-28 05:19:50 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* peer is the peer's certificate. */
X509 *peer;
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* cert_chain is the certificate chain sent by the peer. NOTE: for historical
* reasons, when a client (so the peer is a server), the chain includes
* |peer|, but when a server it does not. */
STACK_OF(X509) *cert_chain;
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* when app_verify_callback accepts a session where the peer's certificate is
* not ok, we must remember the error for session reuse: */
long verify_result; /* only for servers */
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
CRYPTO_refcount_t references;
long timeout;
long time;
Promote SSL_get0_certificate_types to a proper function. BUG=404754 Change-Id: I94785e970d2f08e46826edd2ac41215500f46e99 Reviewed-on: https://boringssl-review.googlesource.com/5671 Reviewed-by: Adam Langley <agl@google.com>
2015-08-09 15:42:33 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
const SSL_CIPHER *cipher;
Remove SSL_get1_curves and promote SSL_(CTX_)?set1_curves. I'm not sure why one would ever want to externally know the curve list supported by the server. The API is new as of 1.0.2 and has no callers. Configuring curves will be much more useful when Curve25519 exists and the API isn't terribly crazy, so keep that API around and promote it to a real function. BUG=404754 Change-Id: Ibd5858791d3dfb30d53dd680cb75b0caddcbb7df Reviewed-on: https://boringssl-review.googlesource.com/5674 Reviewed-by: Adam Langley <agl@google.com>
2015-08-09 16:13:23 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* key_exchange_info contains an indication of the size of the asymmetric
* primitive used in the handshake that created this session. In the event
* that two asymmetric operations are used, this value applies to the one
* that controls the confidentiality of the connection. Its interpretation
* depends on the primitive that was used; as specified by the cipher suite:
* DHE: the size, in bits, of the multiplicative group.
* RSA: the size, in bits, of the modulus.
* ECDHE: the TLS id for the curve.
*
* A zero indicates that the value is unknown. */
uint32_t key_exchange_info;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
CRYPTO_EX_DATA ex_data; /* application specific data */
Add visibility rules. This change marks public symbols as dynamically exported. This means that it becomes viable to build a shared library of libcrypto and libssl with -fvisibility=hidden. On Windows, one not only needs to mark functions for export in a component, but also for import when using them from a different component. Because of this we have to build with |BORINGSSL_IMPLEMENTATION| defined when building the code. Other components, when including our headers, won't have that defined and then the |OPENSSL_EXPORT| tag becomes an import tag instead. See the #defines in base.h In the asm code, symbols are now hidden by default and those that need to be exported are wrapped by a C function. In order to support Chromium, a couple of libssl functions were moved to ssl.h from ssl_locl.h: ssl_get_new_session and ssl_update_cache. Change-Id: Ib4b76e2f1983ee066e7806c24721e8626d08a261 Reviewed-on: https://boringssl-review.googlesource.com/1350 Reviewed-by: Adam Langley <agl@google.com>
2014-07-31 00:02:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* These are used to make removal of session-ids more efficient and to
* implement a maximum cache size. */
SSL_SESSION *prev, *next;
char *tlsext_hostname;
/* RFC4507 info */
uint8_t *tlsext_tick; /* Session ticket */
size_t tlsext_ticklen; /* Session ticket length */
uint32_t tlsext_tick_lifetime_hint; /* Session lifetime hint in seconds */
Add visibility rules. This change marks public symbols as dynamically exported. This means that it becomes viable to build a shared library of libcrypto and libssl with -fvisibility=hidden. On Windows, one not only needs to mark functions for export in a component, but also for import when using them from a different component. Because of this we have to build with |BORINGSSL_IMPLEMENTATION| defined when building the code. Other components, when including our headers, won't have that defined and then the |OPENSSL_EXPORT| tag becomes an import tag instead. See the #defines in base.h In the asm code, symbols are now hidden by default and those that need to be exported are wrapped by a C function. In order to support Chromium, a couple of libssl functions were moved to ssl.h from ssl_locl.h: ssl_get_new_session and ssl_update_cache. Change-Id: Ib4b76e2f1983ee066e7806c24721e8626d08a261 Reviewed-on: https://boringssl-review.googlesource.com/1350 Reviewed-by: Adam Langley <agl@google.com>
2014-07-31 00:02:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
size_t tlsext_signed_cert_timestamp_list_length;
uint8_t *tlsext_signed_cert_timestamp_list; /* Server's list. */
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* The OCSP response that came with the session. */
size_t ocsp_response_length;
uint8_t *ocsp_response;
char peer_sha256_valid; /* Non-zero if peer_sha256 is valid */
uint8_t
peer_sha256[SHA256_DIGEST_LENGTH]; /* SHA256 of peer certificate */
/* original_handshake_hash contains the handshake hash (either SHA-1+MD5 or
* SHA-2, depending on TLS version) for the original, full handshake that
* created a session. This is used by Channel IDs during resumption. */
uint8_t original_handshake_hash[EVP_MAX_MD_SIZE];
unsigned int original_handshake_hash_len;
/* extended_master_secret is true if the master secret in this session was
* generated using EMS and thus isn't vulnerable to the Triple Handshake
* attack. */
char extended_master_secret;
};
/* ssl_cipher_preference_list_st contains a list of SSL_CIPHERs with
* equal-preference groups. For TLS clients, the groups are moot because the
* server picks the cipher and groups cannot be expressed on the wire. However,
* for servers, the equal-preference groups allow the client's preferences to
* be partially respected. (This only has an effect with
* SSL_OP_CIPHER_SERVER_PREFERENCE).
*
* The equal-preference groups are expressed by grouping SSL_CIPHERs together.
* All elements of a group have the same priority: no ordering is expressed
* within a group.
*
* The values in |ciphers| are in one-to-one correspondence with
* |in_group_flags|. (That is, sk_SSL_CIPHER_num(ciphers) is the number of
* bytes in |in_group_flags|.) The bytes in |in_group_flags| are either 1, to
* indicate that the corresponding SSL_CIPHER is not the last element of a
* group, or 0 to indicate that it is.
*
* For example, if |in_group_flags| contains all zeros then that indicates a
* traditional, fully-ordered preference. Every SSL_CIPHER is the last element
* of the group (i.e. they are all in a one-element group).
*
* For a more complex example, consider:
* ciphers: A B C D E F
* in_group_flags: 1 1 0 0 1 0
*
* That would express the following, order:
*
* A E
* B -> D -> F
* C
*/
struct ssl_cipher_preference_list_st {
STACK_OF(SSL_CIPHER) *ciphers;
uint8_t *in_group_flags;
};
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
struct ssl_ctx_st {
const SSL_PROTOCOL_METHOD *method;
Make key exchange strength available. This change stores the size of the group/modulus (for RSA/DHE) or curve ID (for ECDHE) in the |SSL_SESSION|. This makes it available for UIs where desired. Change-Id: I354141da432a08f71704c9683f298b361362483d Reviewed-on: https://boringssl-review.googlesource.com/5280 Reviewed-by: Adam Langley <agl@google.com>
2015-06-29 14:07:26 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* lock is used to protect various operations on this object. */
CRYPTO_MUTEX lock;
Make key exchange strength available. This change stores the size of the group/modulus (for RSA/DHE) or curve ID (for ECDHE) in the |SSL_SESSION|. This makes it available for UIs where desired. Change-Id: I354141da432a08f71704c9683f298b361362483d Reviewed-on: https://boringssl-review.googlesource.com/5280 Reviewed-by: Adam Langley <agl@google.com>
2015-06-29 14:07:26 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* max_version is the maximum acceptable protocol version. If zero, the
* maximum supported version, currently (D)TLS 1.2, is used. */
uint16_t max_version;
Add visibility rules. This change marks public symbols as dynamically exported. This means that it becomes viable to build a shared library of libcrypto and libssl with -fvisibility=hidden. On Windows, one not only needs to mark functions for export in a component, but also for import when using them from a different component. Because of this we have to build with |BORINGSSL_IMPLEMENTATION| defined when building the code. Other components, when including our headers, won't have that defined and then the |OPENSSL_EXPORT| tag becomes an import tag instead. See the #defines in base.h In the asm code, symbols are now hidden by default and those that need to be exported are wrapped by a C function. In order to support Chromium, a couple of libssl functions were moved to ssl.h from ssl_locl.h: ssl_get_new_session and ssl_update_cache. Change-Id: Ib4b76e2f1983ee066e7806c24721e8626d08a261 Reviewed-on: https://boringssl-review.googlesource.com/1350 Reviewed-by: Adam Langley <agl@google.com>
2014-07-31 00:02:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* min_version is the minimum acceptable protocl version. If zero, the
* minimum supported version, currently SSL 3.0 and DTLS 1.0, is used */
uint16_t min_version;
Add SSL_SESSION_up_ref. The fact that an SSL_SESSION is reference-counted is already part of the API. If an external application (like, say, the test code) wishes to participate, we should let it. Change-Id: If04d26a35141da14fd8d917de6cc1c10537ad11a Reviewed-on: https://boringssl-review.googlesource.com/3344 Reviewed-by: Adam Langley <agl@google.com>
2015-02-09 08:34:47 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
struct ssl_cipher_preference_list_st *cipher_list;
/* same as above but sorted for lookup */
STACK_OF(SSL_CIPHER) *cipher_list_by_id;
Add SSL_SESSION_up_ref. The fact that an SSL_SESSION is reference-counted is already part of the API. If an external application (like, say, the test code) wishes to participate, we should let it. Change-Id: If04d26a35141da14fd8d917de6cc1c10537ad11a Reviewed-on: https://boringssl-review.googlesource.com/3344 Reviewed-by: Adam Langley <agl@google.com>
2015-02-09 08:34:47 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* cipher_list_tls10 is the list of ciphers when TLS 1.0 or greater is in
* use. This only applies to server connections as, for clients, the version
* number is known at connect time and so the cipher list can be set then. If
* |cipher_list_tls11| is non-NULL then this applies only to TLS 1.0
* connections.
*
* TODO(agl): this exists to assist in the death of SSLv3. It can hopefully
* be removed after that. */
struct ssl_cipher_preference_list_st *cipher_list_tls10;
Add SSL_SESSION_up_ref. The fact that an SSL_SESSION is reference-counted is already part of the API. If an external application (like, say, the test code) wishes to participate, we should let it. Change-Id: If04d26a35141da14fd8d917de6cc1c10537ad11a Reviewed-on: https://boringssl-review.googlesource.com/3344 Reviewed-by: Adam Langley <agl@google.com>
2015-02-09 08:34:47 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* cipher_list_tls11 is the list of ciphers when TLS 1.1 or greater is in
* use. This only applies to server connections as, for clients, the version
* number is known at connect time and so the cipher list can be set then. */
struct ssl_cipher_preference_list_st *cipher_list_tls11;
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
X509_STORE *cert_store;
LHASH_OF(SSL_SESSION) *sessions;
/* Most session-ids that will be cached, default is
* SSL_SESSION_CACHE_MAX_SIZE_DEFAULT. 0 is unlimited. */
unsigned long session_cache_size;
SSL_SESSION *session_cache_head;
SSL_SESSION *session_cache_tail;
Add SSL_SESSION_to_bytes to replace i2d_SSL_SESSION. Deprecate the old two-pass version of the function. If the ticket is too long, replace it with a placeholder value but keep the connection working. Change-Id: Ib9fdea66389b171862143d79b5540ea90a9bd5fb Reviewed-on: https://boringssl-review.googlesource.com/2011 Reviewed-by: Adam Langley <agl@google.com>
2014-10-21 06:46:30 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* handshakes_since_cache_flush is the number of successful handshakes since
* the last cache flush. */
int handshakes_since_cache_flush;
Add SSL_SESSION_to_bytes to replace i2d_SSL_SESSION. Deprecate the old two-pass version of the function. If the ticket is too long, replace it with a placeholder value but keep the connection working. Change-Id: Ib9fdea66389b171862143d79b5540ea90a9bd5fb Reviewed-on: https://boringssl-review.googlesource.com/2011 Reviewed-by: Adam Langley <agl@google.com>
2014-10-21 06:46:30 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* This can have one of 2 values, ored together,
* SSL_SESS_CACHE_CLIENT,
* SSL_SESS_CACHE_SERVER,
* Default is SSL_SESSION_CACHE_SERVER, which means only
* SSL_accept which cache SSL_SESSIONS. */
int session_cache_mode;
Add SSL_SESSION_from_bytes. Mirrors SSL_SESSION_to_bytes. It avoids having to deal with object-reuse, the non-size_t length parameter, and trailing data. Both it and the object-reuse variant back onto an unexposed SSL_SESSION_parse which reads a CBS. Note that this changes the object reuse story slightly. It's now merely an optional output pointer that frees its old contents. No d2i_SSL_SESSION consumer in Google that's built does reuse, much less reuse with the assumption that the top-level object won't be overridden. Change-Id: I5cb8522f96909bb222cab0f342423f2dd7814282 Reviewed-on: https://boringssl-review.googlesource.com/5121 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 00:41:48 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* If timeout is not 0, it is the default timeout value set when SSL_new() is
* called. This has been put in to make life easier to set things up */
long session_timeout;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* If this callback is not null, it will be called each time a session id is
* added to the cache. If this function returns 1, it means that the
* callback will do a SSL_SESSION_free() when it has finished using it.
* Otherwise, on 0, it means the callback has finished with it. If
* remove_session_cb is not null, it will be called when a session-id is
* removed from the cache. After the call, OpenSSL will SSL_SESSION_free()
* it. */
int (*new_session_cb)(SSL *ssl, SSL_SESSION *sess);
void (*remove_session_cb)(SSL_CTX *ctx, SSL_SESSION *sess);
SSL_SESSION *(*get_session_cb)(SSL *ssl, uint8_t *data, int len,
int *copy);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
CRYPTO_refcount_t references;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* if defined, these override the X509_verify_cert() calls */
Document certificate verification functions in SSL. Or at least group them together and make a passing attempt to document them. The legacy X.509 stack itself remains largely untouched and most of the parameters have to do with it. Change-Id: I9e11e2ad1bbeef53478c787344398c0d8d1b3876 Reviewed-on: https://boringssl-review.googlesource.com/5942 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 18:04:22 +01:00
int (*app_verify_callback)(X509_STORE_CTX *store_ctx, void *arg);
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
void *app_verify_arg;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Default password callback. */
pem_password_cb *default_passwd_callback;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Default password callback user data. */
void *default_passwd_callback_userdata;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* get client cert callback */
Better document the callbacks around client certificates. Deprecate the client_cert_cb variant since you can't really configure intermediates with it. (You might be able to by configuring the intermediates without the leaf or key and leaving the SSL stack to configure those, but that's really weird. cert_cb is simpler.) Also document the two functions the callbacks may use to query the CertificateRequest on the client. Change-Id: Iad6076266fd798cd74ea4e09978e7f5df5c8a670 Reviewed-on: https://boringssl-review.googlesource.com/6092 Reviewed-by: Adam Langley <agl@google.com>
2015-10-03 15:49:20 +01:00
int (*client_cert_cb)(SSL *ssl, X509 **out_x509, EVP_PKEY **out_pkey);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* get channel id callback */
Document Channel ID functions and a few random extras. Change-Id: I34a6352d265615ee08bb18fd537acf70a558f014 Reviewed-on: https://boringssl-review.googlesource.com/5940 Reviewed-by: Adam Langley <agl@google.com>
2015-09-19 06:22:44 +01:00
void (*channel_id_cb)(SSL *ssl, EVP_PKEY **out_pkey);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
CRYPTO_EX_DATA ex_data;
Make key exchange strength available. This change stores the size of the group/modulus (for RSA/DHE) or curve ID (for ECDHE) in the |SSL_SESSION|. This makes it available for UIs where desired. Change-Id: I354141da432a08f71704c9683f298b361362483d Reviewed-on: https://boringssl-review.googlesource.com/5280 Reviewed-by: Adam Langley <agl@google.com>
2015-06-29 14:07:26 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* custom_*_extensions stores any callback sets for custom extensions. Note
* that these pointers will be NULL if the stack would otherwise be empty. */
STACK_OF(SSL_CUSTOM_EXTENSION) *client_custom_extensions;
STACK_OF(SSL_CUSTOM_EXTENSION) *server_custom_extensions;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Default values used when no per-SSL value is defined follow */
Forbid caller-initiated renegotiations and all renego as a servers. The only case where renego is supported is if we are a client and the server sends a HelloRequest. That is still needed to support the renego + client auth hack in Chrome. Beyond that, no other forms of renego will work. The messy logic where the handshake loop is repurposed to send HelloRequest and the extremely confusing tri-state s->renegotiate (which makes SSL_renegotiate_pending a lie during the initial handshake as a server) are now gone. The next change will further simplify things by removing ssl->s3->renegotiate and the renego deferral logic. There's also some server-only renegotiation checks that can go now. Also clean up ssl3_read_bytes' HelloRequest handling. The old logic relied on the handshake state machine to reject bad HelloRequests which... actually that code probably lets you initiate renego by sending the first four bytes of a ServerHello and expecting the peer to read it later. BUG=429450 Change-Id: Ie0f87d0c2b94e13811fe8e22e810ab2ffc8efa6c Reviewed-on: https://boringssl-review.googlesource.com/4824 Reviewed-by: Adam Langley <agl@google.com>
2015-05-21 06:29:55 +01:00
Document the info callback. This callback is some combination of arguably useful stuff (bracket handshakes, alerts) and completely insane things (find out when the state machine advances). Deprecate the latter. Change-Id: Ibea5b32cb360b767b0f45b302fd5f1fe17850593 Reviewed-on: https://boringssl-review.googlesource.com/6305 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 03:51:17 +01:00
void (*info_callback)(const SSL *ssl, int type, int value);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* what we put in client cert requests */
STACK_OF(X509_NAME) *client_CA;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Default values to use in SSL structures follow (these are copied by
* SSL_new) */
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
uint32_t options;
uint32_t mode;
uint32_t max_cert_list;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
struct cert_st /* CERT */ *cert;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* callback that allows applications to peek at protocol messages */
void (*msg_callback)(int write_p, int version, int content_type,
const void *buf, size_t len, SSL *ssl, void *arg);
void *msg_callback_arg;
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
int verify_mode;
unsigned int sid_ctx_length;
uint8_t sid_ctx[SSL_MAX_SID_CTX_LENGTH];
int (*default_verify_callback)(
int ok, X509_STORE_CTX *ctx); /* called 'verify_callback' in the SSL */
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Default generate session ID callback. */
GEN_SESSION_CB generate_session_id;
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
X509_VERIFY_PARAM *param;
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* select_certificate_cb is called before most ClientHello processing and
* before the decision whether to resume a session is made. It may return one
* to continue the handshake or zero to cause the handshake loop to return
* with an error and cause SSL_get_error to return
* SSL_ERROR_PENDING_CERTIFICATE. Note: when the handshake loop is resumed, it
* will not call the callback a second time. */
int (*select_certificate_cb)(const struct ssl_early_callback_ctx *);
Promote everything directly in SSL_CTX_ctrl. BUG=404754 Change-Id: I0e4af2f341fcef5d01c855d97e981b8597d08b63 Reviewed-on: https://boringssl-review.googlesource.com/4563 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:46:38 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* dos_protection_cb is called once the resumption decision for a ClientHello
* has been made. It returns one to continue the handshake or zero to
* abort. */
int (*dos_protection_cb) (const struct ssl_early_callback_ctx *);
Promote everything directly in SSL_CTX_ctrl. BUG=404754 Change-Id: I0e4af2f341fcef5d01c855d97e981b8597d08b63 Reviewed-on: https://boringssl-review.googlesource.com/4563 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:46:38 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* quiet_shutdown is true if the connection should not send a close_notify on
* shutdown. */
int quiet_shutdown;
Promote everything directly in SSL_CTX_ctrl. BUG=404754 Change-Id: I0e4af2f341fcef5d01c855d97e981b8597d08b63 Reviewed-on: https://boringssl-review.googlesource.com/4563 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:46:38 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Maximum amount of data to send in one fragment. actual record size can be
* more than this due to padding and MAC overheads. */
uint16_t max_send_fragment;
Promote everything directly in SSL_CTX_ctrl. BUG=404754 Change-Id: I0e4af2f341fcef5d01c855d97e981b8597d08b63 Reviewed-on: https://boringssl-review.googlesource.com/4563 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:46:38 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* TLS extensions servername callback */
int (*tlsext_servername_callback)(SSL *, int *, void *);
void *tlsext_servername_arg;
/* RFC 4507 session ticket keys */
uint8_t tlsext_tick_key_name[SSL_TICKET_KEY_NAME_LEN];
uint8_t tlsext_tick_hmac_key[16];
uint8_t tlsext_tick_aes_key[16];
/* Callback to support customisation of ticket key setting */
int (*tlsext_ticket_key_cb)(SSL *ssl, uint8_t *name, uint8_t *iv,
EVP_CIPHER_CTX *ectx, HMAC_CTX *hctx, int enc);
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Server-only: psk_identity_hint is the default identity hint to send in
* PSK-based key exchanges. */
char *psk_identity_hint;
Promote max_cert_list and max_send_fragment to functions. Also size them based on the limits in the quantities they control (after checking bounds at the API boundary). BUG=404754 Change-Id: Id56ba45465a473a1a793244904310ef747f29b63 Reviewed-on: https://boringssl-review.googlesource.com/4559 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 20:35:35 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
unsigned int (*psk_client_callback)(SSL *ssl, const char *hint,
char *identity,
unsigned int max_identity_len,
uint8_t *psk, unsigned int max_psk_len);
unsigned int (*psk_server_callback)(SSL *ssl, const char *identity,
uint8_t *psk, unsigned int max_psk_len);
Promote max_cert_list and max_send_fragment to functions. Also size them based on the limits in the quantities they control (after checking bounds at the API boundary). BUG=404754 Change-Id: Id56ba45465a473a1a793244904310ef747f29b63 Reviewed-on: https://boringssl-review.googlesource.com/4559 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 20:35:35 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* retain_only_sha256_of_client_certs is true if we should compute the SHA256
* hash of the peer's certifiate and then discard it to save memory and
* session space. Only effective on the server side. */
char retain_only_sha256_of_client_certs;
Promote max_cert_list and max_send_fragment to functions. Also size them based on the limits in the quantities they control (after checking bounds at the API boundary). BUG=404754 Change-Id: Id56ba45465a473a1a793244904310ef747f29b63 Reviewed-on: https://boringssl-review.googlesource.com/4559 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 20:35:35 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Next protocol negotiation information */
/* (for experimental NPN extension). */
Promote max_cert_list and max_send_fragment to functions. Also size them based on the limits in the quantities they control (after checking bounds at the API boundary). BUG=404754 Change-Id: Id56ba45465a473a1a793244904310ef747f29b63 Reviewed-on: https://boringssl-review.googlesource.com/4559 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 20:35:35 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* For a server, this contains a callback function by which the set of
* advertised protocols can be provided. */
Group NPN functions in their own section. Existing documentation was moved to the header, very slightly tweaked. Change-Id: Ife3c2351e2d7e6a335854284f996918039414446 Reviewed-on: https://boringssl-review.googlesource.com/5897 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 05:25:52 +01:00
int (*next_protos_advertised_cb)(SSL *ssl, const uint8_t **out,
unsigned *out_len, void *arg);
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
void *next_protos_advertised_cb_arg;
/* For a client, this contains a callback function that selects the
* next protocol from the list provided by the server. */
Group NPN functions in their own section. Existing documentation was moved to the header, very slightly tweaked. Change-Id: Ife3c2351e2d7e6a335854284f996918039414446 Reviewed-on: https://boringssl-review.googlesource.com/5897 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 05:25:52 +01:00
int (*next_proto_select_cb)(SSL *ssl, uint8_t **out, uint8_t *out_len,
const uint8_t *in, unsigned in_len, void *arg);
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
void *next_proto_select_cb_arg;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* ALPN information
* (we are in the process of transitioning from NPN to ALPN.) */
Promote all SSL callback ctrl hooks to proper functions. Document them while I'm here. This adds a new 'preprocessor compatibility section' to avoid breaking #ifdefs. The CTRL values themselves are defined to 'doesnt_exist' to catch anything calling SSL_ctrl directly until that function can be unexported completely. BUG=404754 Change-Id: Ia157490ea8efe0215d4079556a0c7643273e7601 Reviewed-on: https://boringssl-review.googlesource.com/4553 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 18:13:55 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* For a server, this contains a callback function that allows the
* server to select the protocol for the connection.
* out: on successful return, this must point to the raw protocol
* name (without the length prefix).
* outlen: on successful return, this contains the length of |*out|.
* in: points to the client's list of supported protocols in
* wire-format.
* inlen: the length of |in|. */
Group ALPN functions into their own section. These were already documented, though some of the documentation was expanded on slightly. Change-Id: I04c6276a83a64a03ab9cce9b9c94d4dea9ddf638 Reviewed-on: https://boringssl-review.googlesource.com/5896 Reviewed-by: Adam Langley <agl@google.com>
2015-09-16 05:10:19 +01:00
int (*alpn_select_cb)(SSL *s, const uint8_t **out, uint8_t *out_len,
const uint8_t *in, unsigned in_len, void *arg);
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
void *alpn_select_cb_arg;
Always enable ecdh_auto. This is a really dumb API wart. Now that we have a limited set of curves that are all reasonable, the automatic logic should just always kick in. This makes set_ecdh_auto a no-op and, instead of making it the first choice, uses it as the fallback behavior should none of the older curve selection APIs be used. Currently, by default, server sockets can only use the plain RSA key exchange. BUG=481139 Change-Id: Iaabc82de766cd00968844a71aaac29bd59841cd4 Reviewed-on: https://boringssl-review.googlesource.com/4531 Reviewed-by: Adam Langley <agl@google.com>
2015-04-24 20:20:13 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* For a client, this contains the list of supported protocols in wire
* format. */
uint8_t *alpn_client_proto_list;
unsigned alpn_client_proto_list_len;
Always enable ecdh_auto. This is a really dumb API wart. Now that we have a limited set of curves that are all reasonable, the automatic logic should just always kick in. This makes set_ecdh_auto a no-op and, instead of making it the first choice, uses it as the fallback behavior should none of the older curve selection APIs be used. Currently, by default, server sockets can only use the plain RSA key exchange. BUG=481139 Change-Id: Iaabc82de766cd00968844a71aaac29bd59841cd4 Reviewed-on: https://boringssl-review.googlesource.com/4531 Reviewed-by: Adam Langley <agl@google.com>
2015-04-24 20:20:13 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* SRTP profiles we are willing to do from RFC 5764 */
STACK_OF(SRTP_PROTECTION_PROFILE) *srtp_profiles;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* EC extension values inherited by SSL structure */
size_t tlsext_ellipticcurvelist_length;
uint16_t *tlsext_ellipticcurvelist;
typedef |COMP_METHOD| to void, for compatibility. Change-Id: I2965c0d698e25f4eb08ddd9fc000b0e4adf6f2c0 Reviewed-on: https://boringssl-review.googlesource.com/5240 Reviewed-by: Adam Langley <agl@google.com>
2015-06-26 20:09:10 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* If true, a client will advertise the Channel ID extension and a server
* will echo it. */
char tlsext_channel_id_enabled;
/* The client's Channel ID private key. */
EVP_PKEY *tlsext_channel_id_private;
typedef |COMP_METHOD| to void, for compatibility. Change-Id: I2965c0d698e25f4eb08ddd9fc000b0e4adf6f2c0 Reviewed-on: https://boringssl-review.googlesource.com/5240 Reviewed-by: Adam Langley <agl@google.com>
2015-06-26 20:09:10 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* If true, a client will request certificate timestamps. */
char signed_cert_timestamps_enabled;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Signed certificate timestamp list to be sent to the client, if requested */
uint8_t *signed_cert_timestamp_list;
size_t signed_cert_timestamp_list_length;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* If true, a client will request a stapled OCSP response. */
char ocsp_stapling_enabled;
Add a callback for DDoS protection. This callback receives information about the ClientHello and can decide whether or not to allow the handshake to continue. Change-Id: I21be28335fa74fedb5b73a310ee24310670fc923 Reviewed-on: https://boringssl-review.googlesource.com/3721 Reviewed-by: Adam Langley <agl@google.com>
2015-02-21 00:04:00 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* OCSP response to be sent to the client, if requested. */
uint8_t *ocsp_response;
size_t ocsp_response_length;
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* If not NULL, session key material will be logged to this BIO for debugging
* purposes. The format matches NSS's and is readable by Wireshark. */
BIO *keylog_bio;
Add SSL_get_rc4_state. This allows the current RC4 state of an SSL* to be extracted. We have internal uses for this functionality. Change-Id: Ic124c4b253c8325751f49e7a4c021768620ea4b7 Reviewed-on: https://boringssl-review.googlesource.com/3722 Reviewed-by: Adam Langley <agl@google.com>
2015-02-20 23:32:52 +00:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* current_time_cb, if not NULL, is the function to use to get the current
* time. It sets |*out_clock| to the current time. */
void (*current_time_cb)(const SSL *ssl, struct timeval *out_clock);
};
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
struct ssl_st {
/* version is the protocol version. */
int version;
Document everything in ssl_ciph.c, now ssl_cipher.c. Just about everything depends on SSL_CIPHER. Move it to the top as the first section in ssl.h. Match the header order and the source file order and document everything. Also make a couple of minor style guide tweaks. Change-Id: I6a810dbe79238278ac480e5ced1447055715a79f Reviewed-on: https://boringssl-review.googlesource.com/4290 Reviewed-by: Adam Langley <agl@google.com>
2015-04-08 07:36:59 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* method is the method table corresponding to the current protocol (DTLS or
* TLS). */
const SSL_PROTOCOL_METHOD *method;
/* enc_method is the method table corresponding to the current protocol
* version. */
const SSL3_ENC_METHOD *enc_method;
Document everything in ssl_ciph.c, now ssl_cipher.c. Just about everything depends on SSL_CIPHER. Move it to the top as the first section in ssl.h. Match the header order and the source file order and document everything. Also make a couple of minor style guide tweaks. Change-Id: I6a810dbe79238278ac480e5ced1447055715a79f Reviewed-on: https://boringssl-review.googlesource.com/4290 Reviewed-by: Adam Langley <agl@google.com>
2015-04-08 07:36:59 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* max_version is the maximum acceptable protocol version. If zero, the
* maximum supported version, currently (D)TLS 1.2, is used. */
uint16_t max_version;
Document everything in ssl_ciph.c, now ssl_cipher.c. Just about everything depends on SSL_CIPHER. Move it to the top as the first section in ssl.h. Match the header order and the source file order and document everything. Also make a couple of minor style guide tweaks. Change-Id: I6a810dbe79238278ac480e5ced1447055715a79f Reviewed-on: https://boringssl-review.googlesource.com/4290 Reviewed-by: Adam Langley <agl@google.com>
2015-04-08 07:36:59 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* min_version is the minimum acceptable protocl version. If zero, the
* minimum supported version, currently SSL 3.0 and DTLS 1.0, is used */
uint16_t min_version;
Document everything in ssl_ciph.c, now ssl_cipher.c. Just about everything depends on SSL_CIPHER. Move it to the top as the first section in ssl.h. Match the header order and the source file order and document everything. Also make a couple of minor style guide tweaks. Change-Id: I6a810dbe79238278ac480e5ced1447055715a79f Reviewed-on: https://boringssl-review.googlesource.com/4290 Reviewed-by: Adam Langley <agl@google.com>
2015-04-08 07:36:59 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* There are 2 BIO's even though they are normally both the same. This is so
* data can be read and written to different handlers */
Document everything in ssl_ciph.c, now ssl_cipher.c. Just about everything depends on SSL_CIPHER. Move it to the top as the first section in ssl.h. Match the header order and the source file order and document everything. Also make a couple of minor style guide tweaks. Change-Id: I6a810dbe79238278ac480e5ced1447055715a79f Reviewed-on: https://boringssl-review.googlesource.com/4290 Reviewed-by: Adam Langley <agl@google.com>
2015-04-08 07:36:59 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
BIO *rbio; /* used by SSL_read */
BIO *wbio; /* used by SSL_write */
BIO *bbio; /* used during session-id reuse to concatenate
* messages */
Document everything in ssl_ciph.c, now ssl_cipher.c. Just about everything depends on SSL_CIPHER. Move it to the top as the first section in ssl.h. Match the header order and the source file order and document everything. Also make a couple of minor style guide tweaks. Change-Id: I6a810dbe79238278ac480e5ced1447055715a79f Reviewed-on: https://boringssl-review.googlesource.com/4290 Reviewed-by: Adam Langley <agl@google.com>
2015-04-08 07:36:59 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* This holds a variable that indicates what we were doing when a 0 or -1 is
* returned. This is needed for non-blocking IO so we know what request
* needs re-doing when in SSL_accept or SSL_connect */
int rwstate;
Start generating documentation for ssl.h. There's this giant "Underdocumented functions" section in the middle, but it doesn't look too silly once the "Deprecated methods" section is merged in with the other deprecated functions. Change-Id: Ib97d88b0f915f60e9790264474a9e4aa3e115382 Reviewed-on: https://boringssl-review.googlesource.com/4291 Reviewed-by: Adam Langley <agl@google.com>
2015-04-09 04:55:15 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* true when we are actually in SSL_accept() or SSL_connect() */
int in_handshake;
int (*handshake_func)(SSL *);
Start generating documentation for ssl.h. There's this giant "Underdocumented functions" section in the middle, but it doesn't look too silly once the "Deprecated methods" section is merged in with the other deprecated functions. Change-Id: Ib97d88b0f915f60e9790264474a9e4aa3e115382 Reviewed-on: https://boringssl-review.googlesource.com/4291 Reviewed-by: Adam Langley <agl@google.com>
2015-04-09 04:55:15 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Imagine that here's a boolean member "init" that is switched as soon as
* SSL_set_{accept/connect}_state is called for the first time, so that
* "state" and "handshake_func" are properly initialized. But as
* handshake_func is == 0 until then, we use this test instead of an "init"
* member. */
Start generating documentation for ssl.h. There's this giant "Underdocumented functions" section in the middle, but it doesn't look too silly once the "Deprecated methods" section is merged in with the other deprecated functions. Change-Id: Ib97d88b0f915f60e9790264474a9e4aa3e115382 Reviewed-on: https://boringssl-review.googlesource.com/4291 Reviewed-by: Adam Langley <agl@google.com>
2015-04-09 04:55:15 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* server is true iff the this SSL* is the server half. Note: before the SSL*
* is initialized by either SSL_set_accept_state or SSL_set_connect_state,
* the side is not determined. In this state, server is always false. */
int server;
Document some core SSL_CTX and SSL methods. Current thought is to organize this by: - Core SSL_CTX APIs (creating, destroying) - Core SSL APIs (creating destroying, maybe handshake, read, write as well) - APIs to configure SSL_CTX/SSL, roughly grouped by feature. Probably options and modes are the first two sections. SSL_TXT_* constants can be part of documenting cipher suite configuration. - APIs to query state from SSL_CTX/SSL, roughly grouped by feature. (Or perhaps these should be folded into the configuration sections?) The functions themselves aren't reordered or reorganized to match the eventual header order yet. Though I did do the s -> ssl rename on the ones I've touched. Also formally deprecate SSL_clear. It would be a core SSL API except it's horrible. Change-Id: Ia7e4fdcb7bad4e9ccdee8cf8c3136dc63aaaa772 Reviewed-on: https://boringssl-review.googlesource.com/4784 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 16:43:13 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* quiet_shutdown is true if the connection should not send a close_notify on
* shutdown. */
int quiet_shutdown;
Always enable ecdh_auto. This is a really dumb API wart. Now that we have a limited set of curves that are all reasonable, the automatic logic should just always kick in. This makes set_ecdh_auto a no-op and, instead of making it the first choice, uses it as the fallback behavior should none of the older curve selection APIs be used. Currently, by default, server sockets can only use the plain RSA key exchange. BUG=481139 Change-Id: Iaabc82de766cd00968844a71aaac29bd59841cd4 Reviewed-on: https://boringssl-review.googlesource.com/4531 Reviewed-by: Adam Langley <agl@google.com>
2015-04-24 20:20:13 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
int shutdown; /* we have shut things down, 0x01 sent, 0x02
* for received */
int state; /* where we are */
Always enable ecdh_auto. This is a really dumb API wart. Now that we have a limited set of curves that are all reasonable, the automatic logic should just always kick in. This makes set_ecdh_auto a no-op and, instead of making it the first choice, uses it as the fallback behavior should none of the older curve selection APIs be used. Currently, by default, server sockets can only use the plain RSA key exchange. BUG=481139 Change-Id: Iaabc82de766cd00968844a71aaac29bd59841cd4 Reviewed-on: https://boringssl-review.googlesource.com/4531 Reviewed-by: Adam Langley <agl@google.com>
2015-04-24 20:20:13 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
BUF_MEM *init_buf; /* buffer used during init */
uint8_t *init_msg; /* pointer to handshake message body, set by
ssl3_get_message() */
int init_num; /* amount read/written */
int init_off; /* amount read/written */
Promote deprecated statistics macros to functions. Not going to bother adding the compatibility macros. If they get ifdef'd out, all the better. BUG=404754 Change-Id: I26414d2fb84ee1f0b15a3b96c871949fe2bb7fb1 Reviewed-on: https://boringssl-review.googlesource.com/4558 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 19:45:04 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
struct ssl3_state_st *s3; /* SSLv3 variables */
struct dtls1_state_st *d1; /* DTLSv1 variables */
Promote deprecated statistics macros to functions. Not going to bother adding the compatibility macros. If they get ifdef'd out, all the better. BUG=404754 Change-Id: I26414d2fb84ee1f0b15a3b96c871949fe2bb7fb1 Reviewed-on: https://boringssl-review.googlesource.com/4558 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 19:45:04 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* callback that allows applications to peek at protocol messages */
void (*msg_callback)(int write_p, int version, int content_type,
const void *buf, size_t len, SSL *ssl, void *arg);
void *msg_callback_arg;
Promote deprecated statistics macros to functions. Not going to bother adding the compatibility macros. If they get ifdef'd out, all the better. BUG=404754 Change-Id: I26414d2fb84ee1f0b15a3b96c871949fe2bb7fb1 Reviewed-on: https://boringssl-review.googlesource.com/4558 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 19:45:04 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
int hit; /* reusing a previous session */
Promote deprecated statistics macros to functions. Not going to bother adding the compatibility macros. If they get ifdef'd out, all the better. BUG=404754 Change-Id: I26414d2fb84ee1f0b15a3b96c871949fe2bb7fb1 Reviewed-on: https://boringssl-review.googlesource.com/4558 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 19:45:04 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
X509_VERIFY_PARAM *param;
Promote deprecated statistics macros to functions. Not going to bother adding the compatibility macros. If they get ifdef'd out, all the better. BUG=404754 Change-Id: I26414d2fb84ee1f0b15a3b96c871949fe2bb7fb1 Reviewed-on: https://boringssl-review.googlesource.com/4558 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 19:45:04 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* crypto */
struct ssl_cipher_preference_list_st *cipher_list;
STACK_OF(SSL_CIPHER) *cipher_list_by_id;
Promote deprecated statistics macros to functions. Not going to bother adding the compatibility macros. If they get ifdef'd out, all the better. BUG=404754 Change-Id: I26414d2fb84ee1f0b15a3b96c871949fe2bb7fb1 Reviewed-on: https://boringssl-review.googlesource.com/4558 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 19:45:04 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
SSL_AEAD_CTX *aead_read_ctx;
SSL_AEAD_CTX *aead_write_ctx;
Promote deprecated statistics macros to functions. Not going to bother adding the compatibility macros. If they get ifdef'd out, all the better. BUG=404754 Change-Id: I26414d2fb84ee1f0b15a3b96c871949fe2bb7fb1 Reviewed-on: https://boringssl-review.googlesource.com/4558 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 19:45:04 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* session info */
Promote deprecated statistics macros to functions. Not going to bother adding the compatibility macros. If they get ifdef'd out, all the better. BUG=404754 Change-Id: I26414d2fb84ee1f0b15a3b96c871949fe2bb7fb1 Reviewed-on: https://boringssl-review.googlesource.com/4558 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 19:45:04 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* client cert? */
/* This is used to hold the server certificate used */
struct cert_st /* CERT */ *cert;
Promote deprecated statistics macros to functions. Not going to bother adding the compatibility macros. If they get ifdef'd out, all the better. BUG=404754 Change-Id: I26414d2fb84ee1f0b15a3b96c871949fe2bb7fb1 Reviewed-on: https://boringssl-review.googlesource.com/4558 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 19:45:04 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* the session_id_context is used to ensure sessions are only reused
* in the appropriate context */
unsigned int sid_ctx_length;
uint8_t sid_ctx[SSL_MAX_SID_CTX_LENGTH];
Promote deprecated statistics macros to functions. Not going to bother adding the compatibility macros. If they get ifdef'd out, all the better. BUG=404754 Change-Id: I26414d2fb84ee1f0b15a3b96c871949fe2bb7fb1 Reviewed-on: https://boringssl-review.googlesource.com/4558 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 19:45:04 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* This can also be in the session once a session is established */
SSL_SESSION *session;
Promote deprecated statistics macros to functions. Not going to bother adding the compatibility macros. If they get ifdef'd out, all the better. BUG=404754 Change-Id: I26414d2fb84ee1f0b15a3b96c871949fe2bb7fb1 Reviewed-on: https://boringssl-review.googlesource.com/4558 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 19:45:04 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Default generate session ID callback. */
GEN_SESSION_CB generate_session_id;
Move SSL_cutthrough_complete to the deprecated section. Change-Id: Ifb966061e52801a87d8be65fc0f23b1a4e57703f Reviewed-on: https://boringssl-review.googlesource.com/4562 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 23:36:23 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Used in SSL2 and SSL3 */
int verify_mode; /* 0 don't care about verify failure.
* 1 fail if verify fails */
int (*verify_callback)(int ok,
X509_STORE_CTX *ctx); /* fail if callback returns 0 */
Promote a few more macros. Next batch. Mostly a bunch of deprecated things. This switches SSL_CTX_set_tmp_rsa from always failing to always succeeding. The latter is probably a safer behavior; a consumer may defensively set a temporary RSA key. We'll successfully "set it" and just never use the result. Change-Id: Idd3d6bf4fc1a20bc9a26605bb9c77c9f799f993c Reviewed-on: https://boringssl-review.googlesource.com/4566 Reviewed-by: Adam Langley <agl@google.com>
2015-04-27 05:28:56 +01:00
Document the info callback. This callback is some combination of arguably useful stuff (bracket handshakes, alerts) and completely insane things (find out when the state machine advances). Deprecate the latter. Change-Id: Ibea5b32cb360b767b0f45b302fd5f1fe17850593 Reviewed-on: https://boringssl-review.googlesource.com/6305 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 03:51:17 +01:00
void (*info_callback)(const SSL *ssl, int type, int value);
Promote a few more macros. Next batch. Mostly a bunch of deprecated things. This switches SSL_CTX_set_tmp_rsa from always failing to always succeeding. The latter is probably a safer behavior; a consumer may defensively set a temporary RSA key. We'll successfully "set it" and just never use the result. Change-Id: Idd3d6bf4fc1a20bc9a26605bb9c77c9f799f993c Reviewed-on: https://boringssl-review.googlesource.com/4566 Reviewed-by: Adam Langley <agl@google.com>
2015-04-27 05:28:56 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Server-only: psk_identity_hint is the identity hint to send in
* PSK-based key exchanges. */
char *psk_identity_hint;
Promote a few more macros. Next batch. Mostly a bunch of deprecated things. This switches SSL_CTX_set_tmp_rsa from always failing to always succeeding. The latter is probably a safer behavior; a consumer may defensively set a temporary RSA key. We'll successfully "set it" and just never use the result. Change-Id: Idd3d6bf4fc1a20bc9a26605bb9c77c9f799f993c Reviewed-on: https://boringssl-review.googlesource.com/4566 Reviewed-by: Adam Langley <agl@google.com>
2015-04-27 05:28:56 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
unsigned int (*psk_client_callback)(SSL *ssl, const char *hint,
char *identity,
unsigned int max_identity_len,
uint8_t *psk, unsigned int max_psk_len);
unsigned int (*psk_server_callback)(SSL *ssl, const char *identity,
uint8_t *psk, unsigned int max_psk_len);
Promote a few more macros. Next batch. Mostly a bunch of deprecated things. This switches SSL_CTX_set_tmp_rsa from always failing to always succeeding. The latter is probably a safer behavior; a consumer may defensively set a temporary RSA key. We'll successfully "set it" and just never use the result. Change-Id: Idd3d6bf4fc1a20bc9a26605bb9c77c9f799f993c Reviewed-on: https://boringssl-review.googlesource.com/4566 Reviewed-by: Adam Langley <agl@google.com>
2015-04-27 05:28:56 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
SSL_CTX *ctx;
Promote a few more macros. Next batch. Mostly a bunch of deprecated things. This switches SSL_CTX_set_tmp_rsa from always failing to always succeeding. The latter is probably a safer behavior; a consumer may defensively set a temporary RSA key. We'll successfully "set it" and just never use the result. Change-Id: Idd3d6bf4fc1a20bc9a26605bb9c77c9f799f993c Reviewed-on: https://boringssl-review.googlesource.com/4566 Reviewed-by: Adam Langley <agl@google.com>
2015-04-27 05:28:56 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* extra application data */
long verify_result;
CRYPTO_EX_DATA ex_data;
Deprecate SSL_*_read_ahead and enforce DTLS packet boundaries. Now that WebRTC honors packet boundaries (https://crbug.com/447431), we can start enforcing them correctly. Configuring read-ahead now does nothing. Instead DTLS will always set "read-ahead" and also correctly enforce packet boundaries when reading records. Add tests to ensure that badly fragmented packets are ignored. Because such packets don't fail the handshake, the tests work by injecting an alert in the front of the handshake stream and ensuring the DTLS implementation ignores them. ssl3_read_n can be be considerably unraveled now, but leave that for future cleanup. For now, make it correct. BUG=468889 Change-Id: I800cfabe06615af31c2ccece436ca52aed9fe899 Reviewed-on: https://boringssl-review.googlesource.com/4820 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 06:30:09 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* for server side, keep the list of CA_dn we can use */
STACK_OF(X509_NAME) *client_CA;
Deprecate SSL_*_read_ahead and enforce DTLS packet boundaries. Now that WebRTC honors packet boundaries (https://crbug.com/447431), we can start enforcing them correctly. Configuring read-ahead now does nothing. Instead DTLS will always set "read-ahead" and also correctly enforce packet boundaries when reading records. Add tests to ensure that badly fragmented packets are ignored. Because such packets don't fail the handshake, the tests work by injecting an alert in the front of the handshake stream and ensuring the DTLS implementation ignores them. ssl3_read_n can be be considerably unraveled now, but leave that for future cleanup. For now, make it correct. BUG=468889 Change-Id: I800cfabe06615af31c2ccece436ca52aed9fe899 Reviewed-on: https://boringssl-review.googlesource.com/4820 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 06:30:09 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
uint32_t options; /* protocol behaviour */
uint32_t mode; /* API behaviour */
uint32_t max_cert_list;
int client_version; /* what was passed, used for
* SSLv3/TLS rollback check */
uint16_t max_send_fragment;
char *tlsext_hostname;
/* RFC4507 session ticket expected to be received or sent */
int tlsext_ticket_expected;
size_t tlsext_ellipticcurvelist_length;
uint16_t *tlsext_ellipticcurvelist; /* our list */
Deprecate SSL_*_read_ahead and enforce DTLS packet boundaries. Now that WebRTC honors packet boundaries (https://crbug.com/447431), we can start enforcing them correctly. Configuring read-ahead now does nothing. Instead DTLS will always set "read-ahead" and also correctly enforce packet boundaries when reading records. Add tests to ensure that badly fragmented packets are ignored. Because such packets don't fail the handshake, the tests work by injecting an alert in the front of the handshake stream and ensuring the DTLS implementation ignores them. ssl3_read_n can be be considerably unraveled now, but leave that for future cleanup. For now, make it correct. BUG=468889 Change-Id: I800cfabe06615af31c2ccece436ca52aed9fe899 Reviewed-on: https://boringssl-review.googlesource.com/4820 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 06:30:09 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
SSL_CTX *initial_ctx; /* initial ctx, used to store sessions */
Deprecate SSL_*_read_ahead and enforce DTLS packet boundaries. Now that WebRTC honors packet boundaries (https://crbug.com/447431), we can start enforcing them correctly. Configuring read-ahead now does nothing. Instead DTLS will always set "read-ahead" and also correctly enforce packet boundaries when reading records. Add tests to ensure that badly fragmented packets are ignored. Because such packets don't fail the handshake, the tests work by injecting an alert in the front of the handshake stream and ensuring the DTLS implementation ignores them. ssl3_read_n can be be considerably unraveled now, but leave that for future cleanup. For now, make it correct. BUG=468889 Change-Id: I800cfabe06615af31c2ccece436ca52aed9fe899 Reviewed-on: https://boringssl-review.googlesource.com/4820 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 06:30:09 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Next protocol negotiation. For the client, this is the protocol that we
* sent in NextProtocol and is set when handling ServerHello extensions.
*
* For a server, this is the client's selected_protocol from NextProtocol and
* is set when handling the NextProtocol message, before the Finished
* message. */
uint8_t *next_proto_negotiated;
size_t next_proto_negotiated_len;
Forbid caller-initiated renegotiations and all renego as a servers. The only case where renego is supported is if we are a client and the server sends a HelloRequest. That is still needed to support the renego + client auth hack in Chrome. Beyond that, no other forms of renego will work. The messy logic where the handshake loop is repurposed to send HelloRequest and the extremely confusing tri-state s->renegotiate (which makes SSL_renegotiate_pending a lie during the initial handshake as a server) are now gone. The next change will further simplify things by removing ssl->s3->renegotiate and the renego deferral logic. There's also some server-only renegotiation checks that can go now. Also clean up ssl3_read_bytes' HelloRequest handling. The old logic relied on the handshake state machine to reject bad HelloRequests which... actually that code probably lets you initiate renego by sending the first four bytes of a ServerHello and expecting the peer to read it later. BUG=429450 Change-Id: Ie0f87d0c2b94e13811fe8e22e810ab2ffc8efa6c Reviewed-on: https://boringssl-review.googlesource.com/4824 Reviewed-by: Adam Langley <agl@google.com>
2015-05-21 06:29:55 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* srtp_profiles is the list of configured SRTP protection profiles for
* DTLS-SRTP. */
STACK_OF(SRTP_PROTECTION_PROFILE) *srtp_profiles;
Deprecated functions get their own sections. A small handful of functions got a 'Deprecated:' prefix instead in documentation. Change-Id: Ic151fb7d797514add66bc6465b6851b666a471bc Reviewed-on: https://boringssl-review.googlesource.com/5825 Reviewed-by: Adam Langley <agl@google.com>
2015-09-07 18:17:45 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* srtp_profile is the selected SRTP protection profile for
* DTLS-SRTP. */
const SRTP_PROTECTION_PROFILE *srtp_profile;
Deprecated functions get their own sections. A small handful of functions got a 'Deprecated:' prefix instead in documentation. Change-Id: Ic151fb7d797514add66bc6465b6851b666a471bc Reviewed-on: https://boringssl-review.googlesource.com/5825 Reviewed-by: Adam Langley <agl@google.com>
2015-09-07 18:17:45 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Copied from the SSL_CTX. For a server, means that we'll accept Channel IDs
* from clients. For a client, means that we'll advertise support. */
char tlsext_channel_id_enabled;
/* The client's Channel ID private key. */
EVP_PKEY *tlsext_channel_id_private;
Deprecated functions get their own sections. A small handful of functions got a 'Deprecated:' prefix instead in documentation. Change-Id: Ic151fb7d797514add66bc6465b6851b666a471bc Reviewed-on: https://boringssl-review.googlesource.com/5825 Reviewed-by: Adam Langley <agl@google.com>
2015-09-07 18:17:45 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* Enable signed certificate time stamps. Currently client only. */
char signed_cert_timestamps_enabled;
Reorder functions in ssl_lib.c to match ssl.h. Just the stuff that has been pulled out into sections already. Change-Id: I3da6bc61d79ccfe2b18d888075dc32026a656464 Reviewed-on: https://boringssl-review.googlesource.com/5873 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:54:37 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* ocsp_stapling_enabled is only used by client connections and indicates
* whether OCSP stapling will be requested. */
char ocsp_stapling_enabled;
Reorder functions in ssl_lib.c to match ssl.h. Just the stuff that has been pulled out into sections already. Change-Id: I3da6bc61d79ccfe2b18d888075dc32026a656464 Reviewed-on: https://boringssl-review.googlesource.com/5873 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 05:54:37 +01:00
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* For a client, this contains the list of supported protocols in wire
* format. */
uint8_t *alpn_client_proto_list;
unsigned alpn_client_proto_list_len;
Add SSL_set_renegotiate_mode. Add a slightly richer API. Notably, one can configure ssl_renegotiate_once to only accept the first renego. Also, this API doesn't repeat the mistake I made with SSL_set_reject_peer_renegotiations which is super-confusing with the negation. Change-Id: I7eb5d534e3e6c553b641793f4677fe5a56451c71 Reviewed-on: https://boringssl-review.googlesource.com/6221 Reviewed-by: Adam Langley <agl@google.com>
2015-10-13 00:54:18 +01:00
/* renegotiate_mode controls how peer renegotiation attempts are handled. */
enum ssl_renegotiate_mode_t renegotiate_mode;
Move structs to a 'Private structures' section in ssl.h. To be consistent with some of the other headers and because SSL_METHOD no longer has a place to anchor documentation, move the type documentation up to the corresponding section headers, rather than attached to a convenient function. Also document thread-safety properties of SSL and SSL_CTX. Change-Id: I7109d704d28dda3f5d83c72d86fe31bc302b816e Reviewed-on: https://boringssl-review.googlesource.com/5876 Reviewed-by: Adam Langley <agl@google.com>
2015-09-13 18:53:19 +01:00
/* These fields are always NULL and exist only to keep wpa_supplicant happy
* about the change to EVP_AEAD. They are only needed for EAP-FAST, which we
* don't support. */
EVP_CIPHER_CTX *enc_read_ctx;
EVP_MD_CTX *read_hash;
};
Deprecate and no-op SSL_set_state. Yes, OpenSSL lets you randomly change its internal state. This is used as part of server-side renegotiation. Server-side renegotiation is gone. BUG=429450 Change-Id: Ic1b013705734357acf64e8bf89a051b2b7521c64 Reviewed-on: https://boringssl-review.googlesource.com/4828 Reviewed-by: Adam Langley <agl@google.com>
2015-05-16 04:52:42 +01:00
Fix ssl3.h / ssl.h circular dependency. Like tls1.h, ssl3.h is now just a bundle of protocol constants. Hopefully we can opaquify this struct in due time, but for now it's still public. Change-Id: I68366eb233702e149c92e21297f70f8a4a45f060 Reviewed-on: https://boringssl-review.googlesource.com/6300 Reviewed-by: Adam Langley <alangley@gmail.com>
2015-10-18 00:45:00 +01:00
typedef struct ssl3_record_st {
/* type is the record type. */
uint8_t type;
/* length is the number of unconsumed bytes of |data|. */
uint16_t length;
/* off is the number of consumed bytes of |data|. */
uint16_t off;
/* data is a non-owning pointer to the record contents. The total length of
* the buffer is |off| + |length|. */
uint8_t *data;
} SSL3_RECORD;
typedef struct ssl3_buffer_st {
/* buf is the memory allocated for this buffer. */
uint8_t *buf;
/* offset is the offset into |buf| which the buffer contents start at. */
uint16_t offset;
/* len is the length of the buffer contents from |buf| + |offset|. */
uint16_t len;
/* cap is how much memory beyond |buf| + |offset| is available. */
uint16_t cap;
} SSL3_BUFFER;
/* TODO(davidben): This flag can probably be merged into s3->change_cipher_spec
* to something tri-state. (Normal / Expect CCS / Between CCS and Finished). */
#define SSL3_FLAGS_EXPECT_CCS 0x0080
typedef struct ssl3_state_st {
long flags;
uint8_t read_sequence[8];
int read_mac_secret_size;
uint8_t read_mac_secret[EVP_MAX_MD_SIZE];
uint8_t write_sequence[8];
int write_mac_secret_size;
uint8_t write_mac_secret[EVP_MAX_MD_SIZE];
uint8_t server_random[SSL3_RANDOM_SIZE];
uint8_t client_random[SSL3_RANDOM_SIZE];
/* flags for countermeasure against known-IV weakness */
int need_record_splitting;
/* have_version is true if the connection's final version is known. Otherwise
* the version has not been negotiated yet. */
char have_version;
/* initial_handshake_complete is true if the initial handshake has
* completed. */
char initial_handshake_complete;
/* read_buffer holds data from the transport to be processed. */
SSL3_BUFFER read_buffer;
/* write_buffer holds data to be written to the transport. */
SSL3_BUFFER write_buffer;
SSL3_RECORD rrec; /* each decoded record goes in here */
/* storage for Handshake protocol data received but not yet processed by
* ssl3_read_bytes: */
uint8_t handshake_fragment[4];
unsigned int handshake_fragment_len;
/* partial write - check the numbers match */
unsigned int wnum; /* number of bytes sent so far */
int wpend_tot; /* number bytes written */
int wpend_type;
int wpend_ret; /* number of bytes submitted */
const uint8_t *wpend_buf;
/* handshake_buffer, if non-NULL, contains the handshake transcript. */
BUF_MEM *handshake_buffer;
/* handshake_hash, if initialized with an |EVP_MD|, maintains the handshake
* hash. For TLS 1.1 and below, it is the SHA-1 half. */
EVP_MD_CTX handshake_hash;
/* handshake_md5, if initialized with an |EVP_MD|, maintains the MD5 half of
* the handshake hash for TLS 1.1 and below. */
EVP_MD_CTX handshake_md5;
/* this is set whenerver we see a change_cipher_spec message come in when we
* are not looking for one */
int change_cipher_spec;
int warn_alert;
int fatal_alert;
/* we allow one fatal and one warning alert to be outstanding, send close
* alert via the warning alert */
int alert_dispatch;
uint8_t send_alert[2];
int total_renegotiations;
/* empty_record_count is the number of consecutive empty records received. */
uint8_t empty_record_count;
/* warning_alert_count is the number of consecutive warning alerts
* received. */
uint8_t warning_alert_count;
/* State pertaining to the pending handshake.
*
* TODO(davidben): State is current spread all over the place. Move
* pending handshake state here so it can be managed separately from
* established connection state in case of renegotiations. */
struct {
/* actually only need to be 16+20 for SSLv3 and 12 for TLS */
uint8_t finish_md[EVP_MAX_MD_SIZE * 2];
int finish_md_len;
uint8_t peer_finish_md[EVP_MAX_MD_SIZE * 2];
int peer_finish_md_len;
unsigned long message_size;
int message_type;
/* used to hold the new cipher we are going to use */
const SSL_CIPHER *new_cipher;
DH *dh;
EC_KEY *ecdh; /* holds short lived ECDH key */
/* used when SSL_ST_FLUSH_DATA is entered */
int next_state;
int reuse_message;
union {
/* sent is a bitset where the bits correspond to elements of kExtensions
* in t1_lib.c. Each bit is set if that extension was sent in a
* ClientHello. It's not used by servers. */
uint32_t sent;
/* received is a bitset, like |sent|, but is used by servers to record
* which extensions were received from a client. */
uint32_t received;
} extensions;
union {
/* sent is a bitset where the bits correspond to elements of
* |client_custom_extensions| in the |SSL_CTX|. Each bit is set if that
* extension was sent in a ClientHello. It's not used by servers. */
uint16_t sent;
/* received is a bitset, like |sent|, but is used by servers to record
* which custom extensions were received from a client. The bits here
* correspond to |server_custom_extensions|. */
uint16_t received;
} custom_extensions;
/* SNI extension */
/* should_ack_sni is used by a server and indicates that the SNI extension
* should be echoed in the ServerHello. */
unsigned should_ack_sni:1;
/* Client-only: cert_req determines if a client certificate is to be sent.
* This is 0 if no client Certificate message is to be sent, 1 if there is
* a client certificate, and 2 to send an empty client Certificate
* message. */
int cert_req;
/* Client-only: ca_names contains the list of CAs received in a
* CertificateRequest message. */
STACK_OF(X509_NAME) *ca_names;
/* Client-only: certificate_types contains the set of certificate types
* received in a CertificateRequest message. */
uint8_t *certificate_types;
size_t num_certificate_types;
int key_block_length;
uint8_t *key_block;
const EVP_AEAD *new_aead;
uint8_t new_mac_secret_len;
uint8_t new_fixed_iv_len;
uint8_t new_variable_iv_len;
/* Server-only: cert_request is true if a client certificate was
* requested. */
int cert_request;
/* certificate_status_expected is true if OCSP stapling was negotiated and
* the server is expected to send a CertificateStatus message. (This is
* used on both the client and server sides.) */
unsigned certificate_status_expected:1;
/* ocsp_stapling_requested is true if a client requested OCSP stapling. */
unsigned ocsp_stapling_requested:1;
/* Server-only: peer_ellipticcurvelist contains the EC curve IDs advertised
* by the peer. This is only set on the server's end. The server does not
* advertise this extension to the client. */
uint16_t *peer_ellipticcurvelist;
size_t peer_ellipticcurvelist_length;
/* extended_master_secret indicates whether the extended master secret
* computation is used in this handshake. Note that this is different from
* whether it was used for the current session. If this is a resumption
* handshake then EMS might be negotiated in the client and server hello
* messages, but it doesn't matter if the session that's being resumed
* didn't use it to create the master secret initially. */
char extended_master_secret;
/* Client-only: peer_psk_identity_hint is the psk_identity_hint sent by the
* server when using a PSK key exchange. */
char *peer_psk_identity_hint;
/* new_mac_secret_size is unused and exists only until wpa_supplicant can
* be updated. It is only needed for EAP-FAST, which we don't support. */
uint8_t new_mac_secret_size;
/* Client-only: in_false_start is one if there is a pending handshake in
* False Start. The client may write data at this point. */
char in_false_start;
/* peer_dh_tmp, on a client, is the server's DHE public key. */
DH *peer_dh_tmp;
/* peer_ecdh_tmp, on a client, is the server's ECDHE public key. */
EC_KEY *peer_ecdh_tmp;
} tmp;
/* Connection binding to prevent renegotiation attacks */
uint8_t previous_client_finished[EVP_MAX_MD_SIZE];
uint8_t previous_client_finished_len;
uint8_t previous_server_finished[EVP_MAX_MD_SIZE];
uint8_t previous_server_finished_len;
int send_connection_binding; /* TODOEKR */
/* Set if we saw the Next Protocol Negotiation extension from our peer. */
int next_proto_neg_seen;
/* ALPN information
* (we are in the process of transitioning from NPN to ALPN.) */
/* In a server these point to the selected ALPN protocol after the
* ClientHello has been processed. In a client these contain the protocol
* that the server selected once the ServerHello has been processed. */
uint8_t *alpn_selected;
size_t alpn_selected_len;
/* In a client, this means that the server supported Channel ID and that a
* Channel ID was sent. In a server it means that we echoed support for
* Channel IDs and that tlsext_channel_id will be valid after the
* handshake. */
char tlsext_channel_id_valid;
/* For a server:
* If |tlsext_channel_id_valid| is true, then this contains the
* verified Channel ID from the client: a P256 point, (x,y), where
* each are big-endian values. */
uint8_t tlsext_channel_id[64];
} SSL3_STATE;
Document everything in ssl_ciph.c, now ssl_cipher.c. Just about everything depends on SSL_CIPHER. Move it to the top as the first section in ssl.h. Match the header order and the source file order and document everything. Also make a couple of minor style guide tweaks. Change-Id: I6a810dbe79238278ac480e5ced1447055715a79f Reviewed-on: https://boringssl-review.googlesource.com/4290 Reviewed-by: Adam Langley <agl@google.com>
2015-04-08 07:36:59 +01:00
Add declarations for Android compatibility funcs. Some parts of Android can't be updated yet so this change adds declarations (only) for some functions that will be stubbed in Android-specific code. (That Android-specific code will live in the Android repo, not the BoringSSL repo.) Trying to use these functions outside of Android will result in a link error. Change-Id: Iaa9b956e6408d21cd8fc34d90d9c15657e429877 Reviewed-on: https://boringssl-review.googlesource.com/2760 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2015-01-07 23:06:31 +00:00
/* Android compatibility section.
*
* These functions are declared, temporarily, for Android because
* wpa_supplicant will take a little time to sync with upstream. Outside of
* Android they'll have no definition. */
#define SSL_F_SSL_SET_SESSION_TICKET_EXT doesnt_exist
Reformat SSL/TLS headers. Change-Id: Id9d848a6bb13a414d7c199674ff980c5011f92cf Reviewed-on: https://boringssl-review.googlesource.com/3000 Reviewed-by: Adam Langley <agl@google.com>
2015-01-23 23:10:10 +00:00
OPENSSL_EXPORT int SSL_set_session_ticket_ext(SSL *s, void *ext_data,
int ext_len);
Add declarations for Android compatibility funcs. Some parts of Android can't be updated yet so this change adds declarations (only) for some functions that will be stubbed in Android-specific code. (That Android-specific code will live in the Android repo, not the BoringSSL repo.) Trying to use these functions outside of Android will result in a link error. Change-Id: Iaa9b956e6408d21cd8fc34d90d9c15657e429877 Reviewed-on: https://boringssl-review.googlesource.com/2760 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2015-01-07 23:06:31 +00:00
OPENSSL_EXPORT int SSL_set_session_secret_cb(SSL *s, void *cb, void *arg);
OPENSSL_EXPORT int SSL_set_session_ticket_ext_cb(SSL *s, void *cb, void *arg);
Add some more Android compatibility declarations. Change-Id: Ia1de2b746dec680eb59dc614295a1da289c5741a
2015-03-20 18:49:44 +00:00
OPENSSL_EXPORT int SSL_set_ssl_method(SSL *s, const SSL_METHOD *method);
Add declarations for Android compatibility funcs. Some parts of Android can't be updated yet so this change adds declarations (only) for some functions that will be stubbed in Android-specific code. (That Android-specific code will live in the Android repo, not the BoringSSL repo.) Trying to use these functions outside of Android will result in a link error. Change-Id: Iaa9b956e6408d21cd8fc34d90d9c15657e429877 Reviewed-on: https://boringssl-review.googlesource.com/2760 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2015-01-07 23:06:31 +00:00
Promote all SSL callback ctrl hooks to proper functions. Document them while I'm here. This adds a new 'preprocessor compatibility section' to avoid breaking #ifdefs. The CTRL values themselves are defined to 'doesnt_exist' to catch anything calling SSL_ctrl directly until that function can be unexported completely. BUG=404754 Change-Id: Ia157490ea8efe0215d4079556a0c7643273e7601 Reviewed-on: https://boringssl-review.googlesource.com/4553 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 18:13:55 +01:00
/* Preprocessor compatibility section.
*
* Historically, a number of APIs were implemented in OpenSSL as macros and
* constants to 'ctrl' functions. To avoid breaking #ifdefs in consumers, this
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
* section defines a number of legacy macros.
*
* Although using either the CTRL values or their wrapper macros in #ifdefs is
* still supported, the CTRL values may not be passed to |SSL_ctrl| and
* |SSL_CTX_ctrl|. Call the functions (previously wrapper macros) instead. */
Promote all SSL callback ctrl hooks to proper functions. Document them while I'm here. This adds a new 'preprocessor compatibility section' to avoid breaking #ifdefs. The CTRL values themselves are defined to 'doesnt_exist' to catch anything calling SSL_ctrl directly until that function can be unexported completely. BUG=404754 Change-Id: Ia157490ea8efe0215d4079556a0c7643273e7601 Reviewed-on: https://boringssl-review.googlesource.com/4553 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 18:13:55 +01:00
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define DTLS_CTRL_GET_TIMEOUT doesnt_exist
#define DTLS_CTRL_HANDLE_TIMEOUT doesnt_exist
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
#define SSL_CTRL_CHAIN doesnt_exist
#define SSL_CTRL_CHAIN_CERT doesnt_exist
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTRL_CHANNEL_ID doesnt_exist
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
#define SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS doesnt_exist
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTRL_CLEAR_MODE doesnt_exist
#define SSL_CTRL_CLEAR_OPTIONS doesnt_exist
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
#define SSL_CTRL_EXTRA_CHAIN_CERT doesnt_exist
#define SSL_CTRL_GET_CHAIN_CERTS doesnt_exist
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTRL_GET_CHANNEL_ID doesnt_exist
Promote SSL_get0_certificate_types to a proper function. BUG=404754 Change-Id: I94785e970d2f08e46826edd2ac41215500f46e99 Reviewed-on: https://boringssl-review.googlesource.com/5671 Reviewed-by: Adam Langley <agl@google.com>
2015-08-09 15:42:33 +01:00
#define SSL_CTRL_GET_CLIENT_CERT_TYPES doesnt_exist
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
#define SSL_CTRL_GET_EXTRA_CHAIN_CERTS doesnt_exist
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTRL_GET_MAX_CERT_LIST doesnt_exist
Promote a few more macros. Next batch. Mostly a bunch of deprecated things. This switches SSL_CTX_set_tmp_rsa from always failing to always succeeding. The latter is probably a safer behavior; a consumer may defensively set a temporary RSA key. We'll successfully "set it" and just never use the result. Change-Id: Idd3d6bf4fc1a20bc9a26605bb9c77c9f799f993c Reviewed-on: https://boringssl-review.googlesource.com/4566 Reviewed-by: Adam Langley <agl@google.com>
2015-04-27 05:28:56 +01:00
#define SSL_CTRL_GET_NUM_RENEGOTIATIONS doesnt_exist
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTRL_GET_READ_AHEAD doesnt_exist
#define SSL_CTRL_GET_RI_SUPPORT doesnt_exist
#define SSL_CTRL_GET_SESSION_REUSED doesnt_exist
#define SSL_CTRL_GET_SESS_CACHE_MODE doesnt_exist
#define SSL_CTRL_GET_SESS_CACHE_SIZE doesnt_exist
Promote SSL_CTX_[gs]et_tlsext_ticket_keys to functions. BUG=404754 Change-Id: Iae75a7ab24d4aa3b30edf578cbfc1058aeadd863 Reviewed-on: https://boringssl-review.googlesource.com/5233 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:29:54 +01:00
#define SSL_CTRL_GET_TLSEXT_TICKET_KEYS doesnt_exist
Promote a few more macros. Next batch. Mostly a bunch of deprecated things. This switches SSL_CTX_set_tmp_rsa from always failing to always succeeding. The latter is probably a safer behavior; a consumer may defensively set a temporary RSA key. We'll successfully "set it" and just never use the result. Change-Id: Idd3d6bf4fc1a20bc9a26605bb9c77c9f799f993c Reviewed-on: https://boringssl-review.googlesource.com/4566 Reviewed-by: Adam Langley <agl@google.com>
2015-04-27 05:28:56 +01:00
#define SSL_CTRL_GET_TOTAL_RENEGOTIATIONS doesnt_exist
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTRL_MODE doesnt_exist
#define SSL_CTRL_NEED_TMP_RSA doesnt_exist
#define SSL_CTRL_OPTIONS doesnt_exist
#define SSL_CTRL_SESS_NUMBER doesnt_exist
#define SSL_CTRL_SET_CHANNEL_ID doesnt_exist
Remove SSL_get1_curves and promote SSL_(CTX_)?set1_curves. I'm not sure why one would ever want to externally know the curve list supported by the server. The API is new as of 1.0.2 and has no callers. Configuring curves will be much more useful when Curve25519 exists and the API isn't terribly crazy, so keep that API around and promote it to a real function. BUG=404754 Change-Id: Ibd5858791d3dfb30d53dd680cb75b0caddcbb7df Reviewed-on: https://boringssl-review.googlesource.com/5674 Reviewed-by: Adam Langley <agl@google.com>
2015-08-09 16:13:23 +01:00
#define SSL_CTRL_SET_CURVES doesnt_exist
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTRL_SET_MAX_CERT_LIST doesnt_exist
#define SSL_CTRL_SET_MAX_SEND_FRAGMENT doesnt_exist
Promote all SSL callback ctrl hooks to proper functions. Document them while I'm here. This adds a new 'preprocessor compatibility section' to avoid breaking #ifdefs. The CTRL values themselves are defined to 'doesnt_exist' to catch anything calling SSL_ctrl directly until that function can be unexported completely. BUG=404754 Change-Id: Ia157490ea8efe0215d4079556a0c7643273e7601 Reviewed-on: https://boringssl-review.googlesource.com/4553 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 18:13:55 +01:00
#define SSL_CTRL_SET_MSG_CALLBACK doesnt_exist
Promote read_ahead, mode and option macros to functions. BUG=404754 Change-Id: Ieeeb538bd25854d5664e33fe3fa79bd686c26704 Reviewed-on: https://boringssl-review.googlesource.com/4557 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:44:51 +01:00
#define SSL_CTRL_SET_MSG_CALLBACK_ARG doesnt_exist
Promote everything directly in SSL_ctrl. BUG=404754 Change-Id: I0b0a1c35f3dc81e81deb34d409ae18a1d248669e Reviewed-on: https://boringssl-review.googlesource.com/4561 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:46:14 +01:00
#define SSL_CTRL_SET_MTU doesnt_exist
Promote read_ahead, mode and option macros to functions. BUG=404754 Change-Id: Ieeeb538bd25854d5664e33fe3fa79bd686c26704 Reviewed-on: https://boringssl-review.googlesource.com/4557 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:44:51 +01:00
#define SSL_CTRL_SET_READ_AHEAD doesnt_exist
Promote everything directly in SSL_CTX_ctrl. BUG=404754 Change-Id: I0e4af2f341fcef5d01c855d97e981b8597d08b63 Reviewed-on: https://boringssl-review.googlesource.com/4563 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:46:38 +01:00
#define SSL_CTRL_SET_SESS_CACHE_MODE doesnt_exist
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTRL_SET_SESS_CACHE_SIZE doesnt_exist
Promote SNI macros to functions. BUG=404754 Change-Id: I2b2e27f3db0c97f2db65ca5e226c6488d2bee2fc Reviewed-on: https://boringssl-review.googlesource.com/4570 Reviewed-by: Adam Langley <agl@google.com>
2015-04-28 05:43:39 +01:00
#define SSL_CTRL_SET_TLSEXT_HOSTNAME doesnt_exist
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG doesnt_exist
#define SSL_CTRL_SET_TLSEXT_SERVERNAME_CB doesnt_exist
Promote SSL_CTX_[gs]et_tlsext_ticket_keys to functions. BUG=404754 Change-Id: Iae75a7ab24d4aa3b30edf578cbfc1058aeadd863 Reviewed-on: https://boringssl-review.googlesource.com/5233 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:29:54 +01:00
#define SSL_CTRL_SET_TLSEXT_TICKET_KEYS doesnt_exist
Promote all SSL callback ctrl hooks to proper functions. Document them while I'm here. This adds a new 'preprocessor compatibility section' to avoid breaking #ifdefs. The CTRL values themselves are defined to 'doesnt_exist' to catch anything calling SSL_ctrl directly until that function can be unexported completely. BUG=404754 Change-Id: Ia157490ea8efe0215d4079556a0c7643273e7601 Reviewed-on: https://boringssl-review.googlesource.com/4553 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 18:13:55 +01:00
#define SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB doesnt_exist
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTRL_SET_TMP_DH doesnt_exist
#define SSL_CTRL_SET_TMP_DH_CB doesnt_exist
#define SSL_CTRL_SET_TMP_ECDH doesnt_exist
#define SSL_CTRL_SET_TMP_ECDH_CB doesnt_exist
#define SSL_CTRL_SET_TMP_RSA doesnt_exist
#define SSL_CTRL_SET_TMP_RSA_CB doesnt_exist
Promote read_ahead, mode and option macros to functions. BUG=404754 Change-Id: Ieeeb538bd25854d5664e33fe3fa79bd686c26704 Reviewed-on: https://boringssl-review.googlesource.com/4557 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:44:51 +01:00
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define DTLSv1_get_timeout DTLSv1_get_timeout
#define DTLSv1_handle_timeout DTLSv1_handle_timeout
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
#define SSL_CTX_add0_chain_cert SSL_CTX_add0_chain_cert
#define SSL_CTX_add1_chain_cert SSL_CTX_add1_chain_cert
#define SSL_CTX_add_extra_chain_cert SSL_CTX_add_extra_chain_cert
#define SSL_CTX_clear_extra_chain_certs SSL_CTX_clear_extra_chain_certs
#define SSL_CTX_clear_chain_certs SSL_CTX_clear_chain_certs
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTX_clear_mode SSL_CTX_clear_mode
#define SSL_CTX_clear_options SSL_CTX_clear_options
#define SSL_CTX_enable_tls_channel_id SSL_CTX_enable_tls_channel_id
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
#define SSL_CTX_get0_chain_certs SSL_CTX_get0_chain_certs
#define SSL_CTX_get_extra_chain_certs SSL_CTX_get_extra_chain_certs
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTX_get_max_cert_list SSL_CTX_get_max_cert_list
Promote read_ahead, mode and option macros to functions. BUG=404754 Change-Id: Ieeeb538bd25854d5664e33fe3fa79bd686c26704 Reviewed-on: https://boringssl-review.googlesource.com/4557 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:44:51 +01:00
#define SSL_CTX_get_mode SSL_CTX_get_mode
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTX_get_options SSL_CTX_get_options
Promote read_ahead, mode and option macros to functions. BUG=404754 Change-Id: Ieeeb538bd25854d5664e33fe3fa79bd686c26704 Reviewed-on: https://boringssl-review.googlesource.com/4557 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:44:51 +01:00
#define SSL_CTX_get_read_ahead SSL_CTX_get_read_ahead
Promote everything directly in SSL_CTX_ctrl. BUG=404754 Change-Id: I0e4af2f341fcef5d01c855d97e981b8597d08b63 Reviewed-on: https://boringssl-review.googlesource.com/4563 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:46:38 +01:00
#define SSL_CTX_get_session_cache_mode SSL_CTX_get_session_cache_mode
Promote SSL_CTX_[gs]et_tlsext_ticket_keys to functions. BUG=404754 Change-Id: Iae75a7ab24d4aa3b30edf578cbfc1058aeadd863 Reviewed-on: https://boringssl-review.googlesource.com/5233 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:29:54 +01:00
#define SSL_CTX_get_tlsext_ticket_keys SSL_CTX_get_tlsext_ticket_keys
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTX_need_tmp_RSA SSL_CTX_need_tmp_RSA
#define SSL_CTX_sess_get_cache_size SSL_CTX_sess_get_cache_size
#define SSL_CTX_sess_number SSL_CTX_sess_number
#define SSL_CTX_sess_set_cache_size SSL_CTX_sess_set_cache_size
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
#define SSL_CTX_set0_chain SSL_CTX_set0_chain
#define SSL_CTX_set1_chain SSL_CTX_set1_chain
Remove SSL_get1_curves and promote SSL_(CTX_)?set1_curves. I'm not sure why one would ever want to externally know the curve list supported by the server. The API is new as of 1.0.2 and has no callers. Configuring curves will be much more useful when Curve25519 exists and the API isn't terribly crazy, so keep that API around and promote it to a real function. BUG=404754 Change-Id: Ibd5858791d3dfb30d53dd680cb75b0caddcbb7df Reviewed-on: https://boringssl-review.googlesource.com/5674 Reviewed-by: Adam Langley <agl@google.com>
2015-08-09 16:13:23 +01:00
#define SSL_CTX_set1_curves SSL_CTX_set1_curves
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTX_set1_tls_channel_id SSL_CTX_set1_tls_channel_id
Promote max_cert_list and max_send_fragment to functions. Also size them based on the limits in the quantities they control (after checking bounds at the API boundary). BUG=404754 Change-Id: Id56ba45465a473a1a793244904310ef747f29b63 Reviewed-on: https://boringssl-review.googlesource.com/4559 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 20:35:35 +01:00
#define SSL_CTX_set_max_cert_list SSL_CTX_set_max_cert_list
#define SSL_CTX_set_max_send_fragment SSL_CTX_set_max_send_fragment
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTX_set_mode SSL_CTX_set_mode
#define SSL_CTX_set_msg_callback_arg SSL_CTX_set_msg_callback_arg
#define SSL_CTX_set_options SSL_CTX_set_options
#define SSL_CTX_set_read_ahead SSL_CTX_set_read_ahead
#define SSL_CTX_set_session_cache_mode SSL_CTX_set_session_cache_mode
#define SSL_CTX_set_tlsext_servername_arg SSL_CTX_set_tlsext_servername_arg
Promote all SSL callback ctrl hooks to proper functions. Document them while I'm here. This adds a new 'preprocessor compatibility section' to avoid breaking #ifdefs. The CTRL values themselves are defined to 'doesnt_exist' to catch anything calling SSL_ctrl directly until that function can be unexported completely. BUG=404754 Change-Id: Ia157490ea8efe0215d4079556a0c7643273e7601 Reviewed-on: https://boringssl-review.googlesource.com/4553 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 18:13:55 +01:00
#define SSL_CTX_set_tlsext_servername_callback \
SSL_CTX_set_tlsext_servername_callback
#define SSL_CTX_set_tlsext_ticket_key_cb SSL_CTX_set_tlsext_ticket_key_cb
Promote SSL_CTX_[gs]et_tlsext_ticket_keys to functions. BUG=404754 Change-Id: Iae75a7ab24d4aa3b30edf578cbfc1058aeadd863 Reviewed-on: https://boringssl-review.googlesource.com/5233 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:29:54 +01:00
#define SSL_CTX_set_tlsext_ticket_keys SSL_CTX_set_tlsext_ticket_keys
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_CTX_set_tmp_dh SSL_CTX_set_tmp_dh
#define SSL_CTX_set_tmp_ecdh SSL_CTX_set_tmp_ecdh
#define SSL_CTX_set_tmp_rsa SSL_CTX_set_tmp_rsa
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
#define SSL_add0_chain_cert SSL_add0_chain_cert
#define SSL_add1_chain_cert SSL_add1_chain_cert
#define SSL_clear_chain_certs SSL_clear_chain_certs
Promote read_ahead, mode and option macros to functions. BUG=404754 Change-Id: Ieeeb538bd25854d5664e33fe3fa79bd686c26704 Reviewed-on: https://boringssl-review.googlesource.com/4557 Reviewed-by: Adam Langley <agl@google.com>
2015-05-05 14:44:51 +01:00
#define SSL_clear_mode SSL_clear_mode
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_clear_options SSL_clear_options
Promote channel ID macros to proper functions. BUG=404754 Change-Id: I002d4602720e207f92a985d90f0d58e89562affa Reviewed-on: https://boringssl-review.googlesource.com/4569 Reviewed-by: Adam Langley <agl@google.com>
2015-04-28 05:19:50 +01:00
#define SSL_enable_tls_channel_id SSL_enable_tls_channel_id
Promote SSL_get0_certificate_types to a proper function. BUG=404754 Change-Id: I94785e970d2f08e46826edd2ac41215500f46e99 Reviewed-on: https://boringssl-review.googlesource.com/5671 Reviewed-by: Adam Langley <agl@google.com>
2015-08-09 15:42:33 +01:00
#define SSL_get0_certificate_types SSL_get0_certificate_types
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
#define SSL_get0_chain_certs SSL_get0_chain_certs
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_get_max_cert_list SSL_get_max_cert_list
#define SSL_get_mode SSL_get_mode
#define SSL_get_options SSL_get_options
#define SSL_get_secure_renegotiation_support \
SSL_get_secure_renegotiation_support
Promote channel ID macros to proper functions. BUG=404754 Change-Id: I002d4602720e207f92a985d90f0d58e89562affa Reviewed-on: https://boringssl-review.googlesource.com/4569 Reviewed-by: Adam Langley <agl@google.com>
2015-04-28 05:19:50 +01:00
#define SSL_get_tls_channel_id SSL_get_tls_channel_id
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_need_tmp_RSA SSL_need_tmp_RSA
#define SSL_num_renegotiations SSL_num_renegotiations
#define SSL_session_reused SSL_session_reused
Promote certificate-related ctrl macros to functions. Also document them in the process. Almost done! BUG=404754 Change-Id: I3333c7e9ea6b4a4844f1cfd02bff8b5161b16143 Reviewed-on: https://boringssl-review.googlesource.com/5355 Reviewed-by: Adam Langley <agl@google.com>
2015-07-06 05:18:15 +01:00
#define SSL_set0_chain SSL_set0_chain
#define SSL_set1_chain SSL_set1_chain
Remove SSL_get1_curves and promote SSL_(CTX_)?set1_curves. I'm not sure why one would ever want to externally know the curve list supported by the server. The API is new as of 1.0.2 and has no callers. Configuring curves will be much more useful when Curve25519 exists and the API isn't terribly crazy, so keep that API around and promote it to a real function. BUG=404754 Change-Id: Ibd5858791d3dfb30d53dd680cb75b0caddcbb7df Reviewed-on: https://boringssl-review.googlesource.com/5674 Reviewed-by: Adam Langley <agl@google.com>
2015-08-09 16:13:23 +01:00
#define SSL_set1_curves SSL_set1_curves
Sort the preprocessor compatibility section. Using the original numerical order made more sense before they were changed to doesnt_exist. BUG=404754 Change-Id: I2971eff7c6fbe7c5d340b103de71bbfa180f1f96 Reviewed-on: https://boringssl-review.googlesource.com/5232 Reviewed-by: Adam Langley <agl@google.com>
2015-06-16 18:20:36 +01:00
#define SSL_set1_tls_channel_id SSL_set1_tls_channel_id
#define SSL_set_max_cert_list SSL_set_max_cert_list
#define SSL_set_max_send_fragment SSL_set_max_send_fragment
#define SSL_set_mode SSL_set_mode
#define SSL_set_msg_callback_arg SSL_set_msg_callback_arg
#define SSL_set_mtu SSL_set_mtu
#define SSL_set_options SSL_set_options
#define SSL_set_tlsext_host_name SSL_set_tlsext_host_name
#define SSL_set_tmp_dh SSL_set_tmp_dh
#define SSL_set_tmp_ecdh SSL_set_tmp_ecdh
#define SSL_set_tmp_rsa SSL_set_tmp_rsa
#define SSL_total_renegotiations SSL_total_renegotiations
Promote all SSL callback ctrl hooks to proper functions. Document them while I'm here. This adds a new 'preprocessor compatibility section' to avoid breaking #ifdefs. The CTRL values themselves are defined to 'doesnt_exist' to catch anything calling SSL_ctrl directly until that function can be unexported completely. BUG=404754 Change-Id: Ia157490ea8efe0215d4079556a0c7643273e7601 Reviewed-on: https://boringssl-review.googlesource.com/4553 Reviewed-by: Adam Langley <agl@google.com>
2015-04-26 18:13:55 +01:00
Fix minor stylistic issues with ssl.h. Mostly stuff that doc.go was grumpy about. The main change is to move the version-specific headers to the bottom. Injecting them in the middle makes it seem as if the definitions above the #include and those below are somehow different, but it compiles fine with them at the bottom. (They have to be at the bottom because those headers depend on ssl.h.) Change-Id: Iaa4139d2f157c7a3fd0ea609b78ff11d2edfc7b0 Reviewed-on: https://boringssl-review.googlesource.com/4289 Reviewed-by: Adam Langley <agl@google.com>
2015-04-09 04:46:10 +01:00
#if defined(__cplusplus)
} /* extern C */
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
#endif
Fix magic SSL reason codes. SSL reason codes corresponding to alerts have special values. Teach make_errors.go that values above 1000 are reserved (otherwise it will assign new values in that namespace). Also fix all the existing reason codes which corresponded to alerts. Change-Id: Ieabdf8fd59f4802938616934e1d84e659227cf84 Reviewed-on: https://boringssl-review.googlesource.com/1212 Reviewed-by: Adam Langley <agl@google.com>
2014-07-16 19:37:51 +01:00
Reset all the error codes. This saves about 6-7k of error data. Change-Id: Ic28593d4a1f5454f00fb2399d281c351ee57fb14 Reviewed-on: https://boringssl-review.googlesource.com/3385 Reviewed-by: Adam Langley <agl@google.com>
2015-02-11 20:55:26 +00:00
#define SSL_R_APP_DATA_IN_HANDSHAKE 100
#define SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT 101
#define SSL_R_BAD_ALERT 102
#define SSL_R_BAD_CHANGE_CIPHER_SPEC 103
#define SSL_R_BAD_DATA_RETURNED_BY_CALLBACK 104
#define SSL_R_BAD_DH_P_LENGTH 105
#define SSL_R_BAD_DIGEST_LENGTH 106
#define SSL_R_BAD_ECC_CERT 107
#define SSL_R_BAD_ECPOINT 108
#define SSL_R_BAD_HANDSHAKE_LENGTH 109
#define SSL_R_BAD_HANDSHAKE_RECORD 110
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
#define SSL_R_BAD_HELLO_REQUEST 111
Reset all the error codes. This saves about 6-7k of error data. Change-Id: Ic28593d4a1f5454f00fb2399d281c351ee57fb14 Reviewed-on: https://boringssl-review.googlesource.com/3385 Reviewed-by: Adam Langley <agl@google.com>
2015-02-11 20:55:26 +00:00
#define SSL_R_BAD_LENGTH 112
#define SSL_R_BAD_PACKET_LENGTH 113
#define SSL_R_BAD_RSA_ENCRYPT 114
#define SSL_R_BAD_SIGNATURE 115
#define SSL_R_BAD_SRTP_MKI_VALUE 116
#define SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST 117
#define SSL_R_BAD_SSL_FILETYPE 118
#define SSL_R_BAD_WRITE_RETRY 119
#define SSL_R_BIO_NOT_SET 120
#define SSL_R_BN_LIB 121
#define SSL_R_CANNOT_SERIALIZE_PUBLIC_KEY 122
#define SSL_R_CA_DN_LENGTH_MISMATCH 123
#define SSL_R_CA_DN_TOO_LONG 124
#define SSL_R_CCS_RECEIVED_EARLY 125
#define SSL_R_CERTIFICATE_VERIFY_FAILED 126
#define SSL_R_CERT_CB_ERROR 127
#define SSL_R_CERT_LENGTH_MISMATCH 128
#define SSL_R_CHANNEL_ID_NOT_P256 129
#define SSL_R_CHANNEL_ID_SIGNATURE_INVALID 130
#define SSL_R_CIPHER_CODE_WRONG_LENGTH 131
#define SSL_R_CIPHER_OR_HASH_UNAVAILABLE 132
#define SSL_R_CLIENTHELLO_PARSE_FAILED 133
#define SSL_R_CLIENTHELLO_TLSEXT 134
#define SSL_R_CONNECTION_REJECTED 135
#define SSL_R_CONNECTION_TYPE_NOT_SET 136
#define SSL_R_COOKIE_MISMATCH 137
#define SSL_R_D2I_ECDSA_SIG 138
#define SSL_R_DATA_BETWEEN_CCS_AND_FINISHED 139
#define SSL_R_DATA_LENGTH_TOO_LONG 140
#define SSL_R_DECODE_ERROR 141
#define SSL_R_DECRYPTION_FAILED 142
#define SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC 143
#define SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG 144
#define SSL_R_DIGEST_CHECK_FAILED 145
#define SSL_R_DTLS_MESSAGE_TOO_BIG 146
#define SSL_R_ECC_CERT_NOT_FOR_SIGNING 147
#define SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST 148
#define SSL_R_ENCRYPTED_LENGTH_TOO_LONG 149
#define SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST 150
#define SSL_R_EVP_DIGESTSIGNFINAL_FAILED 151
#define SSL_R_EVP_DIGESTSIGNINIT_FAILED 152
#define SSL_R_EXCESSIVE_MESSAGE_SIZE 153
#define SSL_R_EXTRA_DATA_IN_MESSAGE 154
#define SSL_R_GOT_A_FIN_BEFORE_A_CCS 155
#define SSL_R_GOT_CHANNEL_ID_BEFORE_A_CCS 156
#define SSL_R_GOT_NEXT_PROTO_BEFORE_A_CCS 157
#define SSL_R_GOT_NEXT_PROTO_WITHOUT_EXTENSION 158
#define SSL_R_HANDSHAKE_FAILURE_ON_CLIENT_HELLO 159
#define SSL_R_HANDSHAKE_RECORD_BEFORE_CCS 160
#define SSL_R_HTTPS_PROXY_REQUEST 161
#define SSL_R_HTTP_REQUEST 162
#define SSL_R_INAPPROPRIATE_FALLBACK 163
#define SSL_R_INVALID_COMMAND 164
#define SSL_R_INVALID_MESSAGE 165
#define SSL_R_INVALID_SSL_SESSION 166
#define SSL_R_INVALID_TICKET_KEYS_LENGTH 167
#define SSL_R_LENGTH_MISMATCH 168
#define SSL_R_LIBRARY_HAS_NO_CIPHERS 169
#define SSL_R_MISSING_DH_KEY 170
#define SSL_R_MISSING_ECDSA_SIGNING_CERT 171
#define SSL_R_MISSING_RSA_CERTIFICATE 172
#define SSL_R_MISSING_RSA_ENCRYPTING_CERT 173
#define SSL_R_MISSING_RSA_SIGNING_CERT 174
#define SSL_R_MISSING_TMP_DH_KEY 175
#define SSL_R_MISSING_TMP_ECDH_KEY 176
#define SSL_R_MIXED_SPECIAL_OPERATOR_WITH_GROUPS 177
#define SSL_R_MTU_TOO_SMALL 178
#define SSL_R_NESTED_GROUP 179
#define SSL_R_NO_CERTIFICATES_RETURNED 180
#define SSL_R_NO_CERTIFICATE_ASSIGNED 181
#define SSL_R_NO_CERTIFICATE_SET 182
#define SSL_R_NO_CIPHERS_AVAILABLE 183
#define SSL_R_NO_CIPHERS_PASSED 184
#define SSL_R_NO_CIPHERS_SPECIFIED 185
#define SSL_R_NO_CIPHER_MATCH 186
#define SSL_R_NO_COMPRESSION_SPECIFIED 187
#define SSL_R_NO_METHOD_SPECIFIED 188
#define SSL_R_NO_P256_SUPPORT 189
#define SSL_R_NO_PRIVATE_KEY_ASSIGNED 190
#define SSL_R_NO_RENEGOTIATION 191
#define SSL_R_NO_REQUIRED_DIGEST 192
#define SSL_R_NO_SHARED_CIPHER 193
#define SSL_R_NO_SHARED_SIGATURE_ALGORITHMS 194
#define SSL_R_NO_SRTP_PROFILES 195
#define SSL_R_NULL_SSL_CTX 196
#define SSL_R_NULL_SSL_METHOD_PASSED 197
#define SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED 198
#define SSL_R_PACKET_LENGTH_TOO_LONG 199
#define SSL_R_PARSE_TLSEXT 200
#define SSL_R_PATH_TOO_LONG 201
#define SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE 202
#define SSL_R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE 203
#define SSL_R_PROTOCOL_IS_SHUTDOWN 204
#define SSL_R_PSK_IDENTITY_NOT_FOUND 205
#define SSL_R_PSK_NO_CLIENT_CB 206
#define SSL_R_PSK_NO_SERVER_CB 207
#define SSL_R_READ_BIO_NOT_SET 208
#define SSL_R_READ_TIMEOUT_EXPIRED 209
#define SSL_R_RECORD_LENGTH_MISMATCH 210
#define SSL_R_RECORD_TOO_LARGE 211
#define SSL_R_RENEGOTIATE_EXT_TOO_LONG 212
#define SSL_R_RENEGOTIATION_ENCODING_ERR 213
#define SSL_R_RENEGOTIATION_MISMATCH 214
#define SSL_R_REQUIRED_CIPHER_MISSING 215
#define SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING 216
#define SSL_R_SERVERHELLO_TLSEXT 217
#define SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED 218
#define SSL_R_SESSION_MAY_NOT_BE_CREATED 219
#define SSL_R_SIGNATURE_ALGORITHMS_ERROR 220
#define SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES 221
#define SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG 222
#define SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE 223
#define SSL_R_SSL3_EXT_INVALID_SERVERNAME 224
#define SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE 225
#define SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION 226
#define SSL_R_SSL_HANDSHAKE_FAILURE 227
#define SSL_R_SSL_SESSION_ID_CALLBACK_FAILED 228
#define SSL_R_SSL_SESSION_ID_CONFLICT 229
#define SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG 230
#define SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH 231
#define SSL_R_TLS_CLIENT_CERT_REQ_WITH_ANON_CIPHER 232
#define SSL_R_TLS_ILLEGAL_EXPORTER_LABEL 233
#define SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST 234
#define SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST 235
#define SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG 236
#define SSL_R_TOO_MANY_EMPTY_FRAGMENTS 237
#define SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS 238
#define SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS 239
#define SSL_R_UNEXPECTED_GROUP_CLOSE 240
#define SSL_R_UNEXPECTED_MESSAGE 241
#define SSL_R_UNEXPECTED_OPERATOR_IN_GROUP 242
#define SSL_R_UNEXPECTED_RECORD 243
#define SSL_R_UNINITIALIZED 244
#define SSL_R_UNKNOWN_ALERT_TYPE 245
#define SSL_R_UNKNOWN_CERTIFICATE_TYPE 246
#define SSL_R_UNKNOWN_CIPHER_RETURNED 247
#define SSL_R_UNKNOWN_CIPHER_TYPE 248
#define SSL_R_UNKNOWN_DIGEST 249
#define SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE 250
#define SSL_R_UNKNOWN_PROTOCOL 251
#define SSL_R_UNKNOWN_SSL_VERSION 252
#define SSL_R_UNKNOWN_STATE 253
#define SSL_R_UNPROCESSED_HANDSHAKE_DATA 254
#define SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED 255
#define SSL_R_UNSUPPORTED_CIPHER 256
#define SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM 257
#define SSL_R_UNSUPPORTED_ELLIPTIC_CURVE 258
#define SSL_R_UNSUPPORTED_PROTOCOL 259
#define SSL_R_UNSUPPORTED_SSL_VERSION 260
#define SSL_R_USE_SRTP_NOT_NEGOTIATED 261
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
#define SSL_R_WRONG_CERTIFICATE_TYPE 262
Reset all the error codes. This saves about 6-7k of error data. Change-Id: Ic28593d4a1f5454f00fb2399d281c351ee57fb14 Reviewed-on: https://boringssl-review.googlesource.com/3385 Reviewed-by: Adam Langley <agl@google.com>
2015-02-11 20:55:26 +00:00
#define SSL_R_WRONG_CIPHER_RETURNED 263
#define SSL_R_WRONG_CURVE 264
#define SSL_R_WRONG_MESSAGE_TYPE 265
#define SSL_R_WRONG_SIGNATURE_TYPE 266
#define SSL_R_WRONG_SSL_VERSION 267
#define SSL_R_WRONG_VERSION_NUMBER 268
#define SSL_R_X509_LIB 269
#define SSL_R_X509_VERIFICATION_SETUP_PROBLEMS 270
Rework DTLS handshake message reassembly logic. Notably, drop all special cases around receiving a message in order and receiving a full message. It makes things more complicated and was the source of bugs (the MixCompleteMessageWithFragments tests added in this CL did not pass before). Instead, every message goes through an hm_fragment, and dtls1_get_message always checks buffered_messages to see if the next is complete. The downside is that we pay one more copy of the message data in the common case. This is only during connection setup, so I think it's worth the simplicity. (If we want to optimize later, we could either tighten ssl3_get_message's interface to allow the handshake data being in the hm_fragment's backing store rather than s->init_buf or swap out s->init_buf with the hm_fragment's backing store when a mesasge completes. This CL does not address ssl_read_bytes being an inappropriate API for DTLS. Future work will revise the handshake/transport boundary to align better with DTLS's needs. Also other problems that I've left as TODOs. Change-Id: Ib4570d45634b5181ecf192894d735e8699b1c86b Reviewed-on: https://boringssl-review.googlesource.com/3764 Reviewed-by: Adam Langley <agl@google.com>
2015-03-03 00:30:30 +00:00
#define SSL_R_FRAGMENT_MISMATCH 271
Clean up do_ssl3_write fragment handling. Separate actually writing the fragment to the network from assembling it so there is no need for is_fragment. record_split_done also needn't be a global; as of 7fdeaf11017b82368e0a97547fc491b90ad40f67, it is always reset to 0 whether or not SSL3_WANT_WRITE occurred, despite the comment. I believe this is sound, but the pre-7fdeaf1 logic wasn't quiiite right; ssl3_write_pending allows a retry to supply *additional* data, so not all plaintext had been commited to before the IV was randomized. We could fix this by tracking how many bytes were committed to the last time we fragmented, but this is purely an optimization and doesn't seem worth the complexity. This also fixes the alignment computation in the record-splitting case. The extra byte was wrong, as demonstrated by the assert. Change-Id: Ia087a45a6622f4faad32e501942cc910eca1237b Reviewed-on: https://boringssl-review.googlesource.com/4234 Reviewed-by: Adam Langley <agl@google.com>
2015-04-05 00:23:10 +01:00
#define SSL_R_BUFFER_TOO_SMALL 272
Enforce that sessions are resumed at the version they're created. After sharding the session cache for fallbacks, the numbers have been pretty good; 0.03% on dev and 0.02% on canary. Stable is at 0.06% but does not have the sharded session cache. Before sharding, stable, beta, and dev had been fairly closely aligned. Between 0.03% being low and the fallback saving us in all but extremely contrived cases, I think this should be fairly safe. Add tests for both the cipher suite and protocol version mismatch checks. BUG=441456 Change-Id: I2374bf64d0aee0119f293d207d45319c274d89ab Reviewed-on: https://boringssl-review.googlesource.com/3972 Reviewed-by: Adam Langley <agl@google.com>
2015-03-16 22:02:20 +00:00
#define SSL_R_OLD_SESSION_VERSION_NOT_RETURNED 273
Factor SSL_AEAD_CTX into a dedicated type. tls1_enc is now SSL_AEAD_CTX_{open,seal}. This starts tidying up a bit of the record-layer logic. This removes rr->input, as encrypting and decrypting records no longer refers to various globals. It also removes wrec altogether. SSL3_RECORD is now only used to maintain state about the current incoming record. Outgoing records go straight to the write buffer. This also removes the outgoing alignment memcpy and simply calls SSL_AEAD_CTX_seal with the parameters as appropriate. From bssl speed tests, this seems to be faster on non-ARM and a bit of a wash on ARM. Later it may be worth recasting these open/seal functions to write into a CBB (tweaked so it can be malloc-averse), but for now they take an out/out_len/max_out trio like their EVP_AEAD counterparts. BUG=468889 Change-Id: Ie9266a818cc053f695d35ef611fd74c5d4def6c3 Reviewed-on: https://boringssl-review.googlesource.com/4792 Reviewed-by: Adam Langley <agl@google.com>
2015-03-03 19:20:26 +00:00
#define SSL_R_OUTPUT_ALIASES_INPUT 274
Tighten up EMS resumption behaviour. The client and server both have to decide on behaviour when resuming a session where the EMS state of the session doesn't match the EMS state as exchanged in the handshake. Original handshake | No Yes ------+-------------------------------------------------------------- | R | Server: ok [1] Server: abort [3] e No | Client: ok [2] Client: abort [4] s | u | m | e | Yes | Server: don't resume No problem | Client: abort; server | shouldn't have resumed [1] Servers want to accept legacy clients. The draft[5] says that resumptions SHOULD be rejected so that Triple-Handshake can't be done, but we'll rather enforce that EMS was used when using tls-unique etc. [2] The draft[5] says that even the initial handshake should be aborted if the server doesn't support EMS, but we need to be able to talk to the world. [3] This is a very weird case where a client has regressed without flushing the session cache. Hopefully we can be strict and reject these. [4] This can happen when a server-farm shares a session cache but frontends are not all updated at once. If Chrome is strict here then hopefully we can prevent any servers from existing that will try to resume an EMS session that they don't understand. OpenSSL appears to be ok here: https://www.ietf.org/mail-archive/web/tls/current/msg16570.html [5] https://tools.ietf.org/html/draft-ietf-tls-session-hash-05#section-5.2 BUG=492200 Change-Id: Ie1225a3960d49117b05eefa5a36263d8e556e467 Reviewed-on: https://boringssl-review.googlesource.com/4981 Reviewed-by: Adam Langley <agl@google.com>
2015-06-02 18:50:35 +01:00
#define SSL_R_RESUMED_EMS_SESSION_WITHOUT_EMS_EXTENSION 275
#define SSL_R_EMS_STATE_INCONSISTENT 276
#define SSL_R_RESUMED_NON_EMS_SESSION_WITH_EMS_EXTENSION 277
Limit the number of warning alerts silently consumed. Per review comments on https://boringssl-review.googlesource.com/#/c/4112/. Change-Id: I82cacf67c6882e64f6637015ac41945522699797 Reviewed-on: https://boringssl-review.googlesource.com/5041 Reviewed-by: Adam Langley <agl@google.com>
2015-06-06 08:28:08 +01:00
#define SSL_R_TOO_MANY_WARNING_ALERTS 278
Add infrastructure for better extension handling. Rather than four massive functions that handle every extension, organise the code by extension with four smaller functions for each. Change-Id: I876b31dacb05aca9884ed3ae7c48462e6ffe3b49 Reviewed-on: https://boringssl-review.googlesource.com/5142 Reviewed-by: Adam Langley <agl@google.com>
2015-06-12 23:26:58 +01:00
#define SSL_R_UNEXPECTED_EXTENSION 279
Convert the signature algorithms extension to the new system Change-Id: Ia53b434acd11e9d2b0151b967387d86745ae441f Reviewed-on: https://boringssl-review.googlesource.com/5362 Reviewed-by: Adam Langley <agl@google.com>
2015-07-02 00:09:19 +01:00
#define SSL_R_SIGNATURE_ALGORITHMS_EXTENSION_SENT_BY_SERVER 280
Tidy up extensions stuff and drop fastradio support. Fastradio was a trick where the ClientHello was padding to at least 1024 bytes in order to trick some mobile radios into entering high-power mode immediately. After experimentation, the feature is being dropped. This change also tidies up a bit of the extensions code now that everything is using the new system. Change-Id: Icf7892e0ac1fbe5d66a5d7b405ec455c6850a41c Reviewed-on: https://boringssl-review.googlesource.com/5466 Reviewed-by: Adam Langley <agl@google.com>
2015-07-21 01:43:53 +01:00
#define SSL_R_ERROR_ADDING_EXTENSION 281
#define SSL_R_ERROR_PARSING_EXTENSION 282
#define SSL_R_MISSING_EXTENSION 283
Implement custom extensions. This change mirrors upstream's custom extension API because we have some internal users that depend on it. Change-Id: I408e442de0a55df7b05c872c953ff048cd406513 Reviewed-on: https://boringssl-review.googlesource.com/5471 Reviewed-by: Adam Langley <agl@google.com>
2015-07-31 02:10:13 +01:00
#define SSL_R_CUSTOM_EXTENSION_CONTENTS_TOO_LARGE 284
#define SSL_R_CUSTOM_EXTENSION_ERROR 285
Forbid a server from negotiating both ALPN and NPN. If the two extensions select different next protocols (quite possible since one is server-selected and the other is client-selected), things will break. This matches the behavior of NSS (Firefox) and Go. Change-Id: Ie1da97bf062b91a370c85c12bc61423220a22f36 Reviewed-on: https://boringssl-review.googlesource.com/5780 Reviewed-by: Adam Langley <agl@google.com>
2015-08-31 19:24:29 +01:00
#define SSL_R_NEGOTIATED_BOTH_NPN_AND_ALPN 286
Add missing errors codes for alerts. This gives inappropriate_fallback and close_notify sent during the handshake error strings. It'd also avoid having to write case SSL_AD_REASON_OFFSET + SSL_AD_CLOSE_NOTIFY: in Chromium. Change-Id: I42123d5452eb7843ead883d112e58b3f087d3067 Reviewed-on: https://boringssl-review.googlesource.com/1780 Reviewed-by: Adam Langley <agl@google.com>
2014-09-17 17:08:13 +01:00
#define SSL_R_SSLV3_ALERT_CLOSE_NOTIFY 1000
Fix magic SSL reason codes. SSL reason codes corresponding to alerts have special values. Teach make_errors.go that values above 1000 are reserved (otherwise it will assign new values in that namespace). Also fix all the existing reason codes which corresponded to alerts. Change-Id: Ieabdf8fd59f4802938616934e1d84e659227cf84 Reviewed-on: https://boringssl-review.googlesource.com/1212 Reviewed-by: Adam Langley <agl@google.com>
2014-07-16 19:37:51 +01:00
#define SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE 1010
#define SSL_R_SSLV3_ALERT_BAD_RECORD_MAC 1020
#define SSL_R_TLSV1_ALERT_DECRYPTION_FAILED 1021
#define SSL_R_TLSV1_ALERT_RECORD_OVERFLOW 1022
#define SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE 1030
#define SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE 1040
#define SSL_R_SSLV3_ALERT_NO_CERTIFICATE 1041
#define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE 1042
#define SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE 1043
#define SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED 1044
#define SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED 1045
#define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN 1046
#define SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER 1047
#define SSL_R_TLSV1_ALERT_UNKNOWN_CA 1048
#define SSL_R_TLSV1_ALERT_ACCESS_DENIED 1049
#define SSL_R_TLSV1_ALERT_DECODE_ERROR 1050
#define SSL_R_TLSV1_ALERT_DECRYPT_ERROR 1051
#define SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION 1060
#define SSL_R_TLSV1_ALERT_PROTOCOL_VERSION 1070
#define SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY 1071
#define SSL_R_TLSV1_ALERT_INTERNAL_ERROR 1080
Add missing errors codes for alerts. This gives inappropriate_fallback and close_notify sent during the handshake error strings. It'd also avoid having to write case SSL_AD_REASON_OFFSET + SSL_AD_CLOSE_NOTIFY: in Chromium. Change-Id: I42123d5452eb7843ead883d112e58b3f087d3067 Reviewed-on: https://boringssl-review.googlesource.com/1780 Reviewed-by: Adam Langley <agl@google.com>
2014-09-17 17:08:13 +01:00
#define SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK 1086
Fix magic SSL reason codes. SSL reason codes corresponding to alerts have special values. Teach make_errors.go that values above 1000 are reserved (otherwise it will assign new values in that namespace). Also fix all the existing reason codes which corresponded to alerts. Change-Id: Ieabdf8fd59f4802938616934e1d84e659227cf84 Reviewed-on: https://boringssl-review.googlesource.com/1212 Reviewed-by: Adam Langley <agl@google.com>
2014-07-16 19:37:51 +01:00
#define SSL_R_TLSV1_ALERT_USER_CANCELLED 1090
#define SSL_R_TLSV1_ALERT_NO_RENEGOTIATION 1100
#define SSL_R_TLSV1_UNSUPPORTED_EXTENSION 1110
#define SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE 1111
#define SSL_R_TLSV1_UNRECOGNIZED_NAME 1112
#define SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE 1113
#define SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE 1114
Move public headers to include/openssl/ Previously, public headers lived next to the respective code and there were symlinks from include/openssl to them. This doesn't work on Windows. This change moves the headers to live in include/openssl. In cases where some symlinks pointed to the same header, I've added a file that just includes the intended target. These cases are all for backwards-compat. Change-Id: I6e285b74caf621c644b5168a4877db226b07fd92 Reviewed-on: https://boringssl-review.googlesource.com/1180 Reviewed-by: David Benjamin <davidben@chromium.org> Reviewed-by: Adam Langley <agl@google.com>
2014-07-14 23:28:14 +01:00
Fix minor stylistic issues with ssl.h. Mostly stuff that doc.go was grumpy about. The main change is to move the version-specific headers to the bottom. Injecting them in the middle makes it seem as if the definitions above the #include and those below are somehow different, but it compiles fine with them at the bottom. (They have to be at the bottom because those headers depend on ssl.h.) Change-Id: Iaa4139d2f157c7a3fd0ea609b78ff11d2edfc7b0 Reviewed-on: https://boringssl-review.googlesource.com/4289 Reviewed-by: Adam Langley <agl@google.com>
2015-04-09 04:46:10 +01:00
#endif /* OPENSSL_HEADER_SSL_H */
Reference in New Issue Copy Permalink