Eneboo - Documentación para desarrolladores
|
00001 /* ssl/ssl_locl.h */ 00002 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 00003 * All rights reserved. 00004 * 00005 * This package is an SSL implementation written 00006 * by Eric Young (eay@cryptsoft.com). 00007 * The implementation was written so as to conform with Netscapes SSL. 00008 * 00009 * This library is free for commercial and non-commercial use as long as 00010 * the following conditions are aheared to. The following conditions 00011 * apply to all code found in this distribution, be it the RC4, RSA, 00012 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 00013 * included with this distribution is covered by the same copyright terms 00014 * except that the holder is Tim Hudson (tjh@cryptsoft.com). 00015 * 00016 * Copyright remains Eric Young's, and as such any Copyright notices in 00017 * the code are not to be removed. 00018 * If this package is used in a product, Eric Young should be given attribution 00019 * as the author of the parts of the library used. 00020 * This can be in the form of a textual message at program startup or 00021 * in documentation (online or textual) provided with the package. 00022 * 00023 * Redistribution and use in source and binary forms, with or without 00024 * modification, are permitted provided that the following conditions 00025 * are met: 00026 * 1. Redistributions of source code must retain the copyright 00027 * notice, this list of conditions and the following disclaimer. 00028 * 2. Redistributions in binary form must reproduce the above copyright 00029 * notice, this list of conditions and the following disclaimer in the 00030 * documentation and/or other materials provided with the distribution. 00031 * 3. All advertising materials mentioning features or use of this software 00032 * must display the following acknowledgement: 00033 * "This product includes cryptographic software written by 00034 * Eric Young (eay@cryptsoft.com)" 00035 * The word 'cryptographic' can be left out if the rouines from the library 00036 * being used are not cryptographic related :-). 00037 * 4. If you include any Windows specific code (or a derivative thereof) from 00038 * the apps directory (application code) you must include an acknowledgement: 00039 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 00040 * 00041 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 00042 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 00043 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 00044 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 00045 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 00046 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 00047 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 00048 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 00049 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 00050 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 00051 * SUCH DAMAGE. 00052 * 00053 * The licence and distribution terms for any publically available version or 00054 * derivative of this code cannot be changed. i.e. this code cannot simply be 00055 * copied and put under another distribution licence 00056 * [including the GNU Public Licence.] 00057 */ 00058 /* ==================================================================== 00059 * Copyright (c) 1998-2001 The OpenSSL Project. All rights reserved. 00060 * 00061 * Redistribution and use in source and binary forms, with or without 00062 * modification, are permitted provided that the following conditions 00063 * are met: 00064 * 00065 * 1. Redistributions of source code must retain the above copyright 00066 * notice, this list of conditions and the following disclaimer. 00067 * 00068 * 2. Redistributions in binary form must reproduce the above copyright 00069 * notice, this list of conditions and the following disclaimer in 00070 * the documentation and/or other materials provided with the 00071 * distribution. 00072 * 00073 * 3. All advertising materials mentioning features or use of this 00074 * software must display the following acknowledgment: 00075 * "This product includes software developed by the OpenSSL Project 00076 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" 00077 * 00078 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 00079 * endorse or promote products derived from this software without 00080 * prior written permission. For written permission, please contact 00081 * openssl-core@openssl.org. 00082 * 00083 * 5. Products derived from this software may not be called "OpenSSL" 00084 * nor may "OpenSSL" appear in their names without prior written 00085 * permission of the OpenSSL Project. 00086 * 00087 * 6. Redistributions of any form whatsoever must retain the following 00088 * acknowledgment: 00089 * "This product includes software developed by the OpenSSL Project 00090 * for use in the OpenSSL Toolkit (http://www.openssl.org/)" 00091 * 00092 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 00093 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 00094 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 00095 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 00096 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 00097 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 00098 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 00099 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 00100 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 00101 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 00102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 00103 * OF THE POSSIBILITY OF SUCH DAMAGE. 00104 * ==================================================================== 00105 * 00106 * This product includes cryptographic software written by Eric Young 00107 * (eay@cryptsoft.com). This product includes software written by Tim 00108 * Hudson (tjh@cryptsoft.com). 00109 * 00110 */ 00111 /* ==================================================================== 00112 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. 00113 * ECC cipher suite support in OpenSSL originally developed by 00114 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. 00115 */ 00116 00117 #ifndef HEADER_SSL_LOCL_H 00118 #define HEADER_SSL_LOCL_H 00119 #include <stdlib.h> 00120 #include <time.h> 00121 #include <string.h> 00122 #include <errno.h> 00123 00124 #include "e_os.h" 00125 00126 #include <openssl/buffer.h> 00127 #ifndef OPENSSL_NO_COMP 00128 #include <openssl/comp.h> 00129 #endif 00130 #include <openssl/bio.h> 00131 #include <openssl/stack.h> 00132 #ifndef OPENSSL_NO_RSA 00133 #include <openssl/rsa.h> 00134 #endif 00135 #ifndef OPENSSL_NO_DSA 00136 #include <openssl/dsa.h> 00137 #endif 00138 #include <openssl/err.h> 00139 #include <openssl/ssl.h> 00140 #include <openssl/symhacks.h> 00141 00142 #ifdef OPENSSL_BUILD_SHLIBSSL 00143 # undef OPENSSL_EXTERN 00144 # define OPENSSL_EXTERN OPENSSL_EXPORT 00145 #endif 00146 00147 #define PKCS1_CHECK 00148 00149 #define c2l(c,l) (l = ((unsigned long)(*((c)++))) , \ 00150 l|=(((unsigned long)(*((c)++)))<< 8), \ 00151 l|=(((unsigned long)(*((c)++)))<<16), \ 00152 l|=(((unsigned long)(*((c)++)))<<24)) 00153 00154 /* NOTE - c is not incremented as per c2l */ 00155 #define c2ln(c,l1,l2,n) { \ 00156 c+=n; \ 00157 l1=l2=0; \ 00158 switch (n) { \ 00159 case 8: l2 =((unsigned long)(*(--(c))))<<24; \ 00160 case 7: l2|=((unsigned long)(*(--(c))))<<16; \ 00161 case 6: l2|=((unsigned long)(*(--(c))))<< 8; \ 00162 case 5: l2|=((unsigned long)(*(--(c)))); \ 00163 case 4: l1 =((unsigned long)(*(--(c))))<<24; \ 00164 case 3: l1|=((unsigned long)(*(--(c))))<<16; \ 00165 case 2: l1|=((unsigned long)(*(--(c))))<< 8; \ 00166 case 1: l1|=((unsigned long)(*(--(c)))); \ 00167 } \ 00168 } 00169 00170 #define l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \ 00171 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \ 00172 *((c)++)=(unsigned char)(((l)>>16)&0xff), \ 00173 *((c)++)=(unsigned char)(((l)>>24)&0xff)) 00174 00175 #define n2l(c,l) (l =((unsigned long)(*((c)++)))<<24, \ 00176 l|=((unsigned long)(*((c)++)))<<16, \ 00177 l|=((unsigned long)(*((c)++)))<< 8, \ 00178 l|=((unsigned long)(*((c)++)))) 00179 00180 #define l2n(l,c) (*((c)++)=(unsigned char)(((l)>>24)&0xff), \ 00181 *((c)++)=(unsigned char)(((l)>>16)&0xff), \ 00182 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \ 00183 *((c)++)=(unsigned char)(((l) )&0xff)) 00184 00185 #define l2n6(l,c) (*((c)++)=(unsigned char)(((l)>>40)&0xff), \ 00186 *((c)++)=(unsigned char)(((l)>>32)&0xff), \ 00187 *((c)++)=(unsigned char)(((l)>>24)&0xff), \ 00188 *((c)++)=(unsigned char)(((l)>>16)&0xff), \ 00189 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \ 00190 *((c)++)=(unsigned char)(((l) )&0xff)) 00191 00192 #define n2l6(c,l) (l =((BN_ULLONG)(*((c)++)))<<40, \ 00193 l|=((BN_ULLONG)(*((c)++)))<<32, \ 00194 l|=((BN_ULLONG)(*((c)++)))<<24, \ 00195 l|=((BN_ULLONG)(*((c)++)))<<16, \ 00196 l|=((BN_ULLONG)(*((c)++)))<< 8, \ 00197 l|=((BN_ULLONG)(*((c)++)))) 00198 00199 /* NOTE - c is not incremented as per l2c */ 00200 #define l2cn(l1,l2,c,n) { \ 00201 c+=n; \ 00202 switch (n) { \ 00203 case 8: *(--(c))=(unsigned char)(((l2)>>24)&0xff); \ 00204 case 7: *(--(c))=(unsigned char)(((l2)>>16)&0xff); \ 00205 case 6: *(--(c))=(unsigned char)(((l2)>> 8)&0xff); \ 00206 case 5: *(--(c))=(unsigned char)(((l2) )&0xff); \ 00207 case 4: *(--(c))=(unsigned char)(((l1)>>24)&0xff); \ 00208 case 3: *(--(c))=(unsigned char)(((l1)>>16)&0xff); \ 00209 case 2: *(--(c))=(unsigned char)(((l1)>> 8)&0xff); \ 00210 case 1: *(--(c))=(unsigned char)(((l1) )&0xff); \ 00211 } \ 00212 } 00213 00214 #define n2s(c,s) ((s=(((unsigned int)(c[0]))<< 8)| \ 00215 (((unsigned int)(c[1])) )),c+=2) 00216 #define s2n(s,c) ((c[0]=(unsigned char)(((s)>> 8)&0xff), \ 00217 c[1]=(unsigned char)(((s) )&0xff)),c+=2) 00218 00219 #define n2l3(c,l) ((l =(((unsigned long)(c[0]))<<16)| \ 00220 (((unsigned long)(c[1]))<< 8)| \ 00221 (((unsigned long)(c[2])) )),c+=3) 00222 00223 #define l2n3(l,c) ((c[0]=(unsigned char)(((l)>>16)&0xff), \ 00224 c[1]=(unsigned char)(((l)>> 8)&0xff), \ 00225 c[2]=(unsigned char)(((l) )&0xff)),c+=3) 00226 00227 /* LOCAL STUFF */ 00228 00229 #define SSL_DECRYPT 0 00230 #define SSL_ENCRYPT 1 00231 00232 #define TWO_BYTE_BIT 0x80 00233 #define SEC_ESC_BIT 0x40 00234 #define TWO_BYTE_MASK 0x7fff 00235 #define THREE_BYTE_MASK 0x3fff 00236 00237 #define INC32(a) ((a)=((a)+1)&0xffffffffL) 00238 #define DEC32(a) ((a)=((a)-1)&0xffffffffL) 00239 #define MAX_MAC_SIZE 20 /* up from 16 for SSLv3 */ 00240 00241 /* 00242 * Define the Bitmasks for SSL_CIPHER.algorithms. 00243 * This bits are used packed as dense as possible. If new methods/ciphers 00244 * etc will be added, the bits a likely to change, so this information 00245 * is for internal library use only, even though SSL_CIPHER.algorithms 00246 * can be publicly accessed. 00247 * Use the according functions for cipher management instead. 00248 * 00249 * The bit mask handling in the selection and sorting scheme in 00250 * ssl_create_cipher_list() has only limited capabilities, reflecting 00251 * that the different entities within are mutually exclusive: 00252 * ONLY ONE BIT PER MASK CAN BE SET AT A TIME. 00253 */ 00254 #define SSL_MKEY_MASK 0x000000FFL 00255 #define SSL_kRSA 0x00000001L /* RSA key exchange */ 00256 #define SSL_kDHr 0x00000002L /* DH cert RSA CA cert */ 00257 #define SSL_kDHd 0x00000004L /* DH cert DSA CA cert */ 00258 #define SSL_kFZA 0x00000008L 00259 #define SSL_kEDH 0x00000010L /* tmp DH key no DH cert */ 00260 #define SSL_kKRB5 0x00000020L /* Kerberos5 key exchange */ 00261 #define SSL_kECDH 0x00000040L /* ECDH w/ long-term keys */ 00262 #define SSL_kECDHE 0x00000080L /* ephemeral ECDH */ 00263 #define SSL_EDH (SSL_kEDH|(SSL_AUTH_MASK^SSL_aNULL)) 00264 00265 #define SSL_AUTH_MASK 0x00007F00L 00266 #define SSL_aRSA 0x00000100L /* Authenticate with RSA */ 00267 #define SSL_aDSS 0x00000200L /* Authenticate with DSS */ 00268 #define SSL_DSS SSL_aDSS 00269 #define SSL_aFZA 0x00000400L 00270 #define SSL_aNULL 0x00000800L /* no Authenticate, ADH */ 00271 #define SSL_aDH 0x00001000L /* no Authenticate, ADH */ 00272 #define SSL_aKRB5 0x00002000L /* Authenticate with KRB5 */ 00273 #define SSL_aECDSA 0x00004000L /* Authenticate with ECDSA */ 00274 00275 #define SSL_NULL (SSL_eNULL) 00276 #define SSL_ADH (SSL_kEDH|SSL_aNULL) 00277 #define SSL_RSA (SSL_kRSA|SSL_aRSA) 00278 #define SSL_DH (SSL_kDHr|SSL_kDHd|SSL_kEDH) 00279 #define SSL_ECDH (SSL_kECDH|SSL_kECDHE) 00280 #define SSL_FZA (SSL_aFZA|SSL_kFZA|SSL_eFZA) 00281 #define SSL_KRB5 (SSL_kKRB5|SSL_aKRB5) 00282 00283 #define SSL_ENC_MASK 0x1C3F8000L 00284 #define SSL_DES 0x00008000L 00285 #define SSL_3DES 0x00010000L 00286 #define SSL_RC4 0x00020000L 00287 #define SSL_RC2 0x00040000L 00288 #define SSL_IDEA 0x00080000L 00289 #define SSL_eFZA 0x00100000L 00290 #define SSL_eNULL 0x00200000L 00291 #define SSL_AES 0x04000000L 00292 #define SSL_CAMELLIA 0x08000000L 00293 #define SSL_SEED 0x10000000L 00294 00295 #define SSL_MAC_MASK 0x00c00000L 00296 #define SSL_MD5 0x00400000L 00297 #define SSL_SHA1 0x00800000L 00298 #define SSL_SHA (SSL_SHA1) 00299 00300 #define SSL_SSL_MASK 0x03000000L 00301 #define SSL_SSLV2 0x01000000L 00302 #define SSL_SSLV3 0x02000000L 00303 #define SSL_TLSV1 SSL_SSLV3 /* for now */ 00304 00305 /* we have used 1fffffff - 3 bits left to go. */ 00306 00307 /* 00308 * Export and cipher strength information. For each cipher we have to decide 00309 * whether it is exportable or not. This information is likely to change 00310 * over time, since the export control rules are no static technical issue. 00311 * 00312 * Independent of the export flag the cipher strength is sorted into classes. 00313 * SSL_EXP40 was denoting the 40bit US export limit of past times, which now 00314 * is at 56bit (SSL_EXP56). If the exportable cipher class is going to change 00315 * again (eg. to 64bit) the use of "SSL_EXP*" becomes blurred even more, 00316 * since SSL_EXP64 could be similar to SSL_LOW. 00317 * For this reason SSL_MICRO and SSL_MINI macros are included to widen the 00318 * namespace of SSL_LOW-SSL_HIGH to lower values. As development of speed 00319 * and ciphers goes, another extension to SSL_SUPER and/or SSL_ULTRA would 00320 * be possible. 00321 */ 00322 #define SSL_EXP_MASK 0x00000003L 00323 #define SSL_NOT_EXP 0x00000001L 00324 #define SSL_EXPORT 0x00000002L 00325 00326 #define SSL_STRONG_MASK 0x000000fcL 00327 #define SSL_STRONG_NONE 0x00000004L 00328 #define SSL_EXP40 0x00000008L 00329 #define SSL_MICRO (SSL_EXP40) 00330 #define SSL_EXP56 0x00000010L 00331 #define SSL_MINI (SSL_EXP56) 00332 #define SSL_LOW 0x00000020L 00333 #define SSL_MEDIUM 0x00000040L 00334 #define SSL_HIGH 0x00000080L 00335 #define SSL_FIPS 0x00000100L 00336 00337 /* we have used 000001ff - 23 bits left to go */ 00338 00339 /* 00340 * Macros to check the export status and cipher strength for export ciphers. 00341 * Even though the macros for EXPORT and EXPORT40/56 have similar names, 00342 * their meaning is different: 00343 * *_EXPORT macros check the 'exportable' status. 00344 * *_EXPORT40/56 macros are used to check whether a certain cipher strength 00345 * is given. 00346 * Since the SSL_IS_EXPORT* and SSL_EXPORT* macros depend on the correct 00347 * algorithm structure element to be passed (algorithms, algo_strength) and no 00348 * typechecking can be done as they are all of type unsigned long, their 00349 * direct usage is discouraged. 00350 * Use the SSL_C_* macros instead. 00351 */ 00352 #define SSL_IS_EXPORT(a) ((a)&SSL_EXPORT) 00353 #define SSL_IS_EXPORT56(a) ((a)&SSL_EXP56) 00354 #define SSL_IS_EXPORT40(a) ((a)&SSL_EXP40) 00355 #define SSL_C_IS_EXPORT(c) SSL_IS_EXPORT((c)->algo_strength) 00356 #define SSL_C_IS_EXPORT56(c) SSL_IS_EXPORT56((c)->algo_strength) 00357 #define SSL_C_IS_EXPORT40(c) SSL_IS_EXPORT40((c)->algo_strength) 00358 00359 #define SSL_EXPORT_KEYLENGTH(a,s) (SSL_IS_EXPORT40(s) ? 5 : \ 00360 ((a)&SSL_ENC_MASK) == SSL_DES ? 8 : 7) 00361 #define SSL_EXPORT_PKEYLENGTH(a) (SSL_IS_EXPORT40(a) ? 512 : 1024) 00362 #define SSL_C_EXPORT_KEYLENGTH(c) SSL_EXPORT_KEYLENGTH((c)->algorithms, \ 00363 (c)->algo_strength) 00364 #define SSL_C_EXPORT_PKEYLENGTH(c) SSL_EXPORT_PKEYLENGTH((c)->algo_strength) 00365 00366 00367 #define SSL_ALL 0xffffffffL 00368 #define SSL_ALL_CIPHERS (SSL_MKEY_MASK|SSL_AUTH_MASK|SSL_ENC_MASK|\ 00369 SSL_MAC_MASK) 00370 #define SSL_ALL_STRENGTHS (SSL_EXP_MASK|SSL_STRONG_MASK) 00371 00372 /* Mostly for SSLv3 */ 00373 #define SSL_PKEY_RSA_ENC 0 00374 #define SSL_PKEY_RSA_SIGN 1 00375 #define SSL_PKEY_DSA_SIGN 2 00376 #define SSL_PKEY_DH_RSA 3 00377 #define SSL_PKEY_DH_DSA 4 00378 #define SSL_PKEY_ECC 5 00379 #define SSL_PKEY_NUM 6 00380 00381 /* SSL_kRSA <- RSA_ENC | (RSA_TMP & RSA_SIGN) | 00382 * <- (EXPORT & (RSA_ENC | RSA_TMP) & RSA_SIGN) 00383 * SSL_kDH <- DH_ENC & (RSA_ENC | RSA_SIGN | DSA_SIGN) 00384 * SSL_kEDH <- RSA_ENC | RSA_SIGN | DSA_SIGN 00385 * SSL_aRSA <- RSA_ENC | RSA_SIGN 00386 * SSL_aDSS <- DSA_SIGN 00387 */ 00388 00389 /* 00390 #define CERT_INVALID 0 00391 #define CERT_PUBLIC_KEY 1 00392 #define CERT_PRIVATE_KEY 2 00393 */ 00394 00395 #ifndef OPENSSL_NO_EC 00396 /* From ECC-TLS draft, used in encoding the curve type in 00397 * ECParameters 00398 */ 00399 #define EXPLICIT_PRIME_CURVE_TYPE 1 00400 #define EXPLICIT_CHAR2_CURVE_TYPE 2 00401 #define NAMED_CURVE_TYPE 3 00402 #endif /* OPENSSL_NO_EC */ 00403 00404 typedef struct cert_pkey_st 00405 { 00406 X509 *x509; 00407 EVP_PKEY *privatekey; 00408 } CERT_PKEY; 00409 00410 typedef struct cert_st 00411 { 00412 /* Current active set */ 00413 CERT_PKEY *key; /* ALWAYS points to an element of the pkeys array 00414 * Probably it would make more sense to store 00415 * an index, not a pointer. */ 00416 00417 /* The following masks are for the key and auth 00418 * algorithms that are supported by the certs below */ 00419 int valid; 00420 unsigned long mask; 00421 unsigned long export_mask; 00422 #ifndef OPENSSL_NO_RSA 00423 RSA *rsa_tmp; 00424 RSA *(*rsa_tmp_cb)(SSL *ssl,int is_export,int keysize); 00425 #endif 00426 #ifndef OPENSSL_NO_DH 00427 DH *dh_tmp; 00428 DH *(*dh_tmp_cb)(SSL *ssl,int is_export,int keysize); 00429 #endif 00430 #ifndef OPENSSL_NO_ECDH 00431 EC_KEY *ecdh_tmp; 00432 /* Callback for generating ephemeral ECDH keys */ 00433 EC_KEY *(*ecdh_tmp_cb)(SSL *ssl,int is_export,int keysize); 00434 #endif 00435 00436 CERT_PKEY pkeys[SSL_PKEY_NUM]; 00437 00438 int references; /* >1 only if SSL_copy_session_id is used */ 00439 } CERT; 00440 00441 00442 typedef struct sess_cert_st 00443 { 00444 STACK_OF(X509) *cert_chain; /* as received from peer (not for SSL2) */ 00445 00446 /* The 'peer_...' members are used only by clients. */ 00447 int peer_cert_type; 00448 00449 CERT_PKEY *peer_key; /* points to an element of peer_pkeys (never NULL!) */ 00450 CERT_PKEY peer_pkeys[SSL_PKEY_NUM]; 00451 /* Obviously we don't have the private keys of these, 00452 * so maybe we shouldn't even use the CERT_PKEY type here. */ 00453 00454 #ifndef OPENSSL_NO_RSA 00455 RSA *peer_rsa_tmp; /* not used for SSL 2 */ 00456 #endif 00457 #ifndef OPENSSL_NO_DH 00458 DH *peer_dh_tmp; /* not used for SSL 2 */ 00459 #endif 00460 #ifndef OPENSSL_NO_ECDH 00461 EC_KEY *peer_ecdh_tmp; 00462 #endif 00463 00464 int references; /* actually always 1 at the moment */ 00465 } SESS_CERT; 00466 00467 00468 /*#define MAC_DEBUG */ 00469 00470 /*#define ERR_DEBUG */ 00471 /*#define ABORT_DEBUG */ 00472 /*#define PKT_DEBUG 1 */ 00473 /*#define DES_DEBUG */ 00474 /*#define DES_OFB_DEBUG */ 00475 /*#define SSL_DEBUG */ 00476 /*#define RSA_DEBUG */ 00477 /*#define IDEA_DEBUG */ 00478 00479 #define FP_ICC (int (*)(const void *,const void *)) 00480 #define ssl_put_cipher_by_char(ssl,ciph,ptr) \ 00481 ((ssl)->method->put_cipher_by_char((ciph),(ptr))) 00482 #define ssl_get_cipher_by_char(ssl,ptr) \ 00483 ((ssl)->method->get_cipher_by_char(ptr)) 00484 00485 /* This is for the SSLv3/TLSv1.0 differences in crypto/hash stuff 00486 * It is a bit of a mess of functions, but hell, think of it as 00487 * an opaque structure :-) */ 00488 typedef struct ssl3_enc_method 00489 { 00490 int (*enc)(SSL *, int); 00491 int (*mac)(SSL *, unsigned char *, int); 00492 int (*setup_key_block)(SSL *); 00493 int (*generate_master_secret)(SSL *, unsigned char *, unsigned char *, int); 00494 int (*change_cipher_state)(SSL *, int); 00495 int (*final_finish_mac)(SSL *, EVP_MD_CTX *, EVP_MD_CTX *, const char *, int, unsigned char *); 00496 int finish_mac_length; 00497 int (*cert_verify_mac)(SSL *, EVP_MD_CTX *, unsigned char *); 00498 const char *client_finished_label; 00499 int client_finished_label_len; 00500 const char *server_finished_label; 00501 int server_finished_label_len; 00502 int (*alert_value)(int); 00503 } SSL3_ENC_METHOD; 00504 00505 #ifndef OPENSSL_NO_COMP 00506 /* Used for holding the relevant compression methods loaded into SSL_CTX */ 00507 typedef struct ssl3_comp_st 00508 { 00509 int comp_id; /* The identifier byte for this compression type */ 00510 char *name; /* Text name used for the compression type */ 00511 COMP_METHOD *method; /* The method :-) */ 00512 } SSL3_COMP; 00513 #endif 00514 00515 extern SSL3_ENC_METHOD ssl3_undef_enc_method; 00516 OPENSSL_EXTERN SSL_CIPHER ssl2_ciphers[]; 00517 OPENSSL_EXTERN SSL_CIPHER ssl3_ciphers[]; 00518 00519 00520 SSL_METHOD *ssl_bad_method(int ver); 00521 SSL_METHOD *sslv2_base_method(void); 00522 SSL_METHOD *sslv23_base_method(void); 00523 SSL_METHOD *sslv3_base_method(void); 00524 00525 extern SSL3_ENC_METHOD TLSv1_enc_data; 00526 extern SSL3_ENC_METHOD SSLv3_enc_data; 00527 extern SSL3_ENC_METHOD DTLSv1_enc_data; 00528 00529 #define IMPLEMENT_tls1_meth_func(func_name, s_accept, s_connect, s_get_meth) \ 00530 SSL_METHOD *func_name(void) \ 00531 { \ 00532 static SSL_METHOD func_name##_data= { \ 00533 TLS1_VERSION, \ 00534 tls1_new, \ 00535 tls1_clear, \ 00536 tls1_free, \ 00537 s_accept, \ 00538 s_connect, \ 00539 ssl3_read, \ 00540 ssl3_peek, \ 00541 ssl3_write, \ 00542 ssl3_shutdown, \ 00543 ssl3_renegotiate, \ 00544 ssl3_renegotiate_check, \ 00545 ssl3_get_message, \ 00546 ssl3_read_bytes, \ 00547 ssl3_write_bytes, \ 00548 ssl3_dispatch_alert, \ 00549 ssl3_ctrl, \ 00550 ssl3_ctx_ctrl, \ 00551 ssl3_get_cipher_by_char, \ 00552 ssl3_put_cipher_by_char, \ 00553 ssl3_pending, \ 00554 ssl3_num_ciphers, \ 00555 ssl3_get_cipher, \ 00556 s_get_meth, \ 00557 tls1_default_timeout, \ 00558 &TLSv1_enc_data, \ 00559 ssl_undefined_void_function, \ 00560 ssl3_callback_ctrl, \ 00561 ssl3_ctx_callback_ctrl, \ 00562 }; \ 00563 return &func_name##_data; \ 00564 } 00565 00566 #define IMPLEMENT_ssl3_meth_func(func_name, s_accept, s_connect, s_get_meth) \ 00567 SSL_METHOD *func_name(void) \ 00568 { \ 00569 static SSL_METHOD func_name##_data= { \ 00570 SSL3_VERSION, \ 00571 ssl3_new, \ 00572 ssl3_clear, \ 00573 ssl3_free, \ 00574 s_accept, \ 00575 s_connect, \ 00576 ssl3_read, \ 00577 ssl3_peek, \ 00578 ssl3_write, \ 00579 ssl3_shutdown, \ 00580 ssl3_renegotiate, \ 00581 ssl3_renegotiate_check, \ 00582 ssl3_get_message, \ 00583 ssl3_read_bytes, \ 00584 ssl3_write_bytes, \ 00585 ssl3_dispatch_alert, \ 00586 ssl3_ctrl, \ 00587 ssl3_ctx_ctrl, \ 00588 ssl3_get_cipher_by_char, \ 00589 ssl3_put_cipher_by_char, \ 00590 ssl3_pending, \ 00591 ssl3_num_ciphers, \ 00592 ssl3_get_cipher, \ 00593 s_get_meth, \ 00594 ssl3_default_timeout, \ 00595 &SSLv3_enc_data, \ 00596 ssl_undefined_void_function, \ 00597 ssl3_callback_ctrl, \ 00598 ssl3_ctx_callback_ctrl, \ 00599 }; \ 00600 return &func_name##_data; \ 00601 } 00602 00603 #define IMPLEMENT_ssl23_meth_func(func_name, s_accept, s_connect, s_get_meth) \ 00604 SSL_METHOD *func_name(void) \ 00605 { \ 00606 static SSL_METHOD func_name##_data= { \ 00607 TLS1_VERSION, \ 00608 tls1_new, \ 00609 tls1_clear, \ 00610 tls1_free, \ 00611 s_accept, \ 00612 s_connect, \ 00613 ssl23_read, \ 00614 ssl23_peek, \ 00615 ssl23_write, \ 00616 ssl_undefined_function, \ 00617 ssl_undefined_function, \ 00618 ssl_ok, \ 00619 ssl3_get_message, \ 00620 ssl3_read_bytes, \ 00621 ssl3_write_bytes, \ 00622 ssl3_dispatch_alert, \ 00623 ssl3_ctrl, \ 00624 ssl3_ctx_ctrl, \ 00625 ssl23_get_cipher_by_char, \ 00626 ssl23_put_cipher_by_char, \ 00627 ssl_undefined_const_function, \ 00628 ssl23_num_ciphers, \ 00629 ssl23_get_cipher, \ 00630 s_get_meth, \ 00631 ssl23_default_timeout, \ 00632 &ssl3_undef_enc_method, \ 00633 ssl_undefined_void_function, \ 00634 ssl3_callback_ctrl, \ 00635 ssl3_ctx_callback_ctrl, \ 00636 }; \ 00637 return &func_name##_data; \ 00638 } 00639 00640 #define IMPLEMENT_ssl2_meth_func(func_name, s_accept, s_connect, s_get_meth) \ 00641 SSL_METHOD *func_name(void) \ 00642 { \ 00643 static SSL_METHOD func_name##_data= { \ 00644 SSL2_VERSION, \ 00645 ssl2_new, /* local */ \ 00646 ssl2_clear, /* local */ \ 00647 ssl2_free, /* local */ \ 00648 s_accept, \ 00649 s_connect, \ 00650 ssl2_read, \ 00651 ssl2_peek, \ 00652 ssl2_write, \ 00653 ssl2_shutdown, \ 00654 ssl_ok, /* NULL - renegotiate */ \ 00655 ssl_ok, /* NULL - check renegotiate */ \ 00656 NULL, /* NULL - ssl_get_message */ \ 00657 NULL, /* NULL - ssl_get_record */ \ 00658 NULL, /* NULL - ssl_write_bytes */ \ 00659 NULL, /* NULL - dispatch_alert */ \ 00660 ssl2_ctrl, /* local */ \ 00661 ssl2_ctx_ctrl, /* local */ \ 00662 ssl2_get_cipher_by_char, \ 00663 ssl2_put_cipher_by_char, \ 00664 ssl2_pending, \ 00665 ssl2_num_ciphers, \ 00666 ssl2_get_cipher, \ 00667 s_get_meth, \ 00668 ssl2_default_timeout, \ 00669 &ssl3_undef_enc_method, \ 00670 ssl_undefined_void_function, \ 00671 ssl2_callback_ctrl, /* local */ \ 00672 ssl2_ctx_callback_ctrl, /* local */ \ 00673 }; \ 00674 return &func_name##_data; \ 00675 } 00676 00677 #define IMPLEMENT_dtls1_meth_func(func_name, s_accept, s_connect, s_get_meth) \ 00678 SSL_METHOD *func_name(void) \ 00679 { \ 00680 static SSL_METHOD func_name##_data= { \ 00681 DTLS1_VERSION, \ 00682 dtls1_new, \ 00683 dtls1_clear, \ 00684 dtls1_free, \ 00685 s_accept, \ 00686 s_connect, \ 00687 ssl3_read, \ 00688 ssl3_peek, \ 00689 ssl3_write, \ 00690 ssl3_shutdown, \ 00691 ssl3_renegotiate, \ 00692 ssl3_renegotiate_check, \ 00693 dtls1_get_message, \ 00694 dtls1_read_bytes, \ 00695 dtls1_write_app_data_bytes, \ 00696 dtls1_dispatch_alert, \ 00697 dtls1_ctrl, \ 00698 ssl3_ctx_ctrl, \ 00699 ssl3_get_cipher_by_char, \ 00700 ssl3_put_cipher_by_char, \ 00701 ssl3_pending, \ 00702 ssl3_num_ciphers, \ 00703 dtls1_get_cipher, \ 00704 s_get_meth, \ 00705 dtls1_default_timeout, \ 00706 &DTLSv1_enc_data, \ 00707 ssl_undefined_void_function, \ 00708 ssl3_callback_ctrl, \ 00709 ssl3_ctx_callback_ctrl, \ 00710 }; \ 00711 return &func_name##_data; \ 00712 } 00713 00714 void ssl_clear_cipher_ctx(SSL *s); 00715 int ssl_clear_bad_session(SSL *s); 00716 CERT *ssl_cert_new(void); 00717 CERT *ssl_cert_dup(CERT *cert); 00718 int ssl_cert_inst(CERT **o); 00719 void ssl_cert_free(CERT *c); 00720 SESS_CERT *ssl_sess_cert_new(void); 00721 void ssl_sess_cert_free(SESS_CERT *sc); 00722 int ssl_set_peer_cert_type(SESS_CERT *c, int type); 00723 int ssl_get_new_session(SSL *s, int session); 00724 int ssl_get_prev_session(SSL *s, unsigned char *session,int len, const unsigned char *limit); 00725 int ssl_cipher_id_cmp(const SSL_CIPHER *a,const SSL_CIPHER *b); 00726 int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap, 00727 const SSL_CIPHER * const *bp); 00728 STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num, 00729 STACK_OF(SSL_CIPHER) **skp); 00730 int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p, 00731 int (*put_cb)(const SSL_CIPHER *, unsigned char *)); 00732 STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *meth, 00733 STACK_OF(SSL_CIPHER) **pref, 00734 STACK_OF(SSL_CIPHER) **sorted, 00735 const char *rule_str); 00736 void ssl_update_cache(SSL *s, int mode); 00737 int ssl_cipher_get_evp(const SSL_SESSION *s,const EVP_CIPHER **enc, 00738 const EVP_MD **md,SSL_COMP **comp); 00739 int ssl_verify_cert_chain(SSL *s,STACK_OF(X509) *sk); 00740 int ssl_undefined_function(SSL *s); 00741 int ssl_undefined_void_function(void); 00742 int ssl_undefined_const_function(const SSL *s); 00743 X509 *ssl_get_server_send_cert(SSL *); 00744 EVP_PKEY *ssl_get_sign_pkey(SSL *,SSL_CIPHER *); 00745 int ssl_cert_type(X509 *x,EVP_PKEY *pkey); 00746 void ssl_set_cert_masks(CERT *c, SSL_CIPHER *cipher); 00747 STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s); 00748 int ssl_verify_alarm_type(long type); 00749 void ssl_load_ciphers(void); 00750 00751 int ssl2_enc_init(SSL *s, int client); 00752 int ssl2_generate_key_material(SSL *s); 00753 void ssl2_enc(SSL *s,int send_data); 00754 void ssl2_mac(SSL *s,unsigned char *mac,int send_data); 00755 SSL_CIPHER *ssl2_get_cipher_by_char(const unsigned char *p); 00756 int ssl2_put_cipher_by_char(const SSL_CIPHER *c,unsigned char *p); 00757 int ssl2_part_read(SSL *s, unsigned long f, int i); 00758 int ssl2_do_write(SSL *s); 00759 int ssl2_set_certificate(SSL *s, int type, int len, const unsigned char *data); 00760 void ssl2_return_error(SSL *s,int reason); 00761 void ssl2_write_error(SSL *s); 00762 int ssl2_num_ciphers(void); 00763 SSL_CIPHER *ssl2_get_cipher(unsigned int u); 00764 int ssl2_new(SSL *s); 00765 void ssl2_free(SSL *s); 00766 int ssl2_accept(SSL *s); 00767 int ssl2_connect(SSL *s); 00768 int ssl2_read(SSL *s, void *buf, int len); 00769 int ssl2_peek(SSL *s, void *buf, int len); 00770 int ssl2_write(SSL *s, const void *buf, int len); 00771 int ssl2_shutdown(SSL *s); 00772 void ssl2_clear(SSL *s); 00773 long ssl2_ctrl(SSL *s,int cmd, long larg, void *parg); 00774 long ssl2_ctx_ctrl(SSL_CTX *s,int cmd, long larg, void *parg); 00775 long ssl2_callback_ctrl(SSL *s,int cmd, void (*fp)(void)); 00776 long ssl2_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)(void)); 00777 int ssl2_pending(const SSL *s); 00778 long ssl2_default_timeout(void ); 00779 00780 SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p); 00781 int ssl3_put_cipher_by_char(const SSL_CIPHER *c,unsigned char *p); 00782 void ssl3_init_finished_mac(SSL *s); 00783 int ssl3_send_server_certificate(SSL *s); 00784 int ssl3_send_newsession_ticket(SSL *s); 00785 int ssl3_send_cert_status(SSL *s); 00786 int ssl3_get_finished(SSL *s,int state_a,int state_b); 00787 int ssl3_setup_key_block(SSL *s); 00788 int ssl3_send_change_cipher_spec(SSL *s,int state_a,int state_b); 00789 int ssl3_change_cipher_state(SSL *s,int which); 00790 void ssl3_cleanup_key_block(SSL *s); 00791 int ssl3_do_write(SSL *s,int type); 00792 int ssl3_send_alert(SSL *s,int level, int desc); 00793 int ssl3_generate_master_secret(SSL *s, unsigned char *out, 00794 unsigned char *p, int len); 00795 int ssl3_get_req_cert_type(SSL *s,unsigned char *p); 00796 long ssl3_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok); 00797 int ssl3_send_finished(SSL *s, int a, int b, const char *sender,int slen); 00798 int ssl3_num_ciphers(void); 00799 SSL_CIPHER *ssl3_get_cipher(unsigned int u); 00800 int ssl3_renegotiate(SSL *ssl); 00801 int ssl3_renegotiate_check(SSL *ssl); 00802 int ssl3_dispatch_alert(SSL *s); 00803 int ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek); 00804 int ssl3_write_bytes(SSL *s, int type, const void *buf, int len); 00805 int ssl3_final_finish_mac(SSL *s, EVP_MD_CTX *ctx1, EVP_MD_CTX *ctx2, 00806 const char *sender, int slen,unsigned char *p); 00807 int ssl3_cert_verify_mac(SSL *s, EVP_MD_CTX *in, unsigned char *p); 00808 void ssl3_finish_mac(SSL *s, const unsigned char *buf, int len); 00809 int ssl3_enc(SSL *s, int send_data); 00810 int ssl3_mac(SSL *ssl, unsigned char *md, int send_data); 00811 unsigned long ssl3_output_cert_chain(SSL *s, X509 *x); 00812 SSL_CIPHER *ssl3_choose_cipher(SSL *ssl,STACK_OF(SSL_CIPHER) *clnt, 00813 STACK_OF(SSL_CIPHER) *srvr); 00814 int ssl3_setup_buffers(SSL *s); 00815 int ssl3_new(SSL *s); 00816 void ssl3_free(SSL *s); 00817 int ssl3_accept(SSL *s); 00818 int ssl3_connect(SSL *s); 00819 int ssl3_read(SSL *s, void *buf, int len); 00820 int ssl3_peek(SSL *s, void *buf, int len); 00821 int ssl3_write(SSL *s, const void *buf, int len); 00822 int ssl3_shutdown(SSL *s); 00823 void ssl3_clear(SSL *s); 00824 long ssl3_ctrl(SSL *s,int cmd, long larg, void *parg); 00825 long ssl3_ctx_ctrl(SSL_CTX *s,int cmd, long larg, void *parg); 00826 long ssl3_callback_ctrl(SSL *s,int cmd, void (*fp)(void)); 00827 long ssl3_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)(void)); 00828 int ssl3_pending(const SSL *s); 00829 00830 void ssl3_record_sequence_update(unsigned char *seq); 00831 int ssl3_do_change_cipher_spec(SSL *ssl); 00832 long ssl3_default_timeout(void ); 00833 00834 int ssl23_num_ciphers(void ); 00835 SSL_CIPHER *ssl23_get_cipher(unsigned int u); 00836 int ssl23_read(SSL *s, void *buf, int len); 00837 int ssl23_peek(SSL *s, void *buf, int len); 00838 int ssl23_write(SSL *s, const void *buf, int len); 00839 int ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p); 00840 SSL_CIPHER *ssl23_get_cipher_by_char(const unsigned char *p); 00841 long ssl23_default_timeout(void ); 00842 00843 long tls1_default_timeout(void); 00844 int dtls1_do_write(SSL *s,int type); 00845 int ssl3_read_n(SSL *s, int n, int max, int extend); 00846 int dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek); 00847 int ssl3_do_compress(SSL *ssl); 00848 int ssl3_do_uncompress(SSL *ssl); 00849 int ssl3_write_pending(SSL *s, int type, const unsigned char *buf, 00850 unsigned int len); 00851 unsigned char *dtls1_set_message_header(SSL *s, 00852 unsigned char *p, unsigned char mt, unsigned long len, 00853 unsigned long frag_off, unsigned long frag_len); 00854 00855 int dtls1_write_app_data_bytes(SSL *s, int type, const void *buf, int len); 00856 int dtls1_write_bytes(SSL *s, int type, const void *buf, int len); 00857 00858 int dtls1_send_change_cipher_spec(SSL *s, int a, int b); 00859 int dtls1_send_finished(SSL *s, int a, int b, const char *sender, int slen); 00860 unsigned long dtls1_output_cert_chain(SSL *s, X509 *x); 00861 int dtls1_read_failed(SSL *s, int code); 00862 int dtls1_buffer_message(SSL *s, int ccs); 00863 int dtls1_retransmit_message(SSL *s, unsigned short seq, 00864 unsigned long frag_off, int *found); 00865 int dtls1_get_queue_priority(unsigned short seq, int is_ccs); 00866 int dtls1_retransmit_buffered_messages(SSL *s); 00867 void dtls1_clear_record_buffer(SSL *s); 00868 void dtls1_get_message_header(unsigned char *data, struct hm_header_st *msg_hdr); 00869 void dtls1_get_ccs_header(unsigned char *data, struct ccs_header_st *ccs_hdr); 00870 void dtls1_reset_seq_numbers(SSL *s, int rw); 00871 long dtls1_default_timeout(void); 00872 struct timeval* dtls1_get_timeout(SSL *s, struct timeval* timeleft); 00873 int dtls1_handle_timeout(SSL *s); 00874 SSL_CIPHER *dtls1_get_cipher(unsigned int u); 00875 void dtls1_start_timer(SSL *s); 00876 void dtls1_stop_timer(SSL *s); 00877 int dtls1_is_timer_expired(SSL *s); 00878 void dtls1_double_timeout(SSL *s); 00879 int dtls1_send_newsession_ticket(SSL *s); 00880 00881 00882 /* some client-only functions */ 00883 int ssl3_client_hello(SSL *s); 00884 int ssl3_get_server_hello(SSL *s); 00885 int ssl3_get_certificate_request(SSL *s); 00886 int ssl3_get_new_session_ticket(SSL *s); 00887 int ssl3_get_cert_status(SSL *s); 00888 int ssl3_get_server_done(SSL *s); 00889 int ssl3_send_client_verify(SSL *s); 00890 int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey); 00891 int ssl3_send_client_certificate(SSL *s); 00892 int ssl3_send_client_key_exchange(SSL *s); 00893 int ssl3_get_key_exchange(SSL *s); 00894 int ssl3_get_server_certificate(SSL *s); 00895 int ssl3_check_cert_and_algorithm(SSL *s); 00896 #ifndef OPENSSL_NO_TLSEXT 00897 int ssl3_check_finished(SSL *s); 00898 #endif 00899 00900 int dtls1_client_hello(SSL *s); 00901 int dtls1_send_client_certificate(SSL *s); 00902 int dtls1_send_client_key_exchange(SSL *s); 00903 int dtls1_send_client_verify(SSL *s); 00904 00905 /* some server-only functions */ 00906 int ssl3_get_client_hello(SSL *s); 00907 int ssl3_send_server_hello(SSL *s); 00908 int ssl3_send_hello_request(SSL *s); 00909 int ssl3_send_server_key_exchange(SSL *s); 00910 int ssl3_send_certificate_request(SSL *s); 00911 int ssl3_send_server_done(SSL *s); 00912 int ssl3_check_client_hello(SSL *s); 00913 int ssl3_get_client_certificate(SSL *s); 00914 int ssl3_get_client_key_exchange(SSL *s); 00915 int ssl3_get_cert_verify(SSL *s); 00916 00917 int dtls1_send_hello_request(SSL *s); 00918 int dtls1_send_server_hello(SSL *s); 00919 int dtls1_send_server_certificate(SSL *s); 00920 int dtls1_send_server_key_exchange(SSL *s); 00921 int dtls1_send_certificate_request(SSL *s); 00922 int dtls1_send_server_done(SSL *s); 00923 00924 00925 00926 int ssl23_accept(SSL *s); 00927 int ssl23_connect(SSL *s); 00928 int ssl23_read_bytes(SSL *s, int n); 00929 int ssl23_write_bytes(SSL *s); 00930 00931 int tls1_new(SSL *s); 00932 void tls1_free(SSL *s); 00933 void tls1_clear(SSL *s); 00934 long tls1_ctrl(SSL *s,int cmd, long larg, void *parg); 00935 long tls1_callback_ctrl(SSL *s,int cmd, void (*fp)(void)); 00936 SSL_METHOD *tlsv1_base_method(void ); 00937 00938 int dtls1_new(SSL *s); 00939 int dtls1_accept(SSL *s); 00940 int dtls1_connect(SSL *s); 00941 void dtls1_free(SSL *s); 00942 void dtls1_clear(SSL *s); 00943 long dtls1_ctrl(SSL *s,int cmd, long larg, void *parg); 00944 SSL_METHOD *dtlsv1_base_method(void ); 00945 00946 long dtls1_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok); 00947 int dtls1_get_record(SSL *s); 00948 int do_dtls1_write(SSL *s, int type, const unsigned char *buf, 00949 unsigned int len, int create_empty_fragement); 00950 int dtls1_dispatch_alert(SSL *s); 00951 int dtls1_enc(SSL *s, int snd); 00952 00953 int ssl_init_wbio_buffer(SSL *s, int push); 00954 void ssl_free_wbio_buffer(SSL *s); 00955 00956 int tls1_change_cipher_state(SSL *s, int which); 00957 int tls1_setup_key_block(SSL *s); 00958 int tls1_enc(SSL *s, int snd); 00959 int tls1_final_finish_mac(SSL *s, EVP_MD_CTX *in1_ctx, EVP_MD_CTX *in2_ctx, 00960 const char *str, int slen, unsigned char *p); 00961 int tls1_cert_verify_mac(SSL *s, EVP_MD_CTX *in, unsigned char *p); 00962 int tls1_mac(SSL *ssl, unsigned char *md, int snd); 00963 int tls1_generate_master_secret(SSL *s, unsigned char *out, 00964 unsigned char *p, int len); 00965 int tls1_alert_code(int code); 00966 int ssl3_alert_code(int code); 00967 int ssl_ok(SSL *s); 00968 00969 int check_srvr_ecc_cert_and_alg(X509 *x, SSL_CIPHER *cs); 00970 00971 SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n); 00972 00973 #ifndef OPENSSL_NO_TLSEXT 00974 unsigned char *ssl_add_clienthello_tlsext(SSL *s, unsigned char *p, unsigned char *limit); 00975 unsigned char *ssl_add_serverhello_tlsext(SSL *s, unsigned char *p, unsigned char *limit); 00976 int ssl_parse_clienthello_tlsext(SSL *s, unsigned char **data, unsigned char *d, int n, int *al); 00977 int ssl_parse_serverhello_tlsext(SSL *s, unsigned char **data, unsigned char *d, int n, int *al); 00978 int ssl_prepare_clienthello_tlsext(SSL *s); 00979 int ssl_prepare_serverhello_tlsext(SSL *s); 00980 int ssl_check_clienthello_tlsext(SSL *s); 00981 int ssl_check_serverhello_tlsext(SSL *s); 00982 00983 #ifdef OPENSSL_NO_SHA256 00984 #define tlsext_tick_md EVP_sha1 00985 #else 00986 #define tlsext_tick_md EVP_sha256 00987 #endif 00988 int tls1_process_ticket(SSL *s, unsigned char *session_id, int len, 00989 const unsigned char *limit, SSL_SESSION **ret); 00990 EVP_MD_CTX* ssl_replace_hash(EVP_MD_CTX **hash,const EVP_MD *md) ; 00991 void ssl_clear_hash_ctx(EVP_MD_CTX **hash); 00992 00993 int ssl_add_serverhello_renegotiate_ext(SSL *s, unsigned char *p, int *len, 00994 int maxlen); 00995 int ssl_parse_serverhello_renegotiate_ext(SSL *s, unsigned char *d, int len, 00996 int *al); 00997 int ssl_add_clienthello_renegotiate_ext(SSL *s, unsigned char *p, int *len, 00998 int maxlen); 00999 int ssl_parse_clienthello_renegotiate_ext(SSL *s, unsigned char *d, int len, 01000 int *al); 01001 #endif 01002 01003 #endif