1998-12-21 10:52:47 +00:00
|
|
|
/* ssl/ssl_locl.h */
|
1998-12-21 10:56:39 +00:00
|
|
|
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
1998-12-21 10:52:47 +00:00
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* 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).
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* 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 :-).
|
|
|
|
* 4. If you include any Windows specific code (or a derivative thereof) from
|
|
|
|
* the apps directory (application code) you must include an acknowledgement:
|
|
|
|
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* 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.]
|
|
|
|
*/
|
2000-12-14 17:36:59 +00:00
|
|
|
/* ====================================================================
|
2007-02-17 06:45:38 +00:00
|
|
|
* Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved.
|
2000-12-14 17:36:59 +00: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 above 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 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).
|
|
|
|
*
|
|
|
|
*/
|
2002-08-09 08:56:08 +00:00
|
|
|
/* ====================================================================
|
|
|
|
* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
|
|
|
|
* ECC cipher suite support in OpenSSL originally developed by
|
|
|
|
* SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
|
|
|
|
*/
|
2006-03-10 23:06:27 +00:00
|
|
|
/* ====================================================================
|
|
|
|
* 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.
|
|
|
|
*/
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
#ifndef HEADER_SSL_LOCL_H
|
|
|
|
#define HEADER_SSL_LOCL_H
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
|
|
|
|
2001-02-22 14:45:02 +00:00
|
|
|
#include "e_os.h"
|
1998-12-21 10:52:47 +00:00
|
|
|
|
1999-04-23 22:13:45 +00:00
|
|
|
#include <openssl/buffer.h>
|
2009-01-05 14:43:05 +00:00
|
|
|
#ifndef OPENSSL_NO_COMP
|
1999-04-23 22:13:45 +00:00
|
|
|
#include <openssl/comp.h>
|
2009-01-05 14:43:05 +00:00
|
|
|
#endif
|
1999-04-23 22:13:45 +00:00
|
|
|
#include <openssl/bio.h>
|
|
|
|
#include <openssl/stack.h>
|
2005-07-16 12:37:36 +00:00
|
|
|
#ifndef OPENSSL_NO_RSA
|
2004-04-19 18:09:28 +00:00
|
|
|
#include <openssl/rsa.h>
|
2005-07-16 12:37:36 +00:00
|
|
|
#endif
|
|
|
|
#ifndef OPENSSL_NO_DSA
|
2004-04-19 18:09:28 +00:00
|
|
|
#include <openssl/dsa.h>
|
2005-07-16 12:37:36 +00:00
|
|
|
#endif
|
1999-04-23 22:13:45 +00:00
|
|
|
#include <openssl/err.h>
|
|
|
|
#include <openssl/ssl.h>
|
2001-02-20 08:13:47 +00:00
|
|
|
#include <openssl/symhacks.h>
|
1998-12-21 10:52:47 +00:00
|
|
|
|
2000-12-31 00:23:17 +00:00
|
|
|
#ifdef OPENSSL_BUILD_SHLIBSSL
|
|
|
|
# undef OPENSSL_EXTERN
|
|
|
|
# define OPENSSL_EXTERN OPENSSL_EXPORT
|
|
|
|
#endif
|
|
|
|
|
2011-05-11 13:37:52 +00:00
|
|
|
#undef PKCS1_CHECK
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
#define c2l(c,l) (l = ((unsigned long)(*((c)++))) , \
|
|
|
|
l|=(((unsigned long)(*((c)++)))<< 8), \
|
|
|
|
l|=(((unsigned long)(*((c)++)))<<16), \
|
|
|
|
l|=(((unsigned long)(*((c)++)))<<24))
|
|
|
|
|
|
|
|
/* NOTE - c is not incremented as per c2l */
|
|
|
|
#define c2ln(c,l1,l2,n) { \
|
|
|
|
c+=n; \
|
|
|
|
l1=l2=0; \
|
|
|
|
switch (n) { \
|
|
|
|
case 8: l2 =((unsigned long)(*(--(c))))<<24; \
|
|
|
|
case 7: l2|=((unsigned long)(*(--(c))))<<16; \
|
|
|
|
case 6: l2|=((unsigned long)(*(--(c))))<< 8; \
|
|
|
|
case 5: l2|=((unsigned long)(*(--(c)))); \
|
|
|
|
case 4: l1 =((unsigned long)(*(--(c))))<<24; \
|
|
|
|
case 3: l1|=((unsigned long)(*(--(c))))<<16; \
|
|
|
|
case 2: l1|=((unsigned long)(*(--(c))))<< 8; \
|
|
|
|
case 1: l1|=((unsigned long)(*(--(c)))); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>> 8)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>>16)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>>24)&0xff))
|
|
|
|
|
|
|
|
#define n2l(c,l) (l =((unsigned long)(*((c)++)))<<24, \
|
|
|
|
l|=((unsigned long)(*((c)++)))<<16, \
|
|
|
|
l|=((unsigned long)(*((c)++)))<< 8, \
|
|
|
|
l|=((unsigned long)(*((c)++))))
|
|
|
|
|
|
|
|
#define l2n(l,c) (*((c)++)=(unsigned char)(((l)>>24)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>>16)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>> 8)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l) )&0xff))
|
|
|
|
|
2005-04-26 16:02:40 +00:00
|
|
|
#define l2n6(l,c) (*((c)++)=(unsigned char)(((l)>>40)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>>32)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>>24)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>>16)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>> 8)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l) )&0xff))
|
|
|
|
|
2013-01-28 17:31:49 +00:00
|
|
|
#define l2n8(l,c) (*((c)++)=(unsigned char)(((l)>>56)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>>48)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>>40)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>>32)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>>24)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>>16)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l)>> 8)&0xff), \
|
|
|
|
*((c)++)=(unsigned char)(((l) )&0xff))
|
|
|
|
|
2005-04-27 16:27:14 +00:00
|
|
|
#define n2l6(c,l) (l =((BN_ULLONG)(*((c)++)))<<40, \
|
|
|
|
l|=((BN_ULLONG)(*((c)++)))<<32, \
|
|
|
|
l|=((BN_ULLONG)(*((c)++)))<<24, \
|
|
|
|
l|=((BN_ULLONG)(*((c)++)))<<16, \
|
|
|
|
l|=((BN_ULLONG)(*((c)++)))<< 8, \
|
|
|
|
l|=((BN_ULLONG)(*((c)++))))
|
2005-04-26 16:02:40 +00:00
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
/* NOTE - c is not incremented as per l2c */
|
|
|
|
#define l2cn(l1,l2,c,n) { \
|
|
|
|
c+=n; \
|
|
|
|
switch (n) { \
|
|
|
|
case 8: *(--(c))=(unsigned char)(((l2)>>24)&0xff); \
|
|
|
|
case 7: *(--(c))=(unsigned char)(((l2)>>16)&0xff); \
|
|
|
|
case 6: *(--(c))=(unsigned char)(((l2)>> 8)&0xff); \
|
|
|
|
case 5: *(--(c))=(unsigned char)(((l2) )&0xff); \
|
|
|
|
case 4: *(--(c))=(unsigned char)(((l1)>>24)&0xff); \
|
|
|
|
case 3: *(--(c))=(unsigned char)(((l1)>>16)&0xff); \
|
|
|
|
case 2: *(--(c))=(unsigned char)(((l1)>> 8)&0xff); \
|
|
|
|
case 1: *(--(c))=(unsigned char)(((l1) )&0xff); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
1998-12-21 11:00:56 +00:00
|
|
|
#define n2s(c,s) ((s=(((unsigned int)(c[0]))<< 8)| \
|
|
|
|
(((unsigned int)(c[1])) )),c+=2)
|
|
|
|
#define s2n(s,c) ((c[0]=(unsigned char)(((s)>> 8)&0xff), \
|
|
|
|
c[1]=(unsigned char)(((s) )&0xff)),c+=2)
|
1998-12-21 10:52:47 +00:00
|
|
|
|
1998-12-21 11:00:56 +00:00
|
|
|
#define n2l3(c,l) ((l =(((unsigned long)(c[0]))<<16)| \
|
|
|
|
(((unsigned long)(c[1]))<< 8)| \
|
|
|
|
(((unsigned long)(c[2])) )),c+=3)
|
1998-12-21 10:52:47 +00:00
|
|
|
|
1998-12-21 11:00:56 +00:00
|
|
|
#define l2n3(l,c) ((c[0]=(unsigned char)(((l)>>16)&0xff), \
|
|
|
|
c[1]=(unsigned char)(((l)>> 8)&0xff), \
|
|
|
|
c[2]=(unsigned char)(((l) )&0xff)),c+=3)
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
/* LOCAL STUFF */
|
|
|
|
|
|
|
|
#define SSL_DECRYPT 0
|
|
|
|
#define SSL_ENCRYPT 1
|
|
|
|
|
|
|
|
#define TWO_BYTE_BIT 0x80
|
|
|
|
#define SEC_ESC_BIT 0x40
|
|
|
|
#define TWO_BYTE_MASK 0x7fff
|
|
|
|
#define THREE_BYTE_MASK 0x3fff
|
|
|
|
|
|
|
|
#define INC32(a) ((a)=((a)+1)&0xffffffffL)
|
|
|
|
#define DEC32(a) ((a)=((a)-1)&0xffffffffL)
|
|
|
|
#define MAX_MAC_SIZE 20 /* up from 16 for SSLv3 */
|
|
|
|
|
2000-01-22 03:17:06 +00:00
|
|
|
/*
|
|
|
|
* Define the Bitmasks for SSL_CIPHER.algorithms.
|
|
|
|
* This bits are used packed as dense as possible. If new methods/ciphers
|
|
|
|
* etc will be added, the bits a likely to change, so this information
|
|
|
|
* is for internal library use only, even though SSL_CIPHER.algorithms
|
|
|
|
* can be publicly accessed.
|
|
|
|
* Use the according functions for cipher management instead.
|
|
|
|
*
|
2000-02-03 23:23:24 +00:00
|
|
|
* The bit mask handling in the selection and sorting scheme in
|
2000-01-22 03:17:06 +00:00
|
|
|
* ssl_create_cipher_list() has only limited capabilities, reflecting
|
2000-02-03 23:23:24 +00:00
|
|
|
* that the different entities within are mutually exclusive:
|
2000-01-22 03:17:06 +00:00
|
|
|
* ONLY ONE BIT PER MASK CAN BE SET AT A TIME.
|
|
|
|
*/
|
2007-02-17 06:45:38 +00:00
|
|
|
|
|
|
|
/* Bits for algorithm_mkey (key exchange algorithm) */
|
1998-12-21 10:52:47 +00:00
|
|
|
#define SSL_kRSA 0x00000001L /* RSA key exchange */
|
2006-06-14 17:40:31 +00:00
|
|
|
#define SSL_kDHr 0x00000002L /* DH cert, RSA CA cert */ /* no such ciphersuites supported! */
|
|
|
|
#define SSL_kDHd 0x00000004L /* DH cert, DSA CA cert */ /* no such ciphersuite supported! */
|
|
|
|
#define SSL_kEDH 0x00000008L /* tmp DH key no DH cert */
|
|
|
|
#define SSL_kKRB5 0x00000010L /* Kerberos5 key exchange */
|
|
|
|
#define SSL_kECDHr 0x00000020L /* ECDH cert, RSA CA cert */
|
|
|
|
#define SSL_kECDHe 0x00000040L /* ECDH cert, ECDSA CA cert */
|
|
|
|
#define SSL_kEECDH 0x00000080L /* ephemeral ECDH */
|
2007-02-17 06:45:38 +00:00
|
|
|
#define SSL_kPSK 0x00000100L /* PSK */
|
2007-08-31 12:42:53 +00:00
|
|
|
#define SSL_kGOST 0x00000200L /* GOST key exchange */
|
2011-03-16 11:26:40 +00:00
|
|
|
#define SSL_kSRP 0x00000400L /* SRP */
|
2007-02-17 06:45:38 +00:00
|
|
|
|
|
|
|
/* Bits for algorithm_auth (server authentication) */
|
|
|
|
#define SSL_aRSA 0x00000001L /* RSA auth */
|
|
|
|
#define SSL_aDSS 0x00000002L /* DSS auth */
|
|
|
|
#define SSL_aNULL 0x00000004L /* no auth (i.e. use ADH or AECDH) */
|
|
|
|
#define SSL_aDH 0x00000008L /* Fixed DH auth (kDHd or kDHr) */ /* no such ciphersuites supported! */
|
|
|
|
#define SSL_aECDH 0x00000010L /* Fixed ECDH auth (kECDHe or kECDHr) */
|
|
|
|
#define SSL_aKRB5 0x00000020L /* KRB5 auth */
|
|
|
|
#define SSL_aECDSA 0x00000040L /* ECDSA auth*/
|
|
|
|
#define SSL_aPSK 0x00000080L /* PSK auth */
|
2007-08-31 12:42:53 +00:00
|
|
|
#define SSL_aGOST94 0x00000100L /* GOST R 34.10-94 signature auth */
|
|
|
|
#define SSL_aGOST01 0x00000200L /* GOST R 34.10-2001 signature auth */
|
2007-02-17 06:45:38 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* Bits for algorithm_enc (symmetric encryption) */
|
|
|
|
#define SSL_DES 0x00000001L
|
|
|
|
#define SSL_3DES 0x00000002L
|
|
|
|
#define SSL_RC4 0x00000004L
|
|
|
|
#define SSL_RC2 0x00000008L
|
|
|
|
#define SSL_IDEA 0x00000010L
|
|
|
|
#define SSL_eNULL 0x00000020L
|
|
|
|
#define SSL_AES128 0x00000040L
|
|
|
|
#define SSL_AES256 0x00000080L
|
|
|
|
#define SSL_CAMELLIA128 0x00000100L
|
|
|
|
#define SSL_CAMELLIA256 0x00000200L
|
2007-03-23 17:04:05 +00:00
|
|
|
#define SSL_eGOST2814789CNT 0x00000400L
|
2007-04-23 23:48:59 +00:00
|
|
|
#define SSL_SEED 0x00000800L
|
2011-08-04 11:13:28 +00:00
|
|
|
#define SSL_AES128GCM 0x00001000L
|
|
|
|
#define SSL_AES256GCM 0x00002000L
|
2007-02-17 06:45:38 +00:00
|
|
|
|
2011-08-04 11:13:28 +00:00
|
|
|
#define SSL_AES (SSL_AES128|SSL_AES256|SSL_AES128GCM|SSL_AES256GCM)
|
2007-02-17 06:45:38 +00:00
|
|
|
#define SSL_CAMELLIA (SSL_CAMELLIA128|SSL_CAMELLIA256)
|
|
|
|
|
|
|
|
|
|
|
|
/* Bits for algorithm_mac (symmetric authentication) */
|
2011-08-04 11:13:28 +00:00
|
|
|
|
2007-02-17 06:45:38 +00:00
|
|
|
#define SSL_MD5 0x00000001L
|
|
|
|
#define SSL_SHA1 0x00000002L
|
2007-06-04 17:04:40 +00:00
|
|
|
#define SSL_GOST94 0x00000004L
|
|
|
|
#define SSL_GOST89MAC 0x00000008L
|
2011-05-11 13:37:52 +00:00
|
|
|
#define SSL_SHA256 0x00000010L
|
2011-07-25 21:45:17 +00:00
|
|
|
#define SSL_SHA384 0x00000020L
|
2011-08-04 11:13:28 +00:00
|
|
|
/* Not a real MAC, just an indication it is part of cipher */
|
|
|
|
#define SSL_AEAD 0x00000040L
|
2007-02-17 06:45:38 +00:00
|
|
|
|
|
|
|
/* Bits for algorithm_ssl (protocol version) */
|
|
|
|
#define SSL_SSLV2 0x00000001L
|
|
|
|
#define SSL_SSLV3 0x00000002L
|
2000-01-22 03:17:06 +00:00
|
|
|
#define SSL_TLSV1 SSL_SSLV3 /* for now */
|
2011-07-25 21:45:17 +00:00
|
|
|
#define SSL_TLSV1_2 0x00000004L
|
2000-01-22 03:17:06 +00:00
|
|
|
|
2007-09-21 06:54:24 +00:00
|
|
|
|
|
|
|
/* Bits for algorithm2 (handshake digests and other extra flags) */
|
2007-08-31 12:42:53 +00:00
|
|
|
|
|
|
|
#define SSL_HANDSHAKE_MAC_MD5 0x10
|
|
|
|
#define SSL_HANDSHAKE_MAC_SHA 0x20
|
|
|
|
#define SSL_HANDSHAKE_MAC_GOST94 0x40
|
2011-05-11 13:37:52 +00:00
|
|
|
#define SSL_HANDSHAKE_MAC_SHA256 0x80
|
2011-07-25 21:45:17 +00:00
|
|
|
#define SSL_HANDSHAKE_MAC_SHA384 0x100
|
2007-08-31 12:42:53 +00:00
|
|
|
#define SSL_HANDSHAKE_MAC_DEFAULT (SSL_HANDSHAKE_MAC_MD5 | SSL_HANDSHAKE_MAC_SHA)
|
|
|
|
|
|
|
|
/* When adding new digest in the ssl_ciph.c and increment SSM_MD_NUM_IDX
|
|
|
|
* make sure to update this constant too */
|
2011-07-25 21:45:17 +00:00
|
|
|
#define SSL_MAX_DIGEST 6
|
2007-08-31 12:42:53 +00:00
|
|
|
|
2011-03-10 18:27:13 +00:00
|
|
|
#define TLS1_PRF_DGST_MASK (0xff << TLS1_PRF_DGST_SHIFT)
|
|
|
|
|
2011-07-25 21:45:17 +00:00
|
|
|
#define TLS1_PRF_DGST_SHIFT 10
|
2007-08-31 12:42:53 +00:00
|
|
|
#define TLS1_PRF_MD5 (SSL_HANDSHAKE_MAC_MD5 << TLS1_PRF_DGST_SHIFT)
|
|
|
|
#define TLS1_PRF_SHA1 (SSL_HANDSHAKE_MAC_SHA << TLS1_PRF_DGST_SHIFT)
|
2011-03-10 18:27:13 +00:00
|
|
|
#define TLS1_PRF_SHA256 (SSL_HANDSHAKE_MAC_SHA256 << TLS1_PRF_DGST_SHIFT)
|
2011-07-25 21:45:17 +00:00
|
|
|
#define TLS1_PRF_SHA384 (SSL_HANDSHAKE_MAC_SHA384 << TLS1_PRF_DGST_SHIFT)
|
2007-08-31 12:42:53 +00:00
|
|
|
#define TLS1_PRF_GOST94 (SSL_HANDSHAKE_MAC_GOST94 << TLS1_PRF_DGST_SHIFT)
|
|
|
|
#define TLS1_PRF (TLS1_PRF_MD5 | TLS1_PRF_SHA1)
|
2007-09-21 06:54:24 +00:00
|
|
|
|
|
|
|
/* Stream MAC for GOST ciphersuites from cryptopro draft
|
|
|
|
* (currently this also goes into algorithm2) */
|
|
|
|
#define TLS1_STREAM_MAC 0x04
|
|
|
|
|
|
|
|
|
|
|
|
|
2000-01-22 03:17:06 +00:00
|
|
|
/*
|
2000-02-03 23:23:24 +00:00
|
|
|
* Export and cipher strength information. For each cipher we have to decide
|
2000-01-22 03:17:06 +00:00
|
|
|
* whether it is exportable or not. This information is likely to change
|
|
|
|
* over time, since the export control rules are no static technical issue.
|
|
|
|
*
|
|
|
|
* Independent of the export flag the cipher strength is sorted into classes.
|
|
|
|
* SSL_EXP40 was denoting the 40bit US export limit of past times, which now
|
|
|
|
* is at 56bit (SSL_EXP56). If the exportable cipher class is going to change
|
2000-02-03 23:23:24 +00:00
|
|
|
* again (eg. to 64bit) the use of "SSL_EXP*" becomes blurred even more,
|
2000-01-22 03:17:06 +00:00
|
|
|
* since SSL_EXP64 could be similar to SSL_LOW.
|
|
|
|
* For this reason SSL_MICRO and SSL_MINI macros are included to widen the
|
|
|
|
* namespace of SSL_LOW-SSL_HIGH to lower values. As development of speed
|
|
|
|
* and ciphers goes, another extension to SSL_SUPER and/or SSL_ULTRA would
|
|
|
|
* be possible.
|
|
|
|
*/
|
|
|
|
#define SSL_EXP_MASK 0x00000003L
|
2008-09-10 16:02:09 +00:00
|
|
|
#define SSL_STRONG_MASK 0x000001fcL
|
2007-02-17 06:45:38 +00:00
|
|
|
|
2000-01-22 03:17:06 +00:00
|
|
|
#define SSL_NOT_EXP 0x00000001L
|
|
|
|
#define SSL_EXPORT 0x00000002L
|
|
|
|
|
2002-07-10 06:41:55 +00:00
|
|
|
#define SSL_STRONG_NONE 0x00000004L
|
|
|
|
#define SSL_EXP40 0x00000008L
|
2000-01-22 03:17:06 +00:00
|
|
|
#define SSL_MICRO (SSL_EXP40)
|
2002-07-10 06:41:55 +00:00
|
|
|
#define SSL_EXP56 0x00000010L
|
2000-01-22 03:17:06 +00:00
|
|
|
#define SSL_MINI (SSL_EXP56)
|
2002-07-10 06:41:55 +00:00
|
|
|
#define SSL_LOW 0x00000020L
|
|
|
|
#define SSL_MEDIUM 0x00000040L
|
|
|
|
#define SSL_HIGH 0x00000080L
|
2008-09-10 16:02:09 +00:00
|
|
|
#define SSL_FIPS 0x00000100L
|
2000-01-22 03:17:06 +00:00
|
|
|
|
2008-09-14 19:50:55 +00:00
|
|
|
/* we have used 000001ff - 23 bits left to go */
|
2000-01-22 03:17:06 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Macros to check the export status and cipher strength for export ciphers.
|
|
|
|
* Even though the macros for EXPORT and EXPORT40/56 have similar names,
|
|
|
|
* their meaning is different:
|
|
|
|
* *_EXPORT macros check the 'exportable' status.
|
|
|
|
* *_EXPORT40/56 macros are used to check whether a certain cipher strength
|
|
|
|
* is given.
|
|
|
|
* Since the SSL_IS_EXPORT* and SSL_EXPORT* macros depend on the correct
|
|
|
|
* algorithm structure element to be passed (algorithms, algo_strength) and no
|
|
|
|
* typechecking can be done as they are all of type unsigned long, their
|
|
|
|
* direct usage is discouraged.
|
|
|
|
* Use the SSL_C_* macros instead.
|
|
|
|
*/
|
|
|
|
#define SSL_IS_EXPORT(a) ((a)&SSL_EXPORT)
|
|
|
|
#define SSL_IS_EXPORT56(a) ((a)&SSL_EXP56)
|
|
|
|
#define SSL_IS_EXPORT40(a) ((a)&SSL_EXP40)
|
|
|
|
#define SSL_C_IS_EXPORT(c) SSL_IS_EXPORT((c)->algo_strength)
|
|
|
|
#define SSL_C_IS_EXPORT56(c) SSL_IS_EXPORT56((c)->algo_strength)
|
|
|
|
#define SSL_C_IS_EXPORT40(c) SSL_IS_EXPORT40((c)->algo_strength)
|
|
|
|
|
|
|
|
#define SSL_EXPORT_KEYLENGTH(a,s) (SSL_IS_EXPORT40(s) ? 5 : \
|
2007-02-17 06:45:38 +00:00
|
|
|
(a) == SSL_DES ? 8 : 7)
|
1999-02-21 20:03:24 +00:00
|
|
|
#define SSL_EXPORT_PKEYLENGTH(a) (SSL_IS_EXPORT40(a) ? 512 : 1024)
|
2007-02-17 06:45:38 +00:00
|
|
|
#define SSL_C_EXPORT_KEYLENGTH(c) SSL_EXPORT_KEYLENGTH((c)->algorithm_enc, \
|
2000-01-22 03:17:06 +00:00
|
|
|
(c)->algo_strength)
|
|
|
|
#define SSL_C_EXPORT_PKEYLENGTH(c) SSL_EXPORT_PKEYLENGTH((c)->algo_strength)
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
|
2007-02-17 06:45:38 +00:00
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
/* Mostly for SSLv3 */
|
|
|
|
#define SSL_PKEY_RSA_ENC 0
|
|
|
|
#define SSL_PKEY_RSA_SIGN 1
|
|
|
|
#define SSL_PKEY_DSA_SIGN 2
|
|
|
|
#define SSL_PKEY_DH_RSA 3
|
|
|
|
#define SSL_PKEY_DH_DSA 4
|
2002-08-09 08:56:08 +00:00
|
|
|
#define SSL_PKEY_ECC 5
|
2007-08-31 12:42:53 +00:00
|
|
|
#define SSL_PKEY_GOST94 6
|
|
|
|
#define SSL_PKEY_GOST01 7
|
|
|
|
#define SSL_PKEY_NUM 8
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
/* SSL_kRSA <- RSA_ENC | (RSA_TMP & RSA_SIGN) |
|
|
|
|
* <- (EXPORT & (RSA_ENC | RSA_TMP) & RSA_SIGN)
|
|
|
|
* SSL_kDH <- DH_ENC & (RSA_ENC | RSA_SIGN | DSA_SIGN)
|
|
|
|
* SSL_kEDH <- RSA_ENC | RSA_SIGN | DSA_SIGN
|
|
|
|
* SSL_aRSA <- RSA_ENC | RSA_SIGN
|
|
|
|
* SSL_aDSS <- DSA_SIGN
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
#define CERT_INVALID 0
|
|
|
|
#define CERT_PUBLIC_KEY 1
|
|
|
|
#define CERT_PRIVATE_KEY 2
|
|
|
|
*/
|
|
|
|
|
2002-08-09 08:56:08 +00:00
|
|
|
#ifndef OPENSSL_NO_EC
|
|
|
|
/* From ECC-TLS draft, used in encoding the curve type in
|
|
|
|
* ECParameters
|
|
|
|
*/
|
|
|
|
#define EXPLICIT_PRIME_CURVE_TYPE 1
|
|
|
|
#define EXPLICIT_CHAR2_CURVE_TYPE 2
|
|
|
|
#define NAMED_CURVE_TYPE 3
|
|
|
|
#endif /* OPENSSL_NO_EC */
|
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
typedef struct cert_pkey_st
|
|
|
|
{
|
|
|
|
X509 *x509;
|
|
|
|
EVP_PKEY *privatekey;
|
2011-05-11 13:37:52 +00:00
|
|
|
/* Digest to use when signing */
|
|
|
|
const EVP_MD *digest;
|
1998-12-21 10:52:47 +00:00
|
|
|
} CERT_PKEY;
|
|
|
|
|
|
|
|
typedef struct cert_st
|
|
|
|
{
|
|
|
|
/* Current active set */
|
1999-05-09 20:12:44 +00:00
|
|
|
CERT_PKEY *key; /* ALWAYS points to an element of the pkeys array
|
2000-02-21 17:09:54 +00:00
|
|
|
* Probably it would make more sense to store
|
|
|
|
* an index, not a pointer. */
|
2000-01-22 03:17:06 +00:00
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
/* The following masks are for the key and auth
|
|
|
|
* algorithms that are supported by the certs below */
|
|
|
|
int valid;
|
2007-02-17 06:45:38 +00:00
|
|
|
unsigned long mask_k;
|
|
|
|
unsigned long mask_a;
|
|
|
|
unsigned long export_mask_k;
|
|
|
|
unsigned long export_mask_a;
|
2001-02-20 08:13:47 +00:00
|
|
|
#ifndef OPENSSL_NO_RSA
|
1998-12-21 10:52:47 +00:00
|
|
|
RSA *rsa_tmp;
|
1999-06-09 16:33:18 +00:00
|
|
|
RSA *(*rsa_tmp_cb)(SSL *ssl,int is_export,int keysize);
|
1999-04-27 03:19:12 +00:00
|
|
|
#endif
|
2001-02-20 08:13:47 +00:00
|
|
|
#ifndef OPENSSL_NO_DH
|
1998-12-21 10:52:47 +00:00
|
|
|
DH *dh_tmp;
|
1999-06-09 16:33:18 +00:00
|
|
|
DH *(*dh_tmp_cb)(SSL *ssl,int is_export,int keysize);
|
1999-04-27 03:19:12 +00:00
|
|
|
#endif
|
2002-08-09 08:56:08 +00:00
|
|
|
#ifndef OPENSSL_NO_ECDH
|
|
|
|
EC_KEY *ecdh_tmp;
|
|
|
|
/* Callback for generating ephemeral ECDH keys */
|
|
|
|
EC_KEY *(*ecdh_tmp_cb)(SSL *ssl,int is_export,int keysize);
|
|
|
|
#endif
|
1999-05-09 15:45:38 +00:00
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
CERT_PKEY pkeys[SSL_PKEY_NUM];
|
|
|
|
|
1999-05-13 10:36:29 +00:00
|
|
|
int references; /* >1 only if SSL_copy_session_id is used */
|
1998-12-21 10:52:47 +00:00
|
|
|
} CERT;
|
|
|
|
|
1999-05-09 15:45:38 +00:00
|
|
|
|
|
|
|
typedef struct sess_cert_st
|
1999-05-13 15:09:38 +00:00
|
|
|
{
|
|
|
|
STACK_OF(X509) *cert_chain; /* as received from peer (not for SSL2) */
|
|
|
|
|
|
|
|
/* The 'peer_...' members are used only by clients. */
|
|
|
|
int peer_cert_type;
|
|
|
|
|
|
|
|
CERT_PKEY *peer_key; /* points to an element of peer_pkeys (never NULL!) */
|
|
|
|
CERT_PKEY peer_pkeys[SSL_PKEY_NUM];
|
|
|
|
/* Obviously we don't have the private keys of these,
|
|
|
|
* so maybe we shouldn't even use the CERT_PKEY type here. */
|
|
|
|
|
2001-02-20 08:13:47 +00:00
|
|
|
#ifndef OPENSSL_NO_RSA
|
1999-05-13 15:09:38 +00:00
|
|
|
RSA *peer_rsa_tmp; /* not used for SSL 2 */
|
|
|
|
#endif
|
2001-02-20 08:13:47 +00:00
|
|
|
#ifndef OPENSSL_NO_DH
|
1999-05-13 15:09:38 +00:00
|
|
|
DH *peer_dh_tmp; /* not used for SSL 2 */
|
1999-05-09 15:45:38 +00:00
|
|
|
#endif
|
2002-08-09 08:56:08 +00:00
|
|
|
#ifndef OPENSSL_NO_ECDH
|
|
|
|
EC_KEY *peer_ecdh_tmp;
|
|
|
|
#endif
|
1999-05-09 15:45:38 +00:00
|
|
|
|
1999-05-13 15:09:38 +00:00
|
|
|
int references; /* actually always 1 at the moment */
|
|
|
|
} SESS_CERT;
|
|
|
|
|
1999-05-09 15:45:38 +00:00
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
/*#define MAC_DEBUG */
|
|
|
|
|
|
|
|
/*#define ERR_DEBUG */
|
|
|
|
/*#define ABORT_DEBUG */
|
|
|
|
/*#define PKT_DEBUG 1 */
|
|
|
|
/*#define DES_DEBUG */
|
|
|
|
/*#define DES_OFB_DEBUG */
|
|
|
|
/*#define SSL_DEBUG */
|
|
|
|
/*#define RSA_DEBUG */
|
|
|
|
/*#define IDEA_DEBUG */
|
|
|
|
|
|
|
|
#define FP_ICC (int (*)(const void *,const void *))
|
|
|
|
#define ssl_put_cipher_by_char(ssl,ciph,ptr) \
|
|
|
|
((ssl)->method->put_cipher_by_char((ciph),(ptr)))
|
|
|
|
#define ssl_get_cipher_by_char(ssl,ptr) \
|
|
|
|
((ssl)->method->get_cipher_by_char(ptr))
|
|
|
|
|
1998-12-21 10:56:39 +00:00
|
|
|
/* This is for the SSLv3/TLSv1.0 differences in crypto/hash stuff
|
|
|
|
* It is a bit of a mess of functions, but hell, think of it as
|
2000-02-03 23:23:24 +00:00
|
|
|
* an opaque structure :-) */
|
1998-12-21 10:56:39 +00:00
|
|
|
typedef struct ssl3_enc_method
|
|
|
|
{
|
2000-01-05 23:31:47 +00:00
|
|
|
int (*enc)(SSL *, int);
|
|
|
|
int (*mac)(SSL *, unsigned char *, int);
|
|
|
|
int (*setup_key_block)(SSL *);
|
|
|
|
int (*generate_master_secret)(SSL *, unsigned char *, unsigned char *, int);
|
|
|
|
int (*change_cipher_state)(SSL *, int);
|
2007-08-31 12:42:53 +00:00
|
|
|
int (*final_finish_mac)(SSL *, const char *, int, unsigned char *);
|
1998-12-21 10:56:39 +00:00
|
|
|
int finish_mac_length;
|
2007-08-31 12:42:53 +00:00
|
|
|
int (*cert_verify_mac)(SSL *, int, unsigned char *);
|
2000-01-05 23:11:51 +00:00
|
|
|
const char *client_finished_label;
|
|
|
|
int client_finished_label_len;
|
|
|
|
const char *server_finished_label;
|
|
|
|
int server_finished_label_len;
|
2000-01-05 23:31:47 +00:00
|
|
|
int (*alert_value)(int);
|
2011-12-13 14:25:11 +00:00
|
|
|
int (*export_keying_material)(SSL *, unsigned char *, size_t,
|
|
|
|
const char *, size_t,
|
|
|
|
const unsigned char *, size_t,
|
2011-11-15 23:51:22 +00:00
|
|
|
int use_context);
|
1998-12-21 10:56:39 +00:00
|
|
|
} SSL3_ENC_METHOD;
|
|
|
|
|
2009-01-05 14:43:05 +00:00
|
|
|
#ifndef OPENSSL_NO_COMP
|
1998-12-22 15:04:48 +00:00
|
|
|
/* Used for holding the relevant compression methods loaded into SSL_CTX */
|
1998-12-21 11:00:56 +00:00
|
|
|
typedef struct ssl3_comp_st
|
|
|
|
{
|
2000-02-03 23:23:24 +00:00
|
|
|
int comp_id; /* The identifier byte for this compression type */
|
1998-12-21 11:00:56 +00:00
|
|
|
char *name; /* Text name used for the compression type */
|
|
|
|
COMP_METHOD *method; /* The method :-) */
|
|
|
|
} SSL3_COMP;
|
2009-01-05 14:43:05 +00:00
|
|
|
#endif
|
1998-12-21 11:00:56 +00:00
|
|
|
|
2008-08-04 22:10:38 +00:00
|
|
|
#ifndef OPENSSL_NO_BUF_FREELISTS
|
2008-06-03 02:48:34 +00:00
|
|
|
typedef struct ssl3_buf_freelist_st
|
|
|
|
{
|
|
|
|
size_t chunklen;
|
2008-06-03 10:17:45 +00:00
|
|
|
unsigned int len;
|
2008-06-03 02:48:34 +00:00
|
|
|
struct ssl3_buf_freelist_entry_st *head;
|
|
|
|
} SSL3_BUF_FREELIST;
|
|
|
|
|
|
|
|
typedef struct ssl3_buf_freelist_entry_st
|
|
|
|
{
|
|
|
|
struct ssl3_buf_freelist_entry_st *next;
|
|
|
|
} SSL3_BUF_FREELIST_ENTRY;
|
|
|
|
#endif
|
|
|
|
|
2005-04-13 21:46:30 +00:00
|
|
|
extern SSL3_ENC_METHOD ssl3_undef_enc_method;
|
2008-10-12 14:32:47 +00:00
|
|
|
OPENSSL_EXTERN const SSL_CIPHER ssl2_ciphers[];
|
1999-05-15 14:30:31 +00:00
|
|
|
OPENSSL_EXTERN SSL_CIPHER ssl3_ciphers[];
|
1999-05-13 11:37:32 +00:00
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
SSL_METHOD *ssl_bad_method(int ver);
|
|
|
|
|
2005-08-05 23:56:11 +00:00
|
|
|
extern SSL3_ENC_METHOD TLSv1_enc_data;
|
|
|
|
extern SSL3_ENC_METHOD SSLv3_enc_data;
|
|
|
|
extern SSL3_ENC_METHOD DTLSv1_enc_data;
|
|
|
|
|
2010-06-27 14:22:11 +00:00
|
|
|
#define IMPLEMENT_tls_meth_func(version, func_name, s_accept, s_connect, \
|
|
|
|
s_get_meth) \
|
2005-08-14 21:48:33 +00:00
|
|
|
const SSL_METHOD *func_name(void) \
|
2005-08-05 23:56:11 +00:00
|
|
|
{ \
|
2005-08-14 21:48:33 +00:00
|
|
|
static const SSL_METHOD func_name##_data= { \
|
2010-06-27 14:22:11 +00:00
|
|
|
version, \
|
2005-08-05 23:56:11 +00:00
|
|
|
tls1_new, \
|
|
|
|
tls1_clear, \
|
|
|
|
tls1_free, \
|
|
|
|
s_accept, \
|
|
|
|
s_connect, \
|
|
|
|
ssl3_read, \
|
|
|
|
ssl3_peek, \
|
|
|
|
ssl3_write, \
|
|
|
|
ssl3_shutdown, \
|
|
|
|
ssl3_renegotiate, \
|
|
|
|
ssl3_renegotiate_check, \
|
|
|
|
ssl3_get_message, \
|
|
|
|
ssl3_read_bytes, \
|
|
|
|
ssl3_write_bytes, \
|
|
|
|
ssl3_dispatch_alert, \
|
|
|
|
ssl3_ctrl, \
|
|
|
|
ssl3_ctx_ctrl, \
|
|
|
|
ssl3_get_cipher_by_char, \
|
|
|
|
ssl3_put_cipher_by_char, \
|
|
|
|
ssl3_pending, \
|
|
|
|
ssl3_num_ciphers, \
|
|
|
|
ssl3_get_cipher, \
|
|
|
|
s_get_meth, \
|
|
|
|
tls1_default_timeout, \
|
|
|
|
&TLSv1_enc_data, \
|
|
|
|
ssl_undefined_void_function, \
|
|
|
|
ssl3_callback_ctrl, \
|
|
|
|
ssl3_ctx_callback_ctrl, \
|
|
|
|
}; \
|
|
|
|
return &func_name##_data; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define IMPLEMENT_ssl3_meth_func(func_name, s_accept, s_connect, s_get_meth) \
|
2005-08-14 21:48:33 +00:00
|
|
|
const SSL_METHOD *func_name(void) \
|
2005-08-05 23:56:11 +00:00
|
|
|
{ \
|
2005-08-14 21:48:33 +00:00
|
|
|
static const SSL_METHOD func_name##_data= { \
|
2005-08-05 23:56:11 +00:00
|
|
|
SSL3_VERSION, \
|
|
|
|
ssl3_new, \
|
|
|
|
ssl3_clear, \
|
|
|
|
ssl3_free, \
|
|
|
|
s_accept, \
|
|
|
|
s_connect, \
|
|
|
|
ssl3_read, \
|
|
|
|
ssl3_peek, \
|
|
|
|
ssl3_write, \
|
|
|
|
ssl3_shutdown, \
|
|
|
|
ssl3_renegotiate, \
|
|
|
|
ssl3_renegotiate_check, \
|
|
|
|
ssl3_get_message, \
|
|
|
|
ssl3_read_bytes, \
|
|
|
|
ssl3_write_bytes, \
|
|
|
|
ssl3_dispatch_alert, \
|
|
|
|
ssl3_ctrl, \
|
|
|
|
ssl3_ctx_ctrl, \
|
|
|
|
ssl3_get_cipher_by_char, \
|
|
|
|
ssl3_put_cipher_by_char, \
|
|
|
|
ssl3_pending, \
|
|
|
|
ssl3_num_ciphers, \
|
|
|
|
ssl3_get_cipher, \
|
|
|
|
s_get_meth, \
|
|
|
|
ssl3_default_timeout, \
|
|
|
|
&SSLv3_enc_data, \
|
|
|
|
ssl_undefined_void_function, \
|
|
|
|
ssl3_callback_ctrl, \
|
|
|
|
ssl3_ctx_callback_ctrl, \
|
|
|
|
}; \
|
|
|
|
return &func_name##_data; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define IMPLEMENT_ssl23_meth_func(func_name, s_accept, s_connect, s_get_meth) \
|
2005-08-14 21:48:33 +00:00
|
|
|
const SSL_METHOD *func_name(void) \
|
2005-08-05 23:56:11 +00:00
|
|
|
{ \
|
2005-08-14 21:48:33 +00:00
|
|
|
static const SSL_METHOD func_name##_data= { \
|
2011-05-11 13:37:52 +00:00
|
|
|
TLS1_2_VERSION, \
|
2005-08-05 23:56:11 +00:00
|
|
|
tls1_new, \
|
|
|
|
tls1_clear, \
|
|
|
|
tls1_free, \
|
|
|
|
s_accept, \
|
|
|
|
s_connect, \
|
|
|
|
ssl23_read, \
|
|
|
|
ssl23_peek, \
|
|
|
|
ssl23_write, \
|
|
|
|
ssl_undefined_function, \
|
|
|
|
ssl_undefined_function, \
|
|
|
|
ssl_ok, \
|
|
|
|
ssl3_get_message, \
|
|
|
|
ssl3_read_bytes, \
|
|
|
|
ssl3_write_bytes, \
|
|
|
|
ssl3_dispatch_alert, \
|
|
|
|
ssl3_ctrl, \
|
|
|
|
ssl3_ctx_ctrl, \
|
|
|
|
ssl23_get_cipher_by_char, \
|
|
|
|
ssl23_put_cipher_by_char, \
|
|
|
|
ssl_undefined_const_function, \
|
|
|
|
ssl23_num_ciphers, \
|
|
|
|
ssl23_get_cipher, \
|
|
|
|
s_get_meth, \
|
|
|
|
ssl23_default_timeout, \
|
|
|
|
&ssl3_undef_enc_method, \
|
|
|
|
ssl_undefined_void_function, \
|
|
|
|
ssl3_callback_ctrl, \
|
|
|
|
ssl3_ctx_callback_ctrl, \
|
|
|
|
}; \
|
|
|
|
return &func_name##_data; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define IMPLEMENT_ssl2_meth_func(func_name, s_accept, s_connect, s_get_meth) \
|
2005-08-14 21:48:33 +00:00
|
|
|
const SSL_METHOD *func_name(void) \
|
2005-08-05 23:56:11 +00:00
|
|
|
{ \
|
2005-08-14 21:48:33 +00:00
|
|
|
static const SSL_METHOD func_name##_data= { \
|
2005-08-05 23:56:11 +00:00
|
|
|
SSL2_VERSION, \
|
|
|
|
ssl2_new, /* local */ \
|
|
|
|
ssl2_clear, /* local */ \
|
|
|
|
ssl2_free, /* local */ \
|
|
|
|
s_accept, \
|
|
|
|
s_connect, \
|
|
|
|
ssl2_read, \
|
|
|
|
ssl2_peek, \
|
|
|
|
ssl2_write, \
|
|
|
|
ssl2_shutdown, \
|
|
|
|
ssl_ok, /* NULL - renegotiate */ \
|
|
|
|
ssl_ok, /* NULL - check renegotiate */ \
|
|
|
|
NULL, /* NULL - ssl_get_message */ \
|
|
|
|
NULL, /* NULL - ssl_get_record */ \
|
|
|
|
NULL, /* NULL - ssl_write_bytes */ \
|
|
|
|
NULL, /* NULL - dispatch_alert */ \
|
|
|
|
ssl2_ctrl, /* local */ \
|
|
|
|
ssl2_ctx_ctrl, /* local */ \
|
|
|
|
ssl2_get_cipher_by_char, \
|
|
|
|
ssl2_put_cipher_by_char, \
|
|
|
|
ssl2_pending, \
|
|
|
|
ssl2_num_ciphers, \
|
|
|
|
ssl2_get_cipher, \
|
|
|
|
s_get_meth, \
|
|
|
|
ssl2_default_timeout, \
|
|
|
|
&ssl3_undef_enc_method, \
|
|
|
|
ssl_undefined_void_function, \
|
|
|
|
ssl2_callback_ctrl, /* local */ \
|
|
|
|
ssl2_ctx_callback_ctrl, /* local */ \
|
|
|
|
}; \
|
|
|
|
return &func_name##_data; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define IMPLEMENT_dtls1_meth_func(func_name, s_accept, s_connect, s_get_meth) \
|
2005-08-14 21:48:33 +00:00
|
|
|
const SSL_METHOD *func_name(void) \
|
2005-08-05 23:56:11 +00:00
|
|
|
{ \
|
2005-08-14 21:48:33 +00:00
|
|
|
static const SSL_METHOD func_name##_data= { \
|
2005-08-05 23:56:11 +00:00
|
|
|
DTLS1_VERSION, \
|
|
|
|
dtls1_new, \
|
|
|
|
dtls1_clear, \
|
|
|
|
dtls1_free, \
|
|
|
|
s_accept, \
|
|
|
|
s_connect, \
|
|
|
|
ssl3_read, \
|
|
|
|
ssl3_peek, \
|
|
|
|
ssl3_write, \
|
2011-12-25 14:45:40 +00:00
|
|
|
dtls1_shutdown, \
|
2005-08-05 23:56:11 +00:00
|
|
|
ssl3_renegotiate, \
|
|
|
|
ssl3_renegotiate_check, \
|
|
|
|
dtls1_get_message, \
|
|
|
|
dtls1_read_bytes, \
|
|
|
|
dtls1_write_app_data_bytes, \
|
|
|
|
dtls1_dispatch_alert, \
|
2009-08-12 13:21:26 +00:00
|
|
|
dtls1_ctrl, \
|
2005-08-05 23:56:11 +00:00
|
|
|
ssl3_ctx_ctrl, \
|
|
|
|
ssl3_get_cipher_by_char, \
|
|
|
|
ssl3_put_cipher_by_char, \
|
|
|
|
ssl3_pending, \
|
|
|
|
ssl3_num_ciphers, \
|
2007-10-05 21:04:56 +00:00
|
|
|
dtls1_get_cipher, \
|
2005-08-05 23:56:11 +00:00
|
|
|
s_get_meth, \
|
|
|
|
dtls1_default_timeout, \
|
|
|
|
&DTLSv1_enc_data, \
|
|
|
|
ssl_undefined_void_function, \
|
|
|
|
ssl3_callback_ctrl, \
|
|
|
|
ssl3_ctx_callback_ctrl, \
|
|
|
|
}; \
|
|
|
|
return &func_name##_data; \
|
|
|
|
}
|
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
void ssl_clear_cipher_ctx(SSL *s);
|
|
|
|
int ssl_clear_bad_session(SSL *s);
|
|
|
|
CERT *ssl_cert_new(void);
|
1999-05-09 20:12:44 +00:00
|
|
|
CERT *ssl_cert_dup(CERT *cert);
|
|
|
|
int ssl_cert_inst(CERT **o);
|
1998-12-21 10:52:47 +00:00
|
|
|
void ssl_cert_free(CERT *c);
|
1999-05-13 15:09:38 +00:00
|
|
|
SESS_CERT *ssl_sess_cert_new(void);
|
|
|
|
void ssl_sess_cert_free(SESS_CERT *sc);
|
|
|
|
int ssl_set_peer_cert_type(SESS_CERT *c, int type);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl_get_new_session(SSL *s, int session);
|
2007-08-11 23:18:29 +00:00
|
|
|
int ssl_get_prev_session(SSL *s, unsigned char *session,int len, const unsigned char *limit);
|
2000-06-01 02:36:58 +00:00
|
|
|
int ssl_cipher_id_cmp(const SSL_CIPHER *a,const SSL_CIPHER *b);
|
2008-10-20 15:12:00 +00:00
|
|
|
DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER,
|
2008-10-22 15:43:01 +00:00
|
|
|
ssl_cipher_id);
|
2000-06-01 02:36:58 +00:00
|
|
|
int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap,
|
|
|
|
const SSL_CIPHER * const *bp);
|
1999-04-12 17:23:57 +00:00
|
|
|
STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
|
|
|
|
STACK_OF(SSL_CIPHER) **skp);
|
2005-05-11 18:25:49 +00:00
|
|
|
int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p,
|
|
|
|
int (*put_cb)(const SSL_CIPHER *, unsigned char *));
|
2000-01-22 03:17:06 +00:00
|
|
|
STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *meth,
|
1999-04-12 17:23:57 +00:00
|
|
|
STACK_OF(SSL_CIPHER) **pref,
|
|
|
|
STACK_OF(SSL_CIPHER) **sorted,
|
2000-01-22 03:17:06 +00:00
|
|
|
const char *rule_str);
|
1998-12-21 10:52:47 +00:00
|
|
|
void ssl_update_cache(SSL *s, int mode);
|
2005-03-30 10:26:02 +00:00
|
|
|
int ssl_cipher_get_evp(const SSL_SESSION *s,const EVP_CIPHER **enc,
|
2007-06-04 17:04:40 +00:00
|
|
|
const EVP_MD **md,int *mac_pkey_type,int *mac_secret_size, SSL_COMP **comp);
|
2007-08-31 12:42:53 +00:00
|
|
|
int ssl_get_handshake_digest(int i,long *mask,const EVP_MD **md);
|
1999-04-12 17:23:57 +00:00
|
|
|
int ssl_verify_cert_chain(SSL *s,STACK_OF(X509) *sk);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl_undefined_function(SSL *s);
|
2005-03-31 09:26:39 +00:00
|
|
|
int ssl_undefined_void_function(void);
|
2005-03-30 10:26:02 +00:00
|
|
|
int ssl_undefined_const_function(const SSL *s);
|
2012-09-21 14:01:59 +00:00
|
|
|
CERT_PKEY *ssl_get_server_send_pkey(const SSL *s);
|
2012-09-17 14:39:38 +00:00
|
|
|
X509 *ssl_get_server_send_cert(const SSL *);
|
2011-05-11 13:37:52 +00:00
|
|
|
EVP_PKEY *ssl_get_sign_pkey(SSL *s,const SSL_CIPHER *c, const EVP_MD **pmd);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl_cert_type(X509 *x,EVP_PKEY *pkey);
|
2008-10-12 14:32:47 +00:00
|
|
|
void ssl_set_cert_masks(CERT *c, const SSL_CIPHER *cipher);
|
1999-04-12 17:23:57 +00:00
|
|
|
STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s);
|
1998-12-21 10:56:39 +00:00
|
|
|
int ssl_verify_alarm_type(long type);
|
2005-08-21 23:06:23 +00:00
|
|
|
void ssl_load_ciphers(void);
|
2013-10-09 14:28:42 +00:00
|
|
|
int ssl_fill_hello_random(SSL *s, int server, unsigned char *field, int len);
|
1998-12-21 10:52:47 +00:00
|
|
|
|
|
|
|
int ssl2_enc_init(SSL *s, int client);
|
2002-08-02 11:48:15 +00:00
|
|
|
int ssl2_generate_key_material(SSL *s);
|
1998-12-21 10:52:47 +00:00
|
|
|
void ssl2_enc(SSL *s,int send_data);
|
|
|
|
void ssl2_mac(SSL *s,unsigned char *mac,int send_data);
|
2008-10-12 14:32:47 +00:00
|
|
|
const SSL_CIPHER *ssl2_get_cipher_by_char(const unsigned char *p);
|
1999-01-16 17:56:00 +00:00
|
|
|
int ssl2_put_cipher_by_char(const SSL_CIPHER *c,unsigned char *p);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl2_part_read(SSL *s, unsigned long f, int i);
|
|
|
|
int ssl2_do_write(SSL *s);
|
2004-03-15 23:15:26 +00:00
|
|
|
int ssl2_set_certificate(SSL *s, int type, int len, const unsigned char *data);
|
1998-12-21 10:52:47 +00:00
|
|
|
void ssl2_return_error(SSL *s,int reason);
|
|
|
|
void ssl2_write_error(SSL *s);
|
|
|
|
int ssl2_num_ciphers(void);
|
2008-10-12 14:32:47 +00:00
|
|
|
const SSL_CIPHER *ssl2_get_cipher(unsigned int u);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl2_new(SSL *s);
|
|
|
|
void ssl2_free(SSL *s);
|
|
|
|
int ssl2_accept(SSL *s);
|
|
|
|
int ssl2_connect(SSL *s);
|
1999-04-23 15:01:15 +00:00
|
|
|
int ssl2_read(SSL *s, void *buf, int len);
|
2001-03-09 10:09:20 +00:00
|
|
|
int ssl2_peek(SSL *s, void *buf, int len);
|
1999-04-23 15:01:15 +00:00
|
|
|
int ssl2_write(SSL *s, const void *buf, int len);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl2_shutdown(SSL *s);
|
|
|
|
void ssl2_clear(SSL *s);
|
2001-10-20 17:56:36 +00:00
|
|
|
long ssl2_ctrl(SSL *s,int cmd, long larg, void *parg);
|
|
|
|
long ssl2_ctx_ctrl(SSL_CTX *s,int cmd, long larg, void *parg);
|
2005-03-31 09:26:39 +00:00
|
|
|
long ssl2_callback_ctrl(SSL *s,int cmd, void (*fp)(void));
|
|
|
|
long ssl2_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)(void));
|
2005-03-30 10:26:02 +00:00
|
|
|
int ssl2_pending(const SSL *s);
|
2005-08-05 23:56:11 +00:00
|
|
|
long ssl2_default_timeout(void );
|
1998-12-21 10:52:47 +00:00
|
|
|
|
2008-10-12 14:32:47 +00:00
|
|
|
const SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p);
|
1999-01-16 17:56:00 +00:00
|
|
|
int ssl3_put_cipher_by_char(const SSL_CIPHER *c,unsigned char *p);
|
1998-12-21 10:52:47 +00:00
|
|
|
void ssl3_init_finished_mac(SSL *s);
|
|
|
|
int ssl3_send_server_certificate(SSL *s);
|
2007-08-11 23:18:29 +00:00
|
|
|
int ssl3_send_newsession_ticket(SSL *s);
|
2007-09-26 21:56:59 +00:00
|
|
|
int ssl3_send_cert_status(SSL *s);
|
1998-12-21 10:56:39 +00:00
|
|
|
int ssl3_get_finished(SSL *s,int state_a,int state_b);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl3_setup_key_block(SSL *s);
|
|
|
|
int ssl3_send_change_cipher_spec(SSL *s,int state_a,int state_b);
|
|
|
|
int ssl3_change_cipher_state(SSL *s,int which);
|
|
|
|
void ssl3_cleanup_key_block(SSL *s);
|
|
|
|
int ssl3_do_write(SSL *s,int type);
|
2009-04-07 16:30:32 +00:00
|
|
|
int ssl3_send_alert(SSL *s,int level, int desc);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl3_generate_master_secret(SSL *s, unsigned char *out,
|
|
|
|
unsigned char *p, int len);
|
|
|
|
int ssl3_get_req_cert_type(SSL *s,unsigned char *p);
|
|
|
|
long ssl3_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok);
|
2000-01-05 23:11:51 +00:00
|
|
|
int ssl3_send_finished(SSL *s, int a, int b, const char *sender,int slen);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl3_num_ciphers(void);
|
2008-10-12 14:32:47 +00:00
|
|
|
const SSL_CIPHER *ssl3_get_cipher(unsigned int u);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl3_renegotiate(SSL *ssl);
|
1998-12-21 10:56:39 +00:00
|
|
|
int ssl3_renegotiate_check(SSL *ssl);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl3_dispatch_alert(SSL *s);
|
2000-12-14 17:36:59 +00:00
|
|
|
int ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek);
|
1999-04-23 15:01:15 +00:00
|
|
|
int ssl3_write_bytes(SSL *s, int type, const void *buf, int len);
|
2007-08-31 12:42:53 +00:00
|
|
|
int ssl3_final_finish_mac(SSL *s, const char *sender, int slen,unsigned char *p);
|
|
|
|
int ssl3_cert_verify_mac(SSL *s, int md_nid, unsigned char *p);
|
1999-04-17 21:25:43 +00:00
|
|
|
void ssl3_finish_mac(SSL *s, const unsigned char *buf, int len);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl3_enc(SSL *s, int send_data);
|
2008-12-29 16:11:58 +00:00
|
|
|
int n_ssl3_mac(SSL *ssl, unsigned char *md, int send_data);
|
2007-08-31 12:42:53 +00:00
|
|
|
void ssl3_free_digest_list(SSL *s);
|
1998-12-21 10:52:47 +00:00
|
|
|
unsigned long ssl3_output_cert_chain(SSL *s, X509 *x);
|
2001-02-09 19:56:31 +00:00
|
|
|
SSL_CIPHER *ssl3_choose_cipher(SSL *ssl,STACK_OF(SSL_CIPHER) *clnt,
|
|
|
|
STACK_OF(SSL_CIPHER) *srvr);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl3_setup_buffers(SSL *s);
|
2008-06-03 02:48:34 +00:00
|
|
|
int ssl3_setup_read_buffer(SSL *s);
|
|
|
|
int ssl3_setup_write_buffer(SSL *s);
|
|
|
|
int ssl3_release_read_buffer(SSL *s);
|
|
|
|
int ssl3_release_write_buffer(SSL *s);
|
2008-12-27 02:00:38 +00:00
|
|
|
int ssl3_digest_cached_records(SSL *s);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl3_new(SSL *s);
|
|
|
|
void ssl3_free(SSL *s);
|
|
|
|
int ssl3_accept(SSL *s);
|
|
|
|
int ssl3_connect(SSL *s);
|
1999-04-23 15:01:15 +00:00
|
|
|
int ssl3_read(SSL *s, void *buf, int len);
|
2001-03-09 10:09:20 +00:00
|
|
|
int ssl3_peek(SSL *s, void *buf, int len);
|
1999-04-23 15:01:15 +00:00
|
|
|
int ssl3_write(SSL *s, const void *buf, int len);
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl3_shutdown(SSL *s);
|
|
|
|
void ssl3_clear(SSL *s);
|
2001-10-20 17:56:36 +00:00
|
|
|
long ssl3_ctrl(SSL *s,int cmd, long larg, void *parg);
|
|
|
|
long ssl3_ctx_ctrl(SSL_CTX *s,int cmd, long larg, void *parg);
|
2005-03-31 09:26:39 +00:00
|
|
|
long ssl3_callback_ctrl(SSL *s,int cmd, void (*fp)(void));
|
|
|
|
long ssl3_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)(void));
|
2005-03-30 10:26:02 +00:00
|
|
|
int ssl3_pending(const SSL *s);
|
1998-12-21 10:52:47 +00:00
|
|
|
|
2005-04-26 18:08:00 +00:00
|
|
|
void ssl3_record_sequence_update(unsigned char *seq);
|
|
|
|
int ssl3_do_change_cipher_spec(SSL *ssl);
|
2005-08-05 23:56:11 +00:00
|
|
|
long ssl3_default_timeout(void );
|
|
|
|
|
|
|
|
int ssl23_num_ciphers(void );
|
2008-10-12 14:32:47 +00:00
|
|
|
const SSL_CIPHER *ssl23_get_cipher(unsigned int u);
|
2005-08-05 23:56:11 +00:00
|
|
|
int ssl23_read(SSL *s, void *buf, int len);
|
|
|
|
int ssl23_peek(SSL *s, void *buf, int len);
|
|
|
|
int ssl23_write(SSL *s, const void *buf, int len);
|
|
|
|
int ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p);
|
2008-10-12 14:32:47 +00:00
|
|
|
const SSL_CIPHER *ssl23_get_cipher_by_char(const unsigned char *p);
|
2005-08-05 23:56:11 +00:00
|
|
|
long ssl23_default_timeout(void );
|
|
|
|
|
|
|
|
long tls1_default_timeout(void);
|
2005-04-26 16:02:40 +00:00
|
|
|
int dtls1_do_write(SSL *s,int type);
|
|
|
|
int ssl3_read_n(SSL *s, int n, int max, int extend);
|
|
|
|
int dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek);
|
|
|
|
int ssl3_do_compress(SSL *ssl);
|
|
|
|
int ssl3_do_uncompress(SSL *ssl);
|
|
|
|
int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
|
|
|
|
unsigned int len);
|
|
|
|
unsigned char *dtls1_set_message_header(SSL *s,
|
|
|
|
unsigned char *p, unsigned char mt, unsigned long len,
|
|
|
|
unsigned long frag_off, unsigned long frag_len);
|
2005-08-05 23:56:11 +00:00
|
|
|
|
2005-04-26 16:02:40 +00:00
|
|
|
int dtls1_write_app_data_bytes(SSL *s, int type, const void *buf, int len);
|
|
|
|
int dtls1_write_bytes(SSL *s, int type, const void *buf, int len);
|
2005-04-26 18:08:00 +00:00
|
|
|
|
2005-04-26 18:18:35 +00:00
|
|
|
int dtls1_send_change_cipher_spec(SSL *s, int a, int b);
|
|
|
|
int dtls1_send_finished(SSL *s, int a, int b, const char *sender, int slen);
|
|
|
|
unsigned long dtls1_output_cert_chain(SSL *s, X509 *x);
|
|
|
|
int dtls1_read_failed(SSL *s, int code);
|
|
|
|
int dtls1_buffer_message(SSL *s, int ccs);
|
|
|
|
int dtls1_retransmit_message(SSL *s, unsigned short seq,
|
|
|
|
unsigned long frag_off, int *found);
|
2009-04-15 14:49:36 +00:00
|
|
|
int dtls1_get_queue_priority(unsigned short seq, int is_ccs);
|
|
|
|
int dtls1_retransmit_buffered_messages(SSL *s);
|
2005-04-26 18:18:35 +00:00
|
|
|
void dtls1_clear_record_buffer(SSL *s);
|
|
|
|
void dtls1_get_message_header(unsigned char *data, struct hm_header_st *msg_hdr);
|
|
|
|
void dtls1_get_ccs_header(unsigned char *data, struct ccs_header_st *ccs_hdr);
|
|
|
|
void dtls1_reset_seq_numbers(SSL *s, int rw);
|
2005-08-05 23:56:11 +00:00
|
|
|
long dtls1_default_timeout(void);
|
2009-05-15 22:58:13 +00:00
|
|
|
struct timeval* dtls1_get_timeout(SSL *s, struct timeval* timeleft);
|
2012-03-09 15:52:20 +00:00
|
|
|
int dtls1_check_timeout_num(SSL *s);
|
2009-08-12 13:21:26 +00:00
|
|
|
int dtls1_handle_timeout(SSL *s);
|
2008-10-12 14:32:47 +00:00
|
|
|
const SSL_CIPHER *dtls1_get_cipher(unsigned int u);
|
2009-05-16 11:14:55 +00:00
|
|
|
void dtls1_start_timer(SSL *s);
|
|
|
|
void dtls1_stop_timer(SSL *s);
|
|
|
|
int dtls1_is_timer_expired(SSL *s);
|
|
|
|
void dtls1_double_timeout(SSL *s);
|
2009-12-08 11:38:18 +00:00
|
|
|
int dtls1_send_newsession_ticket(SSL *s);
|
2011-09-23 13:35:05 +00:00
|
|
|
unsigned int dtls1_min_mtu(void);
|
2005-04-26 18:18:35 +00:00
|
|
|
|
|
|
|
/* some client-only functions */
|
2005-04-26 18:08:00 +00:00
|
|
|
int ssl3_client_hello(SSL *s);
|
|
|
|
int ssl3_get_server_hello(SSL *s);
|
|
|
|
int ssl3_get_certificate_request(SSL *s);
|
2007-08-11 23:18:29 +00:00
|
|
|
int ssl3_get_new_session_ticket(SSL *s);
|
2007-09-26 21:56:59 +00:00
|
|
|
int ssl3_get_cert_status(SSL *s);
|
2005-04-26 18:08:00 +00:00
|
|
|
int ssl3_get_server_done(SSL *s);
|
|
|
|
int ssl3_send_client_verify(SSL *s);
|
|
|
|
int ssl3_send_client_certificate(SSL *s);
|
2008-06-01 22:33:24 +00:00
|
|
|
int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey);
|
2005-04-26 18:08:00 +00:00
|
|
|
int ssl3_send_client_key_exchange(SSL *s);
|
|
|
|
int ssl3_get_key_exchange(SSL *s);
|
|
|
|
int ssl3_get_server_certificate(SSL *s);
|
|
|
|
int ssl3_check_cert_and_algorithm(SSL *s);
|
2009-12-08 11:38:18 +00:00
|
|
|
#ifndef OPENSSL_NO_TLSEXT
|
|
|
|
int ssl3_check_finished(SSL *s);
|
2011-11-13 21:55:42 +00:00
|
|
|
# ifndef OPENSSL_NO_NEXTPROTONEG
|
|
|
|
int ssl3_send_next_proto(SSL *s);
|
|
|
|
# endif
|
2009-12-08 11:38:18 +00:00
|
|
|
#endif
|
2005-04-26 18:08:00 +00:00
|
|
|
|
2005-04-26 18:18:35 +00:00
|
|
|
int dtls1_client_hello(SSL *s);
|
|
|
|
int dtls1_send_client_certificate(SSL *s);
|
|
|
|
int dtls1_send_client_key_exchange(SSL *s);
|
|
|
|
int dtls1_send_client_verify(SSL *s);
|
|
|
|
|
|
|
|
/* some server-only functions */
|
2005-04-26 18:08:00 +00:00
|
|
|
int ssl3_get_client_hello(SSL *s);
|
|
|
|
int ssl3_send_server_hello(SSL *s);
|
|
|
|
int ssl3_send_hello_request(SSL *s);
|
|
|
|
int ssl3_send_server_key_exchange(SSL *s);
|
|
|
|
int ssl3_send_certificate_request(SSL *s);
|
|
|
|
int ssl3_send_server_done(SSL *s);
|
|
|
|
int ssl3_check_client_hello(SSL *s);
|
|
|
|
int ssl3_get_client_certificate(SSL *s);
|
|
|
|
int ssl3_get_client_key_exchange(SSL *s);
|
|
|
|
int ssl3_get_cert_verify(SSL *s);
|
2011-11-13 21:55:42 +00:00
|
|
|
#ifndef OPENSSL_NO_NEXTPROTONEG
|
|
|
|
int ssl3_get_next_proto(SSL *s);
|
|
|
|
#endif
|
2005-04-26 18:08:00 +00:00
|
|
|
|
2005-04-26 18:18:35 +00:00
|
|
|
int dtls1_send_hello_request(SSL *s);
|
|
|
|
int dtls1_send_server_hello(SSL *s);
|
|
|
|
int dtls1_send_server_certificate(SSL *s);
|
|
|
|
int dtls1_send_server_key_exchange(SSL *s);
|
|
|
|
int dtls1_send_certificate_request(SSL *s);
|
|
|
|
int dtls1_send_server_done(SSL *s);
|
|
|
|
|
2005-04-26 18:08:00 +00:00
|
|
|
|
2005-04-26 16:02:40 +00:00
|
|
|
|
1998-12-21 10:52:47 +00:00
|
|
|
int ssl23_accept(SSL *s);
|
|
|
|
int ssl23_connect(SSL *s);
|
|
|
|
int ssl23_read_bytes(SSL *s, int n);
|
|
|
|
int ssl23_write_bytes(SSL *s);
|
|
|
|
|
1998-12-21 10:56:39 +00:00
|
|
|
int tls1_new(SSL *s);
|
|
|
|
void tls1_free(SSL *s);
|
|
|
|
void tls1_clear(SSL *s);
|
2001-10-20 17:56:36 +00:00
|
|
|
long tls1_ctrl(SSL *s,int cmd, long larg, void *parg);
|
2005-03-31 09:26:39 +00:00
|
|
|
long tls1_callback_ctrl(SSL *s,int cmd, void (*fp)(void));
|
1998-12-21 10:56:39 +00:00
|
|
|
|
2005-04-26 16:02:40 +00:00
|
|
|
int dtls1_new(SSL *s);
|
|
|
|
int dtls1_accept(SSL *s);
|
|
|
|
int dtls1_connect(SSL *s);
|
|
|
|
void dtls1_free(SSL *s);
|
|
|
|
void dtls1_clear(SSL *s);
|
|
|
|
long dtls1_ctrl(SSL *s,int cmd, long larg, void *parg);
|
2011-12-25 14:45:40 +00:00
|
|
|
int dtls1_shutdown(SSL *s);
|
2005-04-26 16:02:40 +00:00
|
|
|
|
|
|
|
long dtls1_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok);
|
|
|
|
int dtls1_get_record(SSL *s);
|
|
|
|
int do_dtls1_write(SSL *s, int type, const unsigned char *buf,
|
|
|
|
unsigned int len, int create_empty_fragement);
|
|
|
|
int dtls1_dispatch_alert(SSL *s);
|
|
|
|
int dtls1_enc(SSL *s, int snd);
|
|
|
|
|
1998-12-21 10:56:39 +00:00
|
|
|
int ssl_init_wbio_buffer(SSL *s, int push);
|
Updates to the new SSL compression code
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Fix so that the version number in the master secret, when passed
via RSA, checks that if TLS was proposed, but we roll back to SSLv3
(because the server will not accept higher), that the version number
is 0x03,0x01, not 0x03,0x00
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Submitted by:
Reviewed by:
PR:
1999-02-16 09:22:21 +00:00
|
|
|
void ssl_free_wbio_buffer(SSL *s);
|
1998-12-21 10:56:39 +00:00
|
|
|
|
|
|
|
int tls1_change_cipher_state(SSL *s, int which);
|
|
|
|
int tls1_setup_key_block(SSL *s);
|
|
|
|
int tls1_enc(SSL *s, int snd);
|
2007-08-31 12:42:53 +00:00
|
|
|
int tls1_final_finish_mac(SSL *s,
|
2000-01-05 23:31:47 +00:00
|
|
|
const char *str, int slen, unsigned char *p);
|
2007-08-31 12:42:53 +00:00
|
|
|
int tls1_cert_verify_mac(SSL *s, int md_nid, unsigned char *p);
|
1998-12-21 10:56:39 +00:00
|
|
|
int tls1_mac(SSL *ssl, unsigned char *md, int snd);
|
|
|
|
int tls1_generate_master_secret(SSL *s, unsigned char *out,
|
|
|
|
unsigned char *p, int len);
|
2011-12-13 14:25:11 +00:00
|
|
|
int tls1_export_keying_material(SSL *s, unsigned char *out, size_t olen,
|
|
|
|
const char *label, size_t llen,
|
|
|
|
const unsigned char *p, size_t plen, int use_context);
|
1998-12-21 10:56:39 +00:00
|
|
|
int tls1_alert_code(int code);
|
|
|
|
int ssl3_alert_code(int code);
|
1998-12-21 11:00:56 +00:00
|
|
|
int ssl_ok(SSL *s);
|
1998-12-21 10:56:39 +00:00
|
|
|
|
2006-06-15 19:58:22 +00:00
|
|
|
#ifndef OPENSSL_NO_ECDH
|
2011-05-11 13:37:52 +00:00
|
|
|
int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s);
|
2006-06-15 19:58:22 +00:00
|
|
|
#endif
|
2002-08-09 11:58:28 +00:00
|
|
|
|
1999-04-12 17:23:57 +00:00
|
|
|
SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n);
|
Updates to the new SSL compression code
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Fix so that the version number in the master secret, when passed
via RSA, checks that if TLS was proposed, but we roll back to SSLv3
(because the server will not accept higher), that the version number
is 0x03,0x01, not 0x03,0x00
[Eric A. Young, (from changes to C2Net SSLeay, integrated by Mark Cox)]
Submitted by:
Reviewed by:
PR:
1999-02-16 09:22:21 +00:00
|
|
|
|
2006-03-30 02:44:56 +00:00
|
|
|
#ifndef OPENSSL_NO_EC
|
|
|
|
int tls1_ec_curve_id2nid(int curve_id);
|
|
|
|
int tls1_ec_nid2curve_id(int nid);
|
|
|
|
#endif /* OPENSSL_NO_EC */
|
|
|
|
|
2006-01-02 23:14:37 +00:00
|
|
|
#ifndef OPENSSL_NO_TLSEXT
|
2006-01-03 03:27:19 +00:00
|
|
|
unsigned char *ssl_add_clienthello_tlsext(SSL *s, unsigned char *p, unsigned char *limit);
|
|
|
|
unsigned char *ssl_add_serverhello_tlsext(SSL *s, unsigned char *p, unsigned char *limit);
|
|
|
|
int ssl_parse_clienthello_tlsext(SSL *s, unsigned char **data, unsigned char *d, int n, int *al);
|
|
|
|
int ssl_parse_serverhello_tlsext(SSL *s, unsigned char **data, unsigned char *d, int n, int *al);
|
2006-03-11 23:46:37 +00:00
|
|
|
int ssl_prepare_clienthello_tlsext(SSL *s);
|
|
|
|
int ssl_prepare_serverhello_tlsext(SSL *s);
|
2012-09-17 14:39:38 +00:00
|
|
|
int ssl_check_clienthello_tlsext_early(SSL *s);
|
|
|
|
int ssl_check_clienthello_tlsext_late(SSL *s);
|
2006-03-11 23:46:37 +00:00
|
|
|
int ssl_check_serverhello_tlsext(SSL *s);
|
2009-12-01 17:41:42 +00:00
|
|
|
|
2011-12-31 23:00:36 +00:00
|
|
|
#ifndef OPENSSL_NO_HEARTBEATS
|
|
|
|
int tls1_heartbeat(SSL *s);
|
|
|
|
int dtls1_heartbeat(SSL *s);
|
|
|
|
int tls1_process_heartbeat(SSL *s);
|
|
|
|
int dtls1_process_heartbeat(SSL *s);
|
|
|
|
#endif
|
|
|
|
|
2007-08-20 12:35:20 +00:00
|
|
|
#ifdef OPENSSL_NO_SHA256
|
|
|
|
#define tlsext_tick_md EVP_sha1
|
|
|
|
#else
|
|
|
|
#define tlsext_tick_md EVP_sha256
|
|
|
|
#endif
|
2007-08-11 23:18:29 +00:00
|
|
|
int tls1_process_ticket(SSL *s, unsigned char *session_id, int len,
|
|
|
|
const unsigned char *limit, SSL_SESSION **ret);
|
2011-05-11 13:37:52 +00:00
|
|
|
|
|
|
|
int tls12_get_sigandhash(unsigned char *p, const EVP_PKEY *pk,
|
|
|
|
const EVP_MD *md);
|
|
|
|
int tls12_get_sigid(const EVP_PKEY *pk);
|
|
|
|
const EVP_MD *tls12_get_hash(unsigned char hash_alg);
|
|
|
|
|
2007-08-12 18:56:14 +00:00
|
|
|
#endif
|
2007-06-04 17:04:40 +00:00
|
|
|
EVP_MD_CTX* ssl_replace_hash(EVP_MD_CTX **hash,const EVP_MD *md) ;
|
|
|
|
void ssl_clear_hash_ctx(EVP_MD_CTX **hash);
|
2009-11-09 18:58:50 +00:00
|
|
|
int ssl_add_serverhello_renegotiate_ext(SSL *s, unsigned char *p, int *len,
|
|
|
|
int maxlen);
|
|
|
|
int ssl_parse_serverhello_renegotiate_ext(SSL *s, unsigned char *d, int len,
|
|
|
|
int *al);
|
|
|
|
int ssl_add_clienthello_renegotiate_ext(SSL *s, unsigned char *p, int *len,
|
|
|
|
int maxlen);
|
|
|
|
int ssl_parse_clienthello_renegotiate_ext(SSL *s, unsigned char *d, int len,
|
|
|
|
int *al);
|
2011-05-11 13:37:52 +00:00
|
|
|
long ssl_get_algorithm2(SSL *s);
|
2011-05-12 17:44:59 +00:00
|
|
|
int tls1_process_sigalgs(SSL *s, const unsigned char *data, int dsize);
|
2011-05-20 14:58:45 +00:00
|
|
|
int tls12_get_req_sig_algs(SSL *s, unsigned char *p);
|
2011-11-21 22:52:01 +00:00
|
|
|
|
|
|
|
int ssl_add_clienthello_use_srtp_ext(SSL *s, unsigned char *p, int *len, int maxlen);
|
|
|
|
int ssl_parse_clienthello_use_srtp_ext(SSL *s, unsigned char *d, int len,int *al);
|
|
|
|
int ssl_add_serverhello_use_srtp_ext(SSL *s, unsigned char *p, int *len, int maxlen);
|
|
|
|
int ssl_parse_serverhello_use_srtp_ext(SSL *s, unsigned char *d, int len,int *al);
|
|
|
|
|
2013-01-28 17:31:49 +00:00
|
|
|
/* s3_cbc.c */
|
|
|
|
void ssl3_cbc_copy_mac(unsigned char* out,
|
|
|
|
const SSL3_RECORD *rec,
|
2013-02-01 14:31:50 +00:00
|
|
|
unsigned md_size,unsigned orig_len);
|
2013-01-28 17:31:49 +00:00
|
|
|
int ssl3_cbc_remove_padding(const SSL* s,
|
|
|
|
SSL3_RECORD *rec,
|
|
|
|
unsigned block_size,
|
|
|
|
unsigned mac_size);
|
|
|
|
int tls1_cbc_remove_padding(const SSL* s,
|
|
|
|
SSL3_RECORD *rec,
|
|
|
|
unsigned block_size,
|
|
|
|
unsigned mac_size);
|
|
|
|
char ssl3_cbc_record_digest_supported(const EVP_MD_CTX *ctx);
|
|
|
|
void ssl3_cbc_digest_record(
|
|
|
|
const EVP_MD_CTX *ctx,
|
|
|
|
unsigned char* md_out,
|
|
|
|
size_t* md_out_size,
|
|
|
|
const unsigned char header[13],
|
|
|
|
const unsigned char *data,
|
|
|
|
size_t data_plus_mac_size,
|
|
|
|
size_t data_plus_mac_plus_padding_size,
|
|
|
|
const unsigned char *mac_secret,
|
|
|
|
unsigned mac_secret_length,
|
|
|
|
char is_sslv3);
|
|
|
|
|
2013-01-29 14:44:36 +00:00
|
|
|
void tls_fips_digest_extra(
|
|
|
|
const EVP_CIPHER_CTX *cipher_ctx, EVP_MD_CTX *mac_ctx,
|
|
|
|
const unsigned char *data, size_t data_len, size_t orig_len);
|
|
|
|
|
2006-01-02 23:14:37 +00:00
|
|
|
#endif
|