Home | History | Annotate | Download | only in ssl
      1 /* ssl/ssl_locl.h */
      2 /* Copyright (C) 1995-1998 Eric Young (eay (at) cryptsoft.com)
      3  * All rights reserved.
      4  *
      5  * This package is an SSL implementation written
      6  * by Eric Young (eay (at) cryptsoft.com).
      7  * The implementation was written so as to conform with Netscapes SSL.
      8  *
      9  * This library is free for commercial and non-commercial use as long as
     10  * the following conditions are aheared to.  The following conditions
     11  * apply to all code found in this distribution, be it the RC4, RSA,
     12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
     13  * included with this distribution is covered by the same copyright terms
     14  * except that the holder is Tim Hudson (tjh (at) cryptsoft.com).
     15  *
     16  * Copyright remains Eric Young's, and as such any Copyright notices in
     17  * the code are not to be removed.
     18  * If this package is used in a product, Eric Young should be given attribution
     19  * as the author of the parts of the library used.
     20  * This can be in the form of a textual message at program startup or
     21  * in documentation (online or textual) provided with the package.
     22  *
     23  * Redistribution and use in source and binary forms, with or without
     24  * modification, are permitted provided that the following conditions
     25  * are met:
     26  * 1. Redistributions of source code must retain the copyright
     27  *    notice, this list of conditions and the following disclaimer.
     28  * 2. Redistributions in binary form must reproduce the above copyright
     29  *    notice, this list of conditions and the following disclaimer in the
     30  *    documentation and/or other materials provided with the distribution.
     31  * 3. All advertising materials mentioning features or use of this software
     32  *    must display the following acknowledgement:
     33  *    "This product includes cryptographic software written by
     34  *     Eric Young (eay (at) cryptsoft.com)"
     35  *    The word 'cryptographic' can be left out if the rouines from the library
     36  *    being used are not cryptographic related :-).
     37  * 4. If you include any Windows specific code (or a derivative thereof) from
     38  *    the apps directory (application code) you must include an acknowledgement:
     39  *    "This product includes software written by Tim Hudson (tjh (at) cryptsoft.com)"
     40  *
     41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
     42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     51  * SUCH DAMAGE.
     52  *
     53  * The licence and distribution terms for any publically available version or
     54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
     55  * copied and put under another distribution licence
     56  * [including the GNU Public Licence.]
     57  */
     58 /* ====================================================================
     59  * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.
     60  *
     61  * Redistribution and use in source and binary forms, with or without
     62  * modification, are permitted provided that the following conditions
     63  * are met:
     64  *
     65  * 1. Redistributions of source code must retain the above copyright
     66  *    notice, this list of conditions and the following disclaimer.
     67  *
     68  * 2. Redistributions in binary form must reproduce the above copyright
     69  *    notice, this list of conditions and the following disclaimer in
     70  *    the documentation and/or other materials provided with the
     71  *    distribution.
     72  *
     73  * 3. All advertising materials mentioning features or use of this
     74  *    software must display the following acknowledgment:
     75  *    "This product includes software developed by the OpenSSL Project
     76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
     77  *
     78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
     79  *    endorse or promote products derived from this software without
     80  *    prior written permission. For written permission, please contact
     81  *    openssl-core (at) openssl.org.
     82  *
     83  * 5. Products derived from this software may not be called "OpenSSL"
     84  *    nor may "OpenSSL" appear in their names without prior written
     85  *    permission of the OpenSSL Project.
     86  *
     87  * 6. Redistributions of any form whatsoever must retain the following
     88  *    acknowledgment:
     89  *    "This product includes software developed by the OpenSSL Project
     90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
     91  *
     92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
     93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
     96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
    101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
    103  * OF THE POSSIBILITY OF SUCH DAMAGE.
    104  * ====================================================================
    105  *
    106  * This product includes cryptographic software written by Eric Young
    107  * (eay (at) cryptsoft.com).  This product includes software written by Tim
    108  * Hudson (tjh (at) cryptsoft.com).
    109  *
    110  */
    111 /* ====================================================================
    112  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
    113  * ECC cipher suite support in OpenSSL originally developed by
    114  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
    115  */
    116 /* ====================================================================
    117  * Copyright 2005 Nokia. All rights reserved.
    118  *
    119  * The portions of the attached software ("Contribution") is developed by
    120  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
    121  * license.
    122  *
    123  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
    124  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
    125  * support (see RFC 4279) to OpenSSL.
    126  *
    127  * No patent licenses or other rights except those expressly stated in
    128  * the OpenSSL open source license shall be deemed granted or received
    129  * expressly, by implication, estoppel, or otherwise.
    130  *
    131  * No assurances are provided by Nokia that the Contribution does not
    132  * infringe the patent or other intellectual property rights of any third
    133  * party or that the license provides you with all the necessary rights
    134  * to make use of the Contribution.
    135  *
    136  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
    137  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
    138  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
    139  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
    140  * OTHERWISE.
    141  */
    142 
    143 #ifndef HEADER_SSL_LOCL_H
    144 #define HEADER_SSL_LOCL_H
    145 #include <stdlib.h>
    146 #include <time.h>
    147 #include <string.h>
    148 #include <errno.h>
    149 
    150 #include "e_os.h"
    151 
    152 #include <openssl/buffer.h>
    153 #ifndef OPENSSL_NO_COMP
    154 #include <openssl/comp.h>
    155 #endif
    156 #include <openssl/bio.h>
    157 #include <openssl/stack.h>
    158 #ifndef OPENSSL_NO_RSA
    159 #include <openssl/rsa.h>
    160 #endif
    161 #ifndef OPENSSL_NO_DSA
    162 #include <openssl/dsa.h>
    163 #endif
    164 #include <openssl/err.h>
    165 #include <openssl/ssl.h>
    166 #include <openssl/symhacks.h>
    167 
    168 #ifdef OPENSSL_BUILD_SHLIBSSL
    169 # undef OPENSSL_EXTERN
    170 # define OPENSSL_EXTERN OPENSSL_EXPORT
    171 #endif
    172 
    173 #define PKCS1_CHECK
    174 
    175 #define c2l(c,l)	(l = ((unsigned long)(*((c)++)))     , \
    176 			 l|=(((unsigned long)(*((c)++)))<< 8), \
    177 			 l|=(((unsigned long)(*((c)++)))<<16), \
    178 			 l|=(((unsigned long)(*((c)++)))<<24))
    179 
    180 /* NOTE - c is not incremented as per c2l */
    181 #define c2ln(c,l1,l2,n)	{ \
    182 			c+=n; \
    183 			l1=l2=0; \
    184 			switch (n) { \
    185 			case 8: l2 =((unsigned long)(*(--(c))))<<24; \
    186 			case 7: l2|=((unsigned long)(*(--(c))))<<16; \
    187 			case 6: l2|=((unsigned long)(*(--(c))))<< 8; \
    188 			case 5: l2|=((unsigned long)(*(--(c))));     \
    189 			case 4: l1 =((unsigned long)(*(--(c))))<<24; \
    190 			case 3: l1|=((unsigned long)(*(--(c))))<<16; \
    191 			case 2: l1|=((unsigned long)(*(--(c))))<< 8; \
    192 			case 1: l1|=((unsigned long)(*(--(c))));     \
    193 				} \
    194 			}
    195 
    196 #define l2c(l,c)	(*((c)++)=(unsigned char)(((l)    )&0xff), \
    197 			 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
    198 			 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
    199 			 *((c)++)=(unsigned char)(((l)>>24)&0xff))
    200 
    201 #define n2l(c,l)	(l =((unsigned long)(*((c)++)))<<24, \
    202 			 l|=((unsigned long)(*((c)++)))<<16, \
    203 			 l|=((unsigned long)(*((c)++)))<< 8, \
    204 			 l|=((unsigned long)(*((c)++))))
    205 
    206 #define l2n(l,c)	(*((c)++)=(unsigned char)(((l)>>24)&0xff), \
    207 			 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
    208 			 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
    209 			 *((c)++)=(unsigned char)(((l)    )&0xff))
    210 
    211 #define l2n6(l,c)	(*((c)++)=(unsigned char)(((l)>>40)&0xff), \
    212 			 *((c)++)=(unsigned char)(((l)>>32)&0xff), \
    213 			 *((c)++)=(unsigned char)(((l)>>24)&0xff), \
    214 			 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
    215 			 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
    216 			 *((c)++)=(unsigned char)(((l)    )&0xff))
    217 
    218 #define n2l6(c,l)	(l =((BN_ULLONG)(*((c)++)))<<40, \
    219 			 l|=((BN_ULLONG)(*((c)++)))<<32, \
    220 			 l|=((BN_ULLONG)(*((c)++)))<<24, \
    221 			 l|=((BN_ULLONG)(*((c)++)))<<16, \
    222 			 l|=((BN_ULLONG)(*((c)++)))<< 8, \
    223 			 l|=((BN_ULLONG)(*((c)++))))
    224 
    225 /* NOTE - c is not incremented as per l2c */
    226 #define l2cn(l1,l2,c,n)	{ \
    227 			c+=n; \
    228 			switch (n) { \
    229 			case 8: *(--(c))=(unsigned char)(((l2)>>24)&0xff); \
    230 			case 7: *(--(c))=(unsigned char)(((l2)>>16)&0xff); \
    231 			case 6: *(--(c))=(unsigned char)(((l2)>> 8)&0xff); \
    232 			case 5: *(--(c))=(unsigned char)(((l2)    )&0xff); \
    233 			case 4: *(--(c))=(unsigned char)(((l1)>>24)&0xff); \
    234 			case 3: *(--(c))=(unsigned char)(((l1)>>16)&0xff); \
    235 			case 2: *(--(c))=(unsigned char)(((l1)>> 8)&0xff); \
    236 			case 1: *(--(c))=(unsigned char)(((l1)    )&0xff); \
    237 				} \
    238 			}
    239 
    240 #define n2s(c,s)	((s=(((unsigned int)(c[0]))<< 8)| \
    241 			    (((unsigned int)(c[1]))    )),c+=2)
    242 #define s2n(s,c)	((c[0]=(unsigned char)(((s)>> 8)&0xff), \
    243 			  c[1]=(unsigned char)(((s)    )&0xff)),c+=2)
    244 
    245 #define n2l3(c,l)	((l =(((unsigned long)(c[0]))<<16)| \
    246 			     (((unsigned long)(c[1]))<< 8)| \
    247 			     (((unsigned long)(c[2]))    )),c+=3)
    248 
    249 #define l2n3(l,c)	((c[0]=(unsigned char)(((l)>>16)&0xff), \
    250 			  c[1]=(unsigned char)(((l)>> 8)&0xff), \
    251 			  c[2]=(unsigned char)(((l)    )&0xff)),c+=3)
    252 
    253 /* LOCAL STUFF */
    254 
    255 #define SSL_DECRYPT	0
    256 #define SSL_ENCRYPT	1
    257 
    258 #define TWO_BYTE_BIT	0x80
    259 #define SEC_ESC_BIT	0x40
    260 #define TWO_BYTE_MASK	0x7fff
    261 #define THREE_BYTE_MASK	0x3fff
    262 
    263 #define INC32(a)	((a)=((a)+1)&0xffffffffL)
    264 #define DEC32(a)	((a)=((a)-1)&0xffffffffL)
    265 #define MAX_MAC_SIZE	20 /* up from 16 for SSLv3 */
    266 
    267 /*
    268  * Define the Bitmasks for SSL_CIPHER.algorithms.
    269  * This bits are used packed as dense as possible. If new methods/ciphers
    270  * etc will be added, the bits a likely to change, so this information
    271  * is for internal library use only, even though SSL_CIPHER.algorithms
    272  * can be publicly accessed.
    273  * Use the according functions for cipher management instead.
    274  *
    275  * The bit mask handling in the selection and sorting scheme in
    276  * ssl_create_cipher_list() has only limited capabilities, reflecting
    277  * that the different entities within are mutually exclusive:
    278  * ONLY ONE BIT PER MASK CAN BE SET AT A TIME.
    279  */
    280 
    281 /* Bits for algorithm_mkey (key exchange algorithm) */
    282 #define SSL_kRSA		0x00000001L /* RSA key exchange */
    283 #define SSL_kDHr		0x00000002L /* DH cert, RSA CA cert */ /* no such ciphersuites supported! */
    284 #define SSL_kDHd		0x00000004L /* DH cert, DSA CA cert */ /* no such ciphersuite supported! */
    285 #define SSL_kEDH		0x00000008L /* tmp DH key no DH cert */
    286 #define SSL_kKRB5		0x00000010L /* Kerberos5 key exchange */
    287 #define SSL_kECDHr		0x00000020L /* ECDH cert, RSA CA cert */
    288 #define SSL_kECDHe		0x00000040L /* ECDH cert, ECDSA CA cert */
    289 #define SSL_kEECDH		0x00000080L /* ephemeral ECDH */
    290 #define SSL_kPSK		0x00000100L /* PSK */
    291 #define SSL_kGOST       0x00000200L /* GOST key exchange */
    292 
    293 /* Bits for algorithm_auth (server authentication) */
    294 #define SSL_aRSA		0x00000001L /* RSA auth */
    295 #define SSL_aDSS 		0x00000002L /* DSS auth */
    296 #define SSL_aNULL 		0x00000004L /* no auth (i.e. use ADH or AECDH) */
    297 #define SSL_aDH 		0x00000008L /* Fixed DH auth (kDHd or kDHr) */ /* no such ciphersuites supported! */
    298 #define SSL_aECDH 		0x00000010L /* Fixed ECDH auth (kECDHe or kECDHr) */
    299 #define SSL_aKRB5               0x00000020L /* KRB5 auth */
    300 #define SSL_aECDSA              0x00000040L /* ECDSA auth*/
    301 #define SSL_aPSK                0x00000080L /* PSK auth */
    302 #define SSL_aGOST94				0x00000100L /* GOST R 34.10-94 signature auth */
    303 #define SSL_aGOST01 			0x00000200L /* GOST R 34.10-2001 signature auth */
    304 
    305 
    306 /* Bits for algorithm_enc (symmetric encryption) */
    307 #define SSL_DES			0x00000001L
    308 #define SSL_3DES		0x00000002L
    309 #define SSL_RC4			0x00000004L
    310 #define SSL_RC2			0x00000008L
    311 #define SSL_IDEA		0x00000010L
    312 #define SSL_eNULL		0x00000020L
    313 #define SSL_AES128		0x00000040L
    314 #define SSL_AES256		0x00000080L
    315 #define SSL_CAMELLIA128		0x00000100L
    316 #define SSL_CAMELLIA256		0x00000200L
    317 #define SSL_eGOST2814789CNT	0x00000400L
    318 #define SSL_SEED		0x00000800L
    319 
    320 #define SSL_AES        		(SSL_AES128|SSL_AES256)
    321 #define SSL_CAMELLIA		(SSL_CAMELLIA128|SSL_CAMELLIA256)
    322 
    323 
    324 /* Bits for algorithm_mac (symmetric authentication) */
    325 #define SSL_MD5			0x00000001L
    326 #define SSL_SHA1		0x00000002L
    327 #define SSL_GOST94      0x00000004L
    328 #define SSL_GOST89MAC   0x00000008L
    329 
    330 /* Bits for algorithm_ssl (protocol version) */
    331 #define SSL_SSLV2		0x00000001L
    332 #define SSL_SSLV3		0x00000002L
    333 #define SSL_TLSV1		SSL_SSLV3	/* for now */
    334 
    335 
    336 /* Bits for algorithm2 (handshake digests and other extra flags) */
    337 
    338 #define SSL_HANDSHAKE_MAC_MD5 0x10
    339 #define SSL_HANDSHAKE_MAC_SHA 0x20
    340 #define SSL_HANDSHAKE_MAC_GOST94 0x40
    341 #define SSL_HANDSHAKE_MAC_DEFAULT (SSL_HANDSHAKE_MAC_MD5 | SSL_HANDSHAKE_MAC_SHA)
    342 
    343 /* When adding new digest in the ssl_ciph.c and increment SSM_MD_NUM_IDX
    344  * make sure to update this constant too */
    345 #define SSL_MAX_DIGEST 4
    346 
    347 #define TLS1_PRF_DGST_SHIFT 8
    348 #define TLS1_PRF_MD5 (SSL_HANDSHAKE_MAC_MD5 << TLS1_PRF_DGST_SHIFT)
    349 #define TLS1_PRF_SHA1 (SSL_HANDSHAKE_MAC_SHA << TLS1_PRF_DGST_SHIFT)
    350 #define TLS1_PRF_GOST94 (SSL_HANDSHAKE_MAC_GOST94 << TLS1_PRF_DGST_SHIFT)
    351 #define TLS1_PRF (TLS1_PRF_MD5 | TLS1_PRF_SHA1)
    352 
    353 /* Stream MAC for GOST ciphersuites from cryptopro draft
    354  * (currently this also goes into algorithm2) */
    355 #define TLS1_STREAM_MAC 0x04
    356 
    357 
    358 
    359 /*
    360  * Export and cipher strength information. For each cipher we have to decide
    361  * whether it is exportable or not. This information is likely to change
    362  * over time, since the export control rules are no static technical issue.
    363  *
    364  * Independent of the export flag the cipher strength is sorted into classes.
    365  * SSL_EXP40 was denoting the 40bit US export limit of past times, which now
    366  * is at 56bit (SSL_EXP56). If the exportable cipher class is going to change
    367  * again (eg. to 64bit) the use of "SSL_EXP*" becomes blurred even more,
    368  * since SSL_EXP64 could be similar to SSL_LOW.
    369  * For this reason SSL_MICRO and SSL_MINI macros are included to widen the
    370  * namespace of SSL_LOW-SSL_HIGH to lower values. As development of speed
    371  * and ciphers goes, another extension to SSL_SUPER and/or SSL_ULTRA would
    372  * be possible.
    373  */
    374 #define SSL_EXP_MASK		0x00000003L
    375 #define SSL_STRONG_MASK		0x000001fcL
    376 
    377 #define SSL_NOT_EXP		0x00000001L
    378 #define SSL_EXPORT		0x00000002L
    379 
    380 #define SSL_STRONG_NONE		0x00000004L
    381 #define SSL_EXP40		0x00000008L
    382 #define SSL_MICRO		(SSL_EXP40)
    383 #define SSL_EXP56		0x00000010L
    384 #define SSL_MINI		(SSL_EXP56)
    385 #define SSL_LOW			0x00000020L
    386 #define SSL_MEDIUM		0x00000040L
    387 #define SSL_HIGH		0x00000080L
    388 #define SSL_FIPS		0x00000100L
    389 
    390 /* we have used 000001ff - 23 bits left to go */
    391 
    392 /*
    393  * Macros to check the export status and cipher strength for export ciphers.
    394  * Even though the macros for EXPORT and EXPORT40/56 have similar names,
    395  * their meaning is different:
    396  * *_EXPORT macros check the 'exportable' status.
    397  * *_EXPORT40/56 macros are used to check whether a certain cipher strength
    398  *          is given.
    399  * Since the SSL_IS_EXPORT* and SSL_EXPORT* macros depend on the correct
    400  * algorithm structure element to be passed (algorithms, algo_strength) and no
    401  * typechecking can be done as they are all of type unsigned long, their
    402  * direct usage is discouraged.
    403  * Use the SSL_C_* macros instead.
    404  */
    405 #define SSL_IS_EXPORT(a)	((a)&SSL_EXPORT)
    406 #define SSL_IS_EXPORT56(a)	((a)&SSL_EXP56)
    407 #define SSL_IS_EXPORT40(a)	((a)&SSL_EXP40)
    408 #define SSL_C_IS_EXPORT(c)	SSL_IS_EXPORT((c)->algo_strength)
    409 #define SSL_C_IS_EXPORT56(c)	SSL_IS_EXPORT56((c)->algo_strength)
    410 #define SSL_C_IS_EXPORT40(c)	SSL_IS_EXPORT40((c)->algo_strength)
    411 
    412 #define SSL_EXPORT_KEYLENGTH(a,s)	(SSL_IS_EXPORT40(s) ? 5 : \
    413 				 (a) == SSL_DES ? 8 : 7)
    414 #define SSL_EXPORT_PKEYLENGTH(a) (SSL_IS_EXPORT40(a) ? 512 : 1024)
    415 #define SSL_C_EXPORT_KEYLENGTH(c)	SSL_EXPORT_KEYLENGTH((c)->algorithm_enc, \
    416 				(c)->algo_strength)
    417 #define SSL_C_EXPORT_PKEYLENGTH(c)	SSL_EXPORT_PKEYLENGTH((c)->algo_strength)
    418 
    419 
    420 
    421 
    422 /* Mostly for SSLv3 */
    423 #define SSL_PKEY_RSA_ENC	0
    424 #define SSL_PKEY_RSA_SIGN	1
    425 #define SSL_PKEY_DSA_SIGN	2
    426 #define SSL_PKEY_DH_RSA		3
    427 #define SSL_PKEY_DH_DSA		4
    428 #define SSL_PKEY_ECC            5
    429 #define SSL_PKEY_GOST94		6
    430 #define SSL_PKEY_GOST01		7
    431 #define SSL_PKEY_NUM		8
    432 
    433 /* SSL_kRSA <- RSA_ENC | (RSA_TMP & RSA_SIGN) |
    434  * 	    <- (EXPORT & (RSA_ENC | RSA_TMP) & RSA_SIGN)
    435  * SSL_kDH  <- DH_ENC & (RSA_ENC | RSA_SIGN | DSA_SIGN)
    436  * SSL_kEDH <- RSA_ENC | RSA_SIGN | DSA_SIGN
    437  * SSL_aRSA <- RSA_ENC | RSA_SIGN
    438  * SSL_aDSS <- DSA_SIGN
    439  */
    440 
    441 /*
    442 #define CERT_INVALID		0
    443 #define CERT_PUBLIC_KEY		1
    444 #define CERT_PRIVATE_KEY	2
    445 */
    446 
    447 #ifndef OPENSSL_NO_EC
    448 /* From ECC-TLS draft, used in encoding the curve type in
    449  * ECParameters
    450  */
    451 #define EXPLICIT_PRIME_CURVE_TYPE  1
    452 #define EXPLICIT_CHAR2_CURVE_TYPE  2
    453 #define NAMED_CURVE_TYPE           3
    454 #endif  /* OPENSSL_NO_EC */
    455 
    456 typedef struct cert_pkey_st
    457 	{
    458 	X509 *x509;
    459 	STACK_OF(X509) *cert_chain;
    460 	EVP_PKEY *privatekey;
    461 	} CERT_PKEY;
    462 
    463 typedef struct cert_st
    464 	{
    465 	/* Current active set */
    466 	CERT_PKEY *key; /* ALWAYS points to an element of the pkeys array
    467 			 * Probably it would make more sense to store
    468 			 * an index, not a pointer. */
    469 
    470 	/* The following masks are for the key and auth
    471 	 * algorithms that are supported by the certs below */
    472 	int valid;
    473 	unsigned long mask_k;
    474 	unsigned long mask_a;
    475 	unsigned long export_mask_k;
    476 	unsigned long export_mask_a;
    477 #ifndef OPENSSL_NO_RSA
    478 	RSA *rsa_tmp;
    479 	RSA *(*rsa_tmp_cb)(SSL *ssl,int is_export,int keysize);
    480 #endif
    481 #ifndef OPENSSL_NO_DH
    482 	DH *dh_tmp;
    483 	DH *(*dh_tmp_cb)(SSL *ssl,int is_export,int keysize);
    484 #endif
    485 #ifndef OPENSSL_NO_ECDH
    486 	EC_KEY *ecdh_tmp;
    487 	/* Callback for generating ephemeral ECDH keys */
    488 	EC_KEY *(*ecdh_tmp_cb)(SSL *ssl,int is_export,int keysize);
    489 #endif
    490 
    491 	CERT_PKEY pkeys[SSL_PKEY_NUM];
    492 
    493 	int references; /* >1 only if SSL_copy_session_id is used */
    494 	} CERT;
    495 
    496 
    497 typedef struct sess_cert_st
    498 	{
    499 	STACK_OF(X509) *cert_chain; /* as received from peer (not for SSL2) */
    500 
    501 	/* The 'peer_...' members are used only by clients. */
    502 	int peer_cert_type;
    503 
    504 	CERT_PKEY *peer_key; /* points to an element of peer_pkeys (never NULL!) */
    505 	CERT_PKEY peer_pkeys[SSL_PKEY_NUM];
    506 	/* Obviously we don't have the private keys of these,
    507 	 * so maybe we shouldn't even use the CERT_PKEY type here. */
    508 
    509 #ifndef OPENSSL_NO_RSA
    510 	RSA *peer_rsa_tmp; /* not used for SSL 2 */
    511 #endif
    512 #ifndef OPENSSL_NO_DH
    513 	DH *peer_dh_tmp; /* not used for SSL 2 */
    514 #endif
    515 #ifndef OPENSSL_NO_ECDH
    516 	EC_KEY *peer_ecdh_tmp;
    517 #endif
    518 
    519 	int references; /* actually always 1 at the moment */
    520 	} SESS_CERT;
    521 
    522 
    523 /*#define MAC_DEBUG	*/
    524 
    525 /*#define ERR_DEBUG	*/
    526 /*#define ABORT_DEBUG	*/
    527 /*#define PKT_DEBUG 1   */
    528 /*#define DES_DEBUG	*/
    529 /*#define DES_OFB_DEBUG	*/
    530 /*#define SSL_DEBUG	*/
    531 /*#define RSA_DEBUG	*/
    532 /*#define IDEA_DEBUG	*/
    533 
    534 #define FP_ICC  (int (*)(const void *,const void *))
    535 #define ssl_put_cipher_by_char(ssl,ciph,ptr) \
    536 		((ssl)->method->put_cipher_by_char((ciph),(ptr)))
    537 #define ssl_get_cipher_by_char(ssl,ptr) \
    538 		((ssl)->method->get_cipher_by_char(ptr))
    539 
    540 /* This is for the SSLv3/TLSv1.0 differences in crypto/hash stuff
    541  * It is a bit of a mess of functions, but hell, think of it as
    542  * an opaque structure :-) */
    543 typedef struct ssl3_enc_method
    544 	{
    545 	int (*enc)(SSL *, int);
    546 	int (*mac)(SSL *, unsigned char *, int);
    547 	int (*setup_key_block)(SSL *);
    548 	int (*generate_master_secret)(SSL *, unsigned char *, unsigned char *, int);
    549 	int (*change_cipher_state)(SSL *, int);
    550 	int (*final_finish_mac)(SSL *,  const char *, int, unsigned char *);
    551 	int finish_mac_length;
    552 	int (*cert_verify_mac)(SSL *, int, unsigned char *);
    553 	const char *client_finished_label;
    554 	int client_finished_label_len;
    555 	const char *server_finished_label;
    556 	int server_finished_label_len;
    557 	int (*alert_value)(int);
    558 	} SSL3_ENC_METHOD;
    559 
    560 #ifndef OPENSSL_NO_COMP
    561 /* Used for holding the relevant compression methods loaded into SSL_CTX */
    562 typedef struct ssl3_comp_st
    563 	{
    564 	int comp_id;	/* The identifier byte for this compression type */
    565 	char *name;	/* Text name used for the compression type */
    566 	COMP_METHOD *method; /* The method :-) */
    567 	} SSL3_COMP;
    568 #endif
    569 
    570 #ifndef OPENSSL_NO_BUF_FREELISTS
    571 typedef struct ssl3_buf_freelist_st
    572 	{
    573 	size_t chunklen;
    574 	unsigned int len;
    575 	struct ssl3_buf_freelist_entry_st *head;
    576 	} SSL3_BUF_FREELIST;
    577 
    578 typedef struct ssl3_buf_freelist_entry_st
    579 	{
    580 	struct ssl3_buf_freelist_entry_st *next;
    581 	} SSL3_BUF_FREELIST_ENTRY;
    582 #endif
    583 
    584 extern SSL3_ENC_METHOD ssl3_undef_enc_method;
    585 OPENSSL_EXTERN const SSL_CIPHER ssl2_ciphers[];
    586 OPENSSL_EXTERN SSL_CIPHER ssl3_ciphers[];
    587 
    588 
    589 SSL_METHOD *ssl_bad_method(int ver);
    590 
    591 extern SSL3_ENC_METHOD TLSv1_enc_data;
    592 extern SSL3_ENC_METHOD SSLv3_enc_data;
    593 extern SSL3_ENC_METHOD DTLSv1_enc_data;
    594 
    595 #define IMPLEMENT_tls1_meth_func(func_name, s_accept, s_connect, s_get_meth) \
    596 const SSL_METHOD *func_name(void)  \
    597 	{ \
    598 	static const SSL_METHOD func_name##_data= { \
    599 		TLS1_VERSION, \
    600 		tls1_new, \
    601 		tls1_clear, \
    602 		tls1_free, \
    603 		s_accept, \
    604 		s_connect, \
    605 		ssl3_read, \
    606 		ssl3_peek, \
    607 		ssl3_write, \
    608 		ssl3_shutdown, \
    609 		ssl3_renegotiate, \
    610 		ssl3_renegotiate_check, \
    611 		ssl3_get_message, \
    612 		ssl3_read_bytes, \
    613 		ssl3_write_bytes, \
    614 		ssl3_dispatch_alert, \
    615 		ssl3_ctrl, \
    616 		ssl3_ctx_ctrl, \
    617 		ssl3_get_cipher_by_char, \
    618 		ssl3_put_cipher_by_char, \
    619 		ssl3_pending, \
    620 		ssl3_num_ciphers, \
    621 		ssl3_get_cipher, \
    622 		s_get_meth, \
    623 		tls1_default_timeout, \
    624 		&TLSv1_enc_data, \
    625 		ssl_undefined_void_function, \
    626 		ssl3_callback_ctrl, \
    627 		ssl3_ctx_callback_ctrl, \
    628 	}; \
    629 	return &func_name##_data; \
    630 	}
    631 
    632 #define IMPLEMENT_ssl3_meth_func(func_name, s_accept, s_connect, s_get_meth) \
    633 const SSL_METHOD *func_name(void)  \
    634 	{ \
    635 	static const SSL_METHOD func_name##_data= { \
    636 		SSL3_VERSION, \
    637 		ssl3_new, \
    638 		ssl3_clear, \
    639 		ssl3_free, \
    640 		s_accept, \
    641 		s_connect, \
    642 		ssl3_read, \
    643 		ssl3_peek, \
    644 		ssl3_write, \
    645 		ssl3_shutdown, \
    646 		ssl3_renegotiate, \
    647 		ssl3_renegotiate_check, \
    648 		ssl3_get_message, \
    649 		ssl3_read_bytes, \
    650 		ssl3_write_bytes, \
    651 		ssl3_dispatch_alert, \
    652 		ssl3_ctrl, \
    653 		ssl3_ctx_ctrl, \
    654 		ssl3_get_cipher_by_char, \
    655 		ssl3_put_cipher_by_char, \
    656 		ssl3_pending, \
    657 		ssl3_num_ciphers, \
    658 		ssl3_get_cipher, \
    659 		s_get_meth, \
    660 		ssl3_default_timeout, \
    661 		&SSLv3_enc_data, \
    662 		ssl_undefined_void_function, \
    663 		ssl3_callback_ctrl, \
    664 		ssl3_ctx_callback_ctrl, \
    665 	}; \
    666 	return &func_name##_data; \
    667 	}
    668 
    669 #define IMPLEMENT_ssl23_meth_func(func_name, s_accept, s_connect, s_get_meth) \
    670 const SSL_METHOD *func_name(void)  \
    671 	{ \
    672 	static const SSL_METHOD func_name##_data= { \
    673 	TLS1_VERSION, \
    674 	tls1_new, \
    675 	tls1_clear, \
    676 	tls1_free, \
    677 	s_accept, \
    678 	s_connect, \
    679 	ssl23_read, \
    680 	ssl23_peek, \
    681 	ssl23_write, \
    682 	ssl_undefined_function, \
    683 	ssl_undefined_function, \
    684 	ssl_ok, \
    685 	ssl3_get_message, \
    686 	ssl3_read_bytes, \
    687 	ssl3_write_bytes, \
    688 	ssl3_dispatch_alert, \
    689 	ssl3_ctrl, \
    690 	ssl3_ctx_ctrl, \
    691 	ssl23_get_cipher_by_char, \
    692 	ssl23_put_cipher_by_char, \
    693 	ssl_undefined_const_function, \
    694 	ssl23_num_ciphers, \
    695 	ssl23_get_cipher, \
    696 	s_get_meth, \
    697 	ssl23_default_timeout, \
    698 	&ssl3_undef_enc_method, \
    699 	ssl_undefined_void_function, \
    700 	ssl3_callback_ctrl, \
    701 	ssl3_ctx_callback_ctrl, \
    702 	}; \
    703 	return &func_name##_data; \
    704 	}
    705 
    706 #define IMPLEMENT_ssl2_meth_func(func_name, s_accept, s_connect, s_get_meth) \
    707 const SSL_METHOD *func_name(void)  \
    708 	{ \
    709 	static const SSL_METHOD func_name##_data= { \
    710 		SSL2_VERSION, \
    711 		ssl2_new,	/* local */ \
    712 		ssl2_clear,	/* local */ \
    713 		ssl2_free,	/* local */ \
    714 		s_accept, \
    715 		s_connect, \
    716 		ssl2_read, \
    717 		ssl2_peek, \
    718 		ssl2_write, \
    719 		ssl2_shutdown, \
    720 		ssl_ok,	/* NULL - renegotiate */ \
    721 		ssl_ok,	/* NULL - check renegotiate */ \
    722 		NULL, /* NULL - ssl_get_message */ \
    723 		NULL, /* NULL - ssl_get_record */ \
    724 		NULL, /* NULL - ssl_write_bytes */ \
    725 		NULL, /* NULL - dispatch_alert */ \
    726 		ssl2_ctrl,	/* local */ \
    727 		ssl2_ctx_ctrl,	/* local */ \
    728 		ssl2_get_cipher_by_char, \
    729 		ssl2_put_cipher_by_char, \
    730 		ssl2_pending, \
    731 		ssl2_num_ciphers, \
    732 		ssl2_get_cipher, \
    733 		s_get_meth, \
    734 		ssl2_default_timeout, \
    735 		&ssl3_undef_enc_method, \
    736 		ssl_undefined_void_function, \
    737 		ssl2_callback_ctrl,	/* local */ \
    738 		ssl2_ctx_callback_ctrl,	/* local */ \
    739 	}; \
    740 	return &func_name##_data; \
    741 	}
    742 
    743 #define IMPLEMENT_dtls1_meth_func(func_name, s_accept, s_connect, s_get_meth) \
    744 const SSL_METHOD *func_name(void)  \
    745 	{ \
    746 	static const SSL_METHOD func_name##_data= { \
    747 		DTLS1_VERSION, \
    748 		dtls1_new, \
    749 		dtls1_clear, \
    750 		dtls1_free, \
    751 		s_accept, \
    752 		s_connect, \
    753 		ssl3_read, \
    754 		ssl3_peek, \
    755 		ssl3_write, \
    756 		ssl3_shutdown, \
    757 		ssl3_renegotiate, \
    758 		ssl3_renegotiate_check, \
    759 		dtls1_get_message, \
    760 		dtls1_read_bytes, \
    761 		dtls1_write_app_data_bytes, \
    762 		dtls1_dispatch_alert, \
    763 		dtls1_ctrl, \
    764 		ssl3_ctx_ctrl, \
    765 		ssl3_get_cipher_by_char, \
    766 		ssl3_put_cipher_by_char, \
    767 		ssl3_pending, \
    768 		ssl3_num_ciphers, \
    769 		dtls1_get_cipher, \
    770 		s_get_meth, \
    771 		dtls1_default_timeout, \
    772 		&DTLSv1_enc_data, \
    773 		ssl_undefined_void_function, \
    774 		ssl3_callback_ctrl, \
    775 		ssl3_ctx_callback_ctrl, \
    776 	}; \
    777 	return &func_name##_data; \
    778 	}
    779 
    780 void ssl_clear_cipher_ctx(SSL *s);
    781 int ssl_clear_bad_session(SSL *s);
    782 CERT *ssl_cert_new(void);
    783 CERT *ssl_cert_dup(CERT *cert);
    784 int ssl_cert_inst(CERT **o);
    785 void ssl_cert_free(CERT *c);
    786 SESS_CERT *ssl_sess_cert_new(void);
    787 void ssl_sess_cert_free(SESS_CERT *sc);
    788 int ssl_set_peer_cert_type(SESS_CERT *c, int type);
    789 int ssl_get_new_session(SSL *s, int session);
    790 int ssl_get_prev_session(SSL *s, unsigned char *session,int len, const unsigned char *limit);
    791 int ssl_cipher_id_cmp(const SSL_CIPHER *a,const SSL_CIPHER *b);
    792 DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER,
    793 				  ssl_cipher_id);
    794 int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap,
    795 			const SSL_CIPHER * const *bp);
    796 STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
    797 					       STACK_OF(SSL_CIPHER) **skp);
    798 int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p,
    799                              int (*put_cb)(const SSL_CIPHER *, unsigned char *));
    800 STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *meth,
    801 					     STACK_OF(SSL_CIPHER) **pref,
    802 					     STACK_OF(SSL_CIPHER) **sorted,
    803 					     const char *rule_str);
    804 void ssl_update_cache(SSL *s, int mode);
    805 int ssl_cipher_get_evp(const SSL_SESSION *s,const EVP_CIPHER **enc,
    806 		       const EVP_MD **md,int *mac_pkey_type,int *mac_secret_size, SSL_COMP **comp);
    807 int ssl_get_handshake_digest(int i,long *mask,const EVP_MD **md);
    808 int ssl_verify_cert_chain(SSL *s,STACK_OF(X509) *sk);
    809 int ssl_undefined_function(SSL *s);
    810 int ssl_undefined_void_function(void);
    811 int ssl_undefined_const_function(const SSL *s);
    812 X509 *ssl_get_server_send_cert(SSL *);
    813 EVP_PKEY *ssl_get_sign_pkey(SSL *,const SSL_CIPHER *);
    814 int ssl_cert_type(X509 *x,EVP_PKEY *pkey);
    815 void ssl_set_cert_masks(CERT *c, const SSL_CIPHER *cipher);
    816 STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s);
    817 int ssl_verify_alarm_type(long type);
    818 void ssl_load_ciphers(void);
    819 
    820 int ssl2_enc_init(SSL *s, int client);
    821 int ssl2_generate_key_material(SSL *s);
    822 void ssl2_enc(SSL *s,int send_data);
    823 void ssl2_mac(SSL *s,unsigned char *mac,int send_data);
    824 const SSL_CIPHER *ssl2_get_cipher_by_char(const unsigned char *p);
    825 int ssl2_put_cipher_by_char(const SSL_CIPHER *c,unsigned char *p);
    826 int ssl2_part_read(SSL *s, unsigned long f, int i);
    827 int ssl2_do_write(SSL *s);
    828 int ssl2_set_certificate(SSL *s, int type, int len, const unsigned char *data);
    829 void ssl2_return_error(SSL *s,int reason);
    830 void ssl2_write_error(SSL *s);
    831 int ssl2_num_ciphers(void);
    832 const SSL_CIPHER *ssl2_get_cipher(unsigned int u);
    833 int	ssl2_new(SSL *s);
    834 void	ssl2_free(SSL *s);
    835 int	ssl2_accept(SSL *s);
    836 int	ssl2_connect(SSL *s);
    837 int	ssl2_read(SSL *s, void *buf, int len);
    838 int	ssl2_peek(SSL *s, void *buf, int len);
    839 int	ssl2_write(SSL *s, const void *buf, int len);
    840 int	ssl2_shutdown(SSL *s);
    841 void	ssl2_clear(SSL *s);
    842 long	ssl2_ctrl(SSL *s,int cmd, long larg, void *parg);
    843 long	ssl2_ctx_ctrl(SSL_CTX *s,int cmd, long larg, void *parg);
    844 long	ssl2_callback_ctrl(SSL *s,int cmd, void (*fp)(void));
    845 long	ssl2_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)(void));
    846 int	ssl2_pending(const SSL *s);
    847 long	ssl2_default_timeout(void );
    848 
    849 const SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p);
    850 int ssl3_put_cipher_by_char(const SSL_CIPHER *c,unsigned char *p);
    851 void ssl3_init_finished_mac(SSL *s);
    852 int ssl3_send_server_certificate(SSL *s);
    853 int ssl3_send_newsession_ticket(SSL *s);
    854 int ssl3_send_cert_status(SSL *s);
    855 int ssl3_get_finished(SSL *s,int state_a,int state_b);
    856 int ssl3_setup_key_block(SSL *s);
    857 int ssl3_send_change_cipher_spec(SSL *s,int state_a,int state_b);
    858 int ssl3_change_cipher_state(SSL *s,int which);
    859 void ssl3_cleanup_key_block(SSL *s);
    860 int ssl3_do_write(SSL *s,int type);
    861 int ssl3_send_alert(SSL *s,int level, int desc);
    862 int ssl3_generate_master_secret(SSL *s, unsigned char *out,
    863 	unsigned char *p, int len);
    864 int ssl3_get_req_cert_type(SSL *s,unsigned char *p);
    865 long ssl3_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok);
    866 int ssl3_send_finished(SSL *s, int a, int b, const char *sender,int slen);
    867 int ssl3_num_ciphers(void);
    868 const SSL_CIPHER *ssl3_get_cipher(unsigned int u);
    869 int ssl3_renegotiate(SSL *ssl);
    870 int ssl3_renegotiate_check(SSL *ssl);
    871 int ssl3_dispatch_alert(SSL *s);
    872 int ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek);
    873 int ssl3_write_bytes(SSL *s, int type, const void *buf, int len);
    874 int ssl3_final_finish_mac(SSL *s, const char *sender, int slen,unsigned char *p);
    875 int ssl3_cert_verify_mac(SSL *s, int md_nid, unsigned char *p);
    876 void ssl3_finish_mac(SSL *s, const unsigned char *buf, int len);
    877 int ssl3_enc(SSL *s, int send_data);
    878 int n_ssl3_mac(SSL *ssl, unsigned char *md, int send_data);
    879 void ssl3_free_digest_list(SSL *s);
    880 unsigned long ssl3_output_cert_chain(SSL *s, X509 *x);
    881 SSL_CIPHER *ssl3_choose_cipher(SSL *ssl,STACK_OF(SSL_CIPHER) *clnt,
    882 			       STACK_OF(SSL_CIPHER) *srvr);
    883 int	ssl3_setup_buffers(SSL *s);
    884 int	ssl3_setup_read_buffer(SSL *s);
    885 int	ssl3_setup_write_buffer(SSL *s);
    886 int	ssl3_release_read_buffer(SSL *s);
    887 int	ssl3_release_write_buffer(SSL *s);
    888 int	ssl3_digest_cached_records(SSL *s);
    889 int	ssl3_new(SSL *s);
    890 void	ssl3_free(SSL *s);
    891 int	ssl3_accept(SSL *s);
    892 int	ssl3_connect(SSL *s);
    893 int	ssl3_read(SSL *s, void *buf, int len);
    894 int	ssl3_peek(SSL *s, void *buf, int len);
    895 int	ssl3_write(SSL *s, const void *buf, int len);
    896 int	ssl3_shutdown(SSL *s);
    897 void	ssl3_clear(SSL *s);
    898 long	ssl3_ctrl(SSL *s,int cmd, long larg, void *parg);
    899 long	ssl3_ctx_ctrl(SSL_CTX *s,int cmd, long larg, void *parg);
    900 long	ssl3_callback_ctrl(SSL *s,int cmd, void (*fp)(void));
    901 long	ssl3_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)(void));
    902 int	ssl3_pending(const SSL *s);
    903 
    904 void ssl3_record_sequence_update(unsigned char *seq);
    905 int ssl3_do_change_cipher_spec(SSL *ssl);
    906 long ssl3_default_timeout(void );
    907 
    908 int ssl23_num_ciphers(void );
    909 const SSL_CIPHER *ssl23_get_cipher(unsigned int u);
    910 int ssl23_read(SSL *s, void *buf, int len);
    911 int ssl23_peek(SSL *s, void *buf, int len);
    912 int ssl23_write(SSL *s, const void *buf, int len);
    913 int ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p);
    914 const SSL_CIPHER *ssl23_get_cipher_by_char(const unsigned char *p);
    915 long ssl23_default_timeout(void );
    916 
    917 long tls1_default_timeout(void);
    918 int dtls1_do_write(SSL *s,int type);
    919 int ssl3_read_n(SSL *s, int n, int max, int extend);
    920 int dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek);
    921 int ssl3_do_compress(SSL *ssl);
    922 int ssl3_do_uncompress(SSL *ssl);
    923 int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
    924 	unsigned int len);
    925 unsigned char *dtls1_set_message_header(SSL *s,
    926 	unsigned char *p, unsigned char mt,	unsigned long len,
    927 	unsigned long frag_off, unsigned long frag_len);
    928 
    929 int dtls1_write_app_data_bytes(SSL *s, int type, const void *buf, int len);
    930 int dtls1_write_bytes(SSL *s, int type, const void *buf, int len);
    931 
    932 int dtls1_send_change_cipher_spec(SSL *s, int a, int b);
    933 int dtls1_send_finished(SSL *s, int a, int b, const char *sender, int slen);
    934 unsigned long dtls1_output_cert_chain(SSL *s, X509 *x);
    935 int dtls1_read_failed(SSL *s, int code);
    936 int dtls1_buffer_message(SSL *s, int ccs);
    937 int dtls1_retransmit_message(SSL *s, unsigned short seq,
    938 	unsigned long frag_off, int *found);
    939 int dtls1_get_queue_priority(unsigned short seq, int is_ccs);
    940 int dtls1_retransmit_buffered_messages(SSL *s);
    941 void dtls1_clear_record_buffer(SSL *s);
    942 void dtls1_get_message_header(unsigned char *data, struct hm_header_st *msg_hdr);
    943 void dtls1_get_ccs_header(unsigned char *data, struct ccs_header_st *ccs_hdr);
    944 void dtls1_reset_seq_numbers(SSL *s, int rw);
    945 long dtls1_default_timeout(void);
    946 struct timeval* dtls1_get_timeout(SSL *s, struct timeval* timeleft);
    947 int dtls1_handle_timeout(SSL *s);
    948 const SSL_CIPHER *dtls1_get_cipher(unsigned int u);
    949 void dtls1_start_timer(SSL *s);
    950 void dtls1_stop_timer(SSL *s);
    951 int dtls1_is_timer_expired(SSL *s);
    952 void dtls1_double_timeout(SSL *s);
    953 int dtls1_send_newsession_ticket(SSL *s);
    954 
    955 /* some client-only functions */
    956 int ssl3_client_hello(SSL *s);
    957 int ssl3_get_server_hello(SSL *s);
    958 int ssl3_get_certificate_request(SSL *s);
    959 int ssl3_get_new_session_ticket(SSL *s);
    960 int ssl3_get_cert_status(SSL *s);
    961 int ssl3_get_server_done(SSL *s);
    962 int ssl3_send_client_verify(SSL *s);
    963 int ssl3_send_client_certificate(SSL *s);
    964 int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey);
    965 int ssl3_send_client_key_exchange(SSL *s);
    966 int ssl3_get_key_exchange(SSL *s);
    967 int ssl3_get_server_certificate(SSL *s);
    968 int ssl3_check_cert_and_algorithm(SSL *s);
    969 #ifndef OPENSSL_NO_TLSEXT
    970 int ssl3_check_finished(SSL *s);
    971 #endif
    972 
    973 int dtls1_client_hello(SSL *s);
    974 int dtls1_send_client_certificate(SSL *s);
    975 int dtls1_send_client_key_exchange(SSL *s);
    976 int dtls1_send_client_verify(SSL *s);
    977 
    978 /* some server-only functions */
    979 int ssl3_get_client_hello(SSL *s);
    980 int ssl3_send_server_hello(SSL *s);
    981 int ssl3_send_hello_request(SSL *s);
    982 int ssl3_send_server_key_exchange(SSL *s);
    983 int ssl3_send_certificate_request(SSL *s);
    984 int ssl3_send_server_done(SSL *s);
    985 int ssl3_check_client_hello(SSL *s);
    986 int ssl3_get_client_certificate(SSL *s);
    987 int ssl3_get_client_key_exchange(SSL *s);
    988 int ssl3_get_cert_verify(SSL *s);
    989 
    990 int dtls1_send_hello_request(SSL *s);
    991 int dtls1_send_server_hello(SSL *s);
    992 int dtls1_send_server_certificate(SSL *s);
    993 int dtls1_send_server_key_exchange(SSL *s);
    994 int dtls1_send_certificate_request(SSL *s);
    995 int dtls1_send_server_done(SSL *s);
    996 
    997 
    998 
    999 int ssl23_accept(SSL *s);
   1000 int ssl23_connect(SSL *s);
   1001 int ssl23_read_bytes(SSL *s, int n);
   1002 int ssl23_write_bytes(SSL *s);
   1003 
   1004 int tls1_new(SSL *s);
   1005 void tls1_free(SSL *s);
   1006 void tls1_clear(SSL *s);
   1007 long tls1_ctrl(SSL *s,int cmd, long larg, void *parg);
   1008 long tls1_callback_ctrl(SSL *s,int cmd, void (*fp)(void));
   1009 
   1010 int dtls1_new(SSL *s);
   1011 int	dtls1_accept(SSL *s);
   1012 int	dtls1_connect(SSL *s);
   1013 void dtls1_free(SSL *s);
   1014 void dtls1_clear(SSL *s);
   1015 long dtls1_ctrl(SSL *s,int cmd, long larg, void *parg);
   1016 
   1017 long dtls1_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok);
   1018 int dtls1_get_record(SSL *s);
   1019 int do_dtls1_write(SSL *s, int type, const unsigned char *buf,
   1020 	unsigned int len, int create_empty_fragement);
   1021 int dtls1_dispatch_alert(SSL *s);
   1022 int dtls1_enc(SSL *s, int snd);
   1023 
   1024 int ssl_init_wbio_buffer(SSL *s, int push);
   1025 void ssl_free_wbio_buffer(SSL *s);
   1026 
   1027 int tls1_change_cipher_state(SSL *s, int which);
   1028 int tls1_setup_key_block(SSL *s);
   1029 int tls1_enc(SSL *s, int snd);
   1030 int tls1_final_finish_mac(SSL *s,
   1031 	const char *str, int slen, unsigned char *p);
   1032 int tls1_cert_verify_mac(SSL *s, int md_nid, unsigned char *p);
   1033 int tls1_mac(SSL *ssl, unsigned char *md, int snd);
   1034 int tls1_generate_master_secret(SSL *s, unsigned char *out,
   1035 	unsigned char *p, int len);
   1036 int tls1_alert_code(int code);
   1037 int ssl3_alert_code(int code);
   1038 int ssl_ok(SSL *s);
   1039 
   1040 #ifndef OPENSSL_NO_ECDH
   1041 int ssl_check_srvr_ecc_cert_and_alg(X509 *x, const SSL_CIPHER *cs);
   1042 #endif
   1043 
   1044 SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n);
   1045 
   1046 #ifndef OPENSSL_NO_EC
   1047 int tls1_ec_curve_id2nid(int curve_id);
   1048 int tls1_ec_nid2curve_id(int nid);
   1049 #endif /* OPENSSL_NO_EC */
   1050 
   1051 #ifndef OPENSSL_NO_TLSEXT
   1052 unsigned char *ssl_add_clienthello_tlsext(SSL *s, unsigned char *p, unsigned char *limit);
   1053 unsigned char *ssl_add_serverhello_tlsext(SSL *s, unsigned char *p, unsigned char *limit);
   1054 int ssl_parse_clienthello_tlsext(SSL *s, unsigned char **data, unsigned char *d, int n, int *al);
   1055 int ssl_parse_serverhello_tlsext(SSL *s, unsigned char **data, unsigned char *d, int n, int *al);
   1056 int ssl_prepare_clienthello_tlsext(SSL *s);
   1057 int ssl_prepare_serverhello_tlsext(SSL *s);
   1058 int ssl_check_clienthello_tlsext(SSL *s);
   1059 int ssl_check_serverhello_tlsext(SSL *s);
   1060 
   1061 #ifdef OPENSSL_NO_SHA256
   1062 #define tlsext_tick_md	EVP_sha1
   1063 #else
   1064 #define tlsext_tick_md	EVP_sha256
   1065 #endif
   1066 int tls1_process_ticket(SSL *s, unsigned char *session_id, int len,
   1067 				const unsigned char *limit, SSL_SESSION **ret);
   1068 #endif
   1069 EVP_MD_CTX* ssl_replace_hash(EVP_MD_CTX **hash,const EVP_MD *md) ;
   1070 void ssl_clear_hash_ctx(EVP_MD_CTX **hash);
   1071 int ssl_add_serverhello_renegotiate_ext(SSL *s, unsigned char *p, int *len,
   1072 					int maxlen);
   1073 int ssl_parse_serverhello_renegotiate_ext(SSL *s, unsigned char *d, int len,
   1074 					  int *al);
   1075 int ssl_add_clienthello_renegotiate_ext(SSL *s, unsigned char *p, int *len,
   1076 					int maxlen);
   1077 int ssl_parse_clienthello_renegotiate_ext(SSL *s, unsigned char *d, int len,
   1078 					  int *al);
   1079 #endif
   1080