ssl_locl.h 81.5 KB
Newer Older
1
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2 3 4 5 6
 * 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.
7
 *
8 9 10 11 12 13
 * 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).
14
 *
15 16 17 18 19 20
 * 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.
21
 *
22 23 24 25 26 27 28 29 30 31 32 33 34 35
 * 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 :-).
36
 * 4. If you include any Windows specific code (or a derivative thereof) from
37 38
 *    the apps directory (application code) you must include an acknowledgement:
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39
 *
40 41 42 43 44 45 46 47 48 49 50
 * 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.
51
 *
52 53 54 55 56
 * 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.]
 */
B
Bodo Möller 已提交
57
/* ====================================================================
58
 * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.
B
Bodo Möller 已提交
59 60 61 62 63 64
 *
 * 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
65
 *    notice, this list of conditions and the following disclaimer.
B
Bodo Möller 已提交
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
 *
 * 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).
 *
 */
B
Bodo Möller 已提交
110 111
/* ====================================================================
 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
112
 * ECC cipher suite support in OpenSSL originally developed by
B
Bodo Möller 已提交
113 114
 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
 */
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
/* ====================================================================
 * 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.
 */
141 142

#ifndef HEADER_SSL_LOCL_H
143 144 145 146 147
# define HEADER_SSL_LOCL_H
# include <stdlib.h>
# include <time.h>
# include <string.h>
# include <errno.h>
148

149
# include "e_os.h"
150

151 152 153 154 155 156 157 158 159 160 161 162 163 164
# include <openssl/buffer.h>
# ifndef OPENSSL_NO_COMP
#  include <openssl/comp.h>
# endif
# include <openssl/bio.h>
# include <openssl/stack.h>
# ifndef OPENSSL_NO_RSA
#  include <openssl/rsa.h>
# endif
# ifndef OPENSSL_NO_DSA
#  include <openssl/dsa.h>
# endif
# include <openssl/err.h>
# include <openssl/ssl.h>
M
Matt Caswell 已提交
165
# include <openssl/async.h>
166
# include <openssl/symhacks.h>
167

M
Matt Caswell 已提交
168
#include "record/record.h"
M
Matt Caswell 已提交
169
#include "statem/statem.h"
M
Matt Caswell 已提交
170
#include "packet_locl.h"
171
#include "internal/dane.h"
172

173 174 175 176
# ifdef OPENSSL_BUILD_SHLIBSSL
#  undef OPENSSL_EXTERN
#  define OPENSSL_EXTERN OPENSSL_EXPORT
# endif
177

178
# undef PKCS1_CHECK
179

180 181 182 183
# define c2l(c,l)        (l = ((unsigned long)(*((c)++)))     , \
                         l|=(((unsigned long)(*((c)++)))<< 8), \
                         l|=(((unsigned long)(*((c)++)))<<16), \
                         l|=(((unsigned long)(*((c)++)))<<24))
184 185

/* NOTE - c is not incremented as per c2l */
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
# 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))

# 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))

# 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))

232
/* NOTE - c is not incremented as per l2c */
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
# 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); \
                                } \
                        }

# 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)

# define n2l3(c,l)       ((l =(((unsigned long)(c[0]))<<16)| \
                             (((unsigned long)(c[1]))<< 8)| \
                             (((unsigned long)(c[2]))    )),c+=3)

# 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)
259

260 261 262 263 264
#define DTLS_VERSION_GT(v1, v2) ((v1) < (v2))
#define DTLS_VERSION_GE(v1, v2) ((v1) <= (v2))
#define DTLS_VERSION_LT(v1, v2) ((v1) > (v2))
#define DTLS_VERSION_LE(v1, v2) ((v1) >= (v2))

265 266
/* LOCAL STUFF */

267 268
# define SSL_DECRYPT     0
# define SSL_ENCRYPT     1
269

270 271 272 273
# define TWO_BYTE_BIT    0x80
# define SEC_ESC_BIT     0x40
# define TWO_BYTE_MASK   0x7fff
# define THREE_BYTE_MASK 0x3fff
274

275 276 277
# define INC32(a)        ((a)=((a)+1)&0xffffffffL)
# define DEC32(a)        ((a)=((a)-1)&0xffffffffL)
# define MAX_MAC_SIZE    20     /* up from 16 for SSLv3 */
278

279 280 281 282 283 284 285 286
/*
 * 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.
 *
U
Ulf Möller 已提交
287
 * The bit mask handling in the selection and sorting scheme in
288
 * ssl_create_cipher_list() has only limited capabilities, reflecting
U
Ulf Möller 已提交
289
 * that the different entities within are mutually exclusive:
290 291
 * ONLY ONE BIT PER MASK CAN BE SET AT A TIME.
 */
292 293

/* Bits for algorithm_mkey (key exchange algorithm) */
294
/* RSA key exchange */
D
Dr. Stephen Henson 已提交
295
# define SSL_kRSA                0x00000001U
296
/* tmp DH key no DH cert */
D
Dr. Stephen Henson 已提交
297
# define SSL_kDHE                0x00000002U
298
/* synonym */
299
# define SSL_kEDH                SSL_kDHE
300
/* ECDH cert, RSA CA cert */
D
Dr. Stephen Henson 已提交
301
# define SSL_kECDHr              0x00000004U
302
/* ECDH cert, ECDSA CA cert */
D
Dr. Stephen Henson 已提交
303
# define SSL_kECDHe              0x00000008U
304
/* ephemeral ECDH */
D
Dr. Stephen Henson 已提交
305
# define SSL_kECDHE              0x00000010U
306
/* synonym */
307
# define SSL_kEECDH              SSL_kECDHE
308
/* PSK */
D
Dr. Stephen Henson 已提交
309
# define SSL_kPSK                0x00000020U
310
/* GOST key exchange */
D
Dr. Stephen Henson 已提交
311
# define SSL_kGOST               0x00000040U
312
/* SRP */
D
Dr. Stephen Henson 已提交
313
# define SSL_kSRP                0x00000080U
314

D
Dr. Stephen Henson 已提交
315 316 317
# define SSL_kRSAPSK             0x00000100U
# define SSL_kECDHEPSK           0x00000200U
# define SSL_kDHEPSK             0x00000400U
318 319 320 321 322

/* all PSK */

#define SSL_PSK     (SSL_kPSK | SSL_kRSAPSK | SSL_kECDHEPSK | SSL_kDHEPSK)

323
/* Bits for algorithm_auth (server authentication) */
324
/* RSA auth */
D
Dr. Stephen Henson 已提交
325
# define SSL_aRSA                0x00000001U
326
/* DSS auth */
D
Dr. Stephen Henson 已提交
327
# define SSL_aDSS                0x00000002U
328
/* no auth (i.e. use ADH or AECDH) */
D
Dr. Stephen Henson 已提交
329
# define SSL_aNULL               0x00000004U
330
/* Fixed ECDH auth (kECDHe or kECDHr) */
D
Dr. Stephen Henson 已提交
331
# define SSL_aECDH               0x00000008U
332
/* ECDSA auth*/
D
Dr. Stephen Henson 已提交
333
# define SSL_aECDSA              0x00000010U
334
/* PSK auth */
D
Dr. Stephen Henson 已提交
335
# define SSL_aPSK                0x00000020U
336
/* GOST R 34.10-2001 signature auth */
D
Dr. Stephen Henson 已提交
337
# define SSL_aGOST01             0x00000040U
338
/* SRP auth */
D
Dr. Stephen Henson 已提交
339
# define SSL_aSRP                0x00000080U
340
/* GOST R 34.10-2012 signature auth */
D
Dr. Stephen Henson 已提交
341
# define SSL_aGOST12             0x00000100U
342 343

/* Bits for algorithm_enc (symmetric encryption) */
D
Dr. Stephen Henson 已提交
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
# define SSL_DES                 0x00000001U
# define SSL_3DES                0x00000002U
# define SSL_RC4                 0x00000004U
# define SSL_RC2                 0x00000008U
# define SSL_IDEA                0x00000010U
# define SSL_eNULL               0x00000020U
# define SSL_AES128              0x00000040U
# define SSL_AES256              0x00000080U
# define SSL_CAMELLIA128         0x00000100U
# define SSL_CAMELLIA256         0x00000200U
# define SSL_eGOST2814789CNT     0x00000400U
# define SSL_SEED                0x00000800U
# define SSL_AES128GCM           0x00001000U
# define SSL_AES256GCM           0x00002000U
# define SSL_AES128CCM           0x00004000U
# define SSL_AES256CCM           0x00008000U
# define SSL_AES128CCM8          0x00010000U
# define SSL_AES256CCM8          0x00020000U
362
# define SSL_eGOST2814789CNT12   0x00040000U
A
Andy Polyakov 已提交
363
# define SSL_CHACHA20POLY1305    0x00080000U
364

D
Dr. Stephen Henson 已提交
365
# define SSL_AES                 (SSL_AES128|SSL_AES256|SSL_AES128GCM|SSL_AES256GCM|SSL_AES128CCM|SSL_AES256CCM|SSL_AES128CCM8|SSL_AES256CCM8)
366
# define SSL_CAMELLIA            (SSL_CAMELLIA128|SSL_CAMELLIA256)
367 368

/* Bits for algorithm_mac (symmetric authentication) */
369

D
Dr. Stephen Henson 已提交
370 371 372 373 374 375
# define SSL_MD5                 0x00000001U
# define SSL_SHA1                0x00000002U
# define SSL_GOST94      0x00000004U
# define SSL_GOST89MAC   0x00000008U
# define SSL_SHA256              0x00000010U
# define SSL_SHA384              0x00000020U
376
/* Not a real MAC, just an indication it is part of cipher */
D
Dr. Stephen Henson 已提交
377
# define SSL_AEAD                0x00000040U
378 379 380
# define SSL_GOST12_256          0x00000080U
# define SSL_GOST89MAC12         0x00000100U
# define SSL_GOST12_512          0x00000200U
381 382

/* Bits for algorithm_ssl (protocol version) */
D
Dr. Stephen Henson 已提交
383
# define SSL_SSLV3               0x00000002U
384 385
# define SSL_TLSV1               0x00000004U
# define SSL_TLSV1_2             0x00000008U
386

387
/*
388
 * When adding new digest in the ssl_ciph.c and increment SSL_MD_NUM_IDX make
389 390
 * sure to update this constant too
 */
391 392 393 394 395 396 397 398 399 400 401

# define SSL_MD_MD5_IDX  0
# define SSL_MD_SHA1_IDX 1
# define SSL_MD_GOST94_IDX 2
# define SSL_MD_GOST89MAC_IDX 3
# define SSL_MD_SHA256_IDX 4
# define SSL_MD_SHA384_IDX 5
# define SSL_MD_GOST12_256_IDX  6
# define SSL_MD_GOST89MAC12_IDX 7
# define SSL_MD_GOST12_512_IDX  8
# define SSL_MD_MD5_SHA1_IDX 9
402 403 404
# define SSL_MD_SHA224_IDX 10
# define SSL_MD_SHA512_IDX 11
# define SSL_MAX_DIGEST 12
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426

/* Bits for algorithm2 (handshake digests and other extra flags) */

