2015-01-22 11:40:55 +08:00
|
|
|
/*
|
2021-01-28 03:23:33 +08:00
|
|
|
* Copyright 2012-2023 The OpenSSL Project Authors. All Rights Reserved.
|
2012-06-15 20:46:09 +08:00
|
|
|
*
|
2018-12-06 20:08:51 +08:00
|
|
|
* Licensed under the Apache License 2.0 (the "License"). You may not use
|
2016-05-18 02:18:30 +08:00
|
|
|
* this file except in compliance with the License. You can obtain a copy
|
|
|
|
|
* in the file LICENSE in the source distribution or at
|
|
|
|
|
* https://www.openssl.org/source/license.html
|
2012-06-15 20:46:09 +08:00
|
|
|
*/
|
|
|
|
|
|
2019-09-28 06:45:40 +08:00
|
|
|
#include "ssl_local.h"
|
2012-06-15 20:46:09 +08:00
|
|
|
|
|
|
|
|
#ifndef OPENSSL_NO_SSL_TRACE
|
|
|
|
|
|
|
|
|
|
/* Packet trace support for OpenSSL */
|
2021-02-21 06:39:30 +08:00
|
|
|
#include "internal/nelem.h"
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
typedef struct {
|
|
|
|
|
int num;
|
|
|
|
|
const char *name;
|
|
|
|
|
} ssl_trace_tbl;
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
# define ssl_trace_str(val, tbl) \
|
2018-04-26 19:57:14 +08:00
|
|
|
do_ssl_trace_str(val, tbl, OSSL_NELEM(tbl))
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
|
# define ssl_trace_list(bio, indent, msg, msglen, value, table) \
|
2018-04-26 19:57:14 +08:00
|
|
|
do_ssl_trace_list(bio, indent, msg, msglen, value, \
|
|
|
|
|
table, OSSL_NELEM(table))
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2017-09-11 11:33:37 +08:00
|
|
|
static const char *do_ssl_trace_str(int val, const ssl_trace_tbl *tbl,
|
|
|
|
|
size_t ntbl)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
|
size_t i;
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
for (i = 0; i < ntbl; i++, tbl++) {
|
|
|
|
|
if (tbl->num == val)
|
|
|
|
|
return tbl->name;
|
|
|
|
|
}
|
|
|
|
|
return "UNKNOWN";
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
|
|
|
|
static int do_ssl_trace_list(BIO *bio, int indent,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char *msg, size_t msglen,
|
2017-09-11 11:33:37 +08:00
|
|
|
size_t vlen, const ssl_trace_tbl *tbl, size_t ntbl)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
|
int val;
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (msglen % vlen)
|
|
|
|
|
return 0;
|
|
|
|
|
while (msglen) {
|
|
|
|
|
val = msg[0];
|
|
|
|
|
if (vlen == 2)
|
|
|
|
|
val = (val << 8) | msg[1];
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "%s (%d)\n", do_ssl_trace_str(val, tbl, ntbl), val);
|
|
|
|
|
msg += vlen;
|
|
|
|
|
msglen -= vlen;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
|
|
|
|
/* Version number */
|
|
|
|
|
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_version_tbl[] = {
|
2015-01-22 11:40:55 +08:00
|
|
|
{SSL3_VERSION, "SSL 3.0"},
|
|
|
|
|
{TLS1_VERSION, "TLS 1.0"},
|
|
|
|
|
{TLS1_1_VERSION, "TLS 1.1"},
|
|
|
|
|
{TLS1_2_VERSION, "TLS 1.2"},
|
2016-10-22 00:39:33 +08:00
|
|
|
{TLS1_3_VERSION, "TLS 1.3"},
|
2015-01-22 11:40:55 +08:00
|
|
|
{DTLS1_VERSION, "DTLS 1.0"},
|
|
|
|
|
{DTLS1_2_VERSION, "DTLS 1.2"},
|
|
|
|
|
{DTLS1_BAD_VER, "DTLS 1.0 (bad)"}
|
2012-06-15 20:46:09 +08:00
|
|
|
};
|
|
|
|
|
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_content_tbl[] = {
|
2015-01-22 11:40:55 +08:00
|
|
|
{SSL3_RT_CHANGE_CIPHER_SPEC, "ChangeCipherSpec"},
|
|
|
|
|
{SSL3_RT_ALERT, "Alert"},
|
|
|
|
|
{SSL3_RT_HANDSHAKE, "Handshake"},
|
|
|
|
|
{SSL3_RT_APPLICATION_DATA, "ApplicationData"},
|
2012-06-15 20:46:09 +08:00
|
|
|
};
|
2015-01-22 11:40:55 +08:00
|
|
|
|
2018-03-08 23:32:34 +08:00
|
|
|
/* Handshake types, sorted by ascending id */
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_handshake_tbl[] = {
|
2015-01-22 11:40:55 +08:00
|
|
|
{SSL3_MT_HELLO_REQUEST, "HelloRequest"},
|
|
|
|
|
{SSL3_MT_CLIENT_HELLO, "ClientHello"},
|
|
|
|
|
{SSL3_MT_SERVER_HELLO, "ServerHello"},
|
|
|
|
|
{DTLS1_MT_HELLO_VERIFY_REQUEST, "HelloVerifyRequest"},
|
|
|
|
|
{SSL3_MT_NEWSESSION_TICKET, "NewSessionTicket"},
|
2017-03-17 00:56:01 +08:00
|
|
|
{SSL3_MT_END_OF_EARLY_DATA, "EndOfEarlyData"},
|
2017-02-02 19:16:25 +08:00
|
|
|
{SSL3_MT_ENCRYPTED_EXTENSIONS, "EncryptedExtensions"},
|
2015-01-22 11:40:55 +08:00
|
|
|
{SSL3_MT_CERTIFICATE, "Certificate"},
|
|
|
|
|
{SSL3_MT_SERVER_KEY_EXCHANGE, "ServerKeyExchange"},
|
|
|
|
|
{SSL3_MT_CERTIFICATE_REQUEST, "CertificateRequest"},
|
|
|
|
|
{SSL3_MT_SERVER_DONE, "ServerHelloDone"},
|
|
|
|
|
{SSL3_MT_CERTIFICATE_VERIFY, "CertificateVerify"},
|
|
|
|
|
{SSL3_MT_CLIENT_KEY_EXCHANGE, "ClientKeyExchange"},
|
|
|
|
|
{SSL3_MT_FINISHED, "Finished"},
|
2018-03-08 23:32:34 +08:00
|
|
|
{SSL3_MT_CERTIFICATE_URL, "CertificateUrl"},
|
2017-02-09 01:08:48 +08:00
|
|
|
{SSL3_MT_CERTIFICATE_STATUS, "CertificateStatus"},
|
2018-03-08 23:32:34 +08:00
|
|
|
{SSL3_MT_SUPPLEMENTAL_DATA, "SupplementalData"},
|
2017-03-17 00:56:01 +08:00
|
|
|
{SSL3_MT_KEY_UPDATE, "KeyUpdate"},
|
2021-08-10 04:56:50 +08:00
|
|
|
{SSL3_MT_COMPRESSED_CERTIFICATE, "CompressedCertificate"},
|
2017-03-17 00:56:01 +08:00
|
|
|
# ifndef OPENSSL_NO_NEXTPROTONEG
|
|
|
|
|
{SSL3_MT_NEXT_PROTO, "NextProto"},
|
|
|
|
|
# endif
|
|
|
|
|
{SSL3_MT_MESSAGE_HASH, "MessageHash"}
|
2012-06-15 20:46:09 +08:00
|
|
|
};
|
2015-01-22 11:40:55 +08:00
|
|
|
|
2012-06-15 20:46:09 +08:00
|
|
|
/* Cipher suites */
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_ciphers_tbl[] = {
|
2017-07-31 21:11:18 +08:00
|
|
|
{0x0000, "TLS_NULL_WITH_NULL_NULL"},
|
|
|
|
|
{0x0001, "TLS_RSA_WITH_NULL_MD5"},
|
|
|
|
|
{0x0002, "TLS_RSA_WITH_NULL_SHA"},
|
|
|
|
|
{0x0003, "TLS_RSA_EXPORT_WITH_RC4_40_MD5"},
|
|
|
|
|
{0x0004, "TLS_RSA_WITH_RC4_128_MD5"},
|
|
|
|
|
{0x0005, "TLS_RSA_WITH_RC4_128_SHA"},
|
|
|
|
|
{0x0006, "TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5"},
|
|
|
|
|
{0x0007, "TLS_RSA_WITH_IDEA_CBC_SHA"},
|
|
|
|
|
{0x0008, "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA"},
|
|
|
|
|
{0x0009, "TLS_RSA_WITH_DES_CBC_SHA"},
|
|
|
|
|
{0x000A, "TLS_RSA_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0x000B, "TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA"},
|
|
|
|
|
{0x000C, "TLS_DH_DSS_WITH_DES_CBC_SHA"},
|
|
|
|
|
{0x000D, "TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0x000E, "TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA"},
|
|
|
|
|
{0x000F, "TLS_DH_RSA_WITH_DES_CBC_SHA"},
|
|
|
|
|
{0x0010, "TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0x0011, "TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA"},
|
|
|
|
|
{0x0012, "TLS_DHE_DSS_WITH_DES_CBC_SHA"},
|
|
|
|
|
{0x0013, "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0x0014, "TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA"},
|
|
|
|
|
{0x0015, "TLS_DHE_RSA_WITH_DES_CBC_SHA"},
|
|
|
|
|
{0x0016, "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0x0017, "TLS_DH_anon_EXPORT_WITH_RC4_40_MD5"},
|
|
|
|
|
{0x0018, "TLS_DH_anon_WITH_RC4_128_MD5"},
|
|
|
|
|
{0x0019, "TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA"},
|
|
|
|
|
{0x001A, "TLS_DH_anon_WITH_DES_CBC_SHA"},
|
|
|
|
|
{0x001B, "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA"},
|
2015-01-22 11:40:55 +08:00
|
|
|
{0x001D, "SSL_FORTEZZA_KEA_WITH_FORTEZZA_CBC_SHA"},
|
|
|
|
|
{0x001E, "SSL_FORTEZZA_KEA_WITH_RC4_128_SHA"},
|
|
|
|
|
{0x001F, "TLS_KRB5_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0x0020, "TLS_KRB5_WITH_RC4_128_SHA"},
|
|
|
|
|
{0x0021, "TLS_KRB5_WITH_IDEA_CBC_SHA"},
|
|
|
|
|
{0x0022, "TLS_KRB5_WITH_DES_CBC_MD5"},
|
|
|
|
|
{0x0023, "TLS_KRB5_WITH_3DES_EDE_CBC_MD5"},
|
|
|
|
|
{0x0024, "TLS_KRB5_WITH_RC4_128_MD5"},
|
|
|
|
|
{0x0025, "TLS_KRB5_WITH_IDEA_CBC_MD5"},
|
|
|
|
|
{0x0026, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA"},
|
|
|
|
|
{0x0027, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA"},
|
|
|
|
|
{0x0028, "TLS_KRB5_EXPORT_WITH_RC4_40_SHA"},
|
|
|
|
|
{0x0029, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5"},
|
|
|
|
|
{0x002A, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5"},
|
|
|
|
|
{0x002B, "TLS_KRB5_EXPORT_WITH_RC4_40_MD5"},
|
2015-06-06 19:51:19 +08:00
|
|
|
{0x002C, "TLS_PSK_WITH_NULL_SHA"},
|
|
|
|
|
{0x002D, "TLS_DHE_PSK_WITH_NULL_SHA"},
|
|
|
|
|
{0x002E, "TLS_RSA_PSK_WITH_NULL_SHA"},
|
2015-01-22 11:40:55 +08:00
|
|
|
{0x002F, "TLS_RSA_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0x0030, "TLS_DH_DSS_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0x0031, "TLS_DH_RSA_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0x0032, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0x0033, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0x0034, "TLS_DH_anon_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0x0035, "TLS_RSA_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0x0036, "TLS_DH_DSS_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0x0037, "TLS_DH_RSA_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0x0038, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0x0039, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0x003A, "TLS_DH_anon_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0x003B, "TLS_RSA_WITH_NULL_SHA256"},
|
|
|
|
|
{0x003C, "TLS_RSA_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0x003D, "TLS_RSA_WITH_AES_256_CBC_SHA256"},
|
|
|
|
|
{0x003E, "TLS_DH_DSS_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0x003F, "TLS_DH_RSA_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0x0040, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0x0041, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA"},
|
|
|
|
|
{0x0042, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA"},
|
|
|
|
|
{0x0043, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA"},
|
|
|
|
|
{0x0044, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA"},
|
|
|
|
|
{0x0045, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA"},
|
|
|
|
|
{0x0046, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA"},
|
|
|
|
|
{0x0067, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0x0068, "TLS_DH_DSS_WITH_AES_256_CBC_SHA256"},
|
|
|
|
|
{0x0069, "TLS_DH_RSA_WITH_AES_256_CBC_SHA256"},
|
|
|
|
|
{0x006A, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"},
|
|
|
|
|
{0x006B, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"},
|
|
|
|
|
{0x006C, "TLS_DH_anon_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0x006D, "TLS_DH_anon_WITH_AES_256_CBC_SHA256"},
|
2018-03-30 21:33:21 +08:00
|
|
|
{0x0081, "TLS_GOSTR341001_WITH_28147_CNT_IMIT"},
|
|
|
|
|
{0x0083, "TLS_GOSTR341001_WITH_NULL_GOSTR3411"},
|
2015-01-22 11:40:55 +08:00
|
|
|
{0x0084, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA"},
|
|
|
|
|
{0x0085, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA"},
|
|
|
|
|
{0x0086, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA"},
|
|
|
|
|
{0x0087, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA"},
|
|
|
|
|
{0x0088, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA"},
|
|
|
|
|
{0x0089, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA"},
|
|
|
|
|
{0x008A, "TLS_PSK_WITH_RC4_128_SHA"},
|
|
|
|
|
{0x008B, "TLS_PSK_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0x008C, "TLS_PSK_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0x008D, "TLS_PSK_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0x008E, "TLS_DHE_PSK_WITH_RC4_128_SHA"},
|
|
|
|
|
{0x008F, "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0x0090, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0x0091, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0x0092, "TLS_RSA_PSK_WITH_RC4_128_SHA"},
|
|
|
|
|
{0x0093, "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0x0094, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0x0095, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0x0096, "TLS_RSA_WITH_SEED_CBC_SHA"},
|
|
|
|
|
{0x0097, "TLS_DH_DSS_WITH_SEED_CBC_SHA"},
|
|
|
|
|
{0x0098, "TLS_DH_RSA_WITH_SEED_CBC_SHA"},
|
|
|
|
|
{0x0099, "TLS_DHE_DSS_WITH_SEED_CBC_SHA"},
|
|
|
|
|
{0x009A, "TLS_DHE_RSA_WITH_SEED_CBC_SHA"},
|
|
|
|
|
{0x009B, "TLS_DH_anon_WITH_SEED_CBC_SHA"},
|
|
|
|
|
{0x009C, "TLS_RSA_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0x009D, "TLS_RSA_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0x009E, "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0x009F, "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0x00A0, "TLS_DH_RSA_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0x00A1, "TLS_DH_RSA_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0x00A2, "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0x00A3, "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0x00A4, "TLS_DH_DSS_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0x00A5, "TLS_DH_DSS_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0x00A6, "TLS_DH_anon_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0x00A7, "TLS_DH_anon_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0x00A8, "TLS_PSK_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0x00A9, "TLS_PSK_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0x00AA, "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0x00AB, "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0x00AC, "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0x00AD, "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0x00AE, "TLS_PSK_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0x00AF, "TLS_PSK_WITH_AES_256_CBC_SHA384"},
|
|
|
|
|
{0x00B0, "TLS_PSK_WITH_NULL_SHA256"},
|
|
|
|
|
{0x00B1, "TLS_PSK_WITH_NULL_SHA384"},
|
|
|
|
|
{0x00B2, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0x00B3, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384"},
|
|
|
|
|
{0x00B4, "TLS_DHE_PSK_WITH_NULL_SHA256"},
|
|
|
|
|
{0x00B5, "TLS_DHE_PSK_WITH_NULL_SHA384"},
|
|
|
|
|
{0x00B6, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0x00B7, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384"},
|
|
|
|
|
{0x00B8, "TLS_RSA_PSK_WITH_NULL_SHA256"},
|
|
|
|
|
{0x00B9, "TLS_RSA_PSK_WITH_NULL_SHA384"},
|
|
|
|
|
{0x00BA, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0x00BB, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0x00BC, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0x00BD, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0x00BE, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0x00BF, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0x00C0, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256"},
|
|
|
|
|
{0x00C1, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256"},
|
|
|
|
|
{0x00C2, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256"},
|
|
|
|
|
{0x00C3, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256"},
|
|
|
|
|
{0x00C4, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256"},
|
|
|
|
|
{0x00C5, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256"},
|
|
|
|
|
{0x00FF, "TLS_EMPTY_RENEGOTIATION_INFO_SCSV"},
|
2015-06-06 19:51:19 +08:00
|
|
|
{0x5600, "TLS_FALLBACK_SCSV"},
|
2015-01-22 11:40:55 +08:00
|
|
|
{0xC001, "TLS_ECDH_ECDSA_WITH_NULL_SHA"},
|
|
|
|
|
{0xC002, "TLS_ECDH_ECDSA_WITH_RC4_128_SHA"},
|
|
|
|
|
{0xC003, "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0xC004, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0xC005, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0xC006, "TLS_ECDHE_ECDSA_WITH_NULL_SHA"},
|
|
|
|
|
{0xC007, "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA"},
|
|
|
|
|
{0xC008, "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0xC009, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0xC00A, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0xC00B, "TLS_ECDH_RSA_WITH_NULL_SHA"},
|
|
|
|
|
{0xC00C, "TLS_ECDH_RSA_WITH_RC4_128_SHA"},
|
|
|
|
|
{0xC00D, "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0xC00E, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0xC00F, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0xC010, "TLS_ECDHE_RSA_WITH_NULL_SHA"},
|
|
|
|
|
{0xC011, "TLS_ECDHE_RSA_WITH_RC4_128_SHA"},
|
|
|
|
|
{0xC012, "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0xC013, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0xC014, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0xC015, "TLS_ECDH_anon_WITH_NULL_SHA"},
|
|
|
|
|
{0xC016, "TLS_ECDH_anon_WITH_RC4_128_SHA"},
|
|
|
|
|
{0xC017, "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0xC018, "TLS_ECDH_anon_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0xC019, "TLS_ECDH_anon_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0xC01A, "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0xC01B, "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0xC01C, "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0xC01D, "TLS_SRP_SHA_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0xC01E, "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0xC01F, "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0xC020, "TLS_SRP_SHA_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0xC021, "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0xC022, "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0xC023, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0xC024, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"},
|
|
|
|
|
{0xC025, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0xC026, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"},
|
|
|
|
|
{0xC027, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0xC028, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"},
|
|
|
|
|
{0xC029, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0xC02A, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"},
|
|
|
|
|
{0xC02B, "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0xC02C, "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0xC02D, "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0xC02E, "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0xC02F, "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0xC030, "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"},
|
|
|
|
|
{0xC031, "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"},
|
|
|
|
|
{0xC032, "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"},
|
2015-06-06 19:51:19 +08:00
|
|
|
{0xC033, "TLS_ECDHE_PSK_WITH_RC4_128_SHA"},
|
|
|
|
|
{0xC034, "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA"},
|
|
|
|
|
{0xC035, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"},
|
|
|
|
|
{0xC036, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"},
|
|
|
|
|
{0xC037, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"},
|
|
|
|
|
{0xC038, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"},
|
|
|
|
|
{0xC039, "TLS_ECDHE_PSK_WITH_NULL_SHA"},
|
|
|
|
|
{0xC03A, "TLS_ECDHE_PSK_WITH_NULL_SHA256"},
|
|
|
|
|
{0xC03B, "TLS_ECDHE_PSK_WITH_NULL_SHA384"},
|
|
|
|
|
{0xC03C, "TLS_RSA_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC03D, "TLS_RSA_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC03E, "TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC03F, "TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC040, "TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC041, "TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC042, "TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC043, "TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC044, "TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC045, "TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC046, "TLS_DH_anon_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC047, "TLS_DH_anon_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC048, "TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC049, "TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC04A, "TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC04B, "TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC04C, "TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC04D, "TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC04E, "TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC04F, "TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC050, "TLS_RSA_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC051, "TLS_RSA_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC052, "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC053, "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC054, "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC055, "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC056, "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC057, "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC058, "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC059, "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC05A, "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC05B, "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC05C, "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC05D, "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC05E, "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC05F, "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC060, "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC061, "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC062, "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC063, "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC064, "TLS_PSK_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC065, "TLS_PSK_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC066, "TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC067, "TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC068, "TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC069, "TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC06A, "TLS_PSK_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC06B, "TLS_PSK_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC06C, "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC06D, "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC06E, "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC06F, "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC070, "TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC071, "TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC072, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC073, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC074, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC075, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC076, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC077, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC078, "TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC079, "TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC07A, "TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC07B, "TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC07C, "TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC07D, "TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC07E, "TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC07F, "TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC080, "TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC081, "TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC082, "TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC083, "TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC084, "TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC085, "TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC086, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC087, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC088, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC089, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC08A, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC08B, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC08C, "TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC08D, "TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC08E, "TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC08F, "TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC090, "TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC091, "TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC092, "TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256"},
|
|
|
|
|
{0xC093, "TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384"},
|
|
|
|
|
{0xC094, "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC095, "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC096, "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC097, "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC098, "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC099, "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC09A, "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
|
|
|
|
|
{0xC09B, "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
|
|
|
|
|
{0xC09C, "TLS_RSA_WITH_AES_128_CCM"},
|
|
|
|
|
{0xC09D, "TLS_RSA_WITH_AES_256_CCM"},
|
|
|
|
|
{0xC09E, "TLS_DHE_RSA_WITH_AES_128_CCM"},
|
|
|
|
|
{0xC09F, "TLS_DHE_RSA_WITH_AES_256_CCM"},
|
|
|
|
|
{0xC0A0, "TLS_RSA_WITH_AES_128_CCM_8"},
|
|
|
|
|
{0xC0A1, "TLS_RSA_WITH_AES_256_CCM_8"},
|
|
|
|
|
{0xC0A2, "TLS_DHE_RSA_WITH_AES_128_CCM_8"},
|
|
|
|
|
{0xC0A3, "TLS_DHE_RSA_WITH_AES_256_CCM_8"},
|
|
|
|
|
{0xC0A4, "TLS_PSK_WITH_AES_128_CCM"},
|
|
|
|
|
{0xC0A5, "TLS_PSK_WITH_AES_256_CCM"},
|
|
|
|
|
{0xC0A6, "TLS_DHE_PSK_WITH_AES_128_CCM"},
|
|
|
|
|
{0xC0A7, "TLS_DHE_PSK_WITH_AES_256_CCM"},
|
|
|
|
|
{0xC0A8, "TLS_PSK_WITH_AES_128_CCM_8"},
|
|
|
|
|
{0xC0A9, "TLS_PSK_WITH_AES_256_CCM_8"},
|
|
|
|
|
{0xC0AA, "TLS_PSK_DHE_WITH_AES_128_CCM_8"},
|
|
|
|
|
{0xC0AB, "TLS_PSK_DHE_WITH_AES_256_CCM_8"},
|
|
|
|
|
{0xC0AC, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM"},
|
|
|
|
|
{0xC0AD, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM"},
|
|
|
|
|
{0xC0AE, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8"},
|
|
|
|
|
{0xC0AF, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8"},
|
2020-03-25 21:00:43 +08:00
|
|
|
{0xC102, "IANA-GOST2012-GOST8912-GOST8912"},
|
2017-06-22 11:36:19 +08:00
|
|
|
{0xCCA8, "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"},
|
|
|
|
|
{0xCCA9, "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"},
|
|
|
|
|
{0xCCAA, "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"},
|
|
|
|
|
{0xCCAB, "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256"},
|
|
|
|
|
{0xCCAC, "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"},
|
|
|
|
|
{0xCCAD, "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"},
|
|
|
|
|
{0xCCAE, "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"},
|
2016-11-07 21:44:56 +08:00
|
|
|
{0x1301, "TLS_AES_128_GCM_SHA256"},
|
2017-02-23 01:24:18 +08:00
|
|
|
{0x1302, "TLS_AES_256_GCM_SHA384"},
|
|
|
|
|
{0x1303, "TLS_CHACHA20_POLY1305_SHA256"},
|
|
|
|
|
{0x1304, "TLS_AES_128_CCM_SHA256"},
|
|
|
|
|
{0x1305, "TLS_AES_128_CCM_8_SHA256"},
|
2015-01-22 11:40:55 +08:00
|
|
|
{0xFEFE, "SSL_RSA_FIPS_WITH_DES_CBC_SHA"},
|
|
|
|
|
{0xFEFF, "SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA"},
|
2020-03-25 21:00:43 +08:00
|
|
|
{0xFF85, "LEGACY-GOST2012-GOST8912-GOST8912"},
|
2018-03-30 21:33:21 +08:00
|
|
|
{0xFF87, "GOST2012-NULL-GOST12"},
|
2020-03-30 23:09:24 +08:00
|
|
|
{0xC100, "GOST2012-KUZNYECHIK-KUZNYECHIKOMAC"},
|
|
|
|
|
{0xC101, "GOST2012-MAGMA-MAGMAOMAC"},
|
|
|
|
|
{0xC102, "GOST2012-GOST8912-IANA"},
|
2012-06-15 20:46:09 +08:00
|
|
|
};
|
2015-01-22 11:40:55 +08:00
|
|
|
|
2012-06-15 20:46:09 +08:00
|
|
|
/* Compression methods */
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_comp_tbl[] = {
|
2015-01-22 11:40:55 +08:00
|
|
|
{0x0000, "No Compression"},
|
|
|
|
|
{0x0001, "Zlib Compression"}
|
2012-06-15 20:46:09 +08:00
|
|
|
};
|
2015-01-22 11:40:55 +08:00
|
|
|
|
2018-03-08 23:32:34 +08:00
|
|
|
/* Extensions sorted by ascending id */
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_exts_tbl[] = {
|
2015-01-22 11:40:55 +08:00
|
|
|
{TLSEXT_TYPE_server_name, "server_name"},
|
|
|
|
|
{TLSEXT_TYPE_max_fragment_length, "max_fragment_length"},
|
|
|
|
|
{TLSEXT_TYPE_client_certificate_url, "client_certificate_url"},
|
|
|
|
|
{TLSEXT_TYPE_trusted_ca_keys, "trusted_ca_keys"},
|
|
|
|
|
{TLSEXT_TYPE_truncated_hmac, "truncated_hmac"},
|
|
|
|
|
{TLSEXT_TYPE_status_request, "status_request"},
|
|
|
|
|
{TLSEXT_TYPE_user_mapping, "user_mapping"},
|
|
|
|
|
{TLSEXT_TYPE_client_authz, "client_authz"},
|
|
|
|
|
{TLSEXT_TYPE_server_authz, "server_authz"},
|
|
|
|
|
{TLSEXT_TYPE_cert_type, "cert_type"},
|
2016-11-09 22:51:06 +08:00
|
|
|
{TLSEXT_TYPE_supported_groups, "supported_groups"},
|
2015-01-22 11:40:55 +08:00
|
|
|
{TLSEXT_TYPE_ec_point_formats, "ec_point_formats"},
|
|
|
|
|
{TLSEXT_TYPE_srp, "srp"},
|
|
|
|
|
{TLSEXT_TYPE_signature_algorithms, "signature_algorithms"},
|
|
|
|
|
{TLSEXT_TYPE_use_srtp, "use_srtp"},
|
2017-02-26 11:14:53 +08:00
|
|
|
{TLSEXT_TYPE_application_layer_protocol_negotiation,
|
|
|
|
|
"application_layer_protocol_negotiation"},
|
2016-03-04 00:19:23 +08:00
|
|
|
{TLSEXT_TYPE_signed_certificate_timestamp, "signed_certificate_timestamps"},
|
2021-01-28 03:23:33 +08:00
|
|
|
{TLSEXT_TYPE_client_cert_type, "client_cert_type"},
|
|
|
|
|
{TLSEXT_TYPE_server_cert_type, "server_cert_type"},
|
2015-01-23 10:45:13 +08:00
|
|
|
{TLSEXT_TYPE_padding, "padding"},
|
2015-06-06 19:51:19 +08:00
|
|
|
{TLSEXT_TYPE_encrypt_then_mac, "encrypt_then_mac"},
|
2017-02-18 01:41:46 +08:00
|
|
|
{TLSEXT_TYPE_extended_master_secret, "extended_master_secret"},
|
2021-08-10 04:56:50 +08:00
|
|
|
{TLSEXT_TYPE_compress_certificate, "compress_certificate"},
|
2018-03-08 23:32:34 +08:00
|
|
|
{TLSEXT_TYPE_session_ticket, "session_ticket"},
|
|
|
|
|
{TLSEXT_TYPE_psk, "psk"},
|
Add TLSv1.3 post-handshake authentication (PHA)
Add SSL_verify_client_post_handshake() for servers to initiate PHA
Add SSL_force_post_handshake_auth() for clients that don't have certificates
initially configured, but use a certificate callback.
Update SSL_CTX_set_verify()/SSL_set_verify() mode:
* Add SSL_VERIFY_POST_HANDSHAKE to postpone client authentication until after
the initial handshake.
* Update SSL_VERIFY_CLIENT_ONCE now only sends out one CertRequest regardless
of when the certificate authentication takes place; either initial handshake,
re-negotiation, or post-handshake authentication.
Add 'RequestPostHandshake' and 'RequirePostHandshake' SSL_CONF options that
add the SSL_VERIFY_POST_HANDSHAKE to the 'Request' and 'Require' options
Add support to s_client:
* Enabled automatically when cert is configured
* Can be forced enabled via -force_pha
Add support to s_server:
* Use 'c' to invoke PHA in s_server
* Remove some dead code
Update documentation
Update unit tests:
* Illegal use of PHA extension
* TLSv1.3 certificate tests
DTLS and TLS behave ever-so-slightly differently. So, when DTLS1.3 is
implemented, it's PHA support state machine may need to be different.
Add a TODO and a #error
Update handshake context to deal with PHA.
The handshake context for TLSv1.3 post-handshake auth is up through the
ClientFinish message, plus the CertificateRequest message. Subsequent
Certificate, CertificateVerify, and Finish messages are based on this
handshake context (not the Certificate message per se, but it's included
after the hash). KeyUpdate, NewSessionTicket, and prior Certificate
Request messages are not included in post-handshake authentication.
After the ClientFinished message is processed, save off the digest state
for future post-handshake authentication. When post-handshake auth occurs,
copy over the saved handshake context into the "main" handshake digest.
This effectively discards the any KeyUpdate or NewSessionTicket messages
and any prior post-handshake authentication.
This, of course, assumes that the ID-22 did not mean to include any
previous post-handshake authentication into the new handshake transcript.
This is implied by section 4.4.1 that lists messages only up to the
first ClientFinished.
Reviewed-by: Ben Kaduk <kaduk@mit.edu>
Reviewed-by: Matt Caswell <matt@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/4964)
2017-12-19 05:52:28 +08:00
|
|
|
{TLSEXT_TYPE_early_data, "early_data"},
|
2018-03-08 23:32:34 +08:00
|
|
|
{TLSEXT_TYPE_supported_versions, "supported_versions"},
|
|
|
|
|
{TLSEXT_TYPE_cookie, "cookie_ext"},
|
|
|
|
|
{TLSEXT_TYPE_psk_kex_modes, "psk_key_exchange_modes"},
|
|
|
|
|
{TLSEXT_TYPE_certificate_authorities, "certificate_authorities"},
|
2018-03-13 00:08:31 +08:00
|
|
|
{TLSEXT_TYPE_post_handshake_auth, "post_handshake_auth"},
|
|
|
|
|
{TLSEXT_TYPE_signature_algorithms_cert, "signature_algorithms_cert"},
|
2018-03-08 23:32:34 +08:00
|
|
|
{TLSEXT_TYPE_key_share, "key_share"},
|
2018-03-13 00:08:31 +08:00
|
|
|
{TLSEXT_TYPE_renegotiate, "renegotiate"},
|
2018-03-08 23:32:34 +08:00
|
|
|
# ifndef OPENSSL_NO_NEXTPROTONEG
|
2018-03-13 00:08:31 +08:00
|
|
|
{TLSEXT_TYPE_next_proto_neg, "next_proto_neg"},
|
2018-03-08 23:32:34 +08:00
|
|
|
# endif
|
2012-06-15 20:46:09 +08:00
|
|
|
};
|
|
|
|
|
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_groups_tbl[] = {
|
2015-01-22 11:40:55 +08:00
|
|
|
{1, "sect163k1 (K-163)"},
|
|
|
|
|
{2, "sect163r1"},
|
|
|
|
|
{3, "sect163r2 (B-163)"},
|
|
|
|
|
{4, "sect193r1"},
|
|
|
|
|
{5, "sect193r2"},
|
|
|
|
|
{6, "sect233k1 (K-233)"},
|
|
|
|
|
{7, "sect233r1 (B-233)"},
|
|
|
|
|
{8, "sect239k1"},
|
|
|
|
|
{9, "sect283k1 (K-283)"},
|
|
|
|
|
{10, "sect283r1 (B-283)"},
|
|
|
|
|
{11, "sect409k1 (K-409)"},
|
|
|
|
|
{12, "sect409r1 (B-409)"},
|
|
|
|
|
{13, "sect571k1 (K-571)"},
|
|
|
|
|
{14, "sect571r1 (B-571)"},
|
|
|
|
|
{15, "secp160k1"},
|
|
|
|
|
{16, "secp160r1"},
|
|
|
|
|
{17, "secp160r2"},
|
|
|
|
|
{18, "secp192k1"},
|
|
|
|
|
{19, "secp192r1 (P-192)"},
|
|
|
|
|
{20, "secp224k1"},
|
|
|
|
|
{21, "secp224r1 (P-224)"},
|
|
|
|
|
{22, "secp256k1"},
|
|
|
|
|
{23, "secp256r1 (P-256)"},
|
|
|
|
|
{24, "secp384r1 (P-384)"},
|
|
|
|
|
{25, "secp521r1 (P-521)"},
|
|
|
|
|
{26, "brainpoolP256r1"},
|
|
|
|
|
{27, "brainpoolP384r1"},
|
|
|
|
|
{28, "brainpoolP512r1"},
|
2016-09-02 17:42:36 +08:00
|
|
|
{29, "ecdh_x25519"},
|
2018-02-27 18:12:02 +08:00
|
|
|
{30, "ecdh_x448"},
|
2022-09-30 18:57:23 +08:00
|
|
|
{31, "brainpoolP256r1tls13"},
|
|
|
|
|
{32, "brainpoolP384r1tls13"},
|
|
|
|
|
{33, "brainpoolP512r1tls13"},
|
2020-04-19 04:59:45 +08:00
|
|
|
{34, "GC256A"},
|
|
|
|
|
{35, "GC256B"},
|
|
|
|
|
{36, "GC256C"},
|
|
|
|
|
{37, "GC256D"},
|
|
|
|
|
{38, "GC512A"},
|
|
|
|
|
{39, "GC512B"},
|
|
|
|
|
{40, "GC512C"},
|
2017-02-26 09:16:30 +08:00
|
|
|
{256, "ffdhe2048"},
|
|
|
|
|
{257, "ffdhe3072"},
|
|
|
|
|
{258, "ffdhe4096"},
|
|
|
|
|
{259, "ffdhe6144"},
|
|
|
|
|
{260, "ffdhe8192"},
|
2015-01-22 11:40:55 +08:00
|
|
|
{0xFF01, "arbitrary_explicit_prime_curves"},
|
|
|
|
|
{0xFF02, "arbitrary_explicit_char2_curves"}
|
2012-06-15 20:46:09 +08:00
|
|
|
};
|
|
|
|
|
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_point_tbl[] = {
|
2015-01-22 11:40:55 +08:00
|
|
|
{0, "uncompressed"},
|
|
|
|
|
{1, "ansiX962_compressed_prime"},
|
|
|
|
|
{2, "ansiX962_compressed_char2"}
|
2012-06-15 20:46:09 +08:00
|
|
|
};
|
|
|
|
|
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_mfl_tbl[] = {
|
|
|
|
|
{0, "disabled"},
|
|
|
|
|
{1, "max_fragment_length := 2^9 (512 bytes)"},
|
|
|
|
|
{2, "max_fragment_length := 2^10 (1024 bytes)"},
|
|
|
|
|
{3, "max_fragment_length := 2^11 (2048 bytes)"},
|
|
|
|
|
{4, "max_fragment_length := 2^12 (4096 bytes)"}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const ssl_trace_tbl ssl_sigalg_tbl[] = {
|
2017-01-03 21:43:56 +08:00
|
|
|
{TLSEXT_SIGALG_ecdsa_secp256r1_sha256, "ecdsa_secp256r1_sha256"},
|
|
|
|
|
{TLSEXT_SIGALG_ecdsa_secp384r1_sha384, "ecdsa_secp384r1_sha384"},
|
|
|
|
|
{TLSEXT_SIGALG_ecdsa_secp521r1_sha512, "ecdsa_secp521r1_sha512"},
|
2017-06-09 00:15:45 +08:00
|
|
|
{TLSEXT_SIGALG_ecdsa_sha224, "ecdsa_sha224"},
|
2017-05-24 22:28:40 +08:00
|
|
|
{TLSEXT_SIGALG_ed25519, "ed25519"},
|
2018-02-27 18:12:02 +08:00
|
|
|
{TLSEXT_SIGALG_ed448, "ed448"},
|
2017-01-03 21:43:56 +08:00
|
|
|
{TLSEXT_SIGALG_ecdsa_sha1, "ecdsa_sha1"},
|
2018-01-26 23:21:08 +08:00
|
|
|
{TLSEXT_SIGALG_rsa_pss_rsae_sha256, "rsa_pss_rsae_sha256"},
|
|
|
|
|
{TLSEXT_SIGALG_rsa_pss_rsae_sha384, "rsa_pss_rsae_sha384"},
|
|
|
|
|
{TLSEXT_SIGALG_rsa_pss_rsae_sha512, "rsa_pss_rsae_sha512"},
|
|
|
|
|
{TLSEXT_SIGALG_rsa_pss_pss_sha256, "rsa_pss_pss_sha256"},
|
|
|
|
|
{TLSEXT_SIGALG_rsa_pss_pss_sha384, "rsa_pss_pss_sha384"},
|
|
|
|
|
{TLSEXT_SIGALG_rsa_pss_pss_sha512, "rsa_pss_pss_sha512"},
|
2017-01-03 21:43:56 +08:00
|
|
|
{TLSEXT_SIGALG_rsa_pkcs1_sha256, "rsa_pkcs1_sha256"},
|
|
|
|
|
{TLSEXT_SIGALG_rsa_pkcs1_sha384, "rsa_pkcs1_sha384"},
|
|
|
|
|
{TLSEXT_SIGALG_rsa_pkcs1_sha512, "rsa_pkcs1_sha512"},
|
2017-06-09 00:15:45 +08:00
|
|
|
{TLSEXT_SIGALG_rsa_pkcs1_sha224, "rsa_pkcs1_sha224"},
|
2017-01-03 21:43:56 +08:00
|
|
|
{TLSEXT_SIGALG_rsa_pkcs1_sha1, "rsa_pkcs1_sha1"},
|
|
|
|
|
{TLSEXT_SIGALG_dsa_sha256, "dsa_sha256"},
|
|
|
|
|
{TLSEXT_SIGALG_dsa_sha384, "dsa_sha384"},
|
|
|
|
|
{TLSEXT_SIGALG_dsa_sha512, "dsa_sha512"},
|
2017-06-09 00:15:45 +08:00
|
|
|
{TLSEXT_SIGALG_dsa_sha224, "dsa_sha224"},
|
2017-01-03 21:43:56 +08:00
|
|
|
{TLSEXT_SIGALG_dsa_sha1, "dsa_sha1"},
|
2020-04-07 23:08:07 +08:00
|
|
|
{TLSEXT_SIGALG_gostr34102012_256_intrinsic, "gost2012_256"},
|
|
|
|
|
{TLSEXT_SIGALG_gostr34102012_512_intrinsic, "gost2012_512"},
|
2017-01-03 21:43:56 +08:00
|
|
|
{TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, "gost2012_256"},
|
|
|
|
|
{TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, "gost2012_512"},
|
|
|
|
|
{TLSEXT_SIGALG_gostr34102001_gostr3411, "gost2001_gost94"},
|
2018-10-25 05:10:38 +08:00
|
|
|
{TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256, "ecdsa_brainpoolP256r1_sha256"},
|
|
|
|
|
{TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384, "ecdsa_brainpoolP384r1_sha384"},
|
|
|
|
|
{TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512, "ecdsa_brainpoolP512r1_sha512"},
|
2012-06-15 20:46:09 +08:00
|
|
|
};
|
|
|
|
|
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_ctype_tbl[] = {
|
2015-01-22 11:40:55 +08:00
|
|
|
{1, "rsa_sign"},
|
|
|
|
|
{2, "dss_sign"},
|
|
|
|
|
{3, "rsa_fixed_dh"},
|
|
|
|
|
{4, "dss_fixed_dh"},
|
|
|
|
|
{5, "rsa_ephemeral_dh"},
|
|
|
|
|
{6, "dss_ephemeral_dh"},
|
|
|
|
|
{20, "fortezza_dms"},
|
|
|
|
|
{64, "ecdsa_sign"},
|
|
|
|
|
{65, "rsa_fixed_ecdh"},
|
2020-03-30 23:09:24 +08:00
|
|
|
{66, "ecdsa_fixed_ecdh"},
|
|
|
|
|
{67, "gost_sign256"},
|
|
|
|
|
{68, "gost_sign512"},
|
2012-06-15 20:46:09 +08:00
|
|
|
};
|
|
|
|
|
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_psk_kex_modes_tbl[] = {
|
2017-01-12 23:28:48 +08:00
|
|
|
{TLSEXT_KEX_MODE_KE, "psk_ke"},
|
|
|
|
|
{TLSEXT_KEX_MODE_KE_DHE, "psk_dhe_ke"}
|
|
|
|
|
};
|
|
|
|
|
|
2017-09-11 11:33:37 +08:00
|
|
|
static const ssl_trace_tbl ssl_key_update_tbl[] = {
|
2017-02-09 01:08:48 +08:00
|
|
|
{SSL_KEY_UPDATE_NOT_REQUESTED, "update_not_requested"},
|
|
|
|
|
{SSL_KEY_UPDATE_REQUESTED, "update_requested"}
|
|
|
|
|
};
|
|
|
|
|
|
2021-08-10 04:56:50 +08:00
|
|
|
static const ssl_trace_tbl ssl_comp_cert_tbl[] = {
|
|
|
|
|
{TLSEXT_comp_cert_none, "none"},
|
|
|
|
|
{TLSEXT_comp_cert_zlib, "zlib"},
|
|
|
|
|
{TLSEXT_comp_cert_brotli, "brotli"},
|
|
|
|
|
{TLSEXT_comp_cert_zstd, "zstd"}
|
|
|
|
|
};
|
|
|
|
|
|
2021-01-28 03:23:33 +08:00
|
|
|
/*
|
|
|
|
|
* "pgp" and "1609dot2" are defined in RFC7250,
|
|
|
|
|
* although OpenSSL doesn't support them, it can
|
|
|
|
|
* at least report them in traces
|
|
|
|
|
*/
|
|
|
|
|
static const ssl_trace_tbl ssl_cert_type_tbl[] = {
|
|
|
|
|
{TLSEXT_cert_type_x509, "x509"},
|
|
|
|
|
{TLSEXT_cert_type_pgp, "pgp"},
|
|
|
|
|
{TLSEXT_cert_type_rpk, "rpk"},
|
|
|
|
|
{TLSEXT_cert_type_1609dot2, "1609dot2"}
|
|
|
|
|
};
|
|
|
|
|
|
2012-06-15 20:46:09 +08:00
|
|
|
static void ssl_print_hex(BIO *bio, int indent, const char *name,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char *msg, size_t msglen)
|
|
|
|
|
{
|
|
|
|
|
size_t i;
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "%s (len=%d): ", name, (int)msglen);
|
|
|
|
|
for (i = 0; i < msglen; i++)
|
|
|
|
|
BIO_printf(bio, "%02X", msg[i]);
|
|
|
|
|
BIO_puts(bio, "\n");
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2017-09-11 11:33:37 +08:00
|
|
|
static int ssl_print_hexbuf(BIO *bio, int indent, const char *name, size_t nlen,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char **pmsg, size_t *pmsglen)
|
|
|
|
|
{
|
|
|
|
|
size_t blen;
|
|
|
|
|
const unsigned char *p = *pmsg;
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (*pmsglen < nlen)
|
|
|
|
|
return 0;
|
|
|
|
|
blen = p[0];
|
|
|
|
|
if (nlen > 1)
|
|
|
|
|
blen = (blen << 8) | p[1];
|
|
|
|
|
if (*pmsglen < nlen + blen)
|
|
|
|
|
return 0;
|
|
|
|
|
p += nlen;
|
|
|
|
|
ssl_print_hex(bio, indent, name, p, blen);
|
|
|
|
|
*pmsg += blen + nlen;
|
|
|
|
|
*pmsglen -= blen + nlen;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
|
|
|
|
static int ssl_print_version(BIO *bio, int indent, const char *name,
|
2016-11-07 21:50:43 +08:00
|
|
|
const unsigned char **pmsg, size_t *pmsglen,
|
|
|
|
|
unsigned int *version)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
|
int vers;
|
2016-12-08 01:04:46 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (*pmsglen < 2)
|
|
|
|
|
return 0;
|
|
|
|
|
vers = ((*pmsg)[0] << 8) | (*pmsg)[1];
|
2018-07-18 23:05:49 +08:00
|
|
|
if (version != NULL)
|
|
|
|
|
*version = vers;
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "%s=0x%x (%s)\n",
|
|
|
|
|
name, vers, ssl_trace_str(vers, ssl_version_tbl));
|
|
|
|
|
*pmsg += 2;
|
|
|
|
|
*pmsglen -= 2;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
|
|
|
|
static int ssl_print_random(BIO *bio, int indent,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char **pmsg, size_t *pmsglen)
|
|
|
|
|
{
|
|
|
|
|
unsigned int tm;
|
|
|
|
|
const unsigned char *p = *pmsg;
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (*pmsglen < 32)
|
|
|
|
|
return 0;
|
2020-05-19 16:52:53 +08:00
|
|
|
tm = ((unsigned int)p[0] << 24)
|
|
|
|
|
| ((unsigned int)p[1] << 16)
|
|
|
|
|
| ((unsigned int)p[2] << 8)
|
|
|
|
|
| (unsigned int)p[3];
|
2015-01-22 11:40:55 +08:00
|
|
|
p += 4;
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_puts(bio, "Random:\n");
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
|
|
|
|
BIO_printf(bio, "gmt_unix_time=0x%08X\n", tm);
|
|
|
|
|
ssl_print_hex(bio, indent + 2, "random_bytes", p, 28);
|
|
|
|
|
*pmsg += 32;
|
|
|
|
|
*pmsglen -= 32;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2022-06-20 23:11:28 +08:00
|
|
|
static int ssl_print_signature(BIO *bio, int indent, const SSL_CONNECTION *sc,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char **pmsg, size_t *pmsglen)
|
|
|
|
|
{
|
|
|
|
|
if (*pmsglen < 2)
|
|
|
|
|
return 0;
|
2022-06-20 23:11:28 +08:00
|
|
|
if (SSL_USE_SIGALGS(sc)) {
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char *p = *pmsg;
|
2017-01-03 21:43:56 +08:00
|
|
|
unsigned int sigalg = (p[0] << 8) | p[1];
|
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_indent(bio, indent, 80);
|
2017-01-03 21:43:56 +08:00
|
|
|
BIO_printf(bio, "Signature Algorithm: %s (0x%04x)\n",
|
|
|
|
|
ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg);
|
2015-01-22 11:40:55 +08:00
|
|
|
*pmsg += 2;
|
|
|
|
|
*pmsglen -= 2;
|
|
|
|
|
}
|
|
|
|
|
return ssl_print_hexbuf(bio, indent, "Signature", 2, pmsg, pmsglen);
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2017-02-02 19:16:25 +08:00
|
|
|
static int ssl_print_extension(BIO *bio, int indent, int server,
|
|
|
|
|
unsigned char mt, int extype,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char *ext, size_t extlen)
|
|
|
|
|
{
|
2016-11-01 19:17:10 +08:00
|
|
|
size_t xlen, share_len;
|
2017-01-03 21:43:56 +08:00
|
|
|
unsigned int sigalg;
|
2017-02-18 01:41:46 +08:00
|
|
|
uint32_t max_early_data;
|
2017-01-03 21:43:56 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "extension_type=%s(%d), length=%d\n",
|
|
|
|
|
ssl_trace_str(extype, ssl_exts_tbl), extype, (int)extlen);
|
|
|
|
|
switch (extype) {
|
2021-08-10 04:56:50 +08:00
|
|
|
case TLSEXT_TYPE_compress_certificate:
|
|
|
|
|
if (extlen < 1)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = ext[0];
|
|
|
|
|
if (extlen != xlen + 1)
|
|
|
|
|
return 0;
|
|
|
|
|
return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 2, ssl_comp_cert_tbl);
|
|
|
|
|
|
2017-09-11 11:33:37 +08:00
|
|
|
case TLSEXT_TYPE_max_fragment_length:
|
|
|
|
|
if (extlen < 1)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = extlen;
|
|
|
|
|
return ssl_trace_list(bio, indent + 2, ext, xlen, 1, ssl_mfl_tbl);
|
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
case TLSEXT_TYPE_ec_point_formats:
|
|
|
|
|
if (extlen < 1)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = ext[0];
|
|
|
|
|
if (extlen != xlen + 1)
|
|
|
|
|
return 0;
|
2016-08-06 01:03:17 +08:00
|
|
|
return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, ssl_point_tbl);
|
2015-01-22 11:40:55 +08:00
|
|
|
|
2016-11-09 22:51:06 +08:00
|
|
|
case TLSEXT_TYPE_supported_groups:
|
2015-01-22 11:40:55 +08:00
|
|
|
if (extlen < 2)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = (ext[0] << 8) | ext[1];
|
|
|
|
|
if (extlen != xlen + 2)
|
|
|
|
|
return 0;
|
2016-11-09 22:51:06 +08:00
|
|
|
return ssl_trace_list(bio, indent + 2, ext + 2, xlen, 2, ssl_groups_tbl);
|
2017-02-26 11:14:53 +08:00
|
|
|
case TLSEXT_TYPE_application_layer_protocol_negotiation:
|
|
|
|
|
if (extlen < 2)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = (ext[0] << 8) | ext[1];
|
|
|
|
|
if (extlen != xlen + 2)
|
|
|
|
|
return 0;
|
|
|
|
|
ext += 2;
|
|
|
|
|
while (xlen > 0) {
|
|
|
|
|
size_t plen = *ext++;
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2018-03-21 15:27:34 +08:00
|
|
|
if (plen + 1 > xlen)
|
2017-02-26 11:14:53 +08:00
|
|
|
return 0;
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
|
|
|
|
BIO_write(bio, ext, plen);
|
|
|
|
|
BIO_puts(bio, "\n");
|
|
|
|
|
ext += plen;
|
|
|
|
|
xlen -= plen + 1;
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
|
case TLSEXT_TYPE_signature_algorithms:
|
|
|
|
|
|
|
|
|
|
if (extlen < 2)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = (ext[0] << 8) | ext[1];
|
|
|
|
|
if (extlen != xlen + 2)
|
|
|
|
|
return 0;
|
|
|
|
|
if (xlen & 1)
|
|
|
|
|
return 0;
|
|
|
|
|
ext += 2;
|
|
|
|
|
while (xlen > 0) {
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
2017-01-03 21:43:56 +08:00
|
|
|
sigalg = (ext[0] << 8) | ext[1];
|
|
|
|
|
BIO_printf(bio, "%s (0x%04x)\n",
|
|
|
|
|
ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg);
|
2015-01-22 11:40:55 +08:00
|
|
|
xlen -= 2;
|
|
|
|
|
ext += 2;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TLSEXT_TYPE_renegotiate:
|
|
|
|
|
if (extlen < 1)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = ext[0];
|
|
|
|
|
if (xlen + 1 != extlen)
|
|
|
|
|
return 0;
|
|
|
|
|
ext++;
|
|
|
|
|
if (xlen) {
|
|
|
|
|
if (server) {
|
|
|
|
|
if (xlen & 1)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen >>= 1;
|
|
|
|
|
}
|
|
|
|
|
ssl_print_hex(bio, indent + 4, "client_verify_data", ext, xlen);
|
|
|
|
|
if (server) {
|
|
|
|
|
ext += xlen;
|
2016-08-06 01:03:17 +08:00
|
|
|
ssl_print_hex(bio, indent + 4, "server_verify_data", ext, xlen);
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
BIO_indent(bio, indent + 4, 80);
|
|
|
|
|
BIO_puts(bio, "<EMPTY>\n");
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case TLSEXT_TYPE_session_ticket:
|
|
|
|
|
if (extlen != 0)
|
|
|
|
|
ssl_print_hex(bio, indent + 4, "ticket", ext, extlen);
|
|
|
|
|
break;
|
|
|
|
|
|
2016-11-01 19:17:10 +08:00
|
|
|
case TLSEXT_TYPE_key_share:
|
2017-12-05 18:14:35 +08:00
|
|
|
if (server && extlen == 2) {
|
2017-02-02 19:16:25 +08:00
|
|
|
int group_id;
|
|
|
|
|
|
2017-12-05 18:14:35 +08:00
|
|
|
/* We assume this is an HRR, otherwise this is an invalid key_share */
|
2017-02-02 19:16:25 +08:00
|
|
|
group_id = (ext[0] << 8) | ext[1];
|
|
|
|
|
BIO_indent(bio, indent + 4, 80);
|
2017-02-23 01:25:17 +08:00
|
|
|
BIO_printf(bio, "NamedGroup: %s (%d)\n",
|
|
|
|
|
ssl_trace_str(group_id, ssl_groups_tbl), group_id);
|
2017-02-02 19:16:25 +08:00
|
|
|
break;
|
|
|
|
|
}
|
2016-11-01 19:17:10 +08:00
|
|
|
if (extlen < 2)
|
|
|
|
|
return 0;
|
|
|
|
|
if (server) {
|
|
|
|
|
xlen = extlen;
|
|
|
|
|
} else {
|
|
|
|
|
xlen = (ext[0] << 8) | ext[1];
|
|
|
|
|
if (extlen != xlen + 2)
|
|
|
|
|
return 0;
|
|
|
|
|
ext += 2;
|
|
|
|
|
}
|
|
|
|
|
for (; xlen > 0; ext += share_len, xlen -= share_len) {
|
|
|
|
|
int group_id;
|
|
|
|
|
|
|
|
|
|
if (xlen < 4)
|
|
|
|
|
return 0;
|
|
|
|
|
group_id = (ext[0] << 8) | ext[1];
|
|
|
|
|
share_len = (ext[2] << 8) | ext[3];
|
|
|
|
|
ext += 4;
|
|
|
|
|
xlen -= 4;
|
|
|
|
|
if (xlen < share_len)
|
|
|
|
|
return 0;
|
|
|
|
|
BIO_indent(bio, indent + 4, 80);
|
2017-02-23 01:25:17 +08:00
|
|
|
BIO_printf(bio, "NamedGroup: %s (%d)\n",
|
|
|
|
|
ssl_trace_str(group_id, ssl_groups_tbl), group_id);
|
2016-11-01 19:17:10 +08:00
|
|
|
ssl_print_hex(bio, indent + 4, "key_exchange: ", ext, share_len);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2016-10-22 06:41:18 +08:00
|
|
|
case TLSEXT_TYPE_supported_versions:
|
2017-11-04 00:38:48 +08:00
|
|
|
if (server) {
|
|
|
|
|
int version;
|
|
|
|
|
|
|
|
|
|
if (extlen != 2)
|
|
|
|
|
return 0;
|
|
|
|
|
version = (ext[0] << 8) | ext[1];
|
|
|
|
|
BIO_indent(bio, indent + 4, 80);
|
|
|
|
|
BIO_printf(bio, "%s (%d)\n",
|
|
|
|
|
ssl_trace_str(version, ssl_version_tbl), version);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2016-10-22 06:41:18 +08:00
|
|
|
if (extlen < 1)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = ext[0];
|
|
|
|
|
if (extlen != xlen + 1)
|
|
|
|
|
return 0;
|
|
|
|
|
return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 2,
|
2016-11-09 17:52:37 +08:00
|
|
|
ssl_version_tbl);
|
2016-10-22 06:41:18 +08:00
|
|
|
|
2017-01-12 23:28:48 +08:00
|
|
|
case TLSEXT_TYPE_psk_kex_modes:
|
|
|
|
|
if (extlen < 1)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = ext[0];
|
|
|
|
|
if (extlen != xlen + 1)
|
|
|
|
|
return 0;
|
|
|
|
|
return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1,
|
|
|
|
|
ssl_psk_kex_modes_tbl);
|
|
|
|
|
|
2017-03-09 23:31:55 +08:00
|
|
|
case TLSEXT_TYPE_early_data:
|
|
|
|
|
if (mt != SSL3_MT_NEWSESSION_TICKET)
|
|
|
|
|
break;
|
2017-02-18 01:41:46 +08:00
|
|
|
if (extlen != 4)
|
|
|
|
|
return 0;
|
2020-05-19 16:52:53 +08:00
|
|
|
max_early_data = ((unsigned int)ext[0] << 24)
|
|
|
|
|
| ((unsigned int)ext[1] << 16)
|
|
|
|
|
| ((unsigned int)ext[2] << 8)
|
|
|
|
|
| (unsigned int)ext[3];
|
2017-02-18 01:41:46 +08:00
|
|
|
BIO_indent(bio, indent + 2, 80);
|
2022-10-02 00:41:44 +08:00
|
|
|
BIO_printf(bio, "max_early_data=%u\n", (unsigned int)max_early_data);
|
2017-02-18 01:41:46 +08:00
|
|
|
break;
|
|
|
|
|
|
2021-01-28 03:23:33 +08:00
|
|
|
case TLSEXT_TYPE_server_cert_type:
|
|
|
|
|
case TLSEXT_TYPE_client_cert_type:
|
|
|
|
|
if (server) {
|
|
|
|
|
if (extlen != 1)
|
|
|
|
|
return 0;
|
|
|
|
|
return ssl_trace_list(bio, indent + 2, ext, 1, 1, ssl_cert_type_tbl);
|
|
|
|
|
}
|
|
|
|
|
if (extlen < 1)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = ext[0];
|
|
|
|
|
if (extlen != xlen + 1)
|
|
|
|
|
return 0;
|
|
|
|
|
return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, ssl_cert_type_tbl);
|
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
default:
|
2016-07-08 06:43:32 +08:00
|
|
|
BIO_dump_indent(bio, (const char *)ext, extlen, indent + 2);
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
|
|
|
|
static int ssl_print_extensions(BIO *bio, int indent, int server,
|
2017-02-02 19:16:25 +08:00
|
|
|
unsigned char mt, const unsigned char **msgin,
|
|
|
|
|
size_t *msginlen)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
2017-01-06 19:01:14 +08:00
|
|
|
size_t extslen, msglen = *msginlen;
|
2016-12-03 01:14:59 +08:00
|
|
|
const unsigned char *msg = *msgin;
|
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
if (msglen == 0) {
|
2018-08-20 01:24:44 +08:00
|
|
|
BIO_puts(bio, "No extensions\n");
|
2015-01-22 11:40:55 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
2018-03-24 03:51:38 +08:00
|
|
|
if (msglen < 2)
|
|
|
|
|
return 0;
|
2015-01-22 11:40:55 +08:00
|
|
|
extslen = (msg[0] << 8) | msg[1];
|
2018-08-20 01:24:44 +08:00
|
|
|
msglen -= 2;
|
2015-01-22 11:40:55 +08:00
|
|
|
msg += 2;
|
2018-08-20 01:24:44 +08:00
|
|
|
if (extslen == 0) {
|
|
|
|
|
BIO_puts(bio, "No extensions\n");
|
|
|
|
|
*msgin = msg;
|
|
|
|
|
*msginlen = msglen;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
if (extslen > msglen)
|
|
|
|
|
return 0;
|
|
|
|
|
BIO_printf(bio, "extensions, length = %d\n", (int)extslen);
|
|
|
|
|
msglen -= extslen;
|
|
|
|
|
while (extslen > 0) {
|
2015-01-22 11:40:55 +08:00
|
|
|
int extype;
|
|
|
|
|
size_t extlen;
|
2018-08-20 01:24:44 +08:00
|
|
|
if (extslen < 4)
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
extype = (msg[0] << 8) | msg[1];
|
|
|
|
|
extlen = (msg[2] << 8) | msg[3];
|
2018-08-20 01:24:44 +08:00
|
|
|
if (extslen < extlen + 4) {
|
2017-09-11 11:33:37 +08:00
|
|
|
BIO_printf(bio, "extensions, extype = %d, extlen = %d\n", extype,
|
|
|
|
|
(int)extlen);
|
2018-08-20 01:24:44 +08:00
|
|
|
BIO_dump_indent(bio, (const char *)msg, extslen, indent + 2);
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
2017-09-11 11:33:37 +08:00
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
msg += 4;
|
2017-02-02 19:16:25 +08:00
|
|
|
if (!ssl_print_extension(bio, indent + 2, server, mt, extype, msg,
|
|
|
|
|
extlen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
msg += extlen;
|
2018-08-20 01:24:44 +08:00
|
|
|
extslen -= extlen + 4;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
2016-12-03 01:14:59 +08:00
|
|
|
|
|
|
|
|
*msgin = msg;
|
2017-01-06 19:01:14 +08:00
|
|
|
*msginlen = msglen;
|
2015-01-22 11:40:55 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2022-06-20 23:11:28 +08:00
|
|
|
static int ssl_print_client_hello(BIO *bio, const SSL_CONNECTION *sc, int indent,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char *msg, size_t msglen)
|
|
|
|
|
{
|
|
|
|
|
size_t len;
|
|
|
|
|
unsigned int cs;
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2016-11-07 21:50:43 +08:00
|
|
|
if (!ssl_print_version(bio, indent, "client_version", &msg, &msglen, NULL))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
if (!ssl_print_random(bio, indent, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
if (!ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen))
|
|
|
|
|
return 0;
|
2022-06-20 23:11:28 +08:00
|
|
|
if (SSL_CONNECTION_IS_DTLS(sc)) {
|
2015-01-22 11:40:55 +08:00
|
|
|
if (!ssl_print_hexbuf(bio, indent, "cookie", 1, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (msglen < 2)
|
|
|
|
|
return 0;
|
|
|
|
|
len = (msg[0] << 8) | msg[1];
|
|
|
|
|
msg += 2;
|
|
|
|
|
msglen -= 2;
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "cipher_suites (len=%d)\n", (int)len);
|
|
|
|
|
if (msglen < len || len & 1)
|
|
|
|
|
return 0;
|
|
|
|
|
while (len > 0) {
|
|
|
|
|
cs = (msg[0] << 8) | msg[1];
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
|
|
|
|
BIO_printf(bio, "{0x%02X, 0x%02X} %s\n",
|
|
|
|
|
msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl));
|
|
|
|
|
msg += 2;
|
|
|
|
|
msglen -= 2;
|
|
|
|
|
len -= 2;
|
|
|
|
|
}
|
|
|
|
|
if (msglen < 1)
|
|
|
|
|
return 0;
|
|
|
|
|
len = msg[0];
|
|
|
|
|
msg++;
|
|
|
|
|
msglen--;
|
|
|
|
|
if (msglen < len)
|
|
|
|
|
return 0;
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "compression_methods (len=%d)\n", (int)len);
|
|
|
|
|
while (len > 0) {
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
|
|
|
|
BIO_printf(bio, "%s (0x%02X)\n",
|
|
|
|
|
ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]);
|
|
|
|
|
msg++;
|
|
|
|
|
msglen--;
|
|
|
|
|
len--;
|
|
|
|
|
}
|
2017-02-02 19:16:25 +08:00
|
|
|
if (!ssl_print_extensions(bio, indent, 0, SSL3_MT_CLIENT_HELLO, &msg,
|
|
|
|
|
&msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2013-03-09 00:45:37 +08:00
|
|
|
static int dtls_print_hello_vfyrequest(BIO *bio, int indent,
|
2016-08-06 01:03:17 +08:00
|
|
|
const unsigned char *msg, size_t msglen)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
2016-11-07 21:50:43 +08:00
|
|
|
if (!ssl_print_version(bio, indent, "server_version", &msg, &msglen, NULL))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
if (!ssl_print_hexbuf(bio, indent, "cookie", 1, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2013-03-09 00:45:37 +08:00
|
|
|
|
2012-06-15 20:46:09 +08:00
|
|
|
static int ssl_print_server_hello(BIO *bio, int indent,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char *msg, size_t msglen)
|
|
|
|
|
{
|
|
|
|
|
unsigned int cs;
|
2016-11-07 21:50:43 +08:00
|
|
|
unsigned int vers;
|
2016-12-08 01:04:46 +08:00
|
|
|
|
2016-11-07 21:50:43 +08:00
|
|
|
if (!ssl_print_version(bio, indent, "server_version", &msg, &msglen, &vers))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
if (!ssl_print_random(bio, indent, &msg, &msglen))
|
|
|
|
|
return 0;
|
2016-11-07 21:50:43 +08:00
|
|
|
if (vers != TLS1_3_VERSION
|
|
|
|
|
&& !ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
if (msglen < 2)
|
|
|
|
|
return 0;
|
|
|
|
|
cs = (msg[0] << 8) | msg[1];
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "cipher_suite {0x%02X, 0x%02X} %s\n",
|
|
|
|
|
msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl));
|
|
|
|
|
msg += 2;
|
|
|
|
|
msglen -= 2;
|
2016-11-07 21:50:43 +08:00
|
|
|
if (vers != TLS1_3_VERSION) {
|
|
|
|
|
if (msglen < 1)
|
|
|
|
|
return 0;
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "compression_method: %s (0x%02X)\n",
|
|
|
|
|
ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]);
|
|
|
|
|
msg++;
|
|
|
|
|
msglen--;
|
|
|
|
|
}
|
2017-02-02 19:16:25 +08:00
|
|
|
if (!ssl_print_extensions(bio, indent, 1, SSL3_MT_SERVER_HELLO, &msg,
|
|
|
|
|
&msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2022-06-20 23:11:28 +08:00
|
|
|
static int ssl_get_keyex(const char **pname, const SSL_CONNECTION *sc)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
2022-06-20 23:11:28 +08:00
|
|
|
unsigned long alg_k = sc->s3.tmp.new_cipher->algorithm_mkey;
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (alg_k & SSL_kRSA) {
|
|
|
|
|
*pname = "rsa";
|
|
|
|
|
return SSL_kRSA;
|
|
|
|
|
}
|
|
|
|
|
if (alg_k & SSL_kDHE) {
|
|
|
|
|
*pname = "DHE";
|
|
|
|
|
return SSL_kDHE;
|
|
|
|
|
}
|
|
|
|
|
if (alg_k & SSL_kECDHE) {
|
|
|
|
|
*pname = "ECDHE";
|
|
|
|
|
return SSL_kECDHE;
|
|
|
|
|
}
|
|
|
|
|
if (alg_k & SSL_kPSK) {
|
|
|
|
|
*pname = "PSK";
|
|
|
|
|
return SSL_kPSK;
|
|
|
|
|
}
|
2015-06-28 23:50:53 +08:00
|
|
|
if (alg_k & SSL_kRSAPSK) {
|
|
|
|
|
*pname = "RSAPSK";
|
|
|
|
|
return SSL_kRSAPSK;
|
|
|
|
|
}
|
|
|
|
|
if (alg_k & SSL_kDHEPSK) {
|
|
|
|
|
*pname = "DHEPSK";
|
|
|
|
|
return SSL_kDHEPSK;
|
|
|
|
|
}
|
|
|
|
|
if (alg_k & SSL_kECDHEPSK) {
|
|
|
|
|
*pname = "ECDHEPSK";
|
|
|
|
|
return SSL_kECDHEPSK;
|
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
if (alg_k & SSL_kSRP) {
|
|
|
|
|
*pname = "SRP";
|
|
|
|
|
return SSL_kSRP;
|
|
|
|
|
}
|
|
|
|
|
if (alg_k & SSL_kGOST) {
|
|
|
|
|
*pname = "GOST";
|
|
|
|
|
return SSL_kGOST;
|
|
|
|
|
}
|
2020-03-30 23:09:24 +08:00
|
|
|
if (alg_k & SSL_kGOST18) {
|
|
|
|
|
*pname = "GOST18";
|
|
|
|
|
return SSL_kGOST18;
|
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
*pname = "UNKNOWN";
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2022-06-20 23:11:28 +08:00
|
|
|
static int ssl_print_client_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char *msg, size_t msglen)
|
|
|
|
|
{
|
|
|
|
|
const char *algname;
|
2022-06-20 23:11:28 +08:00
|
|
|
int id = ssl_get_keyex(&algname, sc);
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname);
|
2015-06-28 23:50:53 +08:00
|
|
|
if (id & SSL_PSK) {
|
|
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2,
|
|
|
|
|
"psk_identity", 2, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
switch (id) {
|
|
|
|
|
|
|
|
|
|
case SSL_kRSA:
|
2015-06-28 23:50:53 +08:00
|
|
|
case SSL_kRSAPSK:
|
2022-06-20 23:11:28 +08:00
|
|
|
if (TLS1_get_version(SSL_CONNECTION_GET_SSL(sc)) == SSL3_VERSION) {
|
2015-01-22 11:40:55 +08:00
|
|
|
ssl_print_hex(bio, indent + 2,
|
2018-02-16 22:45:32 +08:00
|
|
|
"EncryptedPreMasterSecret", msg, msglen);
|
2015-01-22 11:40:55 +08:00
|
|
|
} else {
|
|
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2,
|
2018-02-16 22:45:32 +08:00
|
|
|
"EncryptedPreMasterSecret", 2, &msg, &msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL_kDHE:
|
2015-06-28 23:50:53 +08:00
|
|
|
case SSL_kDHEPSK:
|
2015-01-22 11:40:55 +08:00
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2, "dh_Yc", 2, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL_kECDHE:
|
2015-06-28 23:50:53 +08:00
|
|
|
case SSL_kECDHEPSK:
|
2015-01-22 11:40:55 +08:00
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2, "ecdh_Yc", 1, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
break;
|
2019-09-24 17:47:26 +08:00
|
|
|
case SSL_kGOST:
|
|
|
|
|
ssl_print_hex(bio, indent + 2, "GostKeyTransportBlob", msg, msglen);
|
|
|
|
|
msglen = 0;
|
|
|
|
|
break;
|
2020-03-30 23:09:24 +08:00
|
|
|
case SSL_kGOST18:
|
|
|
|
|
ssl_print_hex(bio, indent + 2,
|
|
|
|
|
"GOST-wrapped PreMasterSecret", msg, msglen);
|
|
|
|
|
msglen = 0;
|
|
|
|
|
break;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
|
2015-06-28 23:50:53 +08:00
|
|
|
return !msglen;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2022-06-20 23:11:28 +08:00
|
|
|
static int ssl_print_server_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char *msg, size_t msglen)
|
|
|
|
|
{
|
|
|
|
|
const char *algname;
|
2022-06-20 23:11:28 +08:00
|
|
|
int id = ssl_get_keyex(&algname, sc);
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname);
|
2015-06-28 23:50:53 +08:00
|
|
|
if (id & SSL_PSK) {
|
|
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2,
|
|
|
|
|
"psk_identity_hint", 2, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
switch (id) {
|
|
|
|
|
case SSL_kRSA:
|
|
|
|
|
|
2016-08-06 01:03:17 +08:00
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2, "rsa_modulus", 2, &msg, &msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2, "rsa_exponent", 2,
|
|
|
|
|
&msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL_kDHE:
|
2015-06-28 23:50:53 +08:00
|
|
|
case SSL_kDHEPSK:
|
2015-01-22 11:40:55 +08:00
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2, "dh_p", 2, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2, "dh_g", 2, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2, "dh_Ys", 2, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL_kECDHE:
|
2015-06-28 23:50:53 +08:00
|
|
|
case SSL_kECDHEPSK:
|
2015-01-22 11:40:55 +08:00
|
|
|
if (msglen < 1)
|
|
|
|
|
return 0;
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
|
|
|
|
if (msg[0] == EXPLICIT_PRIME_CURVE_TYPE)
|
|
|
|
|
BIO_puts(bio, "explicit_prime\n");
|
|
|
|
|
else if (msg[0] == EXPLICIT_CHAR2_CURVE_TYPE)
|
|
|
|
|
BIO_puts(bio, "explicit_char2\n");
|
|
|
|
|
else if (msg[0] == NAMED_CURVE_TYPE) {
|
|
|
|
|
int curve;
|
|
|
|
|
if (msglen < 3)
|
|
|
|
|
return 0;
|
|
|
|
|
curve = (msg[1] << 8) | msg[2];
|
|
|
|
|
BIO_printf(bio, "named_curve: %s (%d)\n",
|
2016-11-09 22:51:06 +08:00
|
|
|
ssl_trace_str(curve, ssl_groups_tbl), curve);
|
2015-01-22 11:40:55 +08:00
|
|
|
msg += 3;
|
|
|
|
|
msglen -= 3;
|
|
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2, "point", 1, &msg, &msglen))
|
|
|
|
|
return 0;
|
2015-06-28 23:50:53 +08:00
|
|
|
} else {
|
|
|
|
|
BIO_printf(bio, "UNKNOWN CURVE PARAMETER TYPE %d\n", msg[0]);
|
|
|
|
|
return 0;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
break;
|
2015-06-17 21:47:27 +08:00
|
|
|
|
|
|
|
|
case SSL_kPSK:
|
2015-06-28 23:50:53 +08:00
|
|
|
case SSL_kRSAPSK:
|
|
|
|
|
break;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
2015-06-28 23:50:53 +08:00
|
|
|
if (!(id & SSL_PSK))
|
2022-06-20 23:11:28 +08:00
|
|
|
ssl_print_signature(bio, indent, sc, &msg, &msglen);
|
2015-06-28 23:50:53 +08:00
|
|
|
return !msglen;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
|
2023-05-09 22:20:04 +08:00
|
|
|
static int ssl_print_certificate(BIO *bio, const SSL_CONNECTION *sc, int indent,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char **pmsg, size_t *pmsglen)
|
|
|
|
|
{
|
|
|
|
|
size_t msglen = *pmsglen;
|
|
|
|
|
size_t clen;
|
|
|
|
|
X509 *x;
|
|
|
|
|
const unsigned char *p = *pmsg, *q;
|
2023-05-09 22:20:04 +08:00
|
|
|
SSL_CTX *ctx = SSL_CONNECTION_GET_CTX(sc);
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (msglen < 3)
|
|
|
|
|
return 0;
|
|
|
|
|
clen = (p[0] << 16) | (p[1] << 8) | p[2];
|
|
|
|
|
if (msglen < clen + 3)
|
|
|
|
|
return 0;
|
|
|
|
|
q = p + 3;
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "ASN.1Cert, length=%d", (int)clen);
|
2023-05-09 22:20:04 +08:00
|
|
|
x = X509_new_ex(ctx->libctx, ctx->propq);
|
|
|
|
|
if (x != NULL && d2i_X509(&x, &q, clen) == NULL) {
|
|
|
|
|
X509_free(x);
|
|
|
|
|
x = NULL;
|
|
|
|
|
}
|
|
|
|
|
if (x == NULL)
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_puts(bio, "<UNPARSEABLE CERTIFICATE>\n");
|
|
|
|
|
else {
|
|
|
|
|
BIO_puts(bio, "\n------details-----\n");
|
|
|
|
|
X509_print_ex(bio, x, XN_FLAG_ONELINE, 0);
|
|
|
|
|
PEM_write_bio_X509(bio, x);
|
|
|
|
|
/* Print certificate stuff */
|
|
|
|
|
BIO_puts(bio, "------------------\n");
|
|
|
|
|
X509_free(x);
|
|
|
|
|
}
|
|
|
|
|
if (q != p + 3 + clen) {
|
|
|
|
|
BIO_puts(bio, "<TRAILING GARBAGE AFTER CERTIFICATE>\n");
|
|
|
|
|
}
|
|
|
|
|
*pmsg += clen + 3;
|
|
|
|
|
*pmsglen -= clen + 3;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-28 03:23:33 +08:00
|
|
|
static int ssl_print_raw_public_key(BIO *bio, const SSL *ssl, int server,
|
|
|
|
|
int indent, const unsigned char **pmsg,
|
|
|
|
|
size_t *pmsglen)
|
|
|
|
|
{
|
|
|
|
|
EVP_PKEY *pkey;
|
|
|
|
|
size_t clen;
|
|
|
|
|
const unsigned char *msg = *pmsg;
|
|
|
|
|
size_t msglen = *pmsglen;
|
|
|
|
|
|
|
|
|
|
if (msglen < 3)
|
|
|
|
|
return 0;
|
|
|
|
|
clen = (msg[0] << 16) | (msg[1] << 8) | msg[2];
|
|
|
|
|
if (msglen < clen + 3)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
msg += 3;
|
|
|
|
|
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "raw_public_key, length=%d\n", (int)clen);
|
|
|
|
|
|
|
|
|
|
pkey = d2i_PUBKEY_ex(NULL, &msg, clen, ssl->ctx->libctx, ssl->ctx->propq);
|
|
|
|
|
if (pkey == NULL)
|
|
|
|
|
return 0;
|
|
|
|
|
EVP_PKEY_print_public(bio, pkey, indent + 2, NULL);
|
|
|
|
|
EVP_PKEY_free(pkey);
|
|
|
|
|
*pmsg += clen + 3;
|
|
|
|
|
*pmsglen -= clen + 3;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-20 23:11:28 +08:00
|
|
|
static int ssl_print_certificates(BIO *bio, const SSL_CONNECTION *sc, int server,
|
2017-09-11 11:33:37 +08:00
|
|
|
int indent, const unsigned char *msg,
|
|
|
|
|
size_t msglen)
|
2015-01-22 11:40:55 +08:00
|
|
|
{
|
|
|
|
|
size_t clen;
|
2016-12-03 01:14:59 +08:00
|
|
|
|
2022-06-20 23:11:28 +08:00
|
|
|
if (SSL_CONNECTION_IS_TLS13(sc)
|
2016-12-03 01:14:59 +08:00
|
|
|
&& !ssl_print_hexbuf(bio, indent, "context", 1, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (msglen < 3)
|
|
|
|
|
return 0;
|
|
|
|
|
clen = (msg[0] << 16) | (msg[1] << 8) | msg[2];
|
|
|
|
|
if (msglen != clen + 3)
|
|
|
|
|
return 0;
|
|
|
|
|
msg += 3;
|
2021-01-28 03:23:33 +08:00
|
|
|
if ((server && sc->ext.server_cert_type == TLSEXT_cert_type_rpk)
|
|
|
|
|
|| (!server && sc->ext.client_cert_type == TLSEXT_cert_type_rpk)) {
|
|
|
|
|
if (!ssl_print_raw_public_key(bio, &sc->ssl, server, indent, &msg, &clen))
|
|
|
|
|
return 0;
|
|
|
|
|
if (SSL_CONNECTION_IS_TLS13(sc)
|
|
|
|
|
&& !ssl_print_extensions(bio, indent + 2, server,
|
|
|
|
|
SSL3_MT_CERTIFICATE, &msg, &clen))
|
|
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "certificate_list, length=%d\n", (int)clen);
|
|
|
|
|
while (clen > 0) {
|
2023-05-09 22:20:04 +08:00
|
|
|
if (!ssl_print_certificate(bio, sc, indent + 2, &msg, &clen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
2022-06-20 23:11:28 +08:00
|
|
|
if (SSL_CONNECTION_IS_TLS13(sc)
|
2019-09-24 16:08:23 +08:00
|
|
|
&& !ssl_print_extensions(bio, indent + 2, server,
|
|
|
|
|
SSL3_MT_CERTIFICATE, &msg, &clen))
|
2016-12-03 01:14:59 +08:00
|
|
|
return 0;
|
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2021-08-10 04:56:50 +08:00
|
|
|
static int ssl_print_compressed_certificates(BIO *bio, const SSL_CONNECTION *sc,
|
|
|
|
|
int server, int indent,
|
|
|
|
|
const unsigned char *msg,
|
|
|
|
|
size_t msglen)
|
|
|
|
|
{
|
|
|
|
|
size_t uclen;
|
|
|
|
|
size_t clen;
|
|
|
|
|
unsigned int alg;
|
|
|
|
|
int ret = 1;
|
|
|
|
|
#ifndef OPENSSL_NO_COMP_ALG
|
|
|
|
|
COMP_METHOD *method;
|
|
|
|
|
COMP_CTX *comp = NULL;
|
|
|
|
|
unsigned char* ucdata = NULL;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (msglen < 8)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
alg = (msg[0] << 8) | msg[1];
|
|
|
|
|
uclen = (msg[2] << 16) | (msg[3] << 8) | msg[4];
|
|
|
|
|
clen = (msg[5] << 16) | (msg[6] << 8) | msg[7];
|
|
|
|
|
if (msglen != clen + 8)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
msg += 8;
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "Compression type=%s (0x%04x)\n", ssl_trace_str(alg, ssl_comp_cert_tbl), alg);
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "Uncompressed length=%d\n", (int)uclen);
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
2022-10-19 22:12:57 +08:00
|
|
|
if (clen > 0)
|
|
|
|
|
BIO_printf(bio, "Compressed length=%d, Ratio=%f:1\n", (int)clen, (float)uclen / (float)clen);
|
|
|
|
|
else
|
|
|
|
|
BIO_printf(bio, "Compressed length=%d, Ratio=unknown\n", (int)clen);
|
2021-08-10 04:56:50 +08:00
|
|
|
|
|
|
|
|
BIO_dump_indent(bio, (const char *)msg, clen, indent);
|
|
|
|
|
|
|
|
|
|
#ifndef OPENSSL_NO_COMP_ALG
|
|
|
|
|
if (!ossl_comp_has_alg(alg))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2022-10-27 22:27:29 +08:00
|
|
|
/* Check against certificate maximum size (coverity) */
|
|
|
|
|
if (uclen == 0 || uclen > 0xFFFFFF || (ucdata = OPENSSL_malloc(uclen)) == NULL)
|
2021-08-10 04:56:50 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
switch (alg) {
|
|
|
|
|
case TLSEXT_comp_cert_zlib:
|
|
|
|
|
method = COMP_zlib();
|
|
|
|
|
break;
|
|
|
|
|
case TLSEXT_comp_cert_brotli:
|
|
|
|
|
method = COMP_brotli_oneshot();
|
|
|
|
|
break;
|
|
|
|
|
case TLSEXT_comp_cert_zstd:
|
|
|
|
|
method = COMP_zstd_oneshot();
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((comp = COMP_CTX_new(method)) == NULL
|
|
|
|
|
|| COMP_expand_block(comp, ucdata, uclen, (unsigned char*)msg, clen) != (int)uclen)
|
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
|
|
ret = ssl_print_certificates(bio, sc, server, indent, ucdata, uclen);
|
|
|
|
|
err:
|
|
|
|
|
COMP_CTX_free(comp);
|
|
|
|
|
OPENSSL_free(ucdata);
|
|
|
|
|
#endif
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-20 23:11:28 +08:00
|
|
|
static int ssl_print_cert_request(BIO *bio, int indent, const SSL_CONNECTION *sc,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char *msg, size_t msglen)
|
|
|
|
|
{
|
|
|
|
|
size_t xlen;
|
2017-01-03 21:43:56 +08:00
|
|
|
unsigned int sigalg;
|
|
|
|
|
|
2022-06-20 23:11:28 +08:00
|
|
|
if (SSL_CONNECTION_IS_TLS13(sc)) {
|
2017-02-23 01:26:04 +08:00
|
|
|
if (!ssl_print_hexbuf(bio, indent, "request_context", 1, &msg, &msglen))
|
|
|
|
|
return 0;
|
2018-01-02 23:51:23 +08:00
|
|
|
if (!ssl_print_extensions(bio, indent, 1,
|
|
|
|
|
SSL3_MT_CERTIFICATE_REQUEST, &msg, &msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
return 1;
|
2017-02-23 01:26:04 +08:00
|
|
|
} else {
|
|
|
|
|
if (msglen < 1)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = msg[0];
|
|
|
|
|
if (msglen < xlen + 1)
|
|
|
|
|
return 0;
|
|
|
|
|
msg++;
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "certificate_types (len=%d)\n", (int)xlen);
|
|
|
|
|
if (!ssl_trace_list(bio, indent + 2, msg, xlen, 1, ssl_ctype_tbl))
|
|
|
|
|
return 0;
|
|
|
|
|
msg += xlen;
|
|
|
|
|
msglen -= xlen + 1;
|
|
|
|
|
}
|
2022-06-20 23:11:28 +08:00
|
|
|
if (SSL_USE_SIGALGS(sc)) {
|
2017-02-23 01:26:04 +08:00
|
|
|
if (msglen < 2)
|
|
|
|
|
return 0;
|
|
|
|
|
xlen = (msg[0] << 8) | msg[1];
|
|
|
|
|
if (msglen < xlen + 2 || (xlen & 1))
|
|
|
|
|
return 0;
|
2015-01-22 11:40:55 +08:00
|
|
|
msg += 2;
|
2017-02-23 01:26:04 +08:00
|
|
|
msglen -= xlen + 2;
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "signature_algorithms (len=%d)\n", (int)xlen);
|
|
|
|
|
while (xlen > 0) {
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
|
|
|
|
sigalg = (msg[0] << 8) | msg[1];
|
|
|
|
|
BIO_printf(bio, "%s (0x%04x)\n",
|
|
|
|
|
ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg);
|
|
|
|
|
xlen -= 2;
|
|
|
|
|
msg += 2;
|
|
|
|
|
}
|
|
|
|
|
msg += xlen;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
|
2018-03-24 03:51:38 +08:00
|
|
|
if (msglen < 2)
|
|
|
|
|
return 0;
|
2015-01-22 11:40:55 +08:00
|
|
|
xlen = (msg[0] << 8) | msg[1];
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
if (msglen < xlen + 2)
|
|
|
|
|
return 0;
|
|
|
|
|
msg += 2;
|
2017-02-23 01:26:04 +08:00
|
|
|
msglen -= 2 + xlen;
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_printf(bio, "certificate_authorities (len=%d)\n", (int)xlen);
|
|
|
|
|
while (xlen > 0) {
|
|
|
|
|
size_t dlen;
|
|
|
|
|
X509_NAME *nm;
|
|
|
|
|
const unsigned char *p;
|
|
|
|
|
if (xlen < 2)
|
|
|
|
|
return 0;
|
|
|
|
|
dlen = (msg[0] << 8) | msg[1];
|
|
|
|
|
if (xlen < dlen + 2)
|
|
|
|
|
return 0;
|
|
|
|
|
msg += 2;
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
|
|
|
|
BIO_printf(bio, "DistinguishedName (len=%d): ", (int)dlen);
|
|
|
|
|
p = msg;
|
|
|
|
|
nm = d2i_X509_NAME(NULL, &p, dlen);
|
|
|
|
|
if (!nm) {
|
|
|
|
|
BIO_puts(bio, "<UNPARSEABLE DN>\n");
|
|
|
|
|
} else {
|
|
|
|
|
X509_NAME_print_ex(bio, nm, 0, XN_FLAG_ONELINE);
|
|
|
|
|
BIO_puts(bio, "\n");
|
|
|
|
|
X509_NAME_free(nm);
|
|
|
|
|
}
|
|
|
|
|
xlen -= dlen + 2;
|
|
|
|
|
msg += dlen;
|
|
|
|
|
}
|
2022-06-20 23:11:28 +08:00
|
|
|
if (SSL_CONNECTION_IS_TLS13(sc)) {
|
2017-09-11 11:33:37 +08:00
|
|
|
if (!ssl_print_hexbuf(bio, indent, "request_extensions", 2,
|
|
|
|
|
&msg, &msglen))
|
|
|
|
|
return 0;
|
2017-02-23 01:26:04 +08:00
|
|
|
}
|
|
|
|
|
return msglen == 0;
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
2022-06-20 23:11:28 +08:00
|
|
|
static int ssl_print_ticket(BIO *bio, int indent, const SSL_CONNECTION *sc,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char *msg, size_t msglen)
|
|
|
|
|
{
|
|
|
|
|
unsigned int tick_life;
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (msglen == 0) {
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
|
|
|
|
BIO_puts(bio, "No Ticket\n");
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
if (msglen < 4)
|
|
|
|
|
return 0;
|
2020-05-19 16:52:53 +08:00
|
|
|
tick_life = ((unsigned int)msg[0] << 24)
|
|
|
|
|
| ((unsigned int)msg[1] << 16)
|
|
|
|
|
| ((unsigned int)msg[2] << 8)
|
|
|
|
|
| (unsigned int)msg[3];
|
2015-01-22 11:40:55 +08:00
|
|
|
msglen -= 4;
|
|
|
|
|
msg += 4;
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
|
|
|
|
BIO_printf(bio, "ticket_lifetime_hint=%u\n", tick_life);
|
2022-06-20 23:11:28 +08:00
|
|
|
if (SSL_CONNECTION_IS_TLS13(sc)) {
|
2017-02-26 21:40:03 +08:00
|
|
|
unsigned int ticket_age_add;
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2017-02-26 21:40:03 +08:00
|
|
|
if (msglen < 4)
|
|
|
|
|
return 0;
|
2018-04-26 19:57:14 +08:00
|
|
|
ticket_age_add =
|
2020-05-19 16:52:53 +08:00
|
|
|
((unsigned int)msg[0] << 24)
|
|
|
|
|
| ((unsigned int)msg[1] << 16)
|
|
|
|
|
| ((unsigned int)msg[2] << 8)
|
|
|
|
|
| (unsigned int)msg[3];
|
2017-02-26 21:40:03 +08:00
|
|
|
msglen -= 4;
|
|
|
|
|
msg += 4;
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
|
|
|
|
BIO_printf(bio, "ticket_age_add=%u\n", ticket_age_add);
|
2017-07-05 18:31:51 +08:00
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2, "ticket_nonce", 1, &msg,
|
|
|
|
|
&msglen))
|
|
|
|
|
return 0;
|
2017-02-26 21:40:03 +08:00
|
|
|
}
|
2015-01-22 11:40:55 +08:00
|
|
|
if (!ssl_print_hexbuf(bio, indent + 2, "ticket", 2, &msg, &msglen))
|
|
|
|
|
return 0;
|
2022-06-20 23:11:28 +08:00
|
|
|
if (SSL_CONNECTION_IS_TLS13(sc)
|
2017-09-11 11:33:37 +08:00
|
|
|
&& !ssl_print_extensions(bio, indent + 2, 0,
|
|
|
|
|
SSL3_MT_NEWSESSION_TICKET, &msg, &msglen))
|
2017-02-26 21:40:03 +08:00
|
|
|
return 0;
|
2015-01-22 11:40:55 +08:00
|
|
|
if (msglen)
|
|
|
|
|
return 0;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2013-03-09 00:45:37 +08:00
|
|
|
|
2022-06-20 23:11:28 +08:00
|
|
|
static int ssl_print_handshake(BIO *bio, const SSL_CONNECTION *sc, int server,
|
2015-01-22 11:40:55 +08:00
|
|
|
const unsigned char *msg, size_t msglen,
|
|
|
|
|
int indent)
|
|
|
|
|
{
|
|
|
|
|
size_t hlen;
|
|
|
|
|
unsigned char htype;
|
2017-02-27 00:04:31 +08:00
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
if (msglen < 4)
|
|
|
|
|
return 0;
|
|
|
|
|
htype = msg[0];
|
|
|
|
|
hlen = (msg[1] << 16) | (msg[2] << 8) | msg[3];
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "%s, Length=%d\n",
|
|
|
|
|
ssl_trace_str(htype, ssl_handshake_tbl), (int)hlen);
|
|
|
|
|
msg += 4;
|
|
|
|
|
msglen -= 4;
|
2022-06-20 23:11:28 +08:00
|
|
|
if (SSL_CONNECTION_IS_DTLS(sc)) {
|
2015-01-22 11:40:55 +08:00
|
|
|
if (msglen < 8)
|
|
|
|
|
return 0;
|
|
|
|
|
BIO_indent(bio, indent, 80);
|
|
|
|
|
BIO_printf(bio, "message_seq=%d, fragment_offset=%d, "
|
|
|
|
|
"fragment_length=%d\n",
|
|
|
|
|
(msg[0] << 8) | msg[1],
|
|
|
|
|
(msg[2] << 16) | (msg[3] << 8) | msg[4],
|
|
|
|
|
(msg[5] << 16) | (msg[6] << 8) | msg[7]);
|
|
|
|
|
msg += 8;
|
|
|
|
|
msglen -= 8;
|
|
|
|
|
}
|
|
|
|
|
if (msglen < hlen)
|
|
|
|
|
return 0;
|
|
|
|
|
switch (htype) {
|
|
|
|
|
case SSL3_MT_CLIENT_HELLO:
|
2022-06-20 23:11:28 +08:00
|
|
|
if (!ssl_print_client_hello(bio, sc, indent + 2, msg, msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case DTLS1_MT_HELLO_VERIFY_REQUEST:
|
|
|
|
|
if (!dtls_print_hello_vfyrequest(bio, indent + 2, msg, msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_MT_SERVER_HELLO:
|
|
|
|
|
if (!ssl_print_server_hello(bio, indent + 2, msg, msglen))
|
|
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_MT_SERVER_KEY_EXCHANGE:
|
2022-06-20 23:11:28 +08:00
|
|
|
if (!ssl_print_server_keyex(bio, indent + 2, sc, msg, msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_MT_CLIENT_KEY_EXCHANGE:
|
2022-06-20 23:11:28 +08:00
|
|
|
if (!ssl_print_client_keyex(bio, indent + 2, sc, msg, msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_MT_CERTIFICATE:
|
2022-06-20 23:11:28 +08:00
|
|
|
if (!ssl_print_certificates(bio, sc, server, indent + 2, msg, msglen))
|
2021-08-10 04:56:50 +08:00
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_MT_COMPRESSED_CERTIFICATE:
|
|
|
|
|
if (!ssl_print_compressed_certificates(bio, sc, server, indent + 2, msg, msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_MT_CERTIFICATE_VERIFY:
|
2022-06-20 23:11:28 +08:00
|
|
|
if (!ssl_print_signature(bio, indent + 2, sc, &msg, &msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_MT_CERTIFICATE_REQUEST:
|
2022-06-20 23:11:28 +08:00
|
|
|
if (!ssl_print_cert_request(bio, indent + 2, sc, msg, msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_MT_FINISHED:
|
|
|
|
|
ssl_print_hex(bio, indent + 2, "verify_data", msg, msglen);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_MT_SERVER_DONE:
|
|
|
|
|
if (msglen != 0)
|
|
|
|
|
ssl_print_hex(bio, indent + 2, "unexpected value", msg, msglen);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_MT_NEWSESSION_TICKET:
|
2022-06-20 23:11:28 +08:00
|
|
|
if (!ssl_print_ticket(bio, indent + 2, sc, msg, msglen))
|
2015-01-22 11:40:55 +08:00
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
2016-11-23 23:20:22 +08:00
|
|
|
case SSL3_MT_ENCRYPTED_EXTENSIONS:
|
2017-02-02 19:16:25 +08:00
|
|
|
if (!ssl_print_extensions(bio, indent + 2, 1,
|
|
|
|
|
SSL3_MT_ENCRYPTED_EXTENSIONS, &msg, &msglen))
|
2016-11-23 23:20:22 +08:00
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
2017-02-09 01:08:48 +08:00
|
|
|
case SSL3_MT_KEY_UPDATE:
|
|
|
|
|
if (msglen != 1) {
|
|
|
|
|
ssl_print_hex(bio, indent + 2, "unexpected value", msg, msglen);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (!ssl_trace_list(bio, indent + 2, msg, msglen, 1,
|
|
|
|
|
ssl_key_update_tbl))
|
|
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
default:
|
|
|
|
|
BIO_indent(bio, indent + 2, 80);
|
|
|
|
|
BIO_puts(bio, "Unsupported, hex dump follows:\n");
|
2016-07-08 06:43:32 +08:00
|
|
|
BIO_dump_indent(bio, (const char *)msg, msglen, indent + 4);
|
2015-01-22 11:40:55 +08:00
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
|
|
|
|
void SSL_trace(int write_p, int version, int content_type,
|
2015-01-22 11:40:55 +08:00
|
|
|
const void *buf, size_t msglen, SSL *ssl, void *arg)
|
|
|
|
|
{
|
|
|
|
|
const unsigned char *msg = buf;
|
|
|
|
|
BIO *bio = arg;
|
2022-06-20 23:11:28 +08:00
|
|
|
SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
|
2023-05-02 20:26:47 +08:00
|
|
|
#ifndef OPENSSL_NO_QUIC
|
|
|
|
|
QUIC_CONNECTION *qc = QUIC_CONNECTION_FROM_SSL(ssl);
|
|
|
|
|
|
|
|
|
|
if (qc != NULL) {
|
|
|
|
|
if (ossl_quic_trace(write_p, version, content_type, buf, msglen, ssl,
|
|
|
|
|
arg))
|
|
|
|
|
return;
|
|
|
|
|
/*
|
|
|
|
|
* Otherwise ossl_quic_trace didn't handle this content_type so we
|
|
|
|
|
* fallback to standard TLS handling
|
|
|
|
|
*/
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2022-06-20 23:11:28 +08:00
|
|
|
|
|
|
|
|
if (sc == NULL)
|
|
|
|
|
return;
|
2015-01-22 11:40:55 +08:00
|
|
|
|
|
|
|
|
switch (content_type) {
|
|
|
|
|
case SSL3_RT_HEADER:
|
|
|
|
|
{
|
2018-03-24 03:51:38 +08:00
|
|
|
int hvers;
|
|
|
|
|
|
|
|
|
|
/* avoid overlapping with length at the end of buffer */
|
2022-06-20 23:11:28 +08:00
|
|
|
if (msglen < (size_t)(SSL_CONNECTION_IS_DTLS(sc) ?
|
2018-04-26 19:57:14 +08:00
|
|
|
DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH)) {
|
2018-03-24 03:51:38 +08:00
|
|
|
BIO_puts(bio, write_p ? "Sent" : "Received");
|
|
|
|
|
ssl_print_hex(bio, 0, " too short message", msg, msglen);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
hvers = msg[1] << 8 | msg[2];
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_puts(bio, write_p ? "Sent" : "Received");
|
2023-05-02 20:26:47 +08:00
|
|
|
BIO_printf(bio, " TLS Record\nHeader:\n Version = %s (0x%x)\n",
|
2015-01-22 11:40:55 +08:00
|
|
|
ssl_trace_str(hvers, ssl_version_tbl), hvers);
|
2022-06-20 23:11:28 +08:00
|
|
|
if (SSL_CONNECTION_IS_DTLS(sc)) {
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_printf(bio,
|
|
|
|
|
" epoch=%d, sequence_number=%04x%04x%04x\n",
|
|
|
|
|
(msg[3] << 8 | msg[4]),
|
|
|
|
|
(msg[5] << 8 | msg[6]),
|
|
|
|
|
(msg[7] << 8 | msg[8]), (msg[9] << 8 | msg[10]));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BIO_printf(bio, " Content Type = %s (%d)\n Length = %d",
|
|
|
|
|
ssl_trace_str(msg[0], ssl_content_tbl), msg[0],
|
|
|
|
|
msg[msglen - 2] << 8 | msg[msglen - 1]);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2017-05-05 18:55:55 +08:00
|
|
|
|
|
|
|
|
case SSL3_RT_INNER_CONTENT_TYPE:
|
|
|
|
|
BIO_printf(bio, " Inner Content Type = %s (%d)",
|
|
|
|
|
ssl_trace_str(msg[0], ssl_content_tbl), msg[0]);
|
|
|
|
|
break;
|
|
|
|
|
|
2015-01-22 11:40:55 +08:00
|
|
|
case SSL3_RT_HANDSHAKE:
|
2022-06-20 23:11:28 +08:00
|
|
|
if (!ssl_print_handshake(bio, sc, sc->server ? write_p : !write_p,
|
2016-12-03 01:14:59 +08:00
|
|
|
msg, msglen, 4))
|
2015-01-22 11:40:55 +08:00
|
|
|
BIO_printf(bio, "Message length parse error!\n");
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_RT_CHANGE_CIPHER_SPEC:
|
|
|
|
|
if (msglen == 1 && msg[0] == 1)
|
|
|
|
|
BIO_puts(bio, " change_cipher_spec (1)\n");
|
|
|
|
|
else
|
|
|
|
|
ssl_print_hex(bio, 4, "unknown value", msg, msglen);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case SSL3_RT_ALERT:
|
|
|
|
|
if (msglen != 2)
|
|
|
|
|
BIO_puts(bio, " Illegal Alert Length\n");
|
|
|
|
|
else {
|
|
|
|
|
BIO_printf(bio, " Level=%s(%d), description=%s(%d)\n",
|
|
|
|
|
SSL_alert_type_string_long(msg[0] << 8),
|
|
|
|
|
msg[0], SSL_alert_desc_string_long(msg[1]), msg[1]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BIO_puts(bio, "\n");
|
|
|
|
|
}
|
2012-06-15 20:46:09 +08:00
|
|
|
|
|
|
|
|
#endif
|
