OpenCoverage

ssl_locl.h

Absolute File Name:

/home/opencoverage/opencoverage/guest-scripts/openssl/src/ssl/ssl_locl.h

Source code

Switch to Preprocessed file

Line Source Count

1 /* -

5 * -

6 * Licensed under the OpenSSL license (the "License"). You may not use -

7 * this file except in compliance with the License. You can obtain a copy -

8 * in the file LICENSE in the source distribution or at -

9 * https://www.openssl.org/source/license.html -

10 */ -

11 -

12 #ifndef HEADER_SSL_LOCL_H -

13 # define HEADER_SSL_LOCL_H -

14 -

15 # include "e_os.h" /* struct timeval for DTLS */ -

16 # include <stdlib.h> -

17 # include <time.h> -

18 # include <string.h> -

19 # include <errno.h> -

20 -

21 # include <openssl/buffer.h> -

22 # include <openssl/comp.h> -

23 # include <openssl/bio.h> -

24 # include <openssl/rsa.h> -

25 # include <openssl/dsa.h> -

26 # include <openssl/err.h> -

27 # include <openssl/ssl.h> -

28 # include <openssl/async.h> -

29 # include <openssl/symhacks.h> -

30 # include <openssl/ct.h> -

31 # include "record/record.h" -

32 # include "statem/statem.h" -

33 # include "packet_locl.h" -

34 # include "internal/dane.h" -

35 # include "internal/refcount.h" -

36 # include "internal/tsan_assist.h" -

37 -

38 # ifdef OPENSSL_BUILD_SHLIBSSL -

39 # undef OPENSSL_EXTERN -

40 # define OPENSSL_EXTERN OPENSSL_EXPORT -

41 # endif -

42 -

43 # define c2l(c,l) (l = ((unsigned long)(*((c)++))) , \ -

44 l|=(((unsigned long)(*((c)++)))<< 8), \ -

45 l|=(((unsigned long)(*((c)++)))<<16), \ -

46 l|=(((unsigned long)(*((c)++)))<<24)) -

47 -

48 /* NOTE - c is not incremented as per c2l */ -

49 # define c2ln(c,l1,l2,n) { \ -

50 c+=n; \ -

51 l1=l2=0; \ -

52 switch (n) { \ -

53 case 8: l2 =((unsigned long)(*(--(c))))<<24; \ -

54 case 7: l2|=((unsigned long)(*(--(c))))<<16; \ -

55 case 6: l2|=((unsigned long)(*(--(c))))<< 8; \ -

56 case 5: l2|=((unsigned long)(*(--(c)))); \ -

57 case 4: l1 =((unsigned long)(*(--(c))))<<24; \ -

58 case 3: l1|=((unsigned long)(*(--(c))))<<16; \ -

59 case 2: l1|=((unsigned long)(*(--(c))))<< 8; \ -

60 case 1: l1|=((unsigned long)(*(--(c)))); \ -

61 } \ -

62 } -

63 -

64 # define l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \ -

65 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \ -

66 *((c)++)=(unsigned char)(((l)>>16)&0xff), \ -

67 *((c)++)=(unsigned char)(((l)>>24)&0xff)) -

68 -

69 # define n2l(c,l) (l =((unsigned long)(*((c)++)))<<24, \ -

70 l|=((unsigned long)(*((c)++)))<<16, \ -

71 l|=((unsigned long)(*((c)++)))<< 8, \ -

72 l|=((unsigned long)(*((c)++)))) -

73 -

74 # define n2l8(c,l) (l =((uint64_t)(*((c)++)))<<56, \ -

75 l|=((uint64_t)(*((c)++)))<<48, \ -

76 l|=((uint64_t)(*((c)++)))<<40, \ -

77 l|=((uint64_t)(*((c)++)))<<32, \ -

78 l|=((uint64_t)(*((c)++)))<<24, \ -

79 l|=((uint64_t)(*((c)++)))<<16, \ -

80 l|=((uint64_t)(*((c)++)))<< 8, \ -

81 l|=((uint64_t)(*((c)++)))) -

82 -

83 -

84 # define l2n(l,c) (*((c)++)=(unsigned char)(((l)>>24)&0xff), \ -

85 *((c)++)=(unsigned char)(((l)>>16)&0xff), \ -

86 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \ -

87 *((c)++)=(unsigned char)(((l) )&0xff)) -

88 -

89 # define l2n6(l,c) (*((c)++)=(unsigned char)(((l)>>40)&0xff), \ -

90 *((c)++)=(unsigned char)(((l)>>32)&0xff), \ -

91 *((c)++)=(unsigned char)(((l)>>24)&0xff), \ -

92 *((c)++)=(unsigned char)(((l)>>16)&0xff), \ -

93 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \ -

94 *((c)++)=(unsigned char)(((l) )&0xff)) -

95 -

96 # define l2n8(l,c) (*((c)++)=(unsigned char)(((l)>>56)&0xff), \ -

97 *((c)++)=(unsigned char)(((l)>>48)&0xff), \ -

98 *((c)++)=(unsigned char)(((l)>>40)&0xff), \ -

99 *((c)++)=(unsigned char)(((l)>>32)&0xff), \ -

100 *((c)++)=(unsigned char)(((l)>>24)&0xff), \ -

101 *((c)++)=(unsigned char)(((l)>>16)&0xff), \ -

102 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \ -

103 *((c)++)=(unsigned char)(((l) )&0xff)) -

104 -

105 /* NOTE - c is not incremented as per l2c */ -

106 # define l2cn(l1,l2,c,n) { \ -

107 c+=n; \ -

108 switch (n) { \ -

109 case 8: *(--(c))=(unsigned char)(((l2)>>24)&0xff); \ -

110 case 7: *(--(c))=(unsigned char)(((l2)>>16)&0xff); \ -

111 case 6: *(--(c))=(unsigned char)(((l2)>> 8)&0xff); \ -

112 case 5: *(--(c))=(unsigned char)(((l2) )&0xff); \ -

113 case 4: *(--(c))=(unsigned char)(((l1)>>24)&0xff); \ -

114 case 3: *(--(c))=(unsigned char)(((l1)>>16)&0xff); \ -

115 case 2: *(--(c))=(unsigned char)(((l1)>> 8)&0xff); \ -

116 case 1: *(--(c))=(unsigned char)(((l1) )&0xff); \ -

117 } \ -

118 } -

119 -

120 # define n2s(c,s) ((s=(((unsigned int)((c)[0]))<< 8)| \ -

121 (((unsigned int)((c)[1])) )),(c)+=2) -

122 # define s2n(s,c) (((c)[0]=(unsigned char)(((s)>> 8)&0xff), \ -

123 (c)[1]=(unsigned char)(((s) )&0xff)),(c)+=2) -

124 -

125 # define n2l3(c,l) ((l =(((unsigned long)((c)[0]))<<16)| \ -

126 (((unsigned long)((c)[1]))<< 8)| \ -

127 (((unsigned long)((c)[2])) )),(c)+=3) -

128 -

129 # define l2n3(l,c) (((c)[0]=(unsigned char)(((l)>>16)&0xff), \ -

130 (c)[1]=(unsigned char)(((l)>> 8)&0xff), \ -

131 (c)[2]=(unsigned char)(((l) )&0xff)),(c)+=3) -

132 -

133 /* -

134 * DTLS version numbers are strange because they're inverted. Except for -

135 * DTLS1_BAD_VER, which should be considered "lower" than the rest. -

136 */ -

137 # define dtls_ver_ordinal(v1) (((v1) == DTLS1_BAD_VER) ? 0xff00 : (v1)) -

138 # define DTLS_VERSION_GT(v1, v2) (dtls_ver_ordinal(v1) < dtls_ver_ordinal(v2)) -

139 # define DTLS_VERSION_GE(v1, v2) (dtls_ver_ordinal(v1) <= dtls_ver_ordinal(v2)) -

140 # define DTLS_VERSION_LT(v1, v2) (dtls_ver_ordinal(v1) > dtls_ver_ordinal(v2)) -

141 # define DTLS_VERSION_LE(v1, v2) (dtls_ver_ordinal(v1) >= dtls_ver_ordinal(v2)) -

142 -

143 -

144 /* -

145 * Define the Bitmasks for SSL_CIPHER.algorithms. -

146 * This bits are used packed as dense as possible. If new methods/ciphers -

147 * etc will be added, the bits a likely to change, so this information -

148 * is for internal library use only, even though SSL_CIPHER.algorithms -

149 * can be publicly accessed. -

150 * Use the according functions for cipher management instead. -

151 * -

152 * The bit mask handling in the selection and sorting scheme in -

153 * ssl_create_cipher_list() has only limited capabilities, reflecting -

154 * that the different entities within are mutually exclusive: -

155 * ONLY ONE BIT PER MASK CAN BE SET AT A TIME. -

156 */ -

157 -

158 /* Bits for algorithm_mkey (key exchange algorithm) */ -

159 /* RSA key exchange */ -

160 # define SSL_kRSA 0x00000001U -

161 /* tmp DH key no DH cert */ -

162 # define SSL_kDHE 0x00000002U -

163 /* synonym */ -

164 # define SSL_kEDH SSL_kDHE -

165 /* ephemeral ECDH */ -

166 # define SSL_kECDHE 0x00000004U -

167 /* synonym */ -

168 # define SSL_kEECDH SSL_kECDHE -

169 /* PSK */ -

170 # define SSL_kPSK 0x00000008U -

171 /* GOST key exchange */ -

172 # define SSL_kGOST 0x00000010U -

173 /* SRP */ -

174 # define SSL_kSRP 0x00000020U -

175 -

176 # define SSL_kRSAPSK 0x00000040U -

177 # define SSL_kECDHEPSK 0x00000080U -

178 # define SSL_kDHEPSK 0x00000100U -

179 -

180 /* all PSK */ -

181 -

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

183 -

184 /* Any appropriate key exchange algorithm (for TLS 1.3 ciphersuites) */ -

185 # define SSL_kANY 0x00000000U -

186 -

187 /* Bits for algorithm_auth (server authentication) */ -

188 /* RSA auth */ -

189 # define SSL_aRSA 0x00000001U -

190 /* DSS auth */ -

191 # define SSL_aDSS 0x00000002U -

192 /* no auth (i.e. use ADH or AECDH) */ -

193 # define SSL_aNULL 0x00000004U -

194 /* ECDSA auth*/ -

195 # define SSL_aECDSA 0x00000008U -

196 /* PSK auth */ -

197 # define SSL_aPSK 0x00000010U -

198 /* GOST R 34.10-2001 signature auth */ -

199 # define SSL_aGOST01 0x00000020U -

200 /* SRP auth */ -

201 # define SSL_aSRP 0x00000040U -

202 /* GOST R 34.10-2012 signature auth */ -

203 # define SSL_aGOST12 0x00000080U -

204 /* Any appropriate signature auth (for TLS 1.3 ciphersuites) */ -

205 # define SSL_aANY 0x00000000U -

206 /* All bits requiring a certificate */ -

207 #define SSL_aCERT \ -

208 (SSL_aRSA | SSL_aDSS | SSL_aECDSA | SSL_aGOST01 | SSL_aGOST12) -

209 -

210 /* Bits for algorithm_enc (symmetric encryption) */ -

211 # define SSL_DES 0x00000001U -

212 # define SSL_3DES 0x00000002U -

213 # define SSL_RC4 0x00000004U -

214 # define SSL_RC2 0x00000008U -

215 # define SSL_IDEA 0x00000010U -

216 # define SSL_eNULL 0x00000020U -

217 # define SSL_AES128 0x00000040U -

218 # define SSL_AES256 0x00000080U -

219 # define SSL_CAMELLIA128 0x00000100U -

220 # define SSL_CAMELLIA256 0x00000200U -

221 # define SSL_eGOST2814789CNT 0x00000400U -

222 # define SSL_SEED 0x00000800U -

223 # define SSL_AES128GCM 0x00001000U -

224 # define SSL_AES256GCM 0x00002000U -

225 # define SSL_AES128CCM 0x00004000U -

226 # define SSL_AES256CCM 0x00008000U -

227 # define SSL_AES128CCM8 0x00010000U -

228 # define SSL_AES256CCM8 0x00020000U -

229 # define SSL_eGOST2814789CNT12 0x00040000U -

230 # define SSL_CHACHA20POLY1305 0x00080000U -

231 # define SSL_ARIA128GCM 0x00100000U -

232 # define SSL_ARIA256GCM 0x00200000U -

233 -

234 # define SSL_AESGCM (SSL_AES128GCM | SSL_AES256GCM) -

235 # define SSL_AESCCM (SSL_AES128CCM | SSL_AES256CCM | SSL_AES128CCM8 | SSL_AES256CCM8) -

236 # define SSL_AES (SSL_AES128|SSL_AES256|SSL_AESGCM|SSL_AESCCM) -

237 # define SSL_CAMELLIA (SSL_CAMELLIA128|SSL_CAMELLIA256) -

238 # define SSL_CHACHA20 (SSL_CHACHA20POLY1305) -

239 # define SSL_ARIAGCM (SSL_ARIA128GCM | SSL_ARIA256GCM) -

240 # define SSL_ARIA (SSL_ARIAGCM) -

241 -

242 /* Bits for algorithm_mac (symmetric authentication) */ -

243 -

244 # define SSL_MD5 0x00000001U -

245 # define SSL_SHA1 0x00000002U -

246 # define SSL_GOST94 0x00000004U -

247 # define SSL_GOST89MAC 0x00000008U -

248 # define SSL_SHA256 0x00000010U -

249 # define SSL_SHA384 0x00000020U -

250 /* Not a real MAC, just an indication it is part of cipher */ -

251 # define SSL_AEAD 0x00000040U -

252 # define SSL_GOST12_256 0x00000080U -

253 # define SSL_GOST89MAC12 0x00000100U -

254 # define SSL_GOST12_512 0x00000200U -

255 -

256 /* -

257 * When adding new digest in the ssl_ciph.c and increment SSL_MD_NUM_IDX make -

258 * sure to update this constant too -

259 */ -

260 -

261 # define SSL_MD_MD5_IDX 0 -

262 # define SSL_MD_SHA1_IDX 1 -

263 # define SSL_MD_GOST94_IDX 2 -

264 # define SSL_MD_GOST89MAC_IDX 3 -

265 # define SSL_MD_SHA256_IDX 4 -

266 # define SSL_MD_SHA384_IDX 5 -

267 # define SSL_MD_GOST12_256_IDX 6 -

268 # define SSL_MD_GOST89MAC12_IDX 7 -

269 # define SSL_MD_GOST12_512_IDX 8 -

270 # define SSL_MD_MD5_SHA1_IDX 9 -

271 # define SSL_MD_SHA224_IDX 10 -

272 # define SSL_MD_SHA512_IDX 11 -

273 # define SSL_MAX_DIGEST 12 -

274 -

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

276 -

277 /* Bits 0-7 are handshake MAC */ -

278 # define SSL_HANDSHAKE_MAC_MASK 0xFF -

279 # define SSL_HANDSHAKE_MAC_MD5_SHA1 SSL_MD_MD5_SHA1_IDX -

280 # define SSL_HANDSHAKE_MAC_SHA256 SSL_MD_SHA256_IDX -

281 # define SSL_HANDSHAKE_MAC_SHA384 SSL_MD_SHA384_IDX -

282 # define SSL_HANDSHAKE_MAC_GOST94 SSL_MD_GOST94_IDX -

283 # define SSL_HANDSHAKE_MAC_GOST12_256 SSL_MD_GOST12_256_IDX -

284 # define SSL_HANDSHAKE_MAC_GOST12_512 SSL_MD_GOST12_512_IDX -

285 # define SSL_HANDSHAKE_MAC_DEFAULT SSL_HANDSHAKE_MAC_MD5_SHA1 -

286 -

287 /* Bits 8-15 bits are PRF */ -

288 # define TLS1_PRF_DGST_SHIFT 8 -

289 # define TLS1_PRF_SHA1_MD5 (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT) -

290 # define TLS1_PRF_SHA256 (SSL_MD_SHA256_IDX << TLS1_PRF_DGST_SHIFT) -

291 # define TLS1_PRF_SHA384 (SSL_MD_SHA384_IDX << TLS1_PRF_DGST_SHIFT) -

292 # define TLS1_PRF_GOST94 (SSL_MD_GOST94_IDX << TLS1_PRF_DGST_SHIFT) -

293 # define TLS1_PRF_GOST12_256 (SSL_MD_GOST12_256_IDX << TLS1_PRF_DGST_SHIFT) -

294 # define TLS1_PRF_GOST12_512 (SSL_MD_GOST12_512_IDX << TLS1_PRF_DGST_SHIFT) -

295 # define TLS1_PRF (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT) -

296 -

297 /* -

298 * Stream MAC for GOST ciphersuites from cryptopro draft (currently this also -

299 * goes into algorithm2) -

300 */ -

301 # define TLS1_STREAM_MAC 0x10000 -

302 -

303 # define SSL_STRONG_MASK 0x0000001FU -

304 # define SSL_DEFAULT_MASK 0X00000020U -

305 -

306 # define SSL_STRONG_NONE 0x00000001U -

307 # define SSL_LOW 0x00000002U -

308 # define SSL_MEDIUM 0x00000004U -

309 # define SSL_HIGH 0x00000008U -

310 # define SSL_FIPS 0x00000010U -

311 # define SSL_NOT_DEFAULT 0x00000020U -

312 -

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

314 -

315 /* Flag used on OpenSSL ciphersuite ids to indicate they are for SSLv3+ */ -

316 # define SSL3_CK_CIPHERSUITE_FLAG 0x03000000 -

317 -

318 /* Check if an SSL structure is using DTLS */ -

319 # define SSL_IS_DTLS(s) (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) -

320 -

321 /* Check if we are using TLSv1.3 */ -

322 # define SSL_IS_TLS13(s) (!SSL_IS_DTLS(s) \ -

323 && (s)->method->version >= TLS1_3_VERSION \ -

324 && (s)->method->version != TLS_ANY_VERSION) -

325 -

326 # define SSL_TREAT_AS_TLS13(s) \ -

327 (SSL_IS_TLS13(s) || (s)->early_data_state == SSL_EARLY_DATA_CONNECTING \ -

328 || (s)->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY \ -

329 || (s)->early_data_state == SSL_EARLY_DATA_WRITING \ -

330 || (s)->early_data_state == SSL_EARLY_DATA_WRITE_RETRY \ -

331 || (s)->hello_retry_request == SSL_HRR_PENDING) -

332 -

333 # define SSL_IS_FIRST_HANDSHAKE(S) ((s)->s3->tmp.finish_md_len == 0 \ -

334 || (s)->s3->tmp.peer_finish_md_len == 0) -

335 -

336 /* See if we need explicit IV */ -

337 # define SSL_USE_EXPLICIT_IV(s) \ -

338 (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_EXPLICIT_IV) -

339 /* -

340 * See if we use signature algorithms extension and signature algorithm -

341 * before signatures. -

342 */ -

343 # define SSL_USE_SIGALGS(s) \ -

344 (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_SIGALGS) -

345 /* -

346 * Allow TLS 1.2 ciphersuites: applies to DTLS 1.2 as well as TLS 1.2: may -

347 * apply to others in future. -

348 */ -

349 # define SSL_USE_TLS1_2_CIPHERS(s) \ -

350 (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_TLS1_2_CIPHERS) -

351 /* -

352 * Determine if a client can use TLS 1.2 ciphersuites: can't rely on method -

353 * flags because it may not be set to correct version yet. -

354 */ -

355 # define SSL_CLIENT_USE_TLS1_2_CIPHERS(s) \ -

356 ((!SSL_IS_DTLS(s) && s->client_version >= TLS1_2_VERSION) || \ -

357 (SSL_IS_DTLS(s) && DTLS_VERSION_GE(s->client_version, DTLS1_2_VERSION))) -

358 /* -

359 * Determine if a client should send signature algorithms extension: -

360 * as with TLS1.2 cipher we can't rely on method flags. -

361 */ -

362 # define SSL_CLIENT_USE_SIGALGS(s) \ -

363 SSL_CLIENT_USE_TLS1_2_CIPHERS(s) -

364 -

365 # define IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value) \ -

366 (((value) >= TLSEXT_max_fragment_length_512) && \ -

367 ((value) <= TLSEXT_max_fragment_length_4096)) -

368 # define USE_MAX_FRAGMENT_LENGTH_EXT(session) \ -

369 IS_MAX_FRAGMENT_LENGTH_EXT_VALID(session->ext.max_fragment_len_mode) -

370 # define GET_MAX_FRAGMENT_LENGTH(session) \ -

371 (512U << (session->ext.max_fragment_len_mode - 1)) -

372 -

373 # define SSL_READ_ETM(s) (s->s3->flags & TLS1_FLAGS_ENCRYPT_THEN_MAC_READ) -

374 # define SSL_WRITE_ETM(s) (s->s3->flags & TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE) -

375 -

376 /* Mostly for SSLv3 */ -

377 # define SSL_PKEY_RSA 0 -

378 # define SSL_PKEY_RSA_PSS_SIGN 1 -

379 # define SSL_PKEY_DSA_SIGN 2 -

380 # define SSL_PKEY_ECC 3 -

381 # define SSL_PKEY_GOST01 4 -

382 # define SSL_PKEY_GOST12_256 5 -

383 # define SSL_PKEY_GOST12_512 6 -

384 # define SSL_PKEY_ED25519 7 -

385 # define SSL_PKEY_ED448 8 -

386 # define SSL_PKEY_NUM 9 -

387 -

388 /*- -

389 * SSL_kRSA <- RSA_ENC -

390 * SSL_kDH <- DH_ENC & (RSA_ENC | RSA_SIGN | DSA_SIGN) -

391 * SSL_kDHE <- RSA_ENC | RSA_SIGN | DSA_SIGN -

392 * SSL_aRSA <- RSA_ENC | RSA_SIGN -

393 * SSL_aDSS <- DSA_SIGN -

394 */ -

395 -

396 /*- -

397 #define CERT_INVALID 0 -

398 #define CERT_PUBLIC_KEY 1 -

399 #define CERT_PRIVATE_KEY 2 -

400 */ -

401 -

402 /* Post-Handshake Authentication state */ -

403 typedef enum { -

404 SSL_PHA_NONE = 0, -

405 SSL_PHA_EXT_SENT, /* client-side only: extension sent */ -

406 SSL_PHA_EXT_RECEIVED, /* server-side only: extension received */ -

407 SSL_PHA_REQUEST_PENDING, /* server-side only: request pending */ -

408 SSL_PHA_REQUESTED /* request received by client, or sent by server */ -

409 } SSL_PHA_STATE; -

410 -

411 /* CipherSuite length. SSLv3 and all TLS versions. */ -

412 # define TLS_CIPHER_LEN 2 -

413 /* used to hold info on the particular ciphers used */ -

414 struct ssl_cipher_st { -

415 uint32_t valid; -

416 const char *name; /* text name */ -

417 const char *stdname; /* RFC name */ -

418 uint32_t id; /* id, 4 bytes, first is version */ -

419 /* -

420 * changed in 1.0.0: these four used to be portions of a single value -

421 * 'algorithms' -

422 */ -

423 uint32_t algorithm_mkey; /* key exchange algorithm */ -

424 uint32_t algorithm_auth; /* server authentication */ -

425 uint32_t algorithm_enc; /* symmetric encryption */ -

426 uint32_t algorithm_mac; /* symmetric authentication */ -

427 int min_tls; /* minimum SSL/TLS protocol version */ -

428 int max_tls; /* maximum SSL/TLS protocol version */ -

429 int min_dtls; /* minimum DTLS protocol version */ -

430 int max_dtls; /* maximum DTLS protocol version */ -

431 uint32_t algo_strength; /* strength and export flags */ -

432 uint32_t algorithm2; /* Extra flags */ -

433 int32_t strength_bits; /* Number of bits really used */ -

434 uint32_t alg_bits; /* Number of bits for algorithm */ -

435 }; -

436 -

437 /* Used to hold SSL/TLS functions */ -

438 struct ssl_method_st { -

439 int version; -

440 unsigned flags; -

441 unsigned long mask; -

442 int (*ssl_new) (SSL *s); -

443 int (*ssl_clear) (SSL *s); -

444 void (*ssl_free) (SSL *s); -

445 int (*ssl_accept) (SSL *s); -

446 int (*ssl_connect) (SSL *s); -

447 int (*ssl_read) (SSL *s, void *buf, size_t len, size_t *readbytes); -

448 int (*ssl_peek) (SSL *s, void *buf, size_t len, size_t *readbytes); -

449 int (*ssl_write) (SSL *s, const void *buf, size_t len, size_t *written); -

450 int (*ssl_shutdown) (SSL *s); -

451 int (*ssl_renegotiate) (SSL *s); -

452 int (*ssl_renegotiate_check) (SSL *s, int); -

453 int (*ssl_read_bytes) (SSL *s, int type, int *recvd_type, -

454 unsigned char *buf, size_t len, int peek, -

455 size_t *readbytes); -

456 int (*ssl_write_bytes) (SSL *s, int type, const void *buf_, size_t len, -

457 size_t *written); -

458 int (*ssl_dispatch_alert) (SSL *s); -

459 long (*ssl_ctrl) (SSL *s, int cmd, long larg, void *parg); -

460 long (*ssl_ctx_ctrl) (SSL_CTX *ctx, int cmd, long larg, void *parg); -

461 const SSL_CIPHER *(*get_cipher_by_char) (const unsigned char *ptr); -

462 int (*put_cipher_by_char) (const SSL_CIPHER *cipher, WPACKET *pkt, -

463 size_t *len); -

464 size_t (*ssl_pending) (const SSL *s); -

465 int (*num_ciphers) (void); -

466 const SSL_CIPHER *(*get_cipher) (unsigned ncipher); -

467 long (*get_timeout) (void); -

468 const struct ssl3_enc_method *ssl3_enc; /* Extra SSLv3/TLS stuff */ -

469 int (*ssl_version) (void); -

470 long (*ssl_callback_ctrl) (SSL *s, int cb_id, void (*fp) (void)); -

471 long (*ssl_ctx_callback_ctrl) (SSL_CTX *s, int cb_id, void (*fp) (void)); -

472 }; -

473 -

474 # define TLS13_MAX_RESUMPTION_PSK_LENGTH PSK_MAX_PSK_LEN -

475 -

476 /*- -

477 * Lets make this into an ASN.1 type structure as follows -

478 * SSL_SESSION_ID ::= SEQUENCE { -

479 * version INTEGER, -- structure version number -

480 * SSLversion INTEGER, -- SSL version number -

481 * Cipher OCTET STRING, -- the 3 byte cipher ID -

482 * Session_ID OCTET STRING, -- the Session ID -

483 * Master_key OCTET STRING, -- the master key -

484 * Key_Arg [ 0 ] IMPLICIT OCTET STRING, -- the optional Key argument -

485 * Time [ 1 ] EXPLICIT INTEGER, -- optional Start Time -

486 * Timeout [ 2 ] EXPLICIT INTEGER, -- optional Timeout ins seconds -

487 * Peer [ 3 ] EXPLICIT X509, -- optional Peer Certificate -

488 * Session_ID_context [ 4 ] EXPLICIT OCTET STRING, -- the Session ID context -

489 * Verify_result [ 5 ] EXPLICIT INTEGER, -- X509_V_... code for `Peer' -

490 * HostName [ 6 ] EXPLICIT OCTET STRING, -- optional HostName from servername TLS extension -

491 * PSK_identity_hint [ 7 ] EXPLICIT OCTET STRING, -- optional PSK identity hint -

492 * PSK_identity [ 8 ] EXPLICIT OCTET STRING, -- optional PSK identity -

493 * Ticket_lifetime_hint [9] EXPLICIT INTEGER, -- server's lifetime hint for session ticket -

494 * Ticket [10] EXPLICIT OCTET STRING, -- session ticket (clients only) -

495 * Compression_meth [11] EXPLICIT OCTET STRING, -- optional compression method -

496 * SRP_username [ 12 ] EXPLICIT OCTET STRING -- optional SRP username -

497 * flags [ 13 ] EXPLICIT INTEGER -- optional flags -

498 * } -

499 * Look in ssl/ssl_asn1.c for more details -

500 * I'm using EXPLICIT tags so I can read the damn things using asn1parse :-). -

501 */ -

502 struct ssl_session_st { -

503 int ssl_version; /* what ssl version session info is being kept -

504 * in here? */ -

505 size_t master_key_length; -

506 -

507 /* TLSv1.3 early_secret used for external PSKs */ -

508 unsigned char early_secret[EVP_MAX_MD_SIZE]; -

509 /* -

510 * For <=TLS1.2 this is the master_key. For TLS1.3 this is the resumption -

511 * PSK -

512 */ -

513 unsigned char master_key[TLS13_MAX_RESUMPTION_PSK_LENGTH]; -

514 /* session_id - valid? */ -

515 size_t session_id_length; -

516 unsigned char session_id[SSL_MAX_SSL_SESSION_ID_LENGTH]; -

517 /* -

518 * this is used to determine whether the session is being reused in the -

519 * appropriate context. It is up to the application to set this, via -

520 * SSL_new -

521 */ -

522 size_t sid_ctx_length; -

523 unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; -

524 # ifndef OPENSSL_NO_PSK -

525 char *psk_identity_hint; -

526 char *psk_identity; -

527 # endif -

528 /* -

529 * Used to indicate that session resumption is not allowed. Applications -

530 * can also set this bit for a new session via not_resumable_session_cb -

531 * to disable session caching and tickets. -

532 */ -

533 int not_resumable; -

534 /* This is the cert and type for the other end. */ -

535 X509 *peer; -

536 int peer_type; -

537 /* Certificate chain peer sent. */ -

538 STACK_OF(X509) *peer_chain; -

539 /* -

540 * when app_verify_callback accepts a session where the peer's -

541 * certificate is not ok, we must remember the error for session reuse: -

542 */ -

543 long verify_result; /* only for servers */ -

544 CRYPTO_REF_COUNT references; -

545 long timeout; -

546 long time; -

547 unsigned int compress_meth; /* Need to lookup the method */ -

548 const SSL_CIPHER *cipher; -

549 unsigned long cipher_id; /* when ASN.1 loaded, this needs to be used to -

550 * load the 'cipher' structure */ -

551 STACK_OF(SSL_CIPHER) *ciphers; /* ciphers offered by the client */ -

552 CRYPTO_EX_DATA ex_data; /* application specific data */ -

553 /* -

554 * These are used to make removal of session-ids more efficient and to -

555 * implement a maximum cache size. -

556 */ -

557 struct ssl_session_st *prev, *next; -

558 -

559 struct { -

560 char *hostname; -

561 # ifndef OPENSSL_NO_EC -

562 size_t ecpointformats_len; -

563 unsigned char *ecpointformats; /* peer's list */ -

564 # endif /* OPENSSL_NO_EC */ -

565 size_t supportedgroups_len; -

566 uint16_t *supportedgroups; /* peer's list */ -

567 /* RFC4507 info */ -

568 unsigned char *tick; /* Session ticket */ -

569 size_t ticklen; /* Session ticket length */ -

570 /* Session lifetime hint in seconds */ -

571 unsigned long tick_lifetime_hint; -

572 uint32_t tick_age_add; -

573 int tick_identity; -

574 /* Max number of bytes that can be sent as early data */ -

575 uint32_t max_early_data; -

576 /* The ALPN protocol selected for this session */ -

577 unsigned char *alpn_selected; -

578 size_t alpn_selected_len; -

579 /* -

580 * Maximum Fragment Length as per RFC 4366. -

581 * If this value does not contain RFC 4366 allowed values (1-4) then -

582 * either the Maximum Fragment Length Negotiation failed or was not -

583 * performed at all. -

584 */ -

585 uint8_t max_fragment_len_mode; -

586 } ext; -

587 # ifndef OPENSSL_NO_SRP -

588 char *srp_username; -

589 # endif -

590 unsigned char *ticket_appdata; -

591 size_t ticket_appdata_len; -

592 uint32_t flags; -

593 CRYPTO_RWLOCK *lock; -

594 }; -

595 -

596 /* Extended master secret support */ -

597 # define SSL_SESS_FLAG_EXTMS 0x1 -

598 -

599 # ifndef OPENSSL_NO_SRP -

600 -

601 typedef struct srp_ctx_st { -

602 /* param for all the callbacks */ -

603 void *SRP_cb_arg; -

604 /* set client Hello login callback */ -

605 int (*TLS_ext_srp_username_callback) (SSL *, int *, void *); -

606 /* set SRP N/g param callback for verification */ -

607 int (*SRP_verify_param_callback) (SSL *, void *); -

608 /* set SRP client passwd callback */ -

609 char *(*SRP_give_srp_client_pwd_callback) (SSL *, void *); -

610 char *login; -

611 BIGNUM *N, *g, *s, *B, *A; -

612 BIGNUM *a, *b, *v; -

613 char *info; -

614 int strength; -

615 unsigned long srp_Mask; -

616 } SRP_CTX; -

617 -

618 # endif -

619 -

620 typedef enum { -

621 SSL_EARLY_DATA_NONE = 0, -

622 SSL_EARLY_DATA_CONNECT_RETRY, -

623 SSL_EARLY_DATA_CONNECTING, -

624 SSL_EARLY_DATA_WRITE_RETRY, -

625 SSL_EARLY_DATA_WRITING, -

626 SSL_EARLY_DATA_WRITE_FLUSH, -

627 SSL_EARLY_DATA_UNAUTH_WRITING, -

628 SSL_EARLY_DATA_FINISHED_WRITING, -

629 SSL_EARLY_DATA_ACCEPT_RETRY, -

630 SSL_EARLY_DATA_ACCEPTING, -

631 SSL_EARLY_DATA_READ_RETRY, -

632 SSL_EARLY_DATA_READING, -

633 SSL_EARLY_DATA_FINISHED_READING -

634 } SSL_EARLY_DATA_STATE; -

635 -

636 /* -

637 * We check that the amount of unreadable early data doesn't exceed -

638 * max_early_data. max_early_data is given in plaintext bytes. However if it is -

639 * unreadable then we only know the number of ciphertext bytes. We also don't -

640 * know how much the overhead should be because it depends on the ciphersuite. -

641 * We make a small allowance. We assume 5 records of actual data plus the end -

642 * of early data alert record. Each record has a tag and a content type byte. -

643 * The longest tag length we know of is EVP_GCM_TLS_TAG_LEN. We don't count the -

644 * content of the alert record either which is 2 bytes. -

645 */ -

646 # define EARLY_DATA_CIPHERTEXT_OVERHEAD ((6 * (EVP_GCM_TLS_TAG_LEN + 1)) + 2) -

647 -

648 /* -

649 * The allowance we have between the client's calculated ticket age and our own. -

650 * We allow for 10 seconds (units are in ms). If a ticket is presented and the -

651 * client's age calculation is different by more than this than our own then we -

652 * do not allow that ticket for early_data. -

653 */ -

654 # define TICKET_AGE_ALLOWANCE (10 * 1000) -

655 -

656 #define MAX_COMPRESSIONS_SIZE 255 -

657 -

658 struct ssl_comp_st { -

659 int id; -

660 const char *name; -

661 COMP_METHOD *method; -

662 }; -

663 -

664 typedef struct raw_extension_st { -

665 /* Raw packet data for the extension */ -

666 PACKET data; -

667 /* Set to 1 if the extension is present or 0 otherwise */ -

668 int present; -

669 /* Set to 1 if we have already parsed the extension or 0 otherwise */ -

670 int parsed; -

671 /* The type of this extension, i.e. a TLSEXT_TYPE_* value */ -

672 unsigned int type; -

673 /* Track what order extensions are received in (0-based). */ -

674 size_t received_order; -

675 } RAW_EXTENSION; -

676 -

677 typedef struct { -

678 unsigned int isv2; -

679 unsigned int legacy_version; -

680 unsigned char random[SSL3_RANDOM_SIZE]; -

681 size_t session_id_len; -

682 unsigned char session_id[SSL_MAX_SSL_SESSION_ID_LENGTH]; -

683 size_t dtls_cookie_len; -

684 unsigned char dtls_cookie[DTLS1_COOKIE_LENGTH]; -

685 PACKET ciphersuites; -

686 size_t compressions_len; -

687 unsigned char compressions[MAX_COMPRESSIONS_SIZE]; -

688 PACKET extensions; -

689 size_t pre_proc_exts_len; -

690 RAW_EXTENSION *pre_proc_exts; -

691 } CLIENTHELLO_MSG; -

692 -

693 /* -

694 * Extension index values NOTE: Any updates to these defines should be mirrored -

695 * with equivalent updates to ext_defs in extensions.c -

696 */ -

697 typedef enum tlsext_index_en { -

698 TLSEXT_IDX_renegotiate, -

699 TLSEXT_IDX_server_name, -

700 TLSEXT_IDX_max_fragment_length, -

701 TLSEXT_IDX_srp, -

702 TLSEXT_IDX_ec_point_formats, -

703 TLSEXT_IDX_supported_groups, -

704 TLSEXT_IDX_session_ticket, -

705 TLSEXT_IDX_status_request, -

706 TLSEXT_IDX_next_proto_neg, -

707 TLSEXT_IDX_application_layer_protocol_negotiation, -

708 TLSEXT_IDX_use_srtp, -

709 TLSEXT_IDX_encrypt_then_mac, -

710 TLSEXT_IDX_signed_certificate_timestamp, -

711 TLSEXT_IDX_extended_master_secret, -

712 TLSEXT_IDX_signature_algorithms_cert, -

713 TLSEXT_IDX_post_handshake_auth, -

714 TLSEXT_IDX_signature_algorithms, -

715 TLSEXT_IDX_supported_versions, -

716 TLSEXT_IDX_psk_kex_modes, -

717 TLSEXT_IDX_key_share, -

718 TLSEXT_IDX_cookie, -

719 TLSEXT_IDX_cryptopro_bug, -

720 TLSEXT_IDX_early_data, -

721 TLSEXT_IDX_certificate_authorities, -

722 TLSEXT_IDX_padding, -

723 TLSEXT_IDX_psk, -

724 /* Dummy index - must always be the last entry */ -

725 TLSEXT_IDX_num_builtins -

726 } TLSEXT_INDEX; -

727 -

728

DEFINE_LHASH_OF(SSL_SESSION);

executed 8017 times by 2 tests: end of block

Executed by:

libssl.so.1.1
tls13encryptiontest

never executed: end of block

executed 16034 times by 2 tests: end of block

Executed by:

libssl.so.1.1
tls13encryptiontest

never executed: end of block

executed 8017 times by 2 tests: return (struct lhash_st_SSL_SESSION *) OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn);

Executed by:

libssl.so.1.1
tls13encryptiontest

executed 348 times by 1 test: return (SSL_SESSION *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d);

Executed by:

libssl.so.1.1

executed 341 times by 1 test: return (SSL_SESSION *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d);

Executed by:

libssl.so.1.1

executed 5719 times by 1 test: return (SSL_SESSION *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d);

Executed by:

libssl.so.1.1

never executed: return OPENSSL_LH_error((OPENSSL_LHASH *)lh);

executed 517 times by 1 test: return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh);

Executed by:

libssl.so.1.1

executed 8017 times by 2 tests: return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh);

Executed by:

libssl.so.1.1
tls13encryptiontest

0-16034

729 /* Needed in ssl_cert.c */ -

730

DEFINE_LHASH_OF(X509_NAME);

executed 10 times by 1 test: end of block

Executed by:

libssl.so.1.1

never executed: end of block

executed 10 times by 1 test: return (struct lhash_st_X509_NAME *) OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn);

Executed by:

libssl.so.1.1

executed 10 times by 1 test: return (X509_NAME *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d);

Executed by:

libssl.so.1.1

never executed: return (X509_NAME *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d);

executed 10 times by 1 test: return (X509_NAME *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d);

Executed by:

libssl.so.1.1

never executed: return OPENSSL_LH_error((OPENSSL_LHASH *)lh);

never executed: return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh);

never executed: return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh);

0-10

731 -

732 # define TLSEXT_KEYNAME_LENGTH 16 -

733 # define TLSEXT_TICK_KEY_LENGTH 32 -

734 -

735 typedef struct ssl_ctx_ext_secure_st { -

736 unsigned char tick_hmac_key[TLSEXT_TICK_KEY_LENGTH]; -

737 unsigned char tick_aes_key[TLSEXT_TICK_KEY_LENGTH]; -

738 } SSL_CTX_EXT_SECURE; -

739 -

740 struct ssl_ctx_st { -

741 const SSL_METHOD *method; -

742 STACK_OF(SSL_CIPHER) *cipher_list; -

743 /* same as above but sorted for lookup */ -

744 STACK_OF(SSL_CIPHER) *cipher_list_by_id; -

745 /* TLSv1.3 specific ciphersuites */ -

746 STACK_OF(SSL_CIPHER) *tls13_ciphersuites; -

747 struct x509_store_st /* X509_STORE */ *cert_store; -

748 LHASH_OF(SSL_SESSION) *sessions; -

749 /* -

750 * Most session-ids that will be cached, default is -

751 * SSL_SESSION_CACHE_MAX_SIZE_DEFAULT. 0 is unlimited. -

752 */ -

753 size_t session_cache_size; -

754 struct ssl_session_st *session_cache_head; -

755 struct ssl_session_st *session_cache_tail; -

756 /* -

757 * This can have one of 2 values, ored together, SSL_SESS_CACHE_CLIENT, -

758 * SSL_SESS_CACHE_SERVER, Default is SSL_SESSION_CACHE_SERVER, which -

759 * means only SSL_accept will cache SSL_SESSIONS. -

760 */ -

761 uint32_t session_cache_mode; -

762 /* -

763 * If timeout is not 0, it is the default timeout value set when -

764 * SSL_new() is called. This has been put in to make life easier to set -

765 * things up -

766 */ -

767 long session_timeout; -

768 /* -

769 * If this callback is not null, it will be called each time a session id -

770 * is added to the cache. If this function returns 1, it means that the -

771 * callback will do a SSL_SESSION_free() when it has finished using it. -

772 * Otherwise, on 0, it means the callback has finished with it. If -

773 * remove_session_cb is not null, it will be called when a session-id is -

774 * removed from the cache. After the call, OpenSSL will -

775 * SSL_SESSION_free() it. -

776 */ -

777 int (*new_session_cb) (struct ssl_st *ssl, SSL_SESSION *sess); -

778 void (*remove_session_cb) (struct ssl_ctx_st *ctx, SSL_SESSION *sess); -

779 SSL_SESSION *(*get_session_cb) (struct ssl_st *ssl, -

780 const unsigned char *data, int len, -

781 int *copy); -

782 struct { -

783 TSAN_QUALIFIER int sess_connect; /* SSL new conn - started */ -

784 TSAN_QUALIFIER int sess_connect_renegotiate; /* SSL reneg - requested */ -

785 TSAN_QUALIFIER int sess_connect_good; /* SSL new conne/reneg - finished */ -

786 TSAN_QUALIFIER int sess_accept; /* SSL new accept - started */ -

787 TSAN_QUALIFIER int sess_accept_renegotiate; /* SSL reneg - requested */ -

788 TSAN_QUALIFIER int sess_accept_good; /* SSL accept/reneg - finished */ -

789 TSAN_QUALIFIER int sess_miss; /* session lookup misses */ -

790 TSAN_QUALIFIER int sess_timeout; /* reuse attempt on timeouted session */ -

791 TSAN_QUALIFIER int sess_cache_full; /* session removed due to full cache */ -

792 TSAN_QUALIFIER int sess_hit; /* session reuse actually done */ -

793 TSAN_QUALIFIER int sess_cb_hit; /* session-id that was not in -

794 * the cache was passed back via -

795 * the callback. This indicates -

796 * that the application is -

797 * supplying session-id's from -

798 * other processes - spooky -

799 * :-) */ -

800 } stats; -

801 -

802 CRYPTO_REF_COUNT references; -

803 -

804 /* if defined, these override the X509_verify_cert() calls */ -

805 int (*app_verify_callback) (X509_STORE_CTX *, void *); -

806 void *app_verify_arg; -

807 /* -

808 * before OpenSSL 0.9.7, 'app_verify_arg' was ignored -

809 * ('app_verify_callback' was called with just one argument) -

810 */ -

811 -

812 /* Default password callback. */ -

813 pem_password_cb *default_passwd_callback; -

814 -

815 /* Default password callback user data. */ -

816 void *default_passwd_callback_userdata; -

817 -

818 /* get client cert callback */ -

819 int (*client_cert_cb) (SSL *ssl, X509 **x509, EVP_PKEY **pkey); -

820 -

821 /* cookie generate callback */ -

822 int (*app_gen_cookie_cb) (SSL *ssl, unsigned char *cookie, -

823 unsigned int *cookie_len); -

824 -

825 /* verify cookie callback */ -

826 int (*app_verify_cookie_cb) (SSL *ssl, const unsigned char *cookie, -

827 unsigned int cookie_len); -

828 -

829 /* TLS1.3 app-controlled cookie generate callback */ -

830 int (*gen_stateless_cookie_cb) (SSL *ssl, unsigned char *cookie, -

831 size_t *cookie_len); -

832 -

833 /* TLS1.3 verify app-controlled cookie callback */ -

834 int (*verify_stateless_cookie_cb) (SSL *ssl, const unsigned char *cookie, -

835 size_t cookie_len); -

836 -

837 CRYPTO_EX_DATA ex_data; -

838 -

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

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

841 -

842 STACK_OF(X509) *extra_certs; -

843 STACK_OF(SSL_COMP) *comp_methods; /* stack of SSL_COMP, SSLv3/TLSv1 */ -

844 -

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

846 -

847 /* used if SSL's info_callback is NULL */ -

848 void (*info_callback) (const SSL *ssl, int type, int val); -

849 -

850 /* -

851 * What we put in certificate_authorities extension for TLS 1.3 -

852 * (ClientHello and CertificateRequest) or just client cert requests for -

853 * earlier versions. -

854 */ -

855 STACK_OF(X509_NAME) *ca_names; -

856 -

857 /* -

858 * Default values to use in SSL structures follow (these are copied by -

859 * SSL_new) -

860 */ -

861 -

862 uint32_t options; -

863 uint32_t mode; -

864 int min_proto_version; -

865 int max_proto_version; -

866 size_t max_cert_list; -

867 -

868 struct cert_st /* CERT */ *cert; -

869 int read_ahead; -

870 -

871 /* callback that allows applications to peek at protocol messages */ -

872 void (*msg_callback) (int write_p, int version, int content_type, -

873 const void *buf, size_t len, SSL *ssl, void *arg); -

874 void *msg_callback_arg; -

875 -

876 uint32_t verify_mode; -

877 size_t sid_ctx_length; -

878 unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; -

879 /* called 'verify_callback' in the SSL */ -

880 int (*default_verify_callback) (int ok, X509_STORE_CTX *ctx); -

881 -

882 /* Default generate session ID callback. */ -

883 GEN_SESSION_CB generate_session_id; -

884 -

885 X509_VERIFY_PARAM *param; -

886 -

887 int quiet_shutdown; -

888 -

889 # ifndef OPENSSL_NO_CT -

890 CTLOG_STORE *ctlog_store; /* CT Log Store */ -

891 /* -

892 * Validates that the SCTs (Signed Certificate Timestamps) are sufficient. -

893 * If they are not, the connection should be aborted. -

894 */ -

895 ssl_ct_validation_cb ct_validation_callback; -

896 void *ct_validation_callback_arg; -

897 # endif -

898 -

899 /* -

900 * If we're using more than one pipeline how should we divide the data -

901 * up between the pipes? -

902 */ -

903 size_t split_send_fragment; -

904 /* -

905 * Maximum amount of data to send in one fragment. actual record size can -

906 * be more than this due to padding and MAC overheads. -

907 */ -

908 size_t max_send_fragment; -

909 -

910 /* Up to how many pipelines should we use? If 0 then 1 is assumed */ -

911 size_t max_pipelines; -

912 -

913 /* The default read buffer length to use (0 means not set) */ -

914 size_t default_read_buf_len; -

915 -

916 # ifndef OPENSSL_NO_ENGINE -

917 /* -

918 * Engine to pass requests for client certs to -

919 */ -

920 ENGINE *client_cert_engine; -

921 # endif -

922 -

923 /* ClientHello callback. Mostly for extensions, but not entirely. */ -

924 SSL_client_hello_cb_fn client_hello_cb; -

925 void *client_hello_cb_arg; -

926 -

927 /* TLS extensions. */ -

928 struct { -

929 /* TLS extensions servername callback */ -

930 int (*servername_cb) (SSL *, int *, void *); -

931 void *servername_arg; -

932 /* RFC 4507 session ticket keys */ -

933 unsigned char tick_key_name[TLSEXT_KEYNAME_LENGTH]; -

934 SSL_CTX_EXT_SECURE *secure; -

935 /* Callback to support customisation of ticket key setting */ -

936 int (*ticket_key_cb) (SSL *ssl, -

937 unsigned char *name, unsigned char *iv, -

938 EVP_CIPHER_CTX *ectx, HMAC_CTX *hctx, int enc); -

939 -

940 /* certificate status request info */ -

941 /* Callback for status request */ -

942 int (*status_cb) (SSL *ssl, void *arg); -

943 void *status_arg; -

944 /* ext status type used for CSR extension (OCSP Stapling) */ -

945 int status_type; -

946 /* RFC 4366 Maximum Fragment Length Negotiation */ -

947 uint8_t max_fragment_len_mode; -

948 -

949 # ifndef OPENSSL_NO_EC -

950 /* EC extension values inherited by SSL structure */ -

951 size_t ecpointformats_len; -

952 unsigned char *ecpointformats; -

953 size_t supportedgroups_len; -

954 uint16_t *supportedgroups; -

955 # endif /* OPENSSL_NO_EC */ -

956 -

957 /* -

958 * ALPN information (we are in the process of transitioning from NPN to -

959 * ALPN.) -

960 */ -

961 -

962 /*- -

963 * For a server, this contains a callback function that allows the -

964 * server to select the protocol for the connection. -

965 * out: on successful return, this must point to the raw protocol -

966 * name (without the length prefix). -

967 * outlen: on successful return, this contains the length of |*out|. -

968 * in: points to the client's list of supported protocols in -

969 * wire-format. -

970 * inlen: the length of |in|. -

971 */ -

972 int (*alpn_select_cb) (SSL *s, -

973 const unsigned char **out, -

974 unsigned char *outlen, -

975 const unsigned char *in, -

976 unsigned int inlen, void *arg); -

977 void *alpn_select_cb_arg; -

978 -

979 /* -

980 * For a client, this contains the list of supported protocols in wire -

981 * format. -

982 */ -

983 unsigned char *alpn; -

984 size_t alpn_len; -

985 -

986 # ifndef OPENSSL_NO_NEXTPROTONEG -

987 /* Next protocol negotiation information */ -

988 -

989 /* -

990 * For a server, this contains a callback function by which the set of -

991 * advertised protocols can be provided. -

992 */ -

993 SSL_CTX_npn_advertised_cb_func npn_advertised_cb; -

994 void *npn_advertised_cb_arg; -

995 /* -

996 * For a client, this contains a callback function that selects the next -

997 * protocol from the list provided by the server. -

998 */ -

999 SSL_CTX_npn_select_cb_func npn_select_cb; -

1000 void *npn_select_cb_arg; -

1001 # endif -

1002 -

1003 unsigned char cookie_hmac_key[SHA256_DIGEST_LENGTH]; -

1004 } ext; -

1005 -

1006 # ifndef OPENSSL_NO_PSK -

1007 SSL_psk_client_cb_func psk_client_callback; -

1008 SSL_psk_server_cb_func psk_server_callback; -

1009 # endif -

1010 SSL_psk_find_session_cb_func psk_find_session_cb; -

1011 SSL_psk_use_session_cb_func psk_use_session_cb; -

1012 -

1013 # ifndef OPENSSL_NO_SRP -

1014 SRP_CTX srp_ctx; /* ctx for SRP authentication */ -

1015 # endif -

1016 -

1017 /* Shared DANE context */ -

1018 struct dane_ctx_st dane; -

1019 -

1020 # ifndef OPENSSL_NO_SRTP -

1021 /* SRTP profiles we are willing to do from RFC 5764 */ -

1022 STACK_OF(SRTP_PROTECTION_PROFILE) *srtp_profiles; -

1023 # endif -

1024 /* -

1025 * Callback for disabling session caching and ticket support on a session -

1026 * basis, depending on the chosen cipher. -

1027 */ -

1028 int (*not_resumable_session_cb) (SSL *ssl, int is_forward_secure); -

1029 -

1030 CRYPTO_RWLOCK *lock; -

1031 -

1032 /* -

1033 * Callback for logging key material for use with debugging tools like -

1034 * Wireshark. The callback should log `line` followed by a newline. -

1035 */ -

1036 SSL_CTX_keylog_cb_func keylog_callback; -

1037 -

1038 /* -

1039 * The maximum number of bytes advertised in session tickets that can be -

1040 * sent as early data. -

1041 */ -

1042 uint32_t max_early_data; -

1043 -

1044 /* -

1045 * The maximum number of bytes of early data that a server will tolerate -

1046 * (which should be at least as much as max_early_data). -

1047 */ -

1048 uint32_t recv_max_early_data; -

1049 -

1050 /* TLS1.3 padding callback */ -

1051 size_t (*record_padding_cb)(SSL *s, int type, size_t len, void *arg); -

1052 void *record_padding_arg; -

1053 size_t block_padding; -

1054 -

1055 /* Session ticket appdata */ -

1056 SSL_CTX_generate_session_ticket_fn generate_ticket_cb; -

1057 SSL_CTX_decrypt_session_ticket_fn decrypt_ticket_cb; -

1058 void *ticket_cb_data; -

1059 -

1060 /* The number of TLS1.3 tickets to automatically send */ -

1061 size_t num_tickets; -

1062 -

1063 /* Callback to determine if early_data is acceptable or not */ -

1064 SSL_allow_early_data_cb_fn allow_early_data_cb; -

1065 void *allow_early_data_cb_data; -

1066 -

1067 /* Do we advertise Post-handshake auth support? */ -

1068 int pha_enabled; -

1069 }; -

1070 -

1071 struct ssl_st { -

1072 /* -

1073 * protocol version (one of SSL2_VERSION, SSL3_VERSION, TLS1_VERSION, -

1074 * DTLS1_VERSION) -

1075 */ -

1076 int version; -

1077 /* SSLv3 */ -

1078 const SSL_METHOD *method; -

1079 /* -

1080 * There are 2 BIO's even though they are normally both the same. This -

1081 * is so data can be read and written to different handlers -

1082 */ -

1083 /* used by SSL_read */ -

1084 BIO *rbio; -

1085 /* used by SSL_write */ -

1086 BIO *wbio; -

1087 /* used during session-id reuse to concatenate messages */ -

1088 BIO *bbio; -

1089 /* -

1090 * This holds a variable that indicates what we were doing when a 0 or -1 -

1091 * is returned. This is needed for non-blocking IO so we know what -

1092 * request needs re-doing when in SSL_accept or SSL_connect -

1093 */ -

1094 int rwstate; -

1095 int (*handshake_func) (SSL *); -

1096 /* -

1097 * Imagine that here's a boolean member "init" that is switched as soon -

1098 * as SSL_set_{accept/connect}_state is called for the first time, so -

1099 * that "state" and "handshake_func" are properly initialized. But as -

1100 * handshake_func is == 0 until then, we use this test instead of an -

1101 * "init" member. -

1102 */ -

1103 /* are we the server side? */ -

1104 int server; -

1105 /* -

1106 * Generate a new session or reuse an old one. -

1107 * NB: For servers, the 'new' session may actually be a previously -

1108 * cached session or even the previous session unless -

1109 * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION is set -

1110 */ -

1111 int new_session; -

1112 /* don't send shutdown packets */ -

1113 int quiet_shutdown; -

1114 /* we have shut things down, 0x01 sent, 0x02 for received */ -

1115 int shutdown; -

1116 /* where we are */ -

1117 OSSL_STATEM statem; -

1118 SSL_EARLY_DATA_STATE early_data_state; -

1119 BUF_MEM *init_buf; /* buffer used during init */ -

1120 void *init_msg; /* pointer to handshake message body, set by -

1121 * ssl3_get_message() */ -

1122 size_t init_num; /* amount read/written */ -

1123 size_t init_off; /* amount read/written */ -

1124 struct ssl3_state_st *s3; /* SSLv3 variables */ -

1125 struct dtls1_state_st *d1; /* DTLSv1 variables */ -

1126 /* callback that allows applications to peek at protocol messages */ -

1127 void (*msg_callback) (int write_p, int version, int content_type, -

1128 const void *buf, size_t len, SSL *ssl, void *arg); -

1129 void *msg_callback_arg; -

1130 int hit; /* reusing a previous session */ -

1131 X509_VERIFY_PARAM *param; -

1132 /* Per connection DANE state */ -

1133 SSL_DANE dane; -

1134 /* crypto */ -

1135 STACK_OF(SSL_CIPHER) *cipher_list; -

1136 STACK_OF(SSL_CIPHER) *cipher_list_by_id; -

1137 /* TLSv1.3 specific ciphersuites */ -

1138 STACK_OF(SSL_CIPHER) *tls13_ciphersuites; -

1139 /* -

1140 * These are the ones being used, the ones in SSL_SESSION are the ones to -

1141 * be 'copied' into these ones -

1142 */ -

1143 uint32_t mac_flags; -

1144 /* -

1145 * The TLS1.3 secrets. -

1146 */ -

1147 unsigned char early_secret[EVP_MAX_MD_SIZE]; -

1148 unsigned char handshake_secret[EVP_MAX_MD_SIZE]; -

1149 unsigned char master_secret[EVP_MAX_MD_SIZE]; -

1150 unsigned char resumption_master_secret[EVP_MAX_MD_SIZE]; -

1151 unsigned char client_finished_secret[EVP_MAX_MD_SIZE]; -

1152 unsigned char server_finished_secret[EVP_MAX_MD_SIZE]; -

1153 unsigned char server_finished_hash[EVP_MAX_MD_SIZE]; -

1154 unsigned char handshake_traffic_hash[EVP_MAX_MD_SIZE]; -

1155 unsigned char client_app_traffic_secret[EVP_MAX_MD_SIZE]; -

1156 unsigned char server_app_traffic_secret[EVP_MAX_MD_SIZE]; -

1157 unsigned char exporter_master_secret[EVP_MAX_MD_SIZE]; -

1158 unsigned char early_exporter_master_secret[EVP_MAX_MD_SIZE]; -

1159 EVP_CIPHER_CTX *enc_read_ctx; /* cryptographic state */ -

1160 unsigned char read_iv[EVP_MAX_IV_LENGTH]; /* TLSv1.3 static read IV */ -

1161 EVP_MD_CTX *read_hash; /* used for mac generation */ -

1162 COMP_CTX *compress; /* compression */ -

1163 COMP_CTX *expand; /* uncompress */ -

1164 EVP_CIPHER_CTX *enc_write_ctx; /* cryptographic state */ -

1165 unsigned char write_iv[EVP_MAX_IV_LENGTH]; /* TLSv1.3 static write IV */ -

1166 EVP_MD_CTX *write_hash; /* used for mac generation */ -

1167 /* Count of how many KeyUpdate messages we have received */ -

1168 unsigned int key_update_count; -

1169 /* session info */ -

1170 /* client cert? */ -

1171 /* This is used to hold the server certificate used */ -

1172 struct cert_st /* CERT */ *cert; -

1173 -

1174 /* -

1175 * The hash of all messages prior to the CertificateVerify, and the length -

1176 * of that hash. -

1177 */ -

1178 unsigned char cert_verify_hash[EVP_MAX_MD_SIZE]; -

1179 size_t cert_verify_hash_len; -

1180 -

1181 /* Flag to indicate whether we should send a HelloRetryRequest or not */ -

1182 enum {SSL_HRR_NONE = 0, SSL_HRR_PENDING, SSL_HRR_COMPLETE} -

1183 hello_retry_request; -

1184 -

1185 /* -

1186 * the session_id_context is used to ensure sessions are only reused in -

1187 * the appropriate context -

1188 */ -

1189 size_t sid_ctx_length; -

1190 unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; -

1191 /* This can also be in the session once a session is established */ -

1192 SSL_SESSION *session; -

1193 /* TLSv1.3 PSK session */ -

1194 SSL_SESSION *psksession; -

1195 unsigned char *psksession_id; -

1196 size_t psksession_id_len; -

1197 /* Default generate session ID callback. */ -

1198 GEN_SESSION_CB generate_session_id; -

1199 /* -

1200 * The temporary TLSv1.3 session id. This isn't really a session id at all -

1201 * but is a random value sent in the legacy session id field. -

1202 */ -

1203 unsigned char tmp_session_id[SSL_MAX_SSL_SESSION_ID_LENGTH]; -

1204 size_t tmp_session_id_len; -

1205 /* Used in SSL3 */ -

1206 /* -

1207 * 0 don't care about verify failure. -

1208 * 1 fail if verify fails -

1209 */ -

1210 uint32_t verify_mode; -

1211 /* fail if callback returns 0 */ -

1212 int (*verify_callback) (int ok, X509_STORE_CTX *ctx); -

1213 /* optional informational callback */ -

1214 void (*info_callback) (const SSL *ssl, int type, int val); -

1215 /* error bytes to be written */ -

1216 int error; -

1217 /* actual code */ -

1218 int error_code; -

1219 # ifndef OPENSSL_NO_PSK -

1220 SSL_psk_client_cb_func psk_client_callback; -

1221 SSL_psk_server_cb_func psk_server_callback; -

1222 # endif -

1223 SSL_psk_find_session_cb_func psk_find_session_cb; -

1224 SSL_psk_use_session_cb_func psk_use_session_cb; -

1225 -

1226 SSL_CTX *ctx; -

1227 /* Verified chain of peer */ -

1228 STACK_OF(X509) *verified_chain; -

1229 long verify_result; -

1230 /* extra application data */ -

1231 CRYPTO_EX_DATA ex_data; -

1232 /* for server side, keep the list of CA_dn we can use */ -

1233 STACK_OF(X509_NAME) *ca_names; -

1234 CRYPTO_REF_COUNT references; -

1235 /* protocol behaviour */ -

1236 uint32_t options; -

1237 /* API behaviour */ -

1238 uint32_t mode; -

1239 int min_proto_version; -

1240 int max_proto_version; -

1241 size_t max_cert_list; -

1242 int first_packet; -

1243 /* -

1244 * What was passed in ClientHello.legacy_version. Used for RSA pre-master -

1245 * secret and SSLv3/TLS (<=1.2) rollback check -

1246 */ -

1247 int client_version; -

1248 /* -

1249 * If we're using more than one pipeline how should we divide the data -

1250 * up between the pipes? -

1251 */ -

1252 size_t split_send_fragment; -

1253 /* -

1254 * Maximum amount of data to send in one fragment. actual record size can -

1255 * be more than this due to padding and MAC overheads. -

1256 */ -

1257 size_t max_send_fragment; -

1258 /* Up to how many pipelines should we use? If 0 then 1 is assumed */ -

1259 size_t max_pipelines; -

1260 -

1261 struct { -

1262 /* Built-in extension flags */ -

1263 uint8_t extflags[TLSEXT_IDX_num_builtins]; -

1264 /* TLS extension debug callback */ -

1265 void (*debug_cb)(SSL *s, int client_server, int type, -

1266 const unsigned char *data, int len, void *arg); -

1267 void *debug_arg; -

1268 char *hostname; -

1269 /* certificate status request info */ -

1270 /* Status type or -1 if no status type */ -

1271 int status_type; -

1272 /* Raw extension data, if seen */ -

1273 unsigned char *scts; -

1274 /* Length of raw extension data, if seen */ -

1275 uint16_t scts_len; -

1276 /* Expect OCSP CertificateStatus message */ -

1277 int status_expected; -

1278 -

1279 struct { -

1280 /* OCSP status request only */ -

1281 STACK_OF(OCSP_RESPID) *ids; -

1282 X509_EXTENSIONS *exts; -

1283 /* OCSP response received or to be sent */ -

1284 unsigned char *resp; -

1285 size_t resp_len; -

1286 } ocsp; -

1287 -

1288 /* RFC4507 session ticket expected to be received or sent */ -

1289 int ticket_expected; -

1290 # ifndef OPENSSL_NO_EC -

1291 size_t ecpointformats_len; -

1292 /* our list */ -

1293 unsigned char *ecpointformats; -

1294 # endif /* OPENSSL_NO_EC */ -

1295 size_t supportedgroups_len; -

1296 /* our list */ -

1297 uint16_t *supportedgroups; -

1298 /* TLS Session Ticket extension override */ -

1299 TLS_SESSION_TICKET_EXT *session_ticket; -

1300 /* TLS Session Ticket extension callback */ -

1301 tls_session_ticket_ext_cb_fn session_ticket_cb; -

1302 void *session_ticket_cb_arg; -

1303 /* TLS pre-shared secret session resumption */ -

1304 tls_session_secret_cb_fn session_secret_cb; -

1305 void *session_secret_cb_arg; -

1306 /* -

1307 * For a client, this contains the list of supported protocols in wire -

1308 * format. -

1309 */ -

1310 unsigned char *alpn; -

1311 size_t alpn_len; -

1312 /* -

1313 * Next protocol negotiation. For the client, this is the protocol that -

1314 * we sent in NextProtocol and is set when handling ServerHello -

1315 * extensions. For a server, this is the client's selected_protocol from -

1316 * NextProtocol and is set when handling the NextProtocol message, before -

1317 * the Finished message. -

1318 */ -

1319 unsigned char *npn; -

1320 size_t npn_len; -

1321 -

1322 /* The available PSK key exchange modes */ -

1323 int psk_kex_mode; -

1324 -

1325 /* Set to one if we have negotiated ETM */ -

1326 int use_etm; -

1327 -

1328 /* Are we expecting to receive early data? */ -

1329 int early_data; -

1330 /* Is the session suitable for early data? */ -

1331 int early_data_ok; -

1332 -

1333 /* May be sent by a server in HRR. Must be echoed back in ClientHello */ -

1334 unsigned char *tls13_cookie; -

1335 size_t tls13_cookie_len; -

1336 /* Have we received a cookie from the client? */ -

1337 int cookieok; -

1338 -

1339 /* -

1340 * Maximum Fragment Length as per RFC 4366. -

1341 * If this member contains one of the allowed values (1-4) -

1342 * then we should include Maximum Fragment Length Negotiation -

1343 * extension in Client Hello. -

1344 * Please note that value of this member does not have direct -

1345 * effect. The actual (binding) value is stored in SSL_SESSION, -

1346 * as this extension is optional on server side. -

1347 */ -

1348 uint8_t max_fragment_len_mode; -

1349 } ext; -

1350 -

1351 /* -

1352 * Parsed form of the ClientHello, kept around across client_hello_cb -

1353 * calls. -

1354 */ -

1355 CLIENTHELLO_MSG *clienthello; -

1356 -

1357 /*- -

1358 * no further mod of servername -

1359 * 0 : call the servername extension callback. -

1360 * 1 : prepare 2, allow last ack just after in server callback. -

1361 * 2 : don't call servername callback, no ack in server hello -

1362 */ -

1363 int servername_done; -

1364 # ifndef OPENSSL_NO_CT -

1365 /* -

1366 * Validates that the SCTs (Signed Certificate Timestamps) are sufficient. -

1367 * If they are not, the connection should be aborted. -

1368 */ -

1369 ssl_ct_validation_cb ct_validation_callback; -

1370 /* User-supplied argument that is passed to the ct_validation_callback */ -

1371 void *ct_validation_callback_arg; -

1372 /* -

1373 * Consolidated stack of SCTs from all sources. -

1374 * Lazily populated by CT_get_peer_scts(SSL*) -

1375 */ -

1376 STACK_OF(SCT) *scts; -

1377 /* Have we attempted to find/parse SCTs yet? */ -

1378 int scts_parsed; -

1379 # endif -

1380 SSL_CTX *session_ctx; /* initial ctx, used to store sessions */ -

1381 # ifndef OPENSSL_NO_SRTP -

1382 /* What we'll do */ -

1383 STACK_OF(SRTP_PROTECTION_PROFILE) *srtp_profiles; -

1384 /* What's been chosen */ -

1385 SRTP_PROTECTION_PROFILE *srtp_profile; -

1386 # endif -

1387 /*- -

1388 * 1 if we are renegotiating. -

1389 * 2 if we are a server and are inside a handshake -

1390 * (i.e. not just sending a HelloRequest) -

1391 */ -

1392 int renegotiate; -

1393 /* If sending a KeyUpdate is pending */ -

1394 int key_update; -

1395 /* Post-handshake authentication state */ -

1396 SSL_PHA_STATE post_handshake_auth; -

1397 int pha_enabled; -

1398 uint8_t* pha_context; -

1399 size_t pha_context_len; -

1400 int certreqs_sent; -

1401 EVP_MD_CTX *pha_dgst; /* this is just the digest through ClientFinished */ -

1402 -

1403 # ifndef OPENSSL_NO_SRP -

1404 /* ctx for SRP authentication */ -

1405 SRP_CTX srp_ctx; -

1406 # endif -

1407 /* -

1408 * Callback for disabling session caching and ticket support on a session -

1409 * basis, depending on the chosen cipher. -

1410 */ -

1411 int (*not_resumable_session_cb) (SSL *ssl, int is_forward_secure); -

1412 RECORD_LAYER rlayer; -

1413 /* Default password callback. */ -

1414 pem_password_cb *default_passwd_callback; -

1415 /* Default password callback user data. */ -

1416 void *default_passwd_callback_userdata; -

1417 /* Async Job info */ -

1418 ASYNC_JOB *job; -

1419 ASYNC_WAIT_CTX *waitctx; -

1420 size_t asyncrw; -

1421 -

1422 /* -

1423 * The maximum number of bytes advertised in session tickets that can be -

1424 * sent as early data. -

1425 */ -

1426 uint32_t max_early_data; -

1427 /* -

1428 * The maximum number of bytes of early data that a server will tolerate -

1429 * (which should be at least as much as max_early_data). -

1430 */ -

1431 uint32_t recv_max_early_data; -

1432 -

1433 /* -

1434 * The number of bytes of early data received so far. If we accepted early -

1435 * data then this is a count of the plaintext bytes. If we rejected it then -

1436 * this is a count of the ciphertext bytes. -

1437 */ -

1438 uint32_t early_data_count; -

1439 -

1440 /* TLS1.3 padding callback */ -

1441 size_t (*record_padding_cb)(SSL *s, int type, size_t len, void *arg); -

1442 void *record_padding_arg; -

1443 size_t block_padding; -

1444 -

1445 CRYPTO_RWLOCK *lock; -

1446 RAND_DRBG *drbg; -

1447 -

1448 /* The number of TLS1.3 tickets to automatically send */ -

1449 size_t num_tickets; -

1450 /* The number of TLS1.3 tickets actually sent so far */ -

1451 size_t sent_tickets; -

1452 /* The next nonce value to use when we send a ticket on this connection */ -

1453 uint64_t next_ticket_nonce; -

1454 -

1455 /* Callback to determine if early_data is acceptable or not */ -

1456 SSL_allow_early_data_cb_fn allow_early_data_cb; -

1457 void *allow_early_data_cb_data; -

1458 }; -

1459 -

1460 /* -

1461 * Structure containing table entry of values associated with the signature -

1462 * algorithms (signature scheme) extension -

1463 */ -

1464 typedef struct sigalg_lookup_st { -

1465 /* TLS 1.3 signature scheme name */ -

1466 const char *name; -

1467 /* Raw value used in extension */ -

1468 uint16_t sigalg; -

1469 /* NID of hash algorithm or NID_undef if no hash */ -

1470 int hash; -

1471 /* Index of hash algorithm or -1 if no hash algorithm */ -

1472 int hash_idx; -

1473 /* NID of signature algorithm */ -

1474 int sig; -

1475 /* Index of signature algorithm */ -

1476 int sig_idx; -

1477 /* Combined hash and signature NID, if any */ -

1478 int sigandhash; -

1479 /* Required public key curve (ECDSA only) */ -

1480 int curve; -

1481 } SIGALG_LOOKUP; -

1482 -

1483 typedef struct tls_group_info_st { -

1484 int nid; /* Curve NID */ -

1485 int secbits; /* Bits of security (from SP800-57) */ -

1486 uint16_t flags; /* Flags: currently just group type */ -

1487 } TLS_GROUP_INFO; -

1488 -

1489 /* flags values */ -

1490 # define TLS_CURVE_TYPE 0x3 /* Mask for group type */ -

1491 # define TLS_CURVE_PRIME 0x0 -

1492 # define TLS_CURVE_CHAR2 0x1 -

1493 # define TLS_CURVE_CUSTOM 0x2 -

1494 -

1495 typedef struct cert_pkey_st CERT_PKEY; -

1496 -

1497 /* -

1498 * Structure containing table entry of certificate info corresponding to -

1499 * CERT_PKEY entries -

1500 */ -

1501 typedef struct { -

1502 int nid; /* NID of pubic key algorithm */ -

1503 uint32_t amask; /* authmask corresponding to key type */ -

1504 } SSL_CERT_LOOKUP; -

1505 -

1506 typedef struct ssl3_state_st { -

1507 long flags; -

1508 size_t read_mac_secret_size; -

1509 unsigned char read_mac_secret[EVP_MAX_MD_SIZE]; -

1510 size_t write_mac_secret_size; -

1511 unsigned char write_mac_secret[EVP_MAX_MD_SIZE]; -

1512 unsigned char server_random[SSL3_RANDOM_SIZE]; -

1513 unsigned char client_random[SSL3_RANDOM_SIZE]; -

1514 /* flags for countermeasure against known-IV weakness */ -

1515 int need_empty_fragments; -

1516 int empty_fragment_done; -

1517 /* used during startup, digest all incoming/outgoing packets */ -

1518 BIO *handshake_buffer; -

1519 /* -

1520 * When handshake digest is determined, buffer is hashed and -

1521 * freed and MD_CTX for the required digest is stored here. -

1522 */ -

1523 EVP_MD_CTX *handshake_dgst; -

1524 /* -

1525 * Set whenever an expected ChangeCipherSpec message is processed. -

1526 * Unset when the peer's Finished message is received. -

1527 * Unexpected ChangeCipherSpec messages trigger a fatal alert. -

1528 */ -

1529 int change_cipher_spec; -

1530 int warn_alert; -

1531 int fatal_alert; -

1532 /* -

1533 * we allow one fatal and one warning alert to be outstanding, send close -

1534 * alert via the warning alert -

1535 */ -

1536 int alert_dispatch; -

1537 unsigned char send_alert[2]; -

1538 /* -

1539 * This flag is set when we should renegotiate ASAP, basically when there -

1540 * is no more data in the read or write buffers -

1541 */ -

1542 int renegotiate; -

1543 int total_renegotiations; -

1544 int num_renegotiations; -

1545 int in_read_app_data; -

1546 struct { -

1547 /* actually only need to be 16+20 for SSLv3 and 12 for TLS */ -

1548 unsigned char finish_md[EVP_MAX_MD_SIZE * 2]; -

1549 size_t finish_md_len; -

1550 unsigned char peer_finish_md[EVP_MAX_MD_SIZE * 2]; -

1551 size_t peer_finish_md_len; -

1552 size_t message_size; -

1553 int message_type; -

1554 /* used to hold the new cipher we are going to use */ -

1555 const SSL_CIPHER *new_cipher; -

1556 # if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DH) -

1557 EVP_PKEY *pkey; /* holds short lived DH/ECDH key */ -

1558 # endif -

1559 /* used for certificate requests */ -

1560 int cert_req; -

1561 /* Certificate types in certificate request message. */ -

1562 uint8_t *ctype; -

1563 size_t ctype_len; -

1564 /* Certificate authorities list peer sent */ -

1565 STACK_OF(X509_NAME) *peer_ca_names; -

1566 size_t key_block_length; -

1567 unsigned char *key_block; -

1568 const EVP_CIPHER *new_sym_enc; -

1569 const EVP_MD *new_hash; -

1570 int new_mac_pkey_type; -

1571 size_t new_mac_secret_size; -

1572 # ifndef OPENSSL_NO_COMP -

1573 const SSL_COMP *new_compression; -

1574 # else -

1575 char *new_compression; -

1576 # endif -

1577 int cert_request; -

1578 /* Raw values of the cipher list from a client */ -

1579 unsigned char *ciphers_raw; -

1580 size_t ciphers_rawlen; -

1581 /* Temporary storage for premaster secret */ -

1582 unsigned char *pms; -

1583 size_t pmslen; -

1584 # ifndef OPENSSL_NO_PSK -

1585 /* Temporary storage for PSK key */ -

1586 unsigned char *psk; -

1587 size_t psklen; -

1588 # endif -

1589 /* Signature algorithm we actually use */ -

1590 const SIGALG_LOOKUP *sigalg; -

1591 /* Pointer to certificate we use */ -

1592 CERT_PKEY *cert; -

1593 /* -

1594 * signature algorithms peer reports: e.g. supported signature -

1595 * algorithms extension for server or as part of a certificate -

1596 * request for client. -

1597 * Keep track of the algorithms for TLS and X.509 usage separately. -

1598 */ -

1599 uint16_t *peer_sigalgs; -

1600 uint16_t *peer_cert_sigalgs; -

1601 /* Size of above arrays */ -

1602 size_t peer_sigalgslen; -

1603 size_t peer_cert_sigalgslen; -

1604 /* Sigalg peer actually uses */ -

1605 const SIGALG_LOOKUP *peer_sigalg; -

1606 /* -

1607 * Set if corresponding CERT_PKEY can be used with current -

1608 * SSL session: e.g. appropriate curve, signature algorithms etc. -

1609 * If zero it can't be used at all. -

1610 */ -

1611 uint32_t valid_flags[SSL_PKEY_NUM]; -

1612 /* -

1613 * For servers the following masks are for the key and auth algorithms -

1614 * that are supported by the certs below. For clients they are masks of -

1615 * *disabled* algorithms based on the current session. -

1616 */ -

1617 uint32_t mask_k; -

1618 uint32_t mask_a; -

1619 /* -

1620 * The following are used by the client to see if a cipher is allowed or -

1621 * not. It contains the minimum and maximum version the client's using -

1622 * based on what it knows so far. -

1623 */ -

1624 int min_ver; -

1625 int max_ver; -

1626 } tmp; -

1627 -

1628 /* Connection binding to prevent renegotiation attacks */ -

1629 unsigned char previous_client_finished[EVP_MAX_MD_SIZE]; -

1630 size_t previous_client_finished_len; -

1631 unsigned char previous_server_finished[EVP_MAX_MD_SIZE]; -

1632 size_t previous_server_finished_len; -

1633 int send_connection_binding; /* TODOEKR */ -

1634 -

1635 # ifndef OPENSSL_NO_NEXTPROTONEG -

1636 /* -

1637 * Set if we saw the Next Protocol Negotiation extension from our peer. -

1638 */ -

1639 int npn_seen; -

1640 # endif -

1641 -

1642 /* -

1643 * ALPN information (we are in the process of transitioning from NPN to -

1644 * ALPN.) -

1645 */ -

1646 -

1647 /* -

1648 * In a server these point to the selected ALPN protocol after the -

1649 * ClientHello has been processed. In a client these contain the protocol -

1650 * that the server selected once the ServerHello has been processed. -

1651 */ -

1652 unsigned char *alpn_selected; -

1653 size_t alpn_selected_len; -

1654 /* used by the server to know what options were proposed */ -

1655 unsigned char *alpn_proposed; -

1656 size_t alpn_proposed_len; -

1657 /* used by the client to know if it actually sent alpn */ -

1658 int alpn_sent; -

1659 -

1660 # ifndef OPENSSL_NO_EC -

1661 /* -

1662 * This is set to true if we believe that this is a version of Safari -

1663 * running on OS X 10.6 or newer. We wish to know this because Safari on -

1664 * 10.8 .. 10.8.3 has broken ECDHE-ECDSA support. -

1665 */ -

1666 char is_probably_safari; -

1667 # endif /* !OPENSSL_NO_EC */ -

1668 -

1669 /* For clients: peer temporary key */ -

1670 # if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DH) -

1671 /* The group_id for the DH/ECDH key */ -

1672 uint16_t group_id; -

1673 EVP_PKEY *peer_tmp; -

1674 # endif -

1675 -

1676 } SSL3_STATE; -

1677 -

1678 /* DTLS structures */ -

1679 -

1680 # ifndef OPENSSL_NO_SCTP -

1681 # define DTLS1_SCTP_AUTH_LABEL "EXPORTER_DTLS_OVER_SCTP" -

1682 # endif -

1683 -

1684 /* Max MTU overhead we know about so far is 40 for IPv6 + 8 for UDP */ -

1685 # define DTLS1_MAX_MTU_OVERHEAD 48 -

1686 -

1687 /* -

1688 * Flag used in message reuse to indicate the buffer contains the record -

1689 * header as well as the handshake message header. -

1690 */ -

1691 # define DTLS1_SKIP_RECORD_HEADER 2 -

1692 -

1693 struct dtls1_retransmit_state { -

1694 EVP_CIPHER_CTX *enc_write_ctx; /* cryptographic state */ -

1695 EVP_MD_CTX *write_hash; /* used for mac generation */ -

1696 COMP_CTX *compress; /* compression */ -

1697 SSL_SESSION *session; -

1698 unsigned short epoch; -

1699 }; -

1700 -

1701 struct hm_header_st { -

1702 unsigned char type; -

1703 size_t msg_len; -

1704 unsigned short seq; -

1705 size_t frag_off; -

1706 size_t frag_len; -

1707 unsigned int is_ccs; -

1708 struct dtls1_retransmit_state saved_retransmit_state; -

1709 }; -

1710 -

1711 struct dtls1_timeout_st { -

1712 /* Number of read timeouts so far */ -

1713 unsigned int read_timeouts; -

1714 /* Number of write timeouts so far */ -

1715 unsigned int write_timeouts; -

1716 /* Number of alerts received so far */ -

1717 unsigned int num_alerts; -

1718 }; -

1719 -

1720 typedef struct hm_fragment_st { -

1721 struct hm_header_st msg_header; -

1722 unsigned char *fragment; -

1723 unsigned char *reassembly; -

1724 } hm_fragment; -

1725 -

1726 typedef struct pqueue_st pqueue; -

1727 typedef struct pitem_st pitem; -

1728 -

1729 struct pitem_st { -

1730 unsigned char priority[8]; /* 64-bit value in big-endian encoding */ -

1731 void *data; -

1732 pitem *next; -

1733 }; -

1734 -

1735 typedef struct pitem_st *piterator; -

1736 -

1737 pitem *pitem_new(unsigned char *prio64be, void *data); -

1738 void pitem_free(pitem *item); -

1739 pqueue *pqueue_new(void); -

1740 void pqueue_free(pqueue *pq); -

1741 pitem *pqueue_insert(pqueue *pq, pitem *item); -

1742 pitem *pqueue_peek(pqueue *pq); -

1743 pitem *pqueue_pop(pqueue *pq); -

1744 pitem *pqueue_find(pqueue *pq, unsigned char *prio64be); -

1745 pitem *pqueue_iterator(pqueue *pq); -

1746 pitem *pqueue_next(piterator *iter); -

1747 size_t pqueue_size(pqueue *pq); -

1748 -

1749 typedef struct dtls1_state_st { -

1750 unsigned char cookie[DTLS1_COOKIE_LENGTH]; -

1751 size_t cookie_len; -

1752 unsigned int cookie_verified; -

1753 /* handshake message numbers */ -

1754 unsigned short handshake_write_seq; -

1755 unsigned short next_handshake_write_seq; -

1756 unsigned short handshake_read_seq; -

1757 /* Buffered handshake messages */ -

1758 pqueue *buffered_messages; -

1759 /* Buffered (sent) handshake records */ -

1760 pqueue *sent_messages; -

1761 size_t link_mtu; /* max on-the-wire DTLS packet size */ -

1762 size_t mtu; /* max DTLS packet size */ -

1763 struct hm_header_st w_msg_hdr; -

1764 struct hm_header_st r_msg_hdr; -

1765 struct dtls1_timeout_st timeout; -

1766 /* -

1767 * Indicates when the last handshake msg sent will timeout -

1768 */ -

1769 struct timeval next_timeout; -

1770 /* Timeout duration */ -

1771 unsigned int timeout_duration_us; -

1772 -

1773 unsigned int retransmitting; -

1774 # ifndef OPENSSL_NO_SCTP -

1775 int shutdown_received; -

1776 # endif -

1777 -

1778 DTLS_timer_cb timer_cb; -

1779 -

1780 } DTLS1_STATE; -

1781 -

1782 # ifndef OPENSSL_NO_EC -

1783 /* -

1784 * From ECC-TLS draft, used in encoding the curve type in ECParameters -

1785 */ -

1786 # define EXPLICIT_PRIME_CURVE_TYPE 1 -

1787 # define EXPLICIT_CHAR2_CURVE_TYPE 2 -

1788 # define NAMED_CURVE_TYPE 3 -

1789 # endif /* OPENSSL_NO_EC */ -

1790 -

1791 struct cert_pkey_st { -

1792 X509 *x509; -

1793 EVP_PKEY *privatekey; -

1794 /* Chain for this certificate */ -

1795 STACK_OF(X509) *chain; -

1796 /*- -

1797 * serverinfo data for this certificate. The data is in TLS Extension -

1798 * wire format, specifically it's a series of records like: -

1799 * uint16_t extension_type; // (RFC 5246, 7.4.1.4, Extension) -

1800 * uint16_t length; -

1801 * uint8_t data[length]; -

1802 */ -

1803 unsigned char *serverinfo; -

1804 size_t serverinfo_length; -

1805 }; -

1806 /* Retrieve Suite B flags */ -

1807 # define tls1_suiteb(s) (s->cert->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS) -

1808 /* Uses to check strict mode: suite B modes are always strict */ -

1809 # define SSL_CERT_FLAGS_CHECK_TLS_STRICT \ -

1810 (SSL_CERT_FLAG_SUITEB_128_LOS|SSL_CERT_FLAG_TLS_STRICT) -

1811 -

1812 typedef enum { -

1813 ENDPOINT_CLIENT = 0, -

1814 ENDPOINT_SERVER, -

1815 ENDPOINT_BOTH -

1816 } ENDPOINT; -

1817 -

1818 -

1819 typedef struct { -

1820 unsigned short ext_type; -

1821 ENDPOINT role; -

1822 /* The context which this extension applies to */ -

1823 unsigned int context; -

1824 /* -

1825 * Per-connection flags relating to this extension type: not used if -

1826 * part of an SSL_CTX structure. -

1827 */ -

1828 uint32_t ext_flags; -

1829 SSL_custom_ext_add_cb_ex add_cb; -

1830 SSL_custom_ext_free_cb_ex free_cb; -

1831 void *add_arg; -

1832 SSL_custom_ext_parse_cb_ex parse_cb; -

1833 void *parse_arg; -

1834 } custom_ext_method; -

1835 -

1836 /* ext_flags values */ -

1837 -

1838 /* -

1839 * Indicates an extension has been received. Used to check for unsolicited or -

1840 * duplicate extensions. -

1841 */ -

1842 # define SSL_EXT_FLAG_RECEIVED 0x1 -

1843 /* -

1844 * Indicates an extension has been sent: used to enable sending of -

1845 * corresponding ServerHello extension. -

1846 */ -

1847 # define SSL_EXT_FLAG_SENT 0x2 -

1848 -

1849 typedef struct { -

1850 custom_ext_method *meths; -

1851 size_t meths_count; -

1852 } custom_ext_methods; -

1853 -

1854 typedef struct cert_st { -

1855 /* Current active set */ -

1856 /* -

1857 * ALWAYS points to an element of the pkeys array -

1858 * Probably it would make more sense to store -

1859 * an index, not a pointer. -

1860 */ -

1861 CERT_PKEY *key; -

1862 # ifndef OPENSSL_NO_DH -

1863 EVP_PKEY *dh_tmp; -

1864 DH *(*dh_tmp_cb) (SSL *ssl, int is_export, int keysize); -

1865 int dh_tmp_auto; -

1866 # endif -

1867 /* Flags related to certificates */ -

1868 uint32_t cert_flags; -

1869 CERT_PKEY pkeys[SSL_PKEY_NUM]; -

1870 /* Custom certificate types sent in certificate request message. */ -

1871 uint8_t *ctype; -

1872 size_t ctype_len; -

1873 /* -

1874 * supported signature algorithms. When set on a client this is sent in -

1875 * the client hello as the supported signature algorithms extension. For -

1876 * servers it represents the signature algorithms we are willing to use. -

1877 */ -

1878 uint16_t *conf_sigalgs; -

1879 /* Size of above array */ -

1880 size_t conf_sigalgslen; -

1881 /* -

1882 * Client authentication signature algorithms, if not set then uses -

1883 * conf_sigalgs. On servers these will be the signature algorithms sent -

1884 * to the client in a certificate request for TLS 1.2. On a client this -

1885 * represents the signature algorithms we are willing to use for client -

1886 * authentication. -

1887 */ -

1888 uint16_t *client_sigalgs; -

1889 /* Size of above array */ -

1890 size_t client_sigalgslen; -

1891 /* -

1892 * Signature algorithms shared by client and server: cached because these -

1893 * are used most often. -

1894 */ -

1895 const SIGALG_LOOKUP **shared_sigalgs; -

1896 size_t shared_sigalgslen; -

1897 /* -

1898 * Certificate setup callback: if set is called whenever a certificate -

1899 * may be required (client or server). the callback can then examine any -

1900 * appropriate parameters and setup any certificates required. This -

1901 * allows advanced applications to select certificates on the fly: for -

1902 * example based on supported signature algorithms or curves. -

1903 */ -

1904 int (*cert_cb) (SSL *ssl, void *arg); -

1905 void *cert_cb_arg; -

1906 /* -

1907 * Optional X509_STORE for chain building or certificate validation If -

1908 * NULL the parent SSL_CTX store is used instead. -

1909 */ -

1910 X509_STORE *chain_store; -

1911 X509_STORE *verify_store; -

1912 /* Custom extensions */ -

1913 custom_ext_methods custext; -

1914 /* Security callback */ -

1915 int (*sec_cb) (const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid, -

1916 void *other, void *ex); -

1917 /* Security level */ -

1918 int sec_level; -

1919 void *sec_ex; -

1920 # ifndef OPENSSL_NO_PSK -

1921 /* If not NULL psk identity hint to use for servers */ -

1922 char *psk_identity_hint; -

1923 # endif -

1924 CRYPTO_REF_COUNT references; /* >1 only if SSL_copy_session_id is used */ -

1925 CRYPTO_RWLOCK *lock; -

1926 } CERT; -

1927 -

1928 # define FP_ICC (int (*)(const void *,const void *)) -

1929 -

1930 /* -

1931 * This is for the SSLv3/TLSv1.0 differences in crypto/hash stuff It is a bit -

1932 * of a mess of functions, but hell, think of it as an opaque structure :-) -

1933 */ -

1934 typedef struct ssl3_enc_method { -

1935 int (*enc) (SSL *, SSL3_RECORD *, size_t, int); -

1936 int (*mac) (SSL *, SSL3_RECORD *, unsigned char *, int); -

1937 int (*setup_key_block) (SSL *); -

1938 int (*generate_master_secret) (SSL *, unsigned char *, unsigned char *, -

1939 size_t, size_t *); -

1940 int (*change_cipher_state) (SSL *, int); -

1941 size_t (*final_finish_mac) (SSL *, const char *, size_t, unsigned char *); -

1942 const char *client_finished_label; -

1943 size_t client_finished_label_len; -

1944 const char *server_finished_label; -

1945 size_t server_finished_label_len; -

1946 int (*alert_value) (int); -

1947 int (*export_keying_material) (SSL *, unsigned char *, size_t, -

1948 const char *, size_t, -

1949 const unsigned char *, size_t, -

1950 int use_context); -

1951 /* Various flags indicating protocol version requirements */ -

1952 uint32_t enc_flags; -

1953 /* Set the handshake header */ -

1954 int (*set_handshake_header) (SSL *s, WPACKET *pkt, int type); -

1955 /* Close construction of the handshake message */ -

1956 int (*close_construct_packet) (SSL *s, WPACKET *pkt, int htype); -

1957 /* Write out handshake message */ -

1958 int (*do_write) (SSL *s); -

1959 } SSL3_ENC_METHOD; -

1960 -

1961 # define ssl_set_handshake_header(s, pkt, htype) \ -

1962 s->method->ssl3_enc->set_handshake_header((s), (pkt), (htype)) -

1963 # define ssl_close_construct_packet(s, pkt, htype) \ -

1964 s->method->ssl3_enc->close_construct_packet((s), (pkt), (htype)) -

1965 # define ssl_do_write(s) s->method->ssl3_enc->do_write(s) -

1966 -

1967 /* Values for enc_flags */ -

1968 -

1969 /* Uses explicit IV for CBC mode */ -

1970 # define SSL_ENC_FLAG_EXPLICIT_IV 0x1 -

1971 /* Uses signature algorithms extension */ -

1972 # define SSL_ENC_FLAG_SIGALGS 0x2 -

1973 /* Uses SHA256 default PRF */ -

1974 # define SSL_ENC_FLAG_SHA256_PRF 0x4 -

1975 /* Is DTLS */ -

1976 # define SSL_ENC_FLAG_DTLS 0x8 -

1977 /* -

1978 * Allow TLS 1.2 ciphersuites: applies to DTLS 1.2 as well as TLS 1.2: may -

1979 * apply to others in future. -

1980 */ -

1981 # define SSL_ENC_FLAG_TLS1_2_CIPHERS 0x10 -

1982 -

1983 # ifndef OPENSSL_NO_COMP -

1984 /* Used for holding the relevant compression methods loaded into SSL_CTX */ -

1985 typedef struct ssl3_comp_st { -

1986 int comp_id; /* The identifier byte for this compression -

1987 * type */ -

1988 char *name; /* Text name used for the compression type */ -

1989 COMP_METHOD *method; /* The method :-) */ -

1990 } SSL3_COMP; -

1991 # endif -

1992 -

1993 typedef enum downgrade_en { -

1994 DOWNGRADE_NONE, -

1995 DOWNGRADE_TO_1_2, -

1996 DOWNGRADE_TO_1_1 -

1997 } DOWNGRADE; -

1998 -

1999 /* -

2000 * Dummy status type for the status_type extension. Indicates no status type -

2001 * set -

2002 */ -

2003 #define TLSEXT_STATUSTYPE_nothing -1 -

2004 -

2005 /* Sigalgs values */ -

2006 #define TLSEXT_SIGALG_ecdsa_secp256r1_sha256 0x0403 -

2007 #define TLSEXT_SIGALG_ecdsa_secp384r1_sha384 0x0503 -

2008 #define TLSEXT_SIGALG_ecdsa_secp521r1_sha512 0x0603 -

2009 #define TLSEXT_SIGALG_ecdsa_sha224 0x0303 -

2010 #define TLSEXT_SIGALG_ecdsa_sha1 0x0203 -

2011 #define TLSEXT_SIGALG_rsa_pss_rsae_sha256 0x0804 -

2012 #define TLSEXT_SIGALG_rsa_pss_rsae_sha384 0x0805 -

2013 #define TLSEXT_SIGALG_rsa_pss_rsae_sha512 0x0806 -

2014 #define TLSEXT_SIGALG_rsa_pss_pss_sha256 0x0809 -

2015 #define TLSEXT_SIGALG_rsa_pss_pss_sha384 0x080a -

2016 #define TLSEXT_SIGALG_rsa_pss_pss_sha512 0x080b -

2017 #define TLSEXT_SIGALG_rsa_pkcs1_sha256 0x0401 -

2018 #define TLSEXT_SIGALG_rsa_pkcs1_sha384 0x0501 -

2019 #define TLSEXT_SIGALG_rsa_pkcs1_sha512 0x0601 -

2020 #define TLSEXT_SIGALG_rsa_pkcs1_sha224 0x0301 -

2021 #define TLSEXT_SIGALG_rsa_pkcs1_sha1 0x0201 -

2022 #define TLSEXT_SIGALG_dsa_sha256 0x0402 -

2023 #define TLSEXT_SIGALG_dsa_sha384 0x0502 -

2024 #define TLSEXT_SIGALG_dsa_sha512 0x0602 -

2025 #define TLSEXT_SIGALG_dsa_sha224 0x0302 -

2026 #define TLSEXT_SIGALG_dsa_sha1 0x0202 -

2027 #define TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256 0xeeee -

2028 #define TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512 0xefef -

2029 #define TLSEXT_SIGALG_gostr34102001_gostr3411 0xeded -

2030 -

2031 #define TLSEXT_SIGALG_ed25519 0x0807 -

2032 #define TLSEXT_SIGALG_ed448 0x0808 -

2033 -

2034 /* Known PSK key exchange modes */ -

2035 #define TLSEXT_KEX_MODE_KE 0x00 -

2036 #define TLSEXT_KEX_MODE_KE_DHE 0x01 -

2037 -

2038 /* -

2039 * Internal representations of key exchange modes -

2040 */ -

2041 #define TLSEXT_KEX_MODE_FLAG_NONE 0 -

2042 #define TLSEXT_KEX_MODE_FLAG_KE 1 -

2043 #define TLSEXT_KEX_MODE_FLAG_KE_DHE 2 -

2044 -

2045 /* An invalid index into the TLSv1.3 PSK identities */ -

2046 #define TLSEXT_PSK_BAD_IDENTITY -1 -

2047 -

2048 #define SSL_USE_PSS(s) (s->s3->tmp.peer_sigalg != NULL && \ -

2049 s->s3->tmp.peer_sigalg->sig == EVP_PKEY_RSA_PSS) -

2050 -

2051 /* A dummy signature value not valid for TLSv1.2 signature algs */ -

2052 #define TLSEXT_signature_rsa_pss 0x0101 -

2053 -

2054 /* TLSv1.3 downgrade protection sentinel values */ -

2055 extern const unsigned char tls11downgrade[8]; -

2056 extern const unsigned char tls12downgrade[8]; -

2057 -

2058 extern SSL3_ENC_METHOD ssl3_undef_enc_method; -

2059 -

2060 __owur const SSL_METHOD *ssl_bad_method(int ver); -

2061 __owur const SSL_METHOD *sslv3_method(void); -

2062 __owur const SSL_METHOD *sslv3_server_method(void); -

2063 __owur const SSL_METHOD *sslv3_client_method(void); -

2064 __owur const SSL_METHOD *tlsv1_method(void); -

2065 __owur const SSL_METHOD *tlsv1_server_method(void); -

2066 __owur const SSL_METHOD *tlsv1_client_method(void); -

2067 __owur const SSL_METHOD *tlsv1_1_method(void); -

2068 __owur const SSL_METHOD *tlsv1_1_server_method(void); -

2069 __owur const SSL_METHOD *tlsv1_1_client_method(void); -

2070 __owur const SSL_METHOD *tlsv1_2_method(void); -

2071 __owur const SSL_METHOD *tlsv1_2_server_method(void); -

2072 __owur const SSL_METHOD *tlsv1_2_client_method(void); -

2073 __owur const SSL_METHOD *tlsv1_3_method(void); -

2074 __owur const SSL_METHOD *tlsv1_3_server_method(void); -

2075 __owur const SSL_METHOD *tlsv1_3_client_method(void); -

2076 __owur const SSL_METHOD *dtlsv1_method(void); -

2077 __owur const SSL_METHOD *dtlsv1_server_method(void); -

2078 __owur const SSL_METHOD *dtlsv1_client_method(void); -

2079 __owur const SSL_METHOD *dtls_bad_ver_client_method(void); -

2080 __owur const SSL_METHOD *dtlsv1_2_method(void); -

2081 __owur const SSL_METHOD *dtlsv1_2_server_method(void); -

2082 __owur const SSL_METHOD *dtlsv1_2_client_method(void); -

2083 -

2084 extern const SSL3_ENC_METHOD TLSv1_enc_data; -

2085 extern const SSL3_ENC_METHOD TLSv1_1_enc_data; -

2086 extern const SSL3_ENC_METHOD TLSv1_2_enc_data; -

2087 extern const SSL3_ENC_METHOD TLSv1_3_enc_data; -

2088 extern const SSL3_ENC_METHOD SSLv3_enc_data; -

2089 extern const SSL3_ENC_METHOD DTLSv1_enc_data; -

2090 extern const SSL3_ENC_METHOD DTLSv1_2_enc_data; -

2091 -

2092 /* -

2093 * Flags for SSL methods -

2094 */ -

2095 # define SSL_METHOD_NO_FIPS (1U<<0) -

2096 # define SSL_METHOD_NO_SUITEB (1U<<1) -

2097 -

2098 # define IMPLEMENT_tls_meth_func(version, flags, mask, func_name, s_accept, \ -

2099 s_connect, enc_data) \ -

2100 const SSL_METHOD *func_name(void) \ -

2101 { \ -

2102 static const SSL_METHOD func_name##_data= { \ -

2103 version, \ -

2104 flags, \ -

2105 mask, \ -

2106 tls1_new, \ -

2107 tls1_clear, \ -

2108 tls1_free, \ -

2109 s_accept, \ -

2110 s_connect, \ -

2111 ssl3_read, \ -

2112 ssl3_peek, \ -

2113 ssl3_write, \ -

2114 ssl3_shutdown, \ -

2115 ssl3_renegotiate, \ -

2116 ssl3_renegotiate_check, \ -

2117 ssl3_read_bytes, \ -

2118 ssl3_write_bytes, \ -

2119 ssl3_dispatch_alert, \ -

2120 ssl3_ctrl, \ -

2121 ssl3_ctx_ctrl, \ -

2122 ssl3_get_cipher_by_char, \ -

2123 ssl3_put_cipher_by_char, \ -

2124 ssl3_pending, \ -

2125 ssl3_num_ciphers, \ -

2126 ssl3_get_cipher, \ -

2127 tls1_default_timeout, \ -

2128 &enc_data, \ -

2129 ssl_undefined_void_function, \ -

2130 ssl3_callback_ctrl, \ -

2131 ssl3_ctx_callback_ctrl, \ -

2132 }; \ -

2133 return &func_name##_data; \ -

2134 } -

2135 -

2136 # define IMPLEMENT_ssl3_meth_func(func_name, s_accept, s_connect) \ -

2137 const SSL_METHOD *func_name(void) \ -

2138 { \ -

2139 static const SSL_METHOD func_name##_data= { \ -

2140 SSL3_VERSION, \ -

2141 SSL_METHOD_NO_FIPS | SSL_METHOD_NO_SUITEB, \ -

2142 SSL_OP_NO_SSLv3, \ -

2143 ssl3_new, \ -

2144 ssl3_clear, \ -

2145 ssl3_free, \ -

2146 s_accept, \ -

2147 s_connect, \ -

2148 ssl3_read, \ -

2149 ssl3_peek, \ -

2150 ssl3_write, \ -

2151 ssl3_shutdown, \ -

2152 ssl3_renegotiate, \ -

2153 ssl3_renegotiate_check, \ -

2154 ssl3_read_bytes, \ -

2155 ssl3_write_bytes, \ -

2156 ssl3_dispatch_alert, \ -

2157 ssl3_ctrl, \ -

2158 ssl3_ctx_ctrl, \ -

2159 ssl3_get_cipher_by_char, \ -

2160 ssl3_put_cipher_by_char, \ -

2161 ssl3_pending, \ -

2162 ssl3_num_ciphers, \ -

2163 ssl3_get_cipher, \ -

2164 ssl3_default_timeout, \ -

2165 &SSLv3_enc_data, \ -

2166 ssl_undefined_void_function, \ -

2167 ssl3_callback_ctrl, \ -

2168 ssl3_ctx_callback_ctrl, \ -

2169 }; \ -

2170 return &func_name##_data; \ -

2171 } -

2172 -

2173 # define IMPLEMENT_dtls1_meth_func(version, flags, mask, func_name, s_accept, \ -

2174 s_connect, enc_data) \ -

2175 const SSL_METHOD *func_name(void) \ -

2176 { \ -

2177 static const SSL_METHOD func_name##_data= { \ -

2178 version, \ -

2179 flags, \ -

2180 mask, \ -

2181 dtls1_new, \ -

2182 dtls1_clear, \ -

2183 dtls1_free, \ -

2184 s_accept, \ -

2185 s_connect, \ -

2186 ssl3_read, \ -

2187 ssl3_peek, \ -

2188 ssl3_write, \ -

2189 dtls1_shutdown, \ -

2190 ssl3_renegotiate, \ -

2191 ssl3_renegotiate_check, \ -

2192 dtls1_read_bytes, \ -

2193 dtls1_write_app_data_bytes, \ -

2194 dtls1_dispatch_alert, \ -

2195 dtls1_ctrl, \ -

2196 ssl3_ctx_ctrl, \ -

2197 ssl3_get_cipher_by_char, \ -

2198 ssl3_put_cipher_by_char, \ -

2199 ssl3_pending, \ -

2200 ssl3_num_ciphers, \ -

2201 ssl3_get_cipher, \ -

2202 dtls1_default_timeout, \ -

2203 &enc_data, \ -

2204 ssl_undefined_void_function, \ -

2205 ssl3_callback_ctrl, \ -

2206 ssl3_ctx_callback_ctrl, \ -

2207 }; \ -

2208 return &func_name##_data; \ -

2209 } -

2210 -

2211 struct openssl_ssl_test_functions { -

2212 int (*p_ssl_init_wbio_buffer) (SSL *s); -

2213 int (*p_ssl3_setup_buffers) (SSL *s); -

2214 }; -

2215 -

2216 const char *ssl_protocol_to_string(int version); -

2217 -

2218 /* Returns true if certificate and private key for 'idx' are present */ -

2219 static ossl_inline int ssl_has_cert(const SSL *s, int idx) -

2220 { -

2221

if (idx < 0 || idx >= SSL_PKEY_NUM)

idx < 0	Description
TRUE	never evaluated
FALSE	evaluated 15565 times by 1 test Evaluated by: libssl.so.1.1

idx >= 9	Description
TRUE	never evaluated
FALSE	evaluated 15565 times by 1 test Evaluated by: libssl.so.1.1

0-15565

2222

return 0;

never executed: return 0;

2223

return s->cert->pkeys[idx].x509 != NULL

executed 15565 times by 1 test: return s->cert->pkeys[idx].x509 != ((void *)0) && s->cert->pkeys[idx].privatekey != ((void *)0) ;

Executed by:

libssl.so.1.1

s->cert->pkeys...!= ((void *)0)	Description
TRUE	evaluated 4127 times by 1 test Evaluated by: libssl.so.1.1
FALSE	evaluated 11438 times by 1 test Evaluated by: libssl.so.1.1

4127-15565

2224

&& s->cert->pkeys[idx].privatekey != NULL;

executed 15565 times by 1 test: return s->cert->pkeys[idx].x509 != ((void *)0) && s->cert->pkeys[idx].privatekey != ((void *)0) ;

Executed by:

libssl.so.1.1

s->cert->pkeys...!= ((void *)0)	Description
TRUE	evaluated 4127 times by 1 test Evaluated by: libssl.so.1.1
FALSE	never evaluated

0-15565

2225 } -

2226 -

2227 static ossl_inline void tls1_get_peer_groups(SSL *s, const uint16_t **pgroups, -

2228 size_t *pgroupslen) -

2229 { -

2230 *pgroups = s->session->ext.supportedgroups; -

2231 *pgroupslen = s->session->ext.supportedgroups_len; -

2232

}

executed 8869 times by 1 test: end of block

Executed by:

libssl.so.1.1

8869

2233 -

2234 # ifndef OPENSSL_UNIT_TEST -

2235 -

2236 __owur int ssl_read_internal(SSL *s, void *buf, size_t num, size_t *readbytes); -

2237 __owur int ssl_write_internal(SSL *s, const void *buf, size_t num, size_t *written); -

2238 void ssl_clear_cipher_ctx(SSL *s); -

2239 int ssl_clear_bad_session(SSL *s); -

2240 __owur CERT *ssl_cert_new(void); -

2241 __owur CERT *ssl_cert_dup(CERT *cert); -

2242 void ssl_cert_clear_certs(CERT *c); -

2243 void ssl_cert_free(CERT *c); -

2244 __owur int ssl_generate_session_id(SSL *s, SSL_SESSION *ss); -

2245 __owur int ssl_get_new_session(SSL *s, int session); -

2246 __owur SSL_SESSION *lookup_sess_in_cache(SSL *s, const unsigned char *sess_id, -

2247 size_t sess_id_len); -

2248 __owur int ssl_get_prev_session(SSL *s, CLIENTHELLO_MSG *hello); -

2249 __owur SSL_SESSION *ssl_session_dup(SSL_SESSION *src, int ticket); -

2250 __owur int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b); -

2251 DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id); -

2252 __owur int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap, -

2253 const SSL_CIPHER *const *bp); -

2254 __owur STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *ssl_method, -

2255 STACK_OF(SSL_CIPHER) *tls13_ciphersuites, -

2256 STACK_OF(SSL_CIPHER) **cipher_list, -

2257 STACK_OF(SSL_CIPHER) **cipher_list_by_id, -

2258 const char *rule_str, -

2259 CERT *c); -

2260 __owur int ssl_cache_cipherlist(SSL *s, PACKET *cipher_suites, int sslv2format); -

2261 __owur int bytes_to_cipher_list(SSL *s, PACKET *cipher_suites, -

2262 STACK_OF(SSL_CIPHER) **skp, -

2263 STACK_OF(SSL_CIPHER) **scsvs, int sslv2format, -

2264 int fatal); -

2265 void ssl_update_cache(SSL *s, int mode); -

2266 __owur int ssl_cipher_get_evp(const SSL_SESSION *s, const EVP_CIPHER **enc, -

2267 const EVP_MD **md, int *mac_pkey_type, -

2268 size_t *mac_secret_size, SSL_COMP **comp, -

2269 int use_etm); -

2270 __owur int ssl_cipher_get_overhead(const SSL_CIPHER *c, size_t *mac_overhead, -

2271 size_t *int_overhead, size_t *blocksize, -

2272 size_t *ext_overhead); -

2273 __owur int ssl_cert_is_disabled(size_t idx); -

2274 __owur const SSL_CIPHER *ssl_get_cipher_by_char(SSL *ssl, -

2275 const unsigned char *ptr, -

2276 int all); -

2277 __owur int ssl_cert_set0_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain); -

2278 __owur int ssl_cert_set1_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain); -

2279 __owur int ssl_cert_add0_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x); -

2280 __owur int ssl_cert_add1_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x); -

2281 __owur int ssl_cert_select_current(CERT *c, X509 *x); -

2282 __owur int ssl_cert_set_current(CERT *c, long arg); -

2283 void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg); -

2284 -

2285 __owur int ssl_verify_cert_chain(SSL *s, STACK_OF(X509) *sk); -

2286 __owur int ssl_build_cert_chain(SSL *s, SSL_CTX *ctx, int flags); -

2287 __owur int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain, -

2288 int ref); -

2289 -

2290 __owur int ssl_security(const SSL *s, int op, int bits, int nid, void *other); -

2291 __owur int ssl_ctx_security(const SSL_CTX *ctx, int op, int bits, int nid, -

2292 void *other); -

2293 -

2294 __owur int ssl_cert_lookup_by_nid(int nid, size_t *pidx); -

2295 __owur const SSL_CERT_LOOKUP *ssl_cert_lookup_by_pkey(const EVP_PKEY *pk, -

2296 size_t *pidx); -

2297 __owur const SSL_CERT_LOOKUP *ssl_cert_lookup_by_idx(size_t idx); -

2298 -

2299 int ssl_undefined_function(SSL *s); -

2300 __owur int ssl_undefined_void_function(void); -

2301 __owur int ssl_undefined_const_function(const SSL *s); -

2302 __owur int ssl_get_server_cert_serverinfo(SSL *s, -

2303 const unsigned char **serverinfo, -

2304 size_t *serverinfo_length); -

2305 void ssl_set_masks(SSL *s); -

2306 __owur STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s); -

2307 __owur int ssl_x509err2alert(int type); -

2308 void ssl_sort_cipher_list(void); -

2309 int ssl_load_ciphers(void); -

2310 __owur int ssl_fill_hello_random(SSL *s, int server, unsigned char *field, -

2311 size_t len, DOWNGRADE dgrd); -

2312 __owur int ssl_generate_master_secret(SSL *s, unsigned char *pms, size_t pmslen, -

2313 int free_pms); -

2314 __owur EVP_PKEY *ssl_generate_pkey(EVP_PKEY *pm); -

2315 __owur int ssl_derive(SSL *s, EVP_PKEY *privkey, EVP_PKEY *pubkey, -

2316 int genmaster); -

2317 __owur EVP_PKEY *ssl_dh_to_pkey(DH *dh); -

2318 __owur unsigned int ssl_get_max_send_fragment(const SSL *ssl); -

2319 __owur unsigned int ssl_get_split_send_fragment(const SSL *ssl); -

2320 -

2321 __owur const SSL_CIPHER *ssl3_get_cipher_by_id(uint32_t id); -

2322 __owur const SSL_CIPHER *ssl3_get_cipher_by_std_name(const char *stdname); -

2323 __owur const SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p); -

2324 __owur int ssl3_put_cipher_by_char(const SSL_CIPHER *c, WPACKET *pkt, -

2325 size_t *len); -

2326 int ssl3_init_finished_mac(SSL *s); -

2327 __owur int ssl3_setup_key_block(SSL *s); -

2328 __owur int ssl3_change_cipher_state(SSL *s, int which); -

2329 void ssl3_cleanup_key_block(SSL *s); -

2330 __owur int ssl3_do_write(SSL *s, int type); -

2331 int ssl3_send_alert(SSL *s, int level, int desc); -

2332 __owur int ssl3_generate_master_secret(SSL *s, unsigned char *out, -

2333 unsigned char *p, size_t len, -

2334 size_t *secret_size); -

2335 __owur int ssl3_get_req_cert_type(SSL *s, WPACKET *pkt); -

2336 __owur int ssl3_num_ciphers(void); -

2337 __owur const SSL_CIPHER *ssl3_get_cipher(unsigned int u); -

2338 int ssl3_renegotiate(SSL *ssl); -

2339 int ssl3_renegotiate_check(SSL *ssl, int initok); -

2340 __owur int ssl3_dispatch_alert(SSL *s); -

2341 __owur size_t ssl3_final_finish_mac(SSL *s, const char *sender, size_t slen, -

2342 unsigned char *p); -

2343 __owur int ssl3_finish_mac(SSL *s, const unsigned char *buf, size_t len); -

2344 void ssl3_free_digest_list(SSL *s); -

2345 __owur unsigned long ssl3_output_cert_chain(SSL *s, WPACKET *pkt, -

2346 CERT_PKEY *cpk); -

2347 __owur const SSL_CIPHER *ssl3_choose_cipher(SSL *ssl, -

2348 STACK_OF(SSL_CIPHER) *clnt, -

2349 STACK_OF(SSL_CIPHER) *srvr); -

2350 __owur int ssl3_digest_cached_records(SSL *s, int keep); -

2351 __owur int ssl3_new(SSL *s); -

2352 void ssl3_free(SSL *s); -

2353 __owur int ssl3_read(SSL *s, void *buf, size_t len, size_t *readbytes); -

2354 __owur int ssl3_peek(SSL *s, void *buf, size_t len, size_t *readbytes); -

2355 __owur int ssl3_write(SSL *s, const void *buf, size_t len, size_t *written); -

2356 __owur int ssl3_shutdown(SSL *s); -

2357 int ssl3_clear(SSL *s); -

2358 __owur long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg); -

2359 __owur long ssl3_ctx_ctrl(SSL_CTX *s, int cmd, long larg, void *parg); -

2360 __owur long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp) (void)); -

2361 __owur long ssl3_ctx_callback_ctrl(SSL_CTX *s, int cmd, void (*fp) (void)); -

2362 -

2363 __owur int ssl3_do_change_cipher_spec(SSL *ssl); -

2364 __owur long ssl3_default_timeout(void); -

2365 -

2366 __owur int ssl3_set_handshake_header(SSL *s, WPACKET *pkt, int htype); -

2367 __owur int tls_close_construct_packet(SSL *s, WPACKET *pkt, int htype); -

2368 __owur int tls_setup_handshake(SSL *s); -

2369 __owur int dtls1_set_handshake_header(SSL *s, WPACKET *pkt, int htype); -

2370 __owur int dtls1_close_construct_packet(SSL *s, WPACKET *pkt, int htype); -

2371 __owur int ssl3_handshake_write(SSL *s); -

2372 -

2373 __owur int ssl_allow_compression(SSL *s); -

2374 -

2375 __owur int ssl_version_supported(const SSL *s, int version, -

2376 const SSL_METHOD **meth); -

2377 -

2378 __owur int ssl_set_client_hello_version(SSL *s); -

2379 __owur int ssl_check_version_downgrade(SSL *s); -

2380 __owur int ssl_set_version_bound(int method_version, int version, int *bound); -

2381 __owur int ssl_choose_server_version(SSL *s, CLIENTHELLO_MSG *hello, -

2382 DOWNGRADE *dgrd); -

2383 __owur int ssl_choose_client_version(SSL *s, int version, -

2384 RAW_EXTENSION *extensions); -

2385 __owur int ssl_get_min_max_version(const SSL *s, int *min_version, -

2386 int *max_version, int *real_max); -

2387 -

2388 __owur long tls1_default_timeout(void); -

2389 __owur int dtls1_do_write(SSL *s, int type); -

2390 void dtls1_set_message_header(SSL *s, -

2391 unsigned char mt, -

2392 size_t len, -

2393 size_t frag_off, size_t frag_len); -

2394 -

2395 int dtls1_write_app_data_bytes(SSL *s, int type, const void *buf_, size_t len, -

2396 size_t *written); -

2397 -

2398 __owur int dtls1_read_failed(SSL *s, int code); -

2399 __owur int dtls1_buffer_message(SSL *s, int ccs); -

2400 __owur int dtls1_retransmit_message(SSL *s, unsigned short seq, int *found); -

2401 __owur int dtls1_get_queue_priority(unsigned short seq, int is_ccs); -

2402 int dtls1_retransmit_buffered_messages(SSL *s); -

2403 void dtls1_clear_received_buffer(SSL *s); -

2404 void dtls1_clear_sent_buffer(SSL *s); -

2405 void dtls1_get_message_header(unsigned char *data, -

2406 struct hm_header_st *msg_hdr); -

2407 __owur long dtls1_default_timeout(void); -

2408 __owur struct timeval *dtls1_get_timeout(SSL *s, struct timeval *timeleft); -

2409 __owur int dtls1_check_timeout_num(SSL *s); -

2410 __owur int dtls1_handle_timeout(SSL *s); -

2411 void dtls1_start_timer(SSL *s); -

2412 void dtls1_stop_timer(SSL *s); -

2413 __owur int dtls1_is_timer_expired(SSL *s); -

2414 void dtls1_double_timeout(SSL *s); -

2415 __owur int dtls_raw_hello_verify_request(WPACKET *pkt, unsigned char *cookie, -

2416 size_t cookie_len); -

2417 __owur size_t dtls1_min_mtu(SSL *s); -

2418 void dtls1_hm_fragment_free(hm_fragment *frag); -

2419 __owur int dtls1_query_mtu(SSL *s); -

2420 -

2421 __owur int tls1_new(SSL *s); -

2422 void tls1_free(SSL *s); -

2423 int tls1_clear(SSL *s); -

2424 -

2425 __owur int dtls1_new(SSL *s); -

2426 void dtls1_free(SSL *s); -

2427 int dtls1_clear(SSL *s); -

2428 long dtls1_ctrl(SSL *s, int cmd, long larg, void *parg); -

2429 __owur int dtls1_shutdown(SSL *s); -

2430 -

2431 __owur int dtls1_dispatch_alert(SSL *s); -

2432 -

2433 __owur int ssl_init_wbio_buffer(SSL *s); -

2434 int ssl_free_wbio_buffer(SSL *s); -

2435 -

2436 __owur int tls1_change_cipher_state(SSL *s, int which); -

2437 __owur int tls1_setup_key_block(SSL *s); -

2438 __owur size_t tls1_final_finish_mac(SSL *s, const char *str, size_t slen, -

2439 unsigned char *p); -

2440 __owur int tls1_generate_master_secret(SSL *s, unsigned char *out, -

2441 unsigned char *p, size_t len, -

2442 size_t *secret_size); -

2443 __owur int tls13_setup_key_block(SSL *s); -

2444 __owur size_t tls13_final_finish_mac(SSL *s, const char *str, size_t slen, -

2445 unsigned char *p); -

2446 __owur int tls13_change_cipher_state(SSL *s, int which); -

2447 __owur int tls13_update_key(SSL *s, int send); -

2448 __owur int tls13_hkdf_expand(SSL *s, const EVP_MD *md, -

2449 const unsigned char *secret, -

2450 const unsigned char *label, size_t labellen, -

2451 const unsigned char *data, size_t datalen, -

2452 unsigned char *out, size_t outlen); -

2453 __owur int tls13_derive_key(SSL *s, const EVP_MD *md, -

2454 const unsigned char *secret, unsigned char *key, -

2455 size_t keylen); -

2456 __owur int tls13_derive_iv(SSL *s, const EVP_MD *md, -

2457 const unsigned char *secret, unsigned char *iv, -

2458 size_t ivlen); -

2459 __owur int tls13_derive_finishedkey(SSL *s, const EVP_MD *md, -

2460 const unsigned char *secret, -

2461 unsigned char *fin, size_t finlen); -

2462 int tls13_generate_secret(SSL *s, const EVP_MD *md, -

2463 const unsigned char *prevsecret, -

2464 const unsigned char *insecret, -

2465 size_t insecretlen, -

2466 unsigned char *outsecret); -

2467 __owur int tls13_generate_handshake_secret(SSL *s, -

2468 const unsigned char *insecret, -

2469 size_t insecretlen); -

2470 __owur int tls13_generate_master_secret(SSL *s, unsigned char *out, -

2471 unsigned char *prev, size_t prevlen, -

2472 size_t *secret_size); -

2473 __owur int tls1_export_keying_material(SSL *s, unsigned char *out, size_t olen, -

2474 const char *label, size_t llen, -

2475 const unsigned char *p, size_t plen, -

2476 int use_context); -

2477 __owur int tls13_export_keying_material(SSL *s, unsigned char *out, size_t olen, -

2478 const char *label, size_t llen, -

2479 const unsigned char *context, -

2480 size_t contextlen, int use_context); -

2481 __owur int tls13_export_keying_material_early(SSL *s, unsigned char *out, -

2482 size_t olen, const char *label, -

2483 size_t llen, -

2484 const unsigned char *context, -

2485 size_t contextlen); -

2486 __owur int tls1_alert_code(int code); -

2487 __owur int tls13_alert_code(int code); -

2488 __owur int ssl3_alert_code(int code); -

2489 -

2490 # ifndef OPENSSL_NO_EC -

2491 __owur int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s); -

2492 # endif -

2493 -

2494 SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n); -

2495 -

2496 # ifndef OPENSSL_NO_EC -

2497 -

2498 __owur const TLS_GROUP_INFO *tls1_group_id_lookup(uint16_t curve_id); -

2499 __owur int tls1_check_group_id(SSL *s, uint16_t group_id, int check_own_curves); -

2500 __owur uint16_t tls1_shared_group(SSL *s, int nmatch); -

2501 __owur int tls1_set_groups(uint16_t **pext, size_t *pextlen, -

2502 int *curves, size_t ncurves); -

2503 __owur int tls1_set_groups_list(uint16_t **pext, size_t *pextlen, -

2504 const char *str); -

2505 void tls1_get_formatlist(SSL *s, const unsigned char **pformats, -

2506 size_t *num_formats); -

2507 __owur int tls1_check_ec_tmp_key(SSL *s, unsigned long id); -

2508 __owur EVP_PKEY *ssl_generate_pkey_group(SSL *s, uint16_t id); -

2509 __owur EVP_PKEY *ssl_generate_param_group(uint16_t id); -

2510 # endif /* OPENSSL_NO_EC */ -

2511 -

2512 __owur int tls_curve_allowed(SSL *s, uint16_t curve, int op); -

2513 void tls1_get_supported_groups(SSL *s, const uint16_t **pgroups, -

2514 size_t *pgroupslen); -

2515 -

2516 __owur int tls1_set_server_sigalgs(SSL *s); -

2517 -

2518 __owur SSL_TICKET_STATUS tls_get_ticket_from_client(SSL *s, CLIENTHELLO_MSG *hello, -

2519 SSL_SESSION **ret); -

2520 __owur SSL_TICKET_STATUS tls_decrypt_ticket(SSL *s, const unsigned char *etick, -

2521 size_t eticklen, -

2522 const unsigned char *sess_id, -

2523 size_t sesslen, SSL_SESSION **psess); -

2524 -

2525 __owur int tls_use_ticket(SSL *s); -

2526 -

2527 void ssl_set_sig_mask(uint32_t *pmask_a, SSL *s, int op); -

2528 -

2529 __owur int tls1_set_sigalgs_list(CERT *c, const char *str, int client); -

2530 __owur int tls1_set_raw_sigalgs(CERT *c, const uint16_t *psigs, size_t salglen, -

2531 int client); -

2532 __owur int tls1_set_sigalgs(CERT *c, const int *salg, size_t salglen, -

2533 int client); -

2534 int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain, -

2535 int idx); -

2536 void tls1_set_cert_validity(SSL *s); -

2537 -

2538 # ifndef OPENSSL_NO_CT -

2539 __owur int ssl_validate_ct(SSL *s); -

2540 # endif -

2541 -

2542 # ifndef OPENSSL_NO_DH -

2543 __owur DH *ssl_get_auto_dh(SSL *s); -

2544 # endif -

2545 -

2546 __owur int ssl_security_cert(SSL *s, SSL_CTX *ctx, X509 *x, int vfy, int is_ee); -

2547 __owur int ssl_security_cert_chain(SSL *s, STACK_OF(X509) *sk, X509 *ex, -

2548 int vfy); -

2549 -

2550 int tls_choose_sigalg(SSL *s, int fatalerrs); -

2551 -

2552 __owur EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash, const EVP_MD *md); -

2553 void ssl_clear_hash_ctx(EVP_MD_CTX **hash); -

2554 __owur long ssl_get_algorithm2(SSL *s); -

2555 __owur int tls12_copy_sigalgs(SSL *s, WPACKET *pkt, -

2556 const uint16_t *psig, size_t psiglen); -

2557 __owur int tls1_save_u16(PACKET *pkt, uint16_t **pdest, size_t *pdestlen); -

2558 __owur int tls1_save_sigalgs(SSL *s, PACKET *pkt, int cert); -

2559 __owur int tls1_process_sigalgs(SSL *s); -

2560 __owur int tls1_set_peer_legacy_sigalg(SSL *s, const EVP_PKEY *pkey); -

2561 __owur int tls1_lookup_md(const SIGALG_LOOKUP *lu, const EVP_MD **pmd); -

2562 __owur size_t tls12_get_psigalgs(SSL *s, int sent, const uint16_t **psigs); -

2563 __owur int tls12_check_peer_sigalg(SSL *s, uint16_t, EVP_PKEY *pkey); -

2564 __owur int ssl_set_client_disabled(SSL *s); -

2565 __owur int ssl_cipher_disabled(SSL *s, const SSL_CIPHER *c, int op, int echde); -

2566 -

2567 __owur int ssl_handshake_hash(SSL *s, unsigned char *out, size_t outlen, -

2568 size_t *hashlen); -

2569 __owur const EVP_MD *ssl_md(int idx); -

2570 __owur const EVP_MD *ssl_handshake_md(SSL *s); -

2571 __owur const EVP_MD *ssl_prf_md(SSL *s); -

2572 -

2573 /* -

2574 * ssl_log_rsa_client_key_exchange logs |premaster| to the SSL_CTX associated -

2575 * with |ssl|, if logging is enabled. It returns one on success and zero on -

2576 * failure. The entry is identified by the first 8 bytes of -

2577 * |encrypted_premaster|. -

2578 */ -

2579 __owur int ssl_log_rsa_client_key_exchange(SSL *ssl, -

2580 const uint8_t *encrypted_premaster, -

2581 size_t encrypted_premaster_len, -

2582 const uint8_t *premaster, -

2583 size_t premaster_len); -

2584 -

2585 /* -

2586 * ssl_log_secret logs |secret| to the SSL_CTX associated with |ssl|, if -

2587 * logging is available. It returns one on success and zero on failure. It tags -

2588 * the entry with |label|. -

2589 */ -

2590 __owur int ssl_log_secret(SSL *ssl, const char *label, -

2591 const uint8_t *secret, size_t secret_len); -

2592 -

2593 #define MASTER_SECRET_LABEL "CLIENT_RANDOM" -

2594 #define CLIENT_EARLY_LABEL "CLIENT_EARLY_TRAFFIC_SECRET" -

2595 #define CLIENT_HANDSHAKE_LABEL "CLIENT_HANDSHAKE_TRAFFIC_SECRET" -

2596 #define SERVER_HANDSHAKE_LABEL "SERVER_HANDSHAKE_TRAFFIC_SECRET" -

2597 #define CLIENT_APPLICATION_LABEL "CLIENT_TRAFFIC_SECRET_0" -

2598 #define SERVER_APPLICATION_LABEL "SERVER_TRAFFIC_SECRET_0" -

2599 #define EARLY_EXPORTER_SECRET_LABEL "EARLY_EXPORTER_SECRET" -

2600 #define EXPORTER_SECRET_LABEL "EXPORTER_SECRET" -

2601 -

2602 /* s3_cbc.c */ -

2603 __owur char ssl3_cbc_record_digest_supported(const EVP_MD_CTX *ctx); -

2604 __owur int ssl3_cbc_digest_record(const EVP_MD_CTX *ctx, -

2605 unsigned char *md_out, -

2606 size_t *md_out_size, -

2607 const unsigned char header[13], -

2608 const unsigned char *data, -

2609 size_t data_plus_mac_size, -

2610 size_t data_plus_mac_plus_padding_size, -

2611 const unsigned char *mac_secret, -

2612 size_t mac_secret_length, char is_sslv3); -

2613 -

2614 __owur int srp_generate_server_master_secret(SSL *s); -

2615 __owur int srp_generate_client_master_secret(SSL *s); -

2616 __owur int srp_verify_server_param(SSL *s); -

2617 -

2618 /* statem/statem_srvr.c */ -

2619 -

2620 __owur int send_certificate_request(SSL *s); -

2621 -

2622 /* statem/extensions_cust.c */ -

2623 -

2624 custom_ext_method *custom_ext_find(const custom_ext_methods *exts, -

2625 ENDPOINT role, unsigned int ext_type, -

2626 size_t *idx); -

2627 -

2628 void custom_ext_init(custom_ext_methods *meths); -

2629 -

2630 __owur int custom_ext_parse(SSL *s, unsigned int context, unsigned int ext_type, -

2631 const unsigned char *ext_data, size_t ext_size, -

2632 X509 *x, size_t chainidx); -

2633 __owur int custom_ext_add(SSL *s, int context, WPACKET *pkt, X509 *x, -

2634 size_t chainidx, int maxversion); -

2635 -

2636 __owur int custom_exts_copy(custom_ext_methods *dst, -

2637 const custom_ext_methods *src); -

2638 __owur int custom_exts_copy_flags(custom_ext_methods *dst, -

2639 const custom_ext_methods *src); -

2640 void custom_exts_free(custom_ext_methods *exts); -

2641 -

2642 void ssl_comp_free_compression_methods_int(void); -

2643 -

2644 /* ssl_mcnf.c */ -

2645 void ssl_ctx_system_config(SSL_CTX *ctx); -

2646 -

2647 # else /* OPENSSL_UNIT_TEST */ -

2648 -

2649 # define ssl_init_wbio_buffer SSL_test_functions()->p_ssl_init_wbio_buffer -

2650 # define ssl3_setup_buffers SSL_test_functions()->p_ssl3_setup_buffers -

2651 -

2652 # endif -

2653 #endif -

Source code

Switch to Preprocessed file

Generated by Squish Coco 4.2.2