/* Bits 0-7 are handshake MAC */
# define SSL_HANDSHAKE_MAC_MASK  0xFF
# define SSL_HANDSHAKE_MAC_MD5_SHA1 SSL_MD_MD5_SHA1_IDX
# define SSL_HANDSHAKE_MAC_SHA256   SSL_MD_SHA256_IDX
# define SSL_HANDSHAKE_MAC_SHA384   SSL_MD_SHA384_IDX
# define SSL_HANDSHAKE_MAC_GOST94 SSL_MD_GOST94_IDX
# define SSL_HANDSHAKE_MAC_GOST12_256 SSL_MD_GOST12_256_IDX
# define SSL_HANDSHAKE_MAC_GOST12_512 SSL_MD_GOST12_512_IDX
# define SSL_HANDSHAKE_MAC_DEFAULT  SSL_HANDSHAKE_MAC_MD5_SHA1

/* Bits 8-15 bits are PRF */
# define TLS1_PRF_DGST_SHIFT 8
# define TLS1_PRF_SHA1_MD5 (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT)
# define TLS1_PRF_SHA256 (SSL_MD_SHA256_IDX << TLS1_PRF_DGST_SHIFT)
# define TLS1_PRF_SHA384 (SSL_MD_SHA384_IDX << TLS1_PRF_DGST_SHIFT)
# define TLS1_PRF_GOST94 (SSL_MD_GOST94_IDX << TLS1_PRF_DGST_SHIFT)
# define TLS1_PRF_GOST12_256 (SSL_MD_GOST12_256_IDX << TLS1_PRF_DGST_SHIFT)
# define TLS1_PRF_GOST12_512 (SSL_MD_GOST12_512_IDX << TLS1_PRF_DGST_SHIFT)
# define TLS1_PRF            (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT)
427

428 429 430 431
/*
 * Stream MAC for GOST ciphersuites from cryptopro draft (currently this also
 * goes into algorithm2)
 */
432
# define TLS1_STREAM_MAC 0x10000
433

434
# define SSL_DEFAULT_MASK        0X00000020U
435

436 437 438 439 440 441
# define SSL_STRONG_NONE         0x00000001U
# define SSL_LOW                 0x00000002U
# define SSL_MEDIUM              0x00000004U
# define SSL_HIGH                0x00000008U
# define SSL_FIPS                0x00000010U
# define SSL_NOT_DEFAULT         0x00000020U
442

443
/* we have used 0000003f - 26 bits left to go */
444

D
Dr. Stephen Henson 已提交
445
/* Check if an SSL structure is using DTLS */
446
# define SSL_IS_DTLS(s)  (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS)
447
/* See if we need explicit IV */
448 449 450 451 452
# define SSL_USE_EXPLICIT_IV(s)  \
                (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_EXPLICIT_IV)
/*
 * See if we use signature algorithms extension and signature algorithm
 * before signatures.
453
 */
454 455 456 457 458
# define SSL_USE_SIGALGS(s)      \
                        (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_SIGALGS)
/*
 * Allow TLS 1.2 ciphersuites: applies to DTLS 1.2 as well as TLS 1.2: may
 * apply to others in future.
459
 */
460 461 462 463
# define SSL_USE_TLS1_2_CIPHERS(s)       \
                (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_TLS1_2_CIPHERS)
/*
 * Determine if a client can use TLS 1.2 ciphersuites: can't rely on method
464 465
 * flags because it may not be set to correct version yet.
 */
466
# define SSL_CLIENT_USE_TLS1_2_CIPHERS(s)        \
467 468
    ((!SSL_IS_DTLS(s) && s->client_version >= TLS1_2_VERSION) || \
     (SSL_IS_DTLS(s) && DTLS_VERSION_GE(s->client_version, DTLS1_2_VERSION)))
469 470 471 472 473 474

# ifdef TLSEXT_TYPE_encrypt_then_mac
#  define SSL_USE_ETM(s) (s->s3->flags & TLS1_FLAGS_ENCRYPT_THEN_MAC)
# else
#  define SSL_USE_ETM(s) (0)
# endif
475

476
/* Mostly for SSLv3 */
477 478 479
# define SSL_PKEY_RSA_ENC        0
# define SSL_PKEY_RSA_SIGN       1
# define SSL_PKEY_DSA_SIGN       2
D
Dr. Stephen Henson 已提交
480 481 482 483 484
# define SSL_PKEY_ECC            3
# define SSL_PKEY_GOST01         4
# define SSL_PKEY_GOST12_256     5
# define SSL_PKEY_GOST12_512     6
# define SSL_PKEY_NUM            7
485 486 487 488 489
/*
 * Pseudo-constant. GOST cipher suites can use different certs for 1
 * SSL_CIPHER. So let's see which one we have in fact.
 */
# define SSL_PKEY_GOST_EC SSL_PKEY_NUM+1
490

491
/*-
492
 * SSL_kRSA <- RSA_ENC
493
 * SSL_kDH  <- DH_ENC & (RSA_ENC | RSA_SIGN | DSA_SIGN)
494
 * SSL_kDHE <- RSA_ENC | RSA_SIGN | DSA_SIGN
495 496 497 498
 * SSL_aRSA <- RSA_ENC | RSA_SIGN
 * SSL_aDSS <- DSA_SIGN
 */

M
Matt Caswell 已提交
499
/*-
500 501 502
#define CERT_INVALID            0
#define CERT_PUBLIC_KEY         1
#define CERT_PRIVATE_KEY        2
503 504
*/

E
Emilia Kasper 已提交
505 506 507

/* CipherSuite length. SSLv3 and all TLS versions. */
#define TLS_CIPHER_LEN 2
508 509
/* used to hold info on the particular ciphers used */
struct ssl_cipher_st {
510 511 512
    uint32_t valid;
    const char *name;        /* text name */
    uint32_t id;             /* id, 4 bytes, first is version */
513
    /*
514
     * changed in 1.0.0: these four used to be portions of a single value
515 516
     * 'algorithms'
     */
517 518 519 520 521 522 523 524 525
    uint32_t algorithm_mkey; /* key exchange algorithm */
    uint32_t algorithm_auth; /* server authentication */
    uint32_t algorithm_enc;  /* symmetric encryption */
    uint32_t algorithm_mac;  /* symmetric authentication */
    uint32_t algorithm_ssl;  /* (major) protocol version */
    uint32_t algo_strength;  /* strength and export flags */
    uint32_t algorithm2;     /* Extra flags */
    int32_t strength_bits;   /* Number of bits really used */
    uint32_t alg_bits;       /* Number of bits for algorithm */
526 527
};

M
Matt Caswell 已提交
528
/* Used to hold SSL/TLS functions */
529 530
struct ssl_method_st {
    int version;
531 532
    unsigned flags;
    unsigned long mask;
533 534 535 536 537 538 539 540 541 542 543
    int (*ssl_new) (SSL *s);
    void (*ssl_clear) (SSL *s);
    void (*ssl_free) (SSL *s);
    int (*ssl_accept) (SSL *s);
    int (*ssl_connect) (SSL *s);
    int (*ssl_read) (SSL *s, void *buf, int len);
    int (*ssl_peek) (SSL *s, void *buf, int len);
    int (*ssl_write) (SSL *s, const void *buf, int len);
    int (*ssl_shutdown) (SSL *s);
    int (*ssl_renegotiate) (SSL *s);
    int (*ssl_renegotiate_check) (SSL *s);
544 545
    int (*ssl_read_bytes) (SSL *s, int type, int *recvd_type,
                           unsigned char *buf, int len, int peek);
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
    int (*ssl_write_bytes) (SSL *s, int type, const void *buf_, int len);
    int (*ssl_dispatch_alert) (SSL *s);
    long (*ssl_ctrl) (SSL *s, int cmd, long larg, void *parg);
    long (*ssl_ctx_ctrl) (SSL_CTX *ctx, int cmd, long larg, void *parg);
    const SSL_CIPHER *(*get_cipher_by_char) (const unsigned char *ptr);
    int (*put_cipher_by_char) (const SSL_CIPHER *cipher, unsigned char *ptr);
    int (*ssl_pending) (const SSL *s);
    int (*num_ciphers) (void);
    const SSL_CIPHER *(*get_cipher) (unsigned ncipher);
    const struct ssl_method_st *(*get_ssl_method) (int version);
    long (*get_timeout) (void);
    const struct ssl3_enc_method *ssl3_enc; /* Extra SSLv3/TLS stuff */
    int (*ssl_version) (void);
    long (*ssl_callback_ctrl) (SSL *s, int cb_id, void (*fp) (void));
    long (*ssl_ctx_callback_ctrl) (SSL_CTX *s, int cb_id, void (*fp) (void));
};

/*-
 * Lets make this into an ASN.1 type structure as follows
 * SSL_SESSION_ID ::= SEQUENCE {
 *      version                 INTEGER,        -- structure version number
 *      SSLversion              INTEGER,        -- SSL version number
 *      Cipher                  OCTET STRING,   -- the 3 byte cipher ID
 *      Session_ID              OCTET STRING,   -- the Session ID
 *      Master_key              OCTET STRING,   -- the master key
 *      Key_Arg [ 0 ] IMPLICIT  OCTET STRING,   -- the optional Key argument
 *      Time [ 1 ] EXPLICIT     INTEGER,        -- optional Start Time
 *      Timeout [ 2 ] EXPLICIT  INTEGER,        -- optional Timeout ins seconds
 *      Peer [ 3 ] EXPLICIT     X509,           -- optional Peer Certificate
 *      Session_ID_context [ 4 ] EXPLICIT OCTET STRING,   -- the Session ID context
 *      Verify_result [ 5 ] EXPLICIT INTEGER,   -- X509_V_... code for `Peer'
 *      HostName [ 6 ] EXPLICIT OCTET STRING,   -- optional HostName from servername TLS extension
 *      PSK_identity_hint [ 7 ] EXPLICIT OCTET STRING, -- optional PSK identity hint
 *      PSK_identity [ 8 ] EXPLICIT OCTET STRING,  -- optional PSK identity
 *      Ticket_lifetime_hint [9] EXPLICIT INTEGER, -- server's lifetime hint for session ticket
 *      Ticket [10]             EXPLICIT OCTET STRING, -- session ticket (clients only)
 *      Compression_meth [11]   EXPLICIT OCTET STRING, -- optional compression method
 *      SRP_username [ 12 ] EXPLICIT OCTET STRING -- optional SRP username
584
 *      flags [ 13 ] EXPLICIT INTEGER -- optional flags
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
 *      }
 * Look in ssl/ssl_asn1.c for more details
 * I'm using EXPLICIT tags so I can read the damn things using asn1parse :-).
 */
struct ssl_session_st {
    int ssl_version;            /* what ssl version session info is being
                                 * kept in here? */
    int master_key_length;
    unsigned char master_key[SSL_MAX_MASTER_KEY_LENGTH];
    /* session_id - valid? */
    unsigned int session_id_length;
    unsigned char session_id[SSL_MAX_SSL_SESSION_ID_LENGTH];
    /*
     * this is used to determine whether the session is being reused in the
     * appropriate context. It is up to the application to set this, via
     * SSL_new
     */
    unsigned int sid_ctx_length;
    unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];
# ifndef OPENSSL_NO_PSK
    char *psk_identity_hint;
    char *psk_identity;
# endif
    /*
     * Used to indicate that session resumption is not allowed. Applications
     * can also set this bit for a new session via not_resumable_session_cb
     * to disable session caching and tickets.
     */
    int not_resumable;
614
    /* This is the cert and type for the other end. */
615
    X509 *peer;
616
    int peer_type;
617 618
    /* Certificate chain of peer */
    STACK_OF(X509) *peer_chain;
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
    /*
     * when app_verify_callback accepts a session where the peer's
     * certificate is not ok, we must remember the error for session reuse:
     */
    long verify_result;         /* only for servers */
    int references;
    long timeout;
    long time;
    unsigned int compress_meth; /* Need to lookup the method */
    const SSL_CIPHER *cipher;
    unsigned long cipher_id;    /* when ASN.1 loaded, this needs to be used
                                 * to load the 'cipher' structure */
    STACK_OF(SSL_CIPHER) *ciphers; /* shared ciphers? */
    CRYPTO_EX_DATA ex_data;     /* application specific data */
    /*
     * These are used to make removal of session-ids more efficient and to
     * implement a maximum cache size.
     */
    struct ssl_session_st *prev, *next;
    char *tlsext_hostname;
639
# ifndef OPENSSL_NO_EC
640 641 642 643
    size_t tlsext_ecpointformatlist_length;
    unsigned char *tlsext_ecpointformatlist; /* peer's list */
    size_t tlsext_ellipticcurvelist_length;
    unsigned char *tlsext_ellipticcurvelist; /* peer's list */
644
# endif                       /* OPENSSL_NO_EC */
645 646 647
    /* RFC4507 info */
    unsigned char *tlsext_tick; /* Session ticket */
    size_t tlsext_ticklen;      /* Session ticket length */
648
    unsigned long tlsext_tick_lifetime_hint; /* Session lifetime hint in seconds */
649 650 651
# ifndef OPENSSL_NO_SRP
    char *srp_username;
# endif
652
    uint32_t flags;
653 654
};

655 656 657
/* Extended master secret support */
#  define SSL_SESS_FLAG_EXTMS             0x1

658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685

# ifndef OPENSSL_NO_SRP

typedef struct srp_ctx_st {
    /* param for all the callbacks */
    void *SRP_cb_arg;
    /* set client Hello login callback */
    int (*TLS_ext_srp_username_callback) (SSL *, int *, void *);
    /* set SRP N/g param callback for verification */
    int (*SRP_verify_param_callback) (SSL *, void *);
    /* set SRP client passwd callback */
    char *(*SRP_give_srp_client_pwd_callback) (SSL *, void *);
    char *login;
    BIGNUM *N, *g, *s, *B, *A;
    BIGNUM *a, *b, *v;
    char *info;
    int strength;
    unsigned long srp_Mask;
} SRP_CTX;

# endif

struct ssl_comp_st {
    int id;
    const char *name;
    COMP_METHOD *method;
};

686
DEFINE_LHASH_OF(SSL_SESSION);
687

688

689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
struct ssl_ctx_st {
    const SSL_METHOD *method;
    STACK_OF(SSL_CIPHER) *cipher_list;
    /* same as above but sorted for lookup */
    STACK_OF(SSL_CIPHER) *cipher_list_by_id;
    struct x509_store_st /* X509_STORE */ *cert_store;
    LHASH_OF(SSL_SESSION) *sessions;
    /*
     * Most session-ids that will be cached, default is
     * SSL_SESSION_CACHE_MAX_SIZE_DEFAULT. 0 is unlimited.
     */
    unsigned long session_cache_size;
    struct ssl_session_st *session_cache_head;
    struct ssl_session_st *session_cache_tail;
    /*
     * This can have one of 2 values, ored together, SSL_SESS_CACHE_CLIENT,
     * SSL_SESS_CACHE_SERVER, Default is SSL_SESSION_CACHE_SERVER, which
     * means only SSL_accept which cache SSL_SESSIONS.
     */
708
    uint32_t session_cache_mode;
709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
    /*
     * If timeout is not 0, it is the default timeout value set when
     * SSL_new() is called.  This has been put in to make life easier to set
     * things up
     */
    long session_timeout;
    /*
     * If this callback is not null, it will be called each time a session id
     * is added to the cache.  If this function returns 1, it means that the
     * callback will do a SSL_SESSION_free() when it has finished using it.
     * Otherwise, on 0, it means the callback has finished with it. If
     * remove_session_cb is not null, it will be called when a session-id is
     * removed from the cache.  After the call, OpenSSL will
     * SSL_SESSION_free() it.
     */
    int (*new_session_cb) (struct ssl_st *ssl, SSL_SESSION *sess);
    void (*remove_session_cb) (struct ssl_ctx_st *ctx, SSL_SESSION *sess);
    SSL_SESSION *(*get_session_cb) (struct ssl_st *ssl,
                                    unsigned char *data, int len, int *copy);
    struct {
        int sess_connect;       /* SSL new conn - started */
        int sess_connect_renegotiate; /* SSL reneg - requested */
        int sess_connect_good;  /* SSL new conne/reneg - finished */
        int sess_accept;        /* SSL new accept - started */
        int sess_accept_renegotiate; /* SSL reneg - requested */
        int sess_accept_good;   /* SSL accept/reneg - finished */
        int sess_miss;          /* session lookup misses */
        int sess_timeout;       /* reuse attempt on timeouted session */
        int sess_cache_full;    /* session removed due to full cache */
        int sess_hit;           /* session reuse actually done */
        int sess_cb_hit;        /* session-id that was not in the cache was
                                 * passed back via the callback.  This
                                 * indicates that the application is
                                 * supplying session-id's from other
                                 * processes - spooky :-) */
    } stats;

    int references;

    /* if defined, these override the X509_verify_cert() calls */
    int (*app_verify_callback) (X509_STORE_CTX *, void *);
    void *app_verify_arg;
    /*
     * before OpenSSL 0.9.7, 'app_verify_arg' was ignored
     * ('app_verify_callback' was called with just one argument)
     */

    /* Default password callback. */
    pem_password_cb *default_passwd_callback;

    /* Default password callback user data. */
    void *default_passwd_callback_userdata;

    /* get client cert callback */
    int (*client_cert_cb) (SSL *ssl, X509 **x509, EVP_PKEY **pkey);

    /* cookie generate callback */
    int (*app_gen_cookie_cb) (SSL *ssl, unsigned char *cookie,
                              unsigned int *cookie_len);

    /* verify cookie callback */
E
Emilia Kasper 已提交
770
    int (*app_verify_cookie_cb) (SSL *ssl, const unsigned char *cookie,
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793
                                 unsigned int cookie_len);

    CRYPTO_EX_DATA ex_data;

    const EVP_MD *md5;          /* For SSLv3/TLSv1 'ssl3-md5' */
    const EVP_MD *sha1;         /* For SSLv3/TLSv1 'ssl3->sha1' */

    STACK_OF(X509) *extra_certs;
    STACK_OF(SSL_COMP) *comp_methods; /* stack of SSL_COMP, SSLv3/TLSv1 */

    /* Default values used when no per-SSL value is defined follow */

    /* used if SSL's info_callback is NULL */
    void (*info_callback) (const SSL *ssl, int type, int val);

    /* what we put in client cert requests */
    STACK_OF(X509_NAME) *client_CA;

    /*
     * Default values to use in SSL structures follow (these are copied by
     * SSL_new)
     */

794 795
    uint32_t options;
    uint32_t mode;
796 797
    int min_proto_version;
    int max_proto_version;
798 799 800 801 802 803 804 805 806 807
    long max_cert_list;

    struct cert_st /* CERT */ *cert;
    int read_ahead;

    /* callback that allows applications to peek at protocol messages */
    void (*msg_callback) (int write_p, int version, int content_type,
                          const void *buf, size_t len, SSL *ssl, void *arg);
    void *msg_callback_arg;

808
    uint32_t verify_mode;
809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
    unsigned int sid_ctx_length;
    unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];
    /* called 'verify_callback' in the SSL */
    int (*default_verify_callback) (int ok, X509_STORE_CTX *ctx);

    /* Default generate session ID callback. */
    GEN_SESSION_CB generate_session_id;

    X509_VERIFY_PARAM *param;

    int quiet_shutdown;

    /*
     * Maximum amount of data to send in one fragment. actual record size can
     * be more than this due to padding and MAC overheads.
     */
    unsigned int max_send_fragment;

#  ifndef OPENSSL_NO_ENGINE
    /*
     * Engine to pass requests for client certs to
     */
    ENGINE *client_cert_engine;
#  endif

    /* TLS extensions servername callback */
    int (*tlsext_servername_callback) (SSL *, int *, void *);
    void *tlsext_servername_arg;
    /* RFC 4507 session ticket keys */
    unsigned char tlsext_tick_key_name[16];
    unsigned char tlsext_tick_hmac_key[16];
    unsigned char tlsext_tick_aes_key[16];
    /* Callback to support customisation of ticket key setting */
    int (*tlsext_ticket_key_cb) (SSL *ssl,
                                 unsigned char *name, unsigned char *iv,
                                 EVP_CIPHER_CTX *ectx,
                                 HMAC_CTX *hctx, int enc);

    /* certificate status request info */
    /* Callback for status request */
    int (*tlsext_status_cb) (SSL *ssl, void *arg);
    void *tlsext_status_arg;

#  ifndef OPENSSL_NO_PSK
    unsigned int (*psk_client_callback) (SSL *ssl, const char *hint,
                                         char *identity,
                                         unsigned int max_identity_len,
                                         unsigned char *psk,
                                         unsigned int max_psk_len);
    unsigned int (*psk_server_callback) (SSL *ssl, const char *identity,
                                         unsigned char *psk,
                                         unsigned int max_psk_len);
#  endif

#  ifndef OPENSSL_NO_SRP
    SRP_CTX srp_ctx;            /* ctx for SRP authentication */
#  endif

867
#  ifndef OPENSSL_NO_NEXTPROTONEG
868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886
    /* Next protocol negotiation information */
    /* (for experimental NPN extension). */

    /*
     * For a server, this contains a callback function by which the set of
     * advertised protocols can be provided.
     */
    int (*next_protos_advertised_cb) (SSL *s, const unsigned char **buf,
                                      unsigned int *len, void *arg);
    void *next_protos_advertised_cb_arg;
    /*
     * For a client, this contains a callback function that selects the next
     * protocol from the list provided by the server.
     */
    int (*next_proto_select_cb) (SSL *s, unsigned char **out,
                                 unsigned char *outlen,
                                 const unsigned char *in,
                                 unsigned int inlen, void *arg);
    void *next_proto_select_cb_arg;
887
#  endif
888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917

    /*
     * ALPN information (we are in the process of transitioning from NPN to
     * ALPN.)
     */

        /*-
         * For a server, this contains a callback function that allows the
         * server to select the protocol for the connection.
         *   out: on successful return, this must point to the raw protocol
         *        name (without the length prefix).
         *   outlen: on successful return, this contains the length of |*out|.
         *   in: points to the client's list of supported protocols in
         *       wire-format.
         *   inlen: the length of |in|.
         */
    int (*alpn_select_cb) (SSL *s,
                           const unsigned char **out,
                           unsigned char *outlen,
                           const unsigned char *in,
                           unsigned int inlen, void *arg);
    void *alpn_select_cb_arg;

    /*
     * For a client, this contains the list of supported protocols in wire
     * format.
     */
    unsigned char *alpn_client_proto_list;
    unsigned alpn_client_proto_list_len;

918 919 920
    /* Shared DANE context */
    struct dane_ctx_st dane;

921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943
    /* SRTP profiles we are willing to do from RFC 5764 */
    STACK_OF(SRTP_PROTECTION_PROFILE) *srtp_profiles;
    /*
     * Callback for disabling session caching and ticket support on a session
     * basis, depending on the chosen cipher.
     */
    int (*not_resumable_session_cb) (SSL *ssl, int is_forward_secure);
#  ifndef OPENSSL_NO_EC
    /* EC extension values inherited by SSL structure */
    size_t tlsext_ecpointformatlist_length;
    unsigned char *tlsext_ecpointformatlist;
    size_t tlsext_ellipticcurvelist_length;
    unsigned char *tlsext_ellipticcurvelist;
#  endif                        /* OPENSSL_NO_EC */
};


struct ssl_st {
    /*
     * protocol version (one of SSL2_VERSION, SSL3_VERSION, TLS1_VERSION,
     * DTLS1_VERSION)
     */
    int version;
M
Matt Caswell 已提交
944

945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
    /* SSLv3 */
    const SSL_METHOD *method;
    /*
     * There are 2 BIO's even though they are normally both the same.  This
     * is so data can be read and written to different handlers
     */
    /* used by SSL_read */
    BIO *rbio;
    /* used by SSL_write */
    BIO *wbio;
    /* used during session-id reuse to concatenate messages */
    BIO *bbio;
    /*
     * This holds a variable that indicates what we were doing when a 0 or -1
     * is returned.  This is needed for non-blocking IO so we know what
     * request needs re-doing when in SSL_accept or SSL_connect
     */
    int rwstate;
M
Matt Caswell 已提交
963

964 965 966 967 968 969 970 971
    int (*handshake_func) (SSL *);
    /*
     * Imagine that here's a boolean member "init" that is switched as soon
     * as SSL_set_{accept/connect}_state is called for the first time, so
     * that "state" and "handshake_func" are properly initialized.  But as
     * handshake_func is == 0 until then, we use this test instead of an
     * "init" member.
     */
M
Matt Caswell 已提交
972
    /* are we the server side? */
973 974 975 976 977 978 979 980 981 982 983 984 985
    int server;
    /*
     * Generate a new session or reuse an old one.
     * NB: For servers, the 'new' session may actually be a previously
     * cached session or even the previous session unless
     * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION is set
     */
    int new_session;
    /* don't send shutdown packets */
    int quiet_shutdown;
    /* we have shut things down, 0x01 sent, 0x02 for received */
    int shutdown;
    /* where we are */
M
Matt Caswell 已提交
986
    OSSL_STATEM statem;
987

988 989 990 991 992
    BUF_MEM *init_buf;          /* buffer used during init */
    void *init_msg;             /* pointer to handshake message body, set by
                                 * ssl3_get_message() */
    int init_num;               /* amount read/written */
    int init_off;               /* amount read/written */
993

994 995
    struct ssl3_state_st *s3;   /* SSLv3 variables */
    struct dtls1_state_st *d1;  /* DTLSv1 variables */
996

997 998 999 1000 1001 1002
    /* callback that allows applications to peek at protocol messages */
    void (*msg_callback) (int write_p, int version, int content_type,
                          const void *buf, size_t len, SSL *ssl, void *arg);
    void *msg_callback_arg;
    int hit;                    /* reusing a previous session */
    X509_VERIFY_PARAM *param;
1003 1004 1005 1006

    /* Per connection DANE state */
    struct dane_st dane;

1007 1008 1009 1010 1011 1012 1013
    /* crypto */
    STACK_OF(SSL_CIPHER) *cipher_list;
    STACK_OF(SSL_CIPHER) *cipher_list_by_id;
    /*
     * These are the ones being used, the ones in SSL_SESSION are the ones to
     * be 'copied' into these ones
     */
1014
    uint32_t mac_flags;
1015 1016
    EVP_CIPHER_CTX *enc_read_ctx; /* cryptographic state */
    EVP_MD_CTX *read_hash;      /* used for mac generation */
R
Rich Salz 已提交
1017
    COMP_CTX *compress;         /* compression */
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
    COMP_CTX *expand;           /* uncompress */
    EVP_CIPHER_CTX *enc_write_ctx; /* cryptographic state */
    EVP_MD_CTX *write_hash;     /* used for mac generation */
    /* session info */
    /* client cert? */
    /* This is used to hold the server certificate used */
    struct cert_st /* CERT */ *cert;
    /*
     * the session_id_context is used to ensure sessions are only reused in
     * the appropriate context
     */
    unsigned int sid_ctx_length;
    unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];
    /* This can also be in the session once a session is established */
    SSL_SESSION *session;
    /* Default generate session ID callback. */
    GEN_SESSION_CB generate_session_id;
    /* Used in SSL3 */
    /*
     * 0 don't care about verify failure.
     * 1 fail if verify fails
     */
1040
    uint32_t verify_mode;
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
    /* fail if callback returns 0 */
    int (*verify_callback) (int ok, X509_STORE_CTX *ctx);
    /* optional informational callback */
    void (*info_callback) (const SSL *ssl, int type, int val);
    /* error bytes to be written */
    int error;
    /* actual code */
    int error_code;
#  ifndef OPENSSL_NO_PSK
    unsigned int (*psk_client_callback) (SSL *ssl, const char *hint,
                                         char *identity,
                                         unsigned int max_identity_len,
                                         unsigned char *psk,
                                         unsigned int max_psk_len);
    unsigned int (*psk_server_callback) (SSL *ssl, const char *identity,
                                         unsigned char *psk,
                                         unsigned int max_psk_len);
#  endif
    SSL_CTX *ctx;
    /* extra application data */
    long verify_result;
    CRYPTO_EX_DATA ex_data;
    /* for server side, keep the list of CA_dn we can use */
    STACK_OF(X509_NAME) *client_CA;
    int references;
    /* protocol behaviour */
1067
    uint32_t options;
1068
    /* API behaviour */
1069
    uint32_t mode;
1070 1071
    int min_proto_version;
    int max_proto_version;
1072 1073 1074 1075 1076
    long max_cert_list;
    int first_packet;
    /* what was passed, used for SSLv3/TLS rollback check */
    int client_version;
    unsigned int max_send_fragment;
1077

1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
    /* TLS extension debug callback */
    void (*tlsext_debug_cb) (SSL *s, int client_server, int type,
                             unsigned char *data, int len, void *arg);
    void *tlsext_debug_arg;
    char *tlsext_hostname;
    /*-
     * no further mod of servername
     * 0 : call the servername extension callback.
     * 1 : prepare 2, allow last ack just after in server callback.
     * 2 : don't call servername callback, no ack in server hello
     */
    int servername_done;
    /* certificate status request info */
    /* Status type or -1 if no status type */
    int tlsext_status_type;
    /* Expect OCSP CertificateStatus message */
    int tlsext_status_expected;
    /* OCSP status request only */
    STACK_OF(OCSP_RESPID) *tlsext_ocsp_ids;
    X509_EXTENSIONS *tlsext_ocsp_exts;
    /* OCSP response received or to be sent */
    unsigned char *tlsext_ocsp_resp;
    int tlsext_ocsp_resplen;
    /* RFC4507 session ticket expected to be received or sent */
    int tlsext_ticket_expected;
1103
#  ifndef OPENSSL_NO_EC
1104 1105 1106 1107 1108 1109
    size_t tlsext_ecpointformatlist_length;
    /* our list */
    unsigned char *tlsext_ecpointformatlist;
    size_t tlsext_ellipticcurvelist_length;
    /* our list */
    unsigned char *tlsext_ellipticcurvelist;
1110
#  endif                       /* OPENSSL_NO_EC */
1111 1112 1113 1114 1115 1116 1117 1118 1119
    /* TLS Session Ticket extension override */
    TLS_SESSION_TICKET_EXT *tlsext_session_ticket;
    /* TLS Session Ticket extension callback */
    tls_session_ticket_ext_cb_fn tls_session_ticket_ext_cb;
    void *tls_session_ticket_ext_cb_arg;
    /* TLS pre-shared secret session resumption */
    tls_session_secret_cb_fn tls_session_secret_cb;
    void *tls_session_secret_cb_arg;
    SSL_CTX *initial_ctx;       /* initial ctx, used to store sessions */
1120
#  ifndef OPENSSL_NO_NEXTPROTONEG
1121 1122 1123 1124 1125 1126 1127 1128 1129
    /*
     * Next protocol negotiation. For the client, this is the protocol that
     * we sent in NextProtocol and is set when handling ServerHello
     * extensions. For a server, this is the client's selected_protocol from
     * NextProtocol and is set when handling the NextProtocol message, before
     * the Finished message.
     */
    unsigned char *next_proto_negotiated;
    unsigned char next_proto_negotiated_len;
1130 1131
#  endif
#  define session_ctx initial_ctx
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
    /* What we'll do */
    STACK_OF(SRTP_PROTECTION_PROFILE) *srtp_profiles;
    /* What's been chosen */
    SRTP_PROTECTION_PROFILE *srtp_profile;
        /*-
         * Is use of the Heartbeat extension negotiated?
         *  0: disabled
         *  1: enabled
         *  2: enabled, but not allowed to send Requests
         */
    unsigned int tlsext_heartbeat;
    /* Indicates if a HeartbeatRequest is in flight */
    unsigned int tlsext_hb_pending;
    /* HeartbeatRequest sequence number */
    unsigned int tlsext_hb_seq;
    /*
     * For a client, this contains the list of supported protocols in wire
     * format.
     */
    unsigned char *alpn_client_proto_list;
    unsigned alpn_client_proto_list_len;
1153

1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
    /*-
     * 1 if we are renegotiating.
     * 2 if we are a server and are inside a handshake
     * (i.e. not just sending a HelloRequest)
     */
    int renegotiate;
#  ifndef OPENSSL_NO_SRP
    /* ctx for SRP authentication */
    SRP_CTX srp_ctx;
#  endif
    /*
     * Callback for disabling session caching and ticket support on a session
     * basis, depending on the chosen cipher.
     */
    int (*not_resumable_session_cb) (SSL *ssl, int is_forward_secure);
1169 1170
    
    RECORD_LAYER rlayer;
M
Matt Caswell 已提交
1171 1172 1173 1174 1175 1176

    /* Default password callback. */
    pem_password_cb *default_passwd_callback;

    /* Default password callback user data. */
    void *default_passwd_callback_userdata;
M
Matt Caswell 已提交
1177 1178 1179

    /* Async Job info */
    ASYNC_JOB *job;
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
};


typedef struct ssl3_state_st {
    long flags;
    int read_mac_secret_size;
    unsigned char read_mac_secret[EVP_MAX_MD_SIZE];
    int write_mac_secret_size;
    unsigned char write_mac_secret[EVP_MAX_MD_SIZE];
    unsigned char server_random[SSL3_RANDOM_SIZE];
    unsigned char client_random[SSL3_RANDOM_SIZE];
    /* flags for countermeasure against known-IV weakness */
    int need_empty_fragments;
    int empty_fragment_done;
    /* used during startup, digest all incoming/outgoing packets */
    BIO *handshake_buffer;
    /*
1197 1198
     * When handshake digest is determined, buffer is hashed and
     * freed and MD_CTX for the required digest is stored here.
1199
     */
1200
    EVP_MD_CTX *handshake_dgst;
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
    /*
     * Set whenever an expected ChangeCipherSpec message is processed.
     * Unset when the peer's Finished message is received.
     * Unexpected ChangeCipherSpec messages trigger a fatal alert.
     */
    int change_cipher_spec;
    int warn_alert;
    int fatal_alert;
    /*
     * we allow one fatal and one warning alert to be outstanding, send close
     * alert via the warning alert
     */
    int alert_dispatch;
    unsigned char send_alert[2];
    /*
     * This flag is set when we should renegotiate ASAP, basically when there
     * is no more data in the read or write buffers
     */
    int renegotiate;
    int total_renegotiations;
    int num_renegotiations;
    int in_read_app_data;
    struct {
        /* actually only need to be 16+20 for SSLv3 and 12 for TLS */
        unsigned char finish_md[EVP_MAX_MD_SIZE * 2];
        int finish_md_len;
        unsigned char peer_finish_md[EVP_MAX_MD_SIZE * 2];
        int peer_finish_md_len;
        unsigned long message_size;
        int message_type;
        /* used to hold the new cipher we are going to use */
        const SSL_CIPHER *new_cipher;
D
Dr. Stephen Henson 已提交
1233 1234
#  if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DH)
        EVP_PKEY *pkey;            /* holds short lived DH/ECDH key */
1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
#  endif
        /* used for certificate requests */
        int cert_req;
        int ctype_num;
        char ctype[SSL3_CT_NUMBER];
        STACK_OF(X509_NAME) *ca_names;
        int key_block_length;
        unsigned char *key_block;
        const EVP_CIPHER *new_sym_enc;
        const EVP_MD *new_hash;
        int new_mac_pkey_type;
        int new_mac_secret_size;
#  ifndef OPENSSL_NO_COMP
        const SSL_COMP *new_compression;
#  else
        char *new_compression;
#  endif
        int cert_request;
D
Dr. Stephen Henson 已提交
1253 1254 1255 1256 1257 1258
        /* Raw values of the cipher list from a client */
        unsigned char *ciphers_raw;
        size_t ciphers_rawlen;
        /* Temporary storage for premaster secret */
        unsigned char *pms;
        size_t pmslen;
1259
#ifndef OPENSSL_NO_PSK
1260 1261 1262
        /* Temporary storage for PSK key */
        unsigned char *psk;
        size_t psklen;
1263
#endif
D
Dr. Stephen Henson 已提交
1264 1265 1266 1267 1268 1269 1270 1271
        /*
         * signature algorithms peer reports: e.g. supported signature
         * algorithms extension for server or as part of a certificate
         * request for client.
         */
        unsigned char *peer_sigalgs;
        /* Size of above array */
        size_t peer_sigalgslen;
1272 1273 1274 1275
        /* Digest peer uses for signing */
        const EVP_MD *peer_md;
        /* Array of digests used for signing */
        const EVP_MD *md[SSL_PKEY_NUM];
1276 1277 1278 1279 1280
        /*
         * Set if corresponding CERT_PKEY can be used with current
         * SSL session: e.g. appropriate curve, signature algorithms etc.
         * If zero it can't be used at all.
         */
1281
        uint32_t valid_flags[SSL_PKEY_NUM];
1282 1283 1284 1285 1286
        /*
         * For servers the following masks are for the key and auth algorithms
         * that are supported by the certs below. For clients they are masks of
         * *disabled* algorithms based on the current session.
         */
1287 1288
        uint32_t mask_k;
        uint32_t mask_a;
1289
        /* Client only */
1290
        uint32_t mask_ssl;
1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327
    } tmp;

    /* Connection binding to prevent renegotiation attacks */
    unsigned char previous_client_finished[EVP_MAX_MD_SIZE];
    unsigned char previous_client_finished_len;
    unsigned char previous_server_finished[EVP_MAX_MD_SIZE];
    unsigned char previous_server_finished_len;
    int send_connection_binding; /* TODOEKR */

#  ifndef OPENSSL_NO_NEXTPROTONEG
    /*
     * Set if we saw the Next Protocol Negotiation extension from our peer.
     */
    int next_proto_neg_seen;
#  endif

    /*
     * ALPN information (we are in the process of transitioning from NPN to
     * ALPN.)
     */

    /*
     * In a server these point to the selected ALPN protocol after the
     * ClientHello has been processed. In a client these contain the protocol
     * that the server selected once the ServerHello has been processed.
     */
    unsigned char *alpn_selected;
    unsigned alpn_selected_len;

#   ifndef OPENSSL_NO_EC
    /*
     * This is set to true if we believe that this is a version of Safari
     * running on OS X 10.6 or newer. We wish to know this because Safari on
     * 10.8 .. 10.8.3 has broken ECDHE-ECDSA support.
     */
    char is_probably_safari;
#   endif                       /* !OPENSSL_NO_EC */
1328 1329

    /* For clients: peer temporary key */
D
Dr. Stephen Henson 已提交
1330
# if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DH)
1331
    EVP_PKEY *peer_tmp;
1332 1333
# endif

1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345
} SSL3_STATE;


/* DTLS structures */

#  ifndef OPENSSL_NO_SCTP
#   define DTLS1_SCTP_AUTH_LABEL   "EXPORTER_DTLS_OVER_SCTP"
#  endif

/* Max MTU overhead we know about so far is 40 for IPv6 + 8 for UDP */
#  define DTLS1_MAX_MTU_OVERHEAD                   48

M
Matt Caswell 已提交
1346 1347 1348 1349 1350 1351
/*
 * Flag used in message reuse to indicate the buffer contains the record
 * header as well as the the handshake message header.
 */
#  define DTLS1_SKIP_RECORD_HEADER                 2

1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384
struct dtls1_retransmit_state {
    EVP_CIPHER_CTX *enc_write_ctx; /* cryptographic state */
    EVP_MD_CTX *write_hash;     /* used for mac generation */
    COMP_CTX *compress;         /* compression */
    SSL_SESSION *session;
    unsigned short epoch;
};

struct hm_header_st {
    unsigned char type;
    unsigned long msg_len;
    unsigned short seq;
    unsigned long frag_off;
    unsigned long frag_len;
    unsigned int is_ccs;
    struct dtls1_retransmit_state saved_retransmit_state;
};

struct dtls1_timeout_st {
    /* Number of read timeouts so far */
    unsigned int read_timeouts;
    /* Number of write timeouts so far */
    unsigned int write_timeouts;
    /* Number of alerts received so far */
    unsigned int num_alerts;
};

typedef struct hm_fragment_st {
    struct hm_header_st msg_header;
    unsigned char *fragment;
    unsigned char *reassembly;
} hm_fragment;

R
Rich Salz 已提交
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
typedef struct pqueue_st pqueue;
typedef struct pitem_st pitem;

struct pitem_st {
    unsigned char priority[8];  /* 64-bit value in big-endian encoding */
    void *data;
    pitem *next;
};

typedef struct pitem_st *piterator;

pitem *pitem_new(unsigned char *prio64be, void *data);
void pitem_free(pitem *item);
pqueue* pqueue_new(void);
void pqueue_free(pqueue *pq);
pitem *pqueue_insert(pqueue *pq, pitem *item);
pitem *pqueue_peek(pqueue *pq);
pitem *pqueue_pop(pqueue *pq);
pitem *pqueue_find(pqueue *pq, unsigned char *prio64be);
pitem *pqueue_iterator(pqueue *pq);
pitem *pqueue_next(piterator *iter);
void pqueue_print(pqueue *pq);
int pqueue_size(pqueue *pq);

1409 1410 1411
typedef struct dtls1_state_st {
    unsigned char cookie[DTLS1_COOKIE_LENGTH];
    unsigned int cookie_len;
M
Matt Caswell 已提交
1412
    unsigned int cookie_verified;
1413

1414 1415 1416 1417
    /* handshake message numbers */
    unsigned short handshake_write_seq;
    unsigned short next_handshake_write_seq;
    unsigned short handshake_read_seq;
1418

1419
    /* Buffered handshake messages */
R
Rich Salz 已提交
1420
    pqueue *buffered_messages;
1421
    /* Buffered (sent) handshake records */
R
Rich Salz 已提交
1422
    pqueue *sent_messages;
1423

1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434
    unsigned int link_mtu;      /* max on-the-wire DTLS packet size */
    unsigned int mtu;           /* max DTLS packet size */
    struct hm_header_st w_msg_hdr;
    struct hm_header_st r_msg_hdr;
    struct dtls1_timeout_st timeout;
    /*
     * Indicates when the last handshake msg or heartbeat sent will timeout
     */
    struct timeval next_timeout;
    /* Timeout duration */
    unsigned short timeout_duration;
1435

1436 1437 1438 1439 1440 1441 1442 1443
    unsigned int retransmitting;
#  ifndef OPENSSL_NO_SCTP
    int shutdown_received;
#  endif
} DTLS1_STATE;



1444 1445 1446
# ifndef OPENSSL_NO_EC
/*
 * From ECC-TLS draft, used in encoding the curve type in ECParameters
B
Bodo Möller 已提交
1447
 */
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457
#  define EXPLICIT_PRIME_CURVE_TYPE  1
#  define EXPLICIT_CHAR2_CURVE_TYPE  2
#  define NAMED_CURVE_TYPE           3
# endif                         /* OPENSSL_NO_EC */

typedef struct cert_pkey_st {
    X509 *x509;
    EVP_PKEY *privatekey;
    /* Chain for this certificate */
    STACK_OF(X509) *chain;
1458

1459 1460 1461 1462 1463 1464 1465
    /*-
     * serverinfo data for this certificate.  The data is in TLS Extension
     * wire format, specifically it's a series of records like:
     *   uint16_t extension_type; // (RFC 5246, 7.4.1.4, Extension)
     *   uint16_t length;
     *   uint8_t data[length];
     */
1466 1467 1468
    unsigned char *serverinfo;
    size_t serverinfo_length;
} CERT_PKEY;
1469
/* Retrieve Suite B flags */
1470
# define tls1_suiteb(s)  (s->cert->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS)
1471
/* Uses to check strict mode: suite B modes are always strict */
1472 1473
# define SSL_CERT_FLAGS_CHECK_TLS_STRICT \
        (SSL_CERT_FLAG_SUITEB_128_LOS|SSL_CERT_FLAG_TLS_STRICT)
1474

1475
typedef struct {
1476 1477 1478 1479 1480
    unsigned short ext_type;
    /*
     * Per-connection flags relating to this extension type: not used if
     * part of an SSL_CTX structure.
     */
1481
    uint32_t ext_flags;
1482 1483 1484 1485 1486
    custom_ext_add_cb add_cb;
    custom_ext_free_cb free_cb;
    void *add_arg;
    custom_ext_parse_cb parse_cb;
    void *parse_arg;
D
Dr. Stephen Henson 已提交
1487
} custom_ext_method;
1488

1489 1490
/* ext_flags values */

1491 1492 1493
/*
 * Indicates an extension has been received. Used to check for unsolicited or
 * duplicate extensions.
1494
 */
1495 1496 1497 1498
# define SSL_EXT_FLAG_RECEIVED   0x1
/*
 * Indicates an extension has been sent: used to enable sending of
 * corresponding ServerHello extension.
1499
 */
1500
# define SSL_EXT_FLAG_SENT       0x2
1501

1502
typedef struct {
1503 1504
    custom_ext_method *meths;
    size_t meths_count;
D
Dr. Stephen Henson 已提交
1505
} custom_ext_methods;
1506

1507 1508 1509 1510 1511 1512 1513 1514 1515
typedef struct cert_st {
    /* Current active set */
    /*
     * ALWAYS points to an element of the pkeys array
     * Probably it would make more sense to store
     * an index, not a pointer.
     */
    CERT_PKEY *key;
# ifndef OPENSSL_NO_DH
1516
    EVP_PKEY *dh_tmp;
1517 1518 1519 1520
    DH *(*dh_tmp_cb) (SSL *ssl, int is_export, int keysize);
    int dh_tmp_auto;
# endif
    /* Flags related to certificates */
1521
    uint32_t cert_flags;
1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
    CERT_PKEY pkeys[SSL_PKEY_NUM];
    /*
     * Certificate types (received or sent) in certificate request message.
     * On receive this is only set if number of certificate types exceeds
     * SSL3_CT_NUMBER.
     */
    unsigned char *ctypes;
    size_t ctype_num;
    /*
     * suppported signature algorithms. When set on a client this is sent in
     * the client hello as the supported signature algorithms extension. For
     * servers it represents the signature algorithms we are willing to use.
     */
    unsigned char *conf_sigalgs;
    /* Size of above array */
    size_t conf_sigalgslen;
    /*
     * Client authentication signature algorithms, if not set then uses
     * conf_sigalgs. On servers these will be the signature algorithms sent
     * to the client in a cerificate request for TLS 1.2. On a client this
     * represents the signature algortithms we are willing to use for client
     * authentication.
     */
    unsigned char *client_sigalgs;
    /* Size of above array */
    size_t client_sigalgslen;
    /*
     * Signature algorithms shared by client and server: cached because these
     * are used most often.
     */
    TLS_SIGALGS *shared_sigalgs;
    size_t shared_sigalgslen;
    /*
     * Certificate setup callback: if set is called whenever a certificate
     * may be required (client or server). the callback can then examine any
     * appropriate parameters and setup any certificates required. This
     * allows advanced applications to select certificates on the fly: for
     * example based on supported signature algorithms or curves.
     */
    int (*cert_cb) (SSL *ssl, void *arg);
    void *cert_cb_arg;
    /*
     * Optional X509_STORE for chain building or certificate validation If
     * NULL the parent SSL_CTX store is used instead.
     */
    X509_STORE *chain_store;
    X509_STORE *verify_store;
    /* Custom extension methods for server and client */
    custom_ext_methods cli_ext;
    custom_ext_methods srv_ext;
    /* Security callback */
    int (*sec_cb) (SSL *s, SSL_CTX *ctx, int op, int bits, int nid,
                   void *other, void *ex);
    /* Security level */
    int sec_level;
    void *sec_ex;
1578 1579 1580 1581
#ifndef OPENSSL_NO_PSK
    /* If not NULL psk identity hint to use for servers */
    char *psk_identity_hint;
#endif
1582 1583 1584
    int references;             /* >1 only if SSL_copy_session_id is used */
} CERT;

1585
/* Structure containing decoded values of signature algorithms extension */
1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651
struct tls_sigalgs_st {
    /* NID of hash algorithm */
    int hash_nid;
    /* NID of signature algorithm */
    int sign_nid;
    /* Combined hash and signature NID */
    int signandhash_nid;
    /* Raw values used in extension */
    unsigned char rsign;
    unsigned char rhash;
};

/*
 * #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 *))

/*
 * 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 an opaque structure :-)
 */
typedef struct ssl3_enc_method {
    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);
    int (*final_finish_mac) (SSL *, const char *, int, unsigned char *);
    int finish_mac_length;
    const char *client_finished_label;
    int client_finished_label_len;
    const char *server_finished_label;
    int server_finished_label_len;
    int (*alert_value) (int);
    int (*export_keying_material) (SSL *, unsigned char *, size_t,
                                   const char *, size_t,
                                   const unsigned char *, size_t,
                                   int use_context);
    /* Various flags indicating protocol version requirements */
1652
    uint32_t enc_flags;
1653 1654 1655
    /* Handshake header length */
    unsigned int hhlen;
    /* Set the handshake header */
M
Matt Caswell 已提交
1656
    int (*set_handshake_header) (SSL *s, int type, unsigned long len);
1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
    /* Write out handshake message */
    int (*do_write) (SSL *s);
} SSL3_ENC_METHOD;

# define SSL_HM_HEADER_LENGTH(s) s->method->ssl3_enc->hhlen
# define ssl_handshake_start(s) \
        (((unsigned char *)s->init_buf->data) + s->method->ssl3_enc->hhlen)
# define ssl_set_handshake_header(s, htype, len) \
        s->method->ssl3_enc->set_handshake_header(s, htype, len)
# define ssl_do_write(s)  s->method->ssl3_enc->do_write(s)
D
Dr. Stephen Henson 已提交
1667 1668 1669 1670

/* Values for enc_flags */

/* Uses explicit IV for CBC mode */
1671
# define SSL_ENC_FLAG_EXPLICIT_IV        0x1
D
Dr. Stephen Henson 已提交
1672
/* Uses signature algorithms extension */
1673
# define SSL_ENC_FLAG_SIGALGS            0x2
1674
/* Uses SHA256 default PRF */
1675
# define SSL_ENC_FLAG_SHA256_PRF         0x4
D
Dr. Stephen Henson 已提交
1676
/* Is DTLS */
1677 1678 1679 1680
# define SSL_ENC_FLAG_DTLS               0x8
/*
 * Allow TLS 1.2 ciphersuites: applies to DTLS 1.2 as well as TLS 1.2: may
 * apply to others in future.
1681
 */
1682
# define SSL_ENC_FLAG_TLS1_2_CIPHERS     0x10
D
Dr. Stephen Henson 已提交
1683

1684
# ifndef OPENSSL_NO_COMP
1685
/* Used for holding the relevant compression methods loaded into SSL_CTX */
1686 1687 1688 1689 1690 1691 1692
typedef struct ssl3_comp_st {
    int comp_id;                /* The identifier byte for this compression
                                 * type */
    char *name;                 /* Text name used for the compression type */
    COMP_METHOD *method;        /* The method :-) */
} SSL3_COMP;
# endif
1693

1694
extern SSL3_ENC_METHOD ssl3_undef_enc_method;
1695
OPENSSL_EXTERN const SSL_CIPHER ssl3_ciphers[];
U
Ulf Möller 已提交
1696

1697 1698
SSL_METHOD *ssl_bad_method(int ver);

B
Ben Laurie 已提交
1699 1700 1701
extern const SSL3_ENC_METHOD TLSv1_enc_data;
extern const SSL3_ENC_METHOD TLSv1_1_enc_data;
extern const SSL3_ENC_METHOD TLSv1_2_enc_data;
1702 1703 1704
extern const SSL3_ENC_METHOD SSLv3_enc_data;
extern const SSL3_ENC_METHOD DTLSv1_enc_data;
extern const SSL3_ENC_METHOD DTLSv1_2_enc_data;
1705

1706 1707 1708 1709 1710 1711 1712 1713
/*
 * Flags for SSL methods
 */
#define SSL_METHOD_NO_FIPS      (1U<<0)
#define SSL_METHOD_NO_SUITEB    (1U<<1)

# define IMPLEMENT_tls_meth_func(version, flags, mask, func_name, s_accept, \
                                 s_connect, s_get_meth, enc_data) \
1714
const SSL_METHOD *func_name(void)  \
1715 1716 1717
        { \
        static const SSL_METHOD func_name##_data= { \
                version, \
1718 1719
                flags, \
                mask, \
1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751
                tls1_new, \
                tls1_clear, \
                tls1_free, \
                s_accept, \
                s_connect, \
                ssl3_read, \
                ssl3_peek, \
                ssl3_write, \
                ssl3_shutdown, \
                ssl3_renegotiate, \
                ssl3_renegotiate_check, \
                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, \
                &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) \
1752
const SSL_METHOD *func_name(void)  \
1753 1754 1755
        { \
        static const SSL_METHOD func_name##_data= { \
                SSL3_VERSION, \
1756 1757
                SSL_METHOD_NO_FIPS | SSL_METHOD_NO_SUITEB, \
                SSL_OP_NO_SSLv3, \
1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788
                ssl3_new, \
                ssl3_clear, \
                ssl3_free, \
                s_accept, \
                s_connect, \
                ssl3_read, \
                ssl3_peek, \
                ssl3_write, \
                ssl3_shutdown, \
                ssl3_renegotiate, \
                ssl3_renegotiate_check, \
                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; \
        }

1789 1790
# define IMPLEMENT_dtls1_meth_func(version, flags, mask, func_name, s_accept, \
                                        s_connect, s_get_meth, enc_data) \
1791
const SSL_METHOD *func_name(void)  \
1792 1793 1794
        { \
        static const SSL_METHOD func_name##_data= { \
                version, \
1795 1796
                flags, \
                mask, \
1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830
                dtls1_new, \
                dtls1_clear, \
                dtls1_free, \
                s_accept, \
                s_connect, \
                ssl3_read, \
                ssl3_peek, \
                ssl3_write, \
                dtls1_shutdown, \
                ssl3_renegotiate, \
                ssl3_renegotiate_check, \
                dtls1_read_bytes, \
                dtls1_write_app_data_bytes, \
                dtls1_dispatch_alert, \
                dtls1_ctrl, \
                ssl3_ctx_ctrl, \
                ssl3_get_cipher_by_char, \
                ssl3_put_cipher_by_char, \
                ssl3_pending, \
                ssl3_num_ciphers, \
                dtls1_get_cipher, \
                s_get_meth, \
                dtls1_default_timeout, \
                &enc_data, \
                ssl_undefined_void_function, \
                ssl3_callback_ctrl, \
                ssl3_ctx_callback_ctrl, \
        }; \
        return &func_name##_data; \
        }

struct openssl_ssl_test_functions {
    int (*p_ssl_init_wbio_buffer) (SSL *s, int push);
    int (*p_ssl3_setup_buffers) (SSL *s);
1831 1832 1833 1834
    int (*p_tls1_process_heartbeat) (SSL *s,
        unsigned char *p, unsigned int length);
    int (*p_dtls1_process_heartbeat) (SSL *s,
        unsigned char *p, unsigned int length);
1835 1836 1837
};

# ifndef OPENSSL_UNIT_TEST
1838

1839 1840
void ssl_clear_cipher_ctx(SSL *s);
int ssl_clear_bad_session(SSL *s);
M
Matt Caswell 已提交
1841 1842
__owur CERT *ssl_cert_new(void);
__owur CERT *ssl_cert_dup(CERT *cert);
1843
void ssl_cert_clear_certs(CERT *c);
1844
void ssl_cert_free(CERT *c);
M
Matt Caswell 已提交
1845
__owur int ssl_get_new_session(SSL *s, int session);
1846 1847
__owur int ssl_get_prev_session(SSL *s, const PACKET *ext,
                                const PACKET *session_id);
1848
__owur SSL_SESSION *ssl_session_dup(SSL_SESSION *src, int ticket);
M
Matt Caswell 已提交
1849
__owur int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b);
1850
DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);
M
Matt Caswell 已提交
1851
__owur int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap,
1852
                          const SSL_CIPHER *const *bp);
M
Matt Caswell 已提交
1853
__owur STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *meth,
1854 1855 1856
                                             STACK_OF(SSL_CIPHER) **pref,
                                             STACK_OF(SSL_CIPHER) **sorted,
                                             const char *rule_str, CERT *c);
1857
void ssl_update_cache(SSL *s, int mode);
M
Matt Caswell 已提交
1858
__owur int ssl_cipher_get_evp(const SSL_SESSION *s, const EVP_CIPHER **enc,
1859 1860
                       const EVP_MD **md, int *mac_pkey_type,
                       int *mac_secret_size, SSL_COMP **comp, int use_etm);
M
Matt Caswell 已提交
1861 1862 1863 1864 1865 1866 1867 1868 1869
__owur int ssl_cipher_get_cert_index(const SSL_CIPHER *c);
__owur const SSL_CIPHER *ssl_get_cipher_by_char(SSL *ssl, const unsigned char *ptr);
__owur int ssl_cert_set0_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain);
__owur int ssl_cert_set1_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain);
__owur int ssl_cert_add0_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x);
__owur int ssl_cert_add1_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x);
__owur int ssl_cert_select_current(CERT *c, X509 *x);
__owur int ssl_cert_set_current(CERT *c, long arg);
__owur X509 *ssl_cert_get0_next_certificate(CERT *c, int first);
1870 1871
void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg),
                          void *arg);
1872

M
Matt Caswell 已提交
1873 1874 1875 1876
__owur int ssl_verify_cert_chain(SSL *s, STACK_OF(X509) *sk);
__owur int ssl_add_cert_chain(SSL *s, CERT_PKEY *cpk, unsigned long *l);
__owur int ssl_build_cert_chain(SSL *s, SSL_CTX *ctx, int flags);
__owur int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain, int ref);
D
Dr. Stephen Henson 已提交
1877

M
Matt Caswell 已提交
1878 1879
__owur int ssl_security(SSL *s, int op, int bits, int nid, void *other);
__owur int ssl_ctx_security(SSL_CTX *ctx, int op, int bits, int nid, void *other);
D
Dr. Stephen Henson 已提交
1880

1881
int ssl_undefined_function(SSL *s);
M
Matt Caswell 已提交
1882 1883
__owur int ssl_undefined_void_function(void);
__owur int ssl_undefined_const_function(const SSL *s);
1884
__owur CERT_PKEY *ssl_get_server_send_pkey(SSL *s);
M
Matt Caswell 已提交
1885
__owur int ssl_get_server_cert_serverinfo(SSL *s, const unsigned char **serverinfo,
1886
                                   size_t *serverinfo_length);
M
Matt Caswell 已提交
1887 1888
__owur EVP_PKEY *ssl_get_sign_pkey(SSL *s, const SSL_CIPHER *c, const EVP_MD **pmd);
__owur int ssl_cert_type(X509 *x, EVP_PKEY *pkey);
1889
void ssl_set_masks(SSL *s, const SSL_CIPHER *cipher);
M
Matt Caswell 已提交
1890 1891
__owur STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s);
__owur int ssl_verify_alarm_type(long type);
1892
void ssl_load_ciphers(void);
M
Matt Caswell 已提交
1893
__owur int ssl_fill_hello_random(SSL *s, int server, unsigned char *field, int len);
1894 1895
__owur int ssl_generate_master_secret(SSL *s, unsigned char *pms, size_t pmslen,
                                      int free_pms);
1896 1897
__owur EVP_PKEY *ssl_generate_pkey(EVP_PKEY *pm, int nid);
__owur int ssl_derive(SSL *s, EVP_PKEY *privkey, EVP_PKEY *pubkey);
D
Dr. Stephen Henson 已提交
1898
__owur EVP_PKEY *ssl_dh_to_pkey(DH *dh);
1899

M
Matt Caswell 已提交
1900 1901
__owur const SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p);
__owur int ssl3_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p);
1902
void ssl3_init_finished_mac(SSL *s);
M
Matt Caswell 已提交
1903 1904
__owur int ssl3_setup_key_block(SSL *s);
__owur int ssl3_change_cipher_state(SSL *s, int which);
1905
void ssl3_cleanup_key_block(SSL *s);
M
Matt Caswell 已提交
1906
__owur int ssl3_do_write(SSL *s, int type);
1907
int ssl3_send_alert(SSL *s, int level, int desc);
M
Matt Caswell 已提交
1908
__owur int ssl3_generate_master_secret(SSL *s, unsigned char *out,
1909
                                unsigned char *p, int len);
M
Matt Caswell 已提交
1910 1911 1912
__owur int ssl3_get_req_cert_type(SSL *s, unsigned char *p);
__owur int ssl3_num_ciphers(void);
__owur const SSL_CIPHER *ssl3_get_cipher(unsigned int u);
1913 1914
int ssl3_renegotiate(SSL *ssl);
int ssl3_renegotiate_check(SSL *ssl);
M
Matt Caswell 已提交
1915 1916
__owur int ssl3_dispatch_alert(SSL *s);
__owur int ssl3_final_finish_mac(SSL *s, const char *sender, int slen,
1917
                          unsigned char *p);
B
Ben Laurie 已提交
1918
void ssl3_finish_mac(SSL *s, const unsigned char *buf, int len);
1919
void ssl3_free_digest_list(SSL *s);
M
Matt Caswell 已提交
1920
__owur unsigned long ssl3_output_cert_chain(SSL *s, CERT_PKEY *cpk);
1921 1922 1923
__owur const SSL_CIPHER *ssl3_choose_cipher(SSL *ssl,
                                            STACK_OF(SSL_CIPHER) *clnt,
                                            STACK_OF(SSL_CIPHER) *srvr);
1924
__owur int ssl3_digest_cached_records(SSL *s, int keep);
M
Matt Caswell 已提交
1925
__owur int ssl3_new(SSL *s);
1926
void ssl3_free(SSL *s);
M
Matt Caswell 已提交
1927 1928 1929 1930
__owur int ssl3_read(SSL *s, void *buf, int len);
__owur int ssl3_peek(SSL *s, void *buf, int len);
__owur int ssl3_write(SSL *s, const void *buf, int len);
__owur int ssl3_shutdown(SSL *s);
1931
void ssl3_clear(SSL *s);
M
Matt Caswell 已提交
1932 1933 1934 1935
__owur long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg);
__owur long ssl3_ctx_ctrl(SSL_CTX *s, int cmd, long larg, void *parg);
__owur long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp) (void));
__owur long ssl3_ctx_callback_ctrl(SSL_CTX *s, int cmd, void (*fp) (void));
1936

M
Matt Caswell 已提交
1937 1938
__owur int ssl3_do_change_cipher_spec(SSL *ssl);
__owur long ssl3_default_timeout(void);
1939

M
Matt Caswell 已提交
1940
__owur int ssl3_set_handshake_header(SSL *s, int htype, unsigned long len);
M
Matt Caswell 已提交
1941 1942 1943 1944
__owur int ssl3_handshake_write(SSL *s);

__owur int ssl_allow_compression(SSL *s);

1945 1946 1947 1948 1949 1950
__owur int ssl_set_client_hello_version(SSL *s);
__owur int ssl_check_version_downgrade(SSL *s);
__owur int ssl_set_version_bound(int method_version, int version, int *bound);
__owur int ssl_choose_server_version(SSL *s);
__owur int ssl_choose_client_version(SSL *s, int version);

M
Matt Caswell 已提交
1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963
__owur long tls1_default_timeout(void);
__owur int dtls1_do_write(SSL *s, int type);
void dtls1_set_message_header(SSL *s,
                              unsigned char *p, unsigned char mt,
                              unsigned long len,
                              unsigned long frag_off,
                              unsigned long frag_len);

__owur int dtls1_write_app_data_bytes(SSL *s, int type, const void *buf, int len);

__owur int dtls1_read_failed(SSL *s, int code);
__owur int dtls1_buffer_message(SSL *s, int ccs);
__owur int dtls1_retransmit_message(SSL *s, unsigned short seq,
1964
                             unsigned long frag_off, int *found);
M
Matt Caswell 已提交
1965
__owur int dtls1_get_queue_priority(unsigned short seq, int is_ccs);
M
Matt Caswell 已提交
1966
int dtls1_retransmit_buffered_messages(SSL *s);
1967
void dtls1_clear_record_buffer(SSL *s);
1968 1969
void dtls1_get_message_header(unsigned char *data,
                              struct hm_header_st *msg_hdr);
M
Matt Caswell 已提交
1970 1971 1972 1973 1974
__owur long dtls1_default_timeout(void);
__owur struct timeval *dtls1_get_timeout(SSL *s, struct timeval *timeleft);
__owur int dtls1_check_timeout_num(SSL *s);
__owur int dtls1_handle_timeout(SSL *s);
__owur const SSL_CIPHER *dtls1_get_cipher(unsigned int u);
1975 1976
void dtls1_start_timer(SSL *s);
void dtls1_stop_timer(SSL *s);
M
Matt Caswell 已提交
1977
__owur int dtls1_is_timer_expired(SSL *s);
1978
void dtls1_double_timeout(SSL *s);
M
Matt Caswell 已提交
1979 1980 1981
__owur unsigned int dtls_raw_hello_verify_request(unsigned char *buf,
                                                  unsigned char *cookie,
                                                  unsigned char cookie_len);
M
Matt Caswell 已提交
1982 1983
__owur int dtls1_send_newsession_ticket(SSL *s);
__owur unsigned int dtls1_min_mtu(SSL *s);
1984
void dtls1_hm_fragment_free(hm_fragment *frag);
M
Matt Caswell 已提交
1985
__owur int dtls1_query_mtu(SSL *s);
1986

M
Matt Caswell 已提交
1987
__owur int tls1_new(SSL *s);
1988 1989
void tls1_free(SSL *s);
void tls1_clear(SSL *s);
1990 1991
long tls1_ctrl(SSL *s, int cmd, long larg, void *parg);
long tls1_callback_ctrl(SSL *s, int cmd, void (*fp) (void));
1992

M
Matt Caswell 已提交
1993
__owur int dtls1_new(SSL *s);
B
Ben Laurie 已提交
1994 1995
void dtls1_free(SSL *s);
void dtls1_clear(SSL *s);
1996
long dtls1_ctrl(SSL *s, int cmd, long larg, void *parg);
M
Matt Caswell 已提交
1997
__owur int dtls1_shutdown(SSL *s);
B
Ben Laurie 已提交
1998

M
Matt Caswell 已提交
1999
__owur int dtls1_dispatch_alert(SSL *s);
B
Ben Laurie 已提交
2000

M
Matt Caswell 已提交
2001
__owur int ssl_init_wbio_buffer(SSL *s, int push);
2002
void ssl_free_wbio_buffer(SSL *s);
2003

M
Matt Caswell 已提交
2004 2005 2006
__owur int tls1_change_cipher_state(SSL *s, int which);
__owur int tls1_setup_key_block(SSL *s);
__owur int tls1_final_finish_mac(SSL *s,
2007
                          const char *str, int slen, unsigned char *p);
M
Matt Caswell 已提交
2008
__owur int tls1_generate_master_secret(SSL *s, unsigned char *out,
2009
                                unsigned char *p, int len);
M
Matt Caswell 已提交
2010
__owur int tls1_export_keying_material(SSL *s, unsigned char *out, size_t olen,
2011 2012 2013
                                const char *label, size_t llen,
                                const unsigned char *p, size_t plen,
                                int use_context);
M
Matt Caswell 已提交
2014 2015 2016
__owur int tls1_alert_code(int code);
__owur int ssl3_alert_code(int code);
__owur int ssl_ok(SSL *s);
2017

2018
#  ifndef OPENSSL_NO_EC
M
Matt Caswell 已提交
2019
__owur int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s);
2020
#  endif
B
Bodo Möller 已提交
2021

B
Ben Laurie 已提交
2022
SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n);
2023

2024
#  ifndef OPENSSL_NO_EC
M
Matt Caswell 已提交
2025 2026 2027 2028 2029
__owur int tls1_ec_curve_id2nid(int curve_id);
__owur int tls1_ec_nid2curve_id(int nid);
__owur int tls1_check_curve(SSL *s, const unsigned char *p, size_t len);
__owur int tls1_shared_curve(SSL *s, int nmatch);
__owur int tls1_set_curves(unsigned char **pext, size_t *pextlen,
2030
                    int *curves, size_t ncurves);
M
Matt Caswell 已提交
2031
__owur int tls1_set_curves_list(unsigned char **pext, size_t *pextlen,
2032
                         const char *str);
M
Matt Caswell 已提交
2033
__owur int tls1_check_ec_tmp_key(SSL *s, unsigned long id);
2034
#  endif                        /* OPENSSL_NO_EC */
2035

M
Matt Caswell 已提交
2036
__owur int tls1_shared_list(SSL *s,
2037 2038
                     const unsigned char *l1, size_t l1len,
                     const unsigned char *l2, size_t l2len, int nmatch);
M
Matt Caswell 已提交
2039
__owur unsigned char *ssl_add_clienthello_tlsext(SSL *s, unsigned char *buf,
2040
                                          unsigned char *limit, int *al);
M
Matt Caswell 已提交
2041
__owur unsigned char *ssl_add_serverhello_tlsext(SSL *s, unsigned char *buf,
2042
                                          unsigned char *limit, int *al);
M
Matt Caswell 已提交
2043
__owur int ssl_parse_clienthello_tlsext(SSL *s, PACKET *pkt);
2044
void ssl_set_default_md(SSL *s);
M
Matt Caswell 已提交
2045 2046
__owur int tls1_set_server_sigalgs(SSL *s);
__owur int ssl_check_clienthello_tlsext_late(SSL *s);
M
Matt Caswell 已提交
2047
__owur int ssl_parse_serverhello_tlsext(SSL *s, PACKET *pkt);
M
Matt Caswell 已提交
2048 2049
__owur int ssl_prepare_clienthello_tlsext(SSL *s);
__owur int ssl_prepare_serverhello_tlsext(SSL *s);
D
Dr. Stephen Henson 已提交
2050

2051
#  ifndef OPENSSL_NO_HEARTBEATS
M
Matt Caswell 已提交
2052 2053
__owur int tls1_heartbeat(SSL *s);
__owur int dtls1_heartbeat(SSL *s);
2054 2055
__owur int tls1_process_heartbeat(SSL *s, unsigned char *p, unsigned int length);
__owur int dtls1_process_heartbeat(SSL *s, unsigned char *p, unsigned int length);
2056
#  endif
D
Dr. Stephen Henson 已提交
2057

2058 2059 2060
__owur int tls_check_serverhello_tlsext_early(SSL *s, const PACKET *ext,
                                              const PACKET *session_id,
                                              SSL_SESSION **ret);
2061

M
Matt Caswell 已提交
2062
__owur int tls12_get_sigandhash(unsigned char *p, const EVP_PKEY *pk,
2063
                         const EVP_MD *md);
M
Matt Caswell 已提交
2064 2065
__owur int tls12_get_sigid(const EVP_PKEY *pk);
__owur const EVP_MD *tls12_get_hash(unsigned char hash_alg);
2066
void ssl_set_sig_mask(uint32_t *pmask_a, SSL *s, int op);
2067

M
Matt Caswell 已提交
2068 2069
__owur int tls1_set_sigalgs_list(CERT *c, const char *str, int client);
__owur int tls1_set_sigalgs(CERT *c, const int *salg, size_t salglen, int client);
M
Matt Caswell 已提交
2070
int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain,
2071
                     int idx);
2072
void tls1_set_cert_validity(SSL *s);
2073

2074
#  ifndef OPENSSL_NO_DH
M
Matt Caswell 已提交
2075
__owur DH *ssl_get_auto_dh(SSL *s);
2076
#  endif
D
Dr. Stephen Henson 已提交
2077

M
Matt Caswell 已提交
2078 2079
__owur int ssl_security_cert(SSL *s, SSL_CTX *ctx, X509 *x, int vfy, int is_ee);
__owur int ssl_security_cert_chain(SSL *s, STACK_OF(X509) *sk, X509 *ex, int vfy);
D
Dr. Stephen Henson 已提交
2080

M
Matt Caswell 已提交
2081
__owur EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash, const EVP_MD *md);
2082
void ssl_clear_hash_ctx(EVP_MD_CTX **hash);
M
Matt Caswell 已提交
2083
__owur int ssl_add_serverhello_renegotiate_ext(SSL *s, unsigned char *p, int *len,
2084
                                        int maxlen);
M
Matt Caswell 已提交
2085
__owur int ssl_parse_serverhello_renegotiate_ext(SSL *s, PACKET *pkt,
2086
                                          int *al);
M
Matt Caswell 已提交
2087
__owur int ssl_add_clienthello_renegotiate_ext(SSL *s, unsigned char *p, int *len,
2088
                                        int maxlen);
M
Matt Caswell 已提交
2089
__owur int ssl_parse_clienthello_renegotiate_ext(SSL *s, PACKET *pkt, int *al);
M
Matt Caswell 已提交
2090 2091
__owur long ssl_get_algorithm2(SSL *s);
__owur size_t tls12_copy_sigalgs(SSL *s, unsigned char *out,
2092
                          const unsigned char *psig, size_t psiglen);
M
Matt Caswell 已提交
2093 2094 2095 2096
__owur int tls1_save_sigalgs(SSL *s, const unsigned char *data, int dsize);
__owur int tls1_process_sigalgs(SSL *s);
__owur size_t tls12_get_psigalgs(SSL *s, const unsigned char **psigs);
__owur int tls12_check_peer_sigalg(const EVP_MD **pmd, SSL *s,
2097
                            const unsigned char *sig, EVP_PKEY *pkey);
2098
void ssl_set_client_disabled(SSL *s);
M
Matt Caswell 已提交
2099
__owur int ssl_cipher_disabled(SSL *s, const SSL_CIPHER *c, int op);
2100

M
Matt Caswell 已提交
2101
__owur int ssl_add_clienthello_use_srtp_ext(SSL *s, unsigned char *p, int *len,
2102
                                     int maxlen);
M
Matt Caswell 已提交
2103
__owur int ssl_parse_clienthello_use_srtp_ext(SSL *s, PACKET *pkt, int *al);
M
Matt Caswell 已提交
2104
__owur int ssl_add_serverhello_use_srtp_ext(SSL *s, unsigned char *p, int *len,
2105
                                     int maxlen);
M
Matt Caswell 已提交
2106
__owur int ssl_parse_serverhello_use_srtp_ext(SSL *s, PACKET *pkt, int *al);
2107

M
Matt Caswell 已提交
2108
__owur int ssl_handshake_hash(SSL *s, unsigned char *out, int outlen);
2109
__owur const EVP_MD *ssl_md(int idx);
2110 2111
__owur const EVP_MD *ssl_handshake_md(SSL *s);
__owur const EVP_MD *ssl_prf_md(SSL *s);
2112

B
Ben Laurie 已提交
2113
/* s3_cbc.c */
M
Matt Caswell 已提交
2114
__owur char ssl3_cbc_record_digest_supported(const EVP_MD_CTX *ctx);
2115 2116 2117 2118 2119 2120 2121 2122 2123
__owur int 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);
2124 2125 2126 2127

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);
D
Dr. Stephen Henson 已提交
2128

2129 2130
__owur int srp_generate_server_master_secret(SSL *s);
__owur int srp_generate_client_master_secret(SSL *s);
M
Matt Caswell 已提交
2131
__owur int srp_verify_server_param(SSL *s, int *al);
D
Dr. Stephen Henson 已提交
2132

D
Dr. Stephen Henson 已提交
2133 2134
/* t1_ext.c */

2135 2136
void custom_ext_init(custom_ext_methods *meths);

M
Matt Caswell 已提交
2137
__owur int custom_ext_parse(SSL *s, int server,
2138 2139
                     unsigned int ext_type,
                     const unsigned char *ext_data, size_t ext_size, int *al);
M
Matt Caswell 已提交
2140
__owur int custom_ext_add(SSL *s, int server,
2141
                   unsigned char **pret, unsigned char *limit, int *al);
D
Dr. Stephen Henson 已提交
2142

M
Matt Caswell 已提交
2143
__owur int custom_exts_copy(custom_ext_methods *dst, const custom_ext_methods *src);
D
Dr. Stephen Henson 已提交
2144 2145
void custom_exts_free(custom_ext_methods *exts);

2146
# else
2147

2148 2149 2150 2151
#  define ssl_init_wbio_buffer SSL_test_functions()->p_ssl_init_wbio_buffer
#  define ssl3_setup_buffers SSL_test_functions()->p_ssl3_setup_buffers
#  define tls1_process_heartbeat SSL_test_functions()->p_tls1_process_heartbeat
#  define dtls1_process_heartbeat SSL_test_functions()->p_dtls1_process_heartbeat
2152

2153
# endif
2154
#endif