/* packet-tls-utils.h

 * ssl manipulation functions

 * By Paolo Abeni <paolo.abeni@email.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

#ifndef __PACKET_TLS_UTILS_H__

#define __PACKET_TLS_UTILS_H__

#include <stdio.h>      /* some APIs we declare take a stdio stream as an argument */

#include <glib.h>

#include <epan/packet.h>

#include <epan/prefs.h>

#include <epan/wmem_scopes.h>

#include <epan/expert.h>

#include <epan/conversation.h>

#include <epan/tap.h>

#include <epan/unit_strings.h>

#include <wsutil/wsgcrypt.h>

/* TODO inline this now that Libgcrypt is mandatory? */

#define SSL_CIPHER_CTX gcry_cipher_hd_t

#define SSL_DECRYPT_DEBUG

/* other defines */

typedef enum {

    SSL_ID_CHG_CIPHER_SPEC         = 0x14,

    SSL_ID_ALERT                   = 0x15,

    SSL_ID_HANDSHAKE               = 0x16,

    SSL_ID_APP_DATA                = 0x17,

    SSL_ID_HEARTBEAT               = 0x18,

    SSL_ID_TLS12_CID               = 0x19,

    SSL_ID_DTLS13_ACK              = 0x1A,

} ContentType;

typedef enum {

    SSL_HND_HELLO_REQUEST          = 0,

    SSL_HND_CLIENT_HELLO           = 1,

    SSL_HND_SERVER_HELLO           = 2,

    SSL_HND_HELLO_VERIFY_REQUEST   = 3,

    SSL_HND_NEWSESSION_TICKET      = 4,

    SSL_HND_END_OF_EARLY_DATA      = 5,

    SSL_HND_HELLO_RETRY_REQUEST    = 6,

    SSL_HND_ENCRYPTED_EXTENSIONS   = 8,

    SSL_HND_CERTIFICATE            = 11,

    SSL_HND_SERVER_KEY_EXCHG       = 12,

    SSL_HND_CERT_REQUEST           = 13,

    SSL_HND_SVR_HELLO_DONE         = 14,

    SSL_HND_CERT_VERIFY            = 15,

    SSL_HND_CLIENT_KEY_EXCHG       = 16,

    SSL_HND_FINISHED               = 20,

    SSL_HND_CERT_URL               = 21,

    SSL_HND_CERT_STATUS            = 22,

    SSL_HND_SUPPLEMENTAL_DATA      = 23,

    SSL_HND_KEY_UPDATE             = 24,

    SSL_HND_COMPRESSED_CERTIFICATE = 25,

    /* Encrypted Extensions was NextProtocol in draft-agl-tls-nextprotoneg-03

     * and changed in draft 04. Not to be confused with TLS 1.3 EE. */

    SSL_HND_ENCRYPTED_EXTS         = 67,

    SSL_HND_MESSAGE_HASH           = 254

} HandshakeType;

#define SSL2_HND_ERROR                 0x00

#define SSL2_HND_CLIENT_HELLO          0x01

#define SSL2_HND_CLIENT_MASTER_KEY     0x02

#define SSL2_HND_CLIENT_FINISHED       0x03

#define SSL2_HND_SERVER_HELLO          0x04

#define SSL2_HND_SERVER_VERIFY         0x05

#define SSL2_HND_SERVER_FINISHED       0x06

#define SSL2_HND_REQUEST_CERTIFICATE   0x07

#define SSL2_HND_CLIENT_CERTIFICATE    0x08

#define SSL_HND_HELLO_EXT_SERVER_NAME                   0

#define SSL_HND_HELLO_EXT_MAX_FRAGMENT_LENGTH           1

#define SSL_HND_HELLO_EXT_CLIENT_CERTIFICATE_URL        2

#define SSL_HND_HELLO_EXT_TRUSTED_CA_KEYS               3

#define SSL_HND_HELLO_EXT_TRUNCATED_HMAC                4

#define SSL_HND_HELLO_EXT_STATUS_REQUEST                5

#define SSL_HND_HELLO_EXT_USER_MAPPING                  6

#define SSL_HND_HELLO_EXT_CLIENT_AUTHZ                  7

#define SSL_HND_HELLO_EXT_SERVER_AUTHZ                  8

#define SSL_HND_HELLO_EXT_CERT_TYPE                     9

#define SSL_HND_HELLO_EXT_SUPPORTED_GROUPS              10 /* renamed from "elliptic_curves" (RFC 7919 / TLS 1.3) */

#define SSL_HND_HELLO_EXT_EC_POINT_FORMATS              11

#define SSL_HND_HELLO_EXT_SRP                           12

#define SSL_HND_HELLO_EXT_SIGNATURE_ALGORITHMS          13

#define SSL_HND_HELLO_EXT_USE_SRTP                      14

#define SSL_HND_HELLO_EXT_HEARTBEAT                     15

#define SSL_HND_HELLO_EXT_ALPN                          16

#define SSL_HND_HELLO_EXT_STATUS_REQUEST_V2             17

#define SSL_HND_HELLO_EXT_SIGNED_CERTIFICATE_TIMESTAMP  18

#define SSL_HND_HELLO_EXT_CLIENT_CERT_TYPE              19

#define SSL_HND_HELLO_EXT_SERVER_CERT_TYPE              20

#define SSL_HND_HELLO_EXT_PADDING                       21

#define SSL_HND_HELLO_EXT_ENCRYPT_THEN_MAC              22

#define SSL_HND_HELLO_EXT_EXTENDED_MASTER_SECRET        23

#define SSL_HND_HELLO_EXT_TOKEN_BINDING                 24

#define SSL_HND_HELLO_EXT_CACHED_INFO                   25

#define SSL_HND_HELLO_EXT_COMPRESS_CERTIFICATE          27

#define SSL_HND_HELLO_EXT_RECORD_SIZE_LIMIT             28

/* 26-33  Unassigned*/

#define SSL_HND_HELLO_EXT_DELEGATED_CREDENTIALS         34 /* draft-ietf-tls-subcerts-10.txt */

#define SSL_HND_HELLO_EXT_SESSION_TICKET_TLS            35

/* RFC 8446 (TLS 1.3) */

#define SSL_HND_HELLO_EXT_KEY_SHARE_OLD                 40 /* draft-ietf-tls-tls13-22 (removed in -23) */

#define SSL_HND_HELLO_EXT_PRE_SHARED_KEY                41

#define SSL_HND_HELLO_EXT_EARLY_DATA                    42

#define SSL_HND_HELLO_EXT_SUPPORTED_VERSIONS            43

#define SSL_HND_HELLO_EXT_COOKIE                        44

#define SSL_HND_HELLO_EXT_PSK_KEY_EXCHANGE_MODES        45

#define SSL_HND_HELLO_EXT_TICKET_EARLY_DATA_INFO        46 /* draft-ietf-tls-tls13-18 (removed in -19) */

#define SSL_HND_HELLO_EXT_CERTIFICATE_AUTHORITIES       47

#define SSL_HND_HELLO_EXT_OID_FILTERS                   48

#define SSL_HND_HELLO_EXT_POST_HANDSHAKE_AUTH           49

#define SSL_HND_HELLO_EXT_SIGNATURE_ALGORITHMS_CERT     50

#define SSL_HND_HELLO_EXT_KEY_SHARE                     51

#define SSL_HND_HELLO_EXT_TRANSPARENCY_INFO             52 /* draft-ietf-trans-rfc6962-bis-41 */

#define SSL_HND_HELLO_EXT_CONNECTION_ID_DEPRECATED      53 /* draft-ietf-tls-dtls-connection-id-07 */

#define SSL_HND_HELLO_EXT_CONNECTION_ID                 54

#define SSL_HND_HELLO_EXT_EXTERNAL_ID_HASH              55 /* RFC 8844 */

#define SSL_HND_HELLO_EXT_EXTERNAL_SESSION_ID           56 /* RFC 8844 */

#define SSL_HND_HELLO_EXT_QUIC_TRANSPORT_PARAMETERS_V1  57 /* draft-ietf-quic-tls-33 */

#define SSL_HND_HELLO_EXT_TICKET_REQUEST                58 /* draft-ietf-tls-ticketrequests-07 */

#define SSL_HND_HELLO_EXT_DNSSEC_CHAIN                  59 /* RFC 9102 */

#define SSL_HND_HELLO_EXT_GREASE_0A0A                   2570

#define SSL_HND_HELLO_EXT_GREASE_1A1A                   6682

#define SSL_HND_HELLO_EXT_GREASE_2A2A                   10794

#define SSL_HND_HELLO_EXT_NPN                           13172 /* 0x3374 */

#define SSL_HND_HELLO_EXT_GREASE_3A3A                   14906

#define SSL_HND_HELLO_EXT_ALPS_OLD                      17513 /* draft-vvv-tls-alps-01, previous value used in BoringSSL implementation */

#define SSL_HND_HELLO_EXT_ALPS                          17613 /* draft-vvv-tls-alps-01, current value used in BoringSSL implementation */

#define SSL_HND_HELLO_EXT_GREASE_4A4A                   19018

#define SSL_HND_HELLO_EXT_GREASE_5A5A                   23130

#define SSL_HND_HELLO_EXT_GREASE_6A6A                   27242

#define SSL_HND_HELLO_EXT_CHANNEL_ID_OLD                30031 /* 0x754f */

#define SSL_HND_HELLO_EXT_CHANNEL_ID                    30032 /* 0x7550 */

#define SSL_HND_HELLO_EXT_GREASE_7A7A                   31354

#define SSL_HND_HELLO_EXT_GREASE_8A8A                   35466

#define SSL_HND_HELLO_EXT_GREASE_9A9A                   39578

#define SSL_HND_HELLO_EXT_GREASE_AAAA                   43690

#define SSL_HND_HELLO_EXT_GREASE_BABA                   47802

#define SSL_HND_HELLO_EXT_GREASE_CACA                   51914

#define SSL_HND_HELLO_EXT_GREASE_DADA                   56026

#define SSL_HND_HELLO_EXT_GREASE_EAEA                   60138

#define SSL_HND_HELLO_EXT_GREASE_FAFA                   64250

#define SSL_HND_HELLO_EXT_ECH_OUTER_EXTENSIONS          64768 /* 0xfd00 draft-ietf-tls-esni-16 */

#define SSL_HND_HELLO_EXT_ENCRYPTED_CLIENT_HELLO        65037 /* 0xfe0d draft-ietf-tls-esni-16 */

#define SSL_HND_HELLO_EXT_RENEGOTIATION_INFO            65281 /* 0xFF01 */

#define SSL_HND_HELLO_EXT_QUIC_TRANSPORT_PARAMETERS     65445 /* 0xffa5 draft-ietf-quic-tls-13 */

#define SSL_HND_HELLO_EXT_ENCRYPTED_SERVER_NAME         65486 /* 0xffce draft-ietf-tls-esni-01 */

#define SSL_HND_CERT_URL_TYPE_INDIVIDUAL_CERT       1

#define SSL_HND_CERT_URL_TYPE_PKIPATH               2

#define SSL_HND_CERT_STATUS_TYPE_OCSP        1

#define SSL_HND_CERT_STATUS_TYPE_OCSP_MULTI  2

#define SSL_HND_CERT_TYPE_RAW_PUBLIC_KEY     2

/* https://github.com/quicwg/base-drafts/wiki/Temporary-IANA-Registry#quic-transport-parameters */

#define SSL_HND_QUIC_TP_ORIGINAL_DESTINATION_CONNECTION_ID  0x00

#define SSL_HND_QUIC_TP_MAX_IDLE_TIMEOUT                    0x01

#define SSL_HND_QUIC_TP_STATELESS_RESET_TOKEN               0x02

#define SSL_HND_QUIC_TP_MAX_UDP_PAYLOAD_SIZE                0x03

#define SSL_HND_QUIC_TP_INITIAL_MAX_DATA                    0x04

#define SSL_HND_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL  0x05

#define SSL_HND_QUIC_TP_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE 0x06

#define SSL_HND_QUIC_TP_INITIAL_MAX_STREAM_DATA_UNI         0x07

#define SSL_HND_QUIC_TP_INITIAL_MAX_STREAMS_BIDI            0x08

#define SSL_HND_QUIC_TP_INITIAL_MAX_STREAMS_UNI             0x09

#define SSL_HND_QUIC_TP_ACK_DELAY_EXPONENT                  0x0a

#define SSL_HND_QUIC_TP_MAX_ACK_DELAY                       0x0b

#define SSL_HND_QUIC_TP_DISABLE_ACTIVE_MIGRATION            0x0c

#define SSL_HND_QUIC_TP_PREFERRED_ADDRESS                   0x0d

#define SSL_HND_QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT          0x0e

#define SSL_HND_QUIC_TP_INITIAL_SOURCE_CONNECTION_ID        0x0f

#define SSL_HND_QUIC_TP_RETRY_SOURCE_CONNECTION_ID          0x10

#define SSL_HND_QUIC_TP_VERSION_INFORMATION                 0x11 /* https://tools.ietf.org/html/draft-ietf-quic-version-negotiation-14 */

#define SSL_HND_QUIC_TP_MAX_DATAGRAM_FRAME_SIZE             0x20 /* https://datatracker.ietf.org/doc/html/draft-ietf-quic-datagram-06 */

#define SSL_HND_QUIC_TP_CIBIR_ENCODING                      0x1000 /* https://datatracker.ietf.org/doc/html/draft-banks-quic-cibir-01 */

#define SSL_HND_QUIC_TP_LOSS_BITS                           0x1057 /* https://tools.ietf.org/html/draft-ferrieuxhamchaoui-quic-lossbits-03 */

#define SSL_HND_QUIC_TP_GREASE_QUIC_BIT                     0x2ab2 /* RFC 9287 */

#define SSL_HND_QUIC_TP_ENABLE_TIME_STAMP                   0x7157 /* https://tools.ietf.org/html/draft-huitema-quic-ts-02 */

#define SSL_HND_QUIC_TP_ENABLE_TIME_STAMP_V2                0x7158 /* https://tools.ietf.org/html/draft-huitema-quic-ts-03 */

#define SSL_HND_QUIC_TP_MIN_ACK_DELAY_OLD                   0xde1a /* https://tools.ietf.org/html/draft-iyengar-quic-delayed-ack-00 */

/* https://quiche.googlesource.com/quiche/+/refs/heads/master/quic/core/crypto/transport_parameters.cc */

#define SSL_HND_QUIC_TP_GOOGLE_USER_AGENT                   0x3129

#define SSL_HND_QUIC_TP_GOOGLE_KEY_UPDATE_NOT_YET_SUPPORTED 0x312B

#define SSL_HND_QUIC_TP_GOOGLE_QUIC_VERSION                 0x4752

#define SSL_HND_QUIC_TP_GOOGLE_INITIAL_RTT                  0x3127

#define SSL_HND_QUIC_TP_GOOGLE_SUPPORT_HANDSHAKE_DONE       0x312A

#define SSL_HND_QUIC_TP_GOOGLE_QUIC_PARAMS                  0x4751

#define SSL_HND_QUIC_TP_GOOGLE_CONNECTION_OPTIONS           0x3128

/* https://github.com/facebookincubator/mvfst/blob/master/quic/QuicConstants.h */

#define SSL_HND_QUIC_TP_FACEBOOK_PARTIAL_RELIABILITY        0xFF00

#define SSL_HND_QUIC_TP_VERSION_INFORMATION_DRAFT           0xff73db /* https://datatracker.ietf.org/doc/draft-ietf-quic-version-negotiation/13/ */

#define SSL_HND_QUIC_TP_ADDRESS_DISCOVERY                   0x9f81a176 /* https://tools.ietf.org/html/draft-ietf-quic-address-discovery-00 */

#define SSL_HND_QUIC_TP_MIN_ACK_DELAY_DRAFT_V1              0xFF03DE1A /* https://tools.ietf.org/html/draft-ietf-quic-ack-frequency-01 */

#define SSL_HND_QUIC_TP_MIN_ACK_DELAY_DRAFT05               0xff04de1a /* https://tools.ietf.org/html/draft-ietf-quic-ack-frequency-04 / draft-05 */

#define SSL_HND_QUIC_TP_MIN_ACK_DELAY                       0xff04de1b /* https://tools.ietf.org/html/draft-ietf-quic-ack-frequency-07 */

#define SSL_HND_QUIC_TP_ENABLE_MULTIPATH_DRAFT04            0x0f739bbc1b666d04 /* https://tools.ietf.org/html/draft-ietf-quic-multipath-04 */

#define SSL_HND_QUIC_TP_ENABLE_MULTIPATH_DRAFT05            0x0f739bbc1b666d05 /* https://tools.ietf.org/html/draft-ietf-quic-multipath-05 */

#define SSL_HND_QUIC_TP_ENABLE_MULTIPATH                    0x0f739bbc1b666d06 /* https://tools.ietf.org/html/draft-ietf-quic-multipath-06 */

#define SSL_HND_QUIC_TP_INITIAL_MAX_PATHS                   0x0f739bbc1b666d07 /* https://tools.ietf.org/html/draft-ietf-quic-multipath-07 */

#define SSL_HND_QUIC_TP_INITIAL_MAX_PATH_ID_DRAFT09         0x0f739bbc1b666d09 /* https://tools.ietf.org/html/draft-ietf-quic-multipath-09 */

#define SSL_HND_QUIC_TP_INITIAL_MAX_PATH_ID_DRAFT11         0x0f739bbc1b666d11 /* https://tools.ietf.org/html/draft-ietf-quic-multipath-11 */

#define SSL_HND_QUIC_TP_INITIAL_MAX_PATH_ID_DRAFT12         0x0f739bbc1b666d0c /* https://tools.ietf.org/html/draft-ietf-quic-multipath-12 */

#define SSL_HND_QUIC_TP_INITIAL_MAX_PATH_ID_DRAFT13         0x0f739bbc1b666d0d /* https://tools.ietf.org/html/draft-ietf-quic-multipath-13 */

#define SSL_HND_QUIC_TP_INITIAL_MAX_PATH_ID                 0x3e /* https://tools.ietf.org/html/draft-ietf-quic-multipath-19 */

/*

 * Lookup tables

 */

extern const value_string ssl_version_short_names[];

extern const value_string ssl_20_msg_types[];

extern value_string_ext ssl_20_cipher_suites_ext;

extern const value_string ssl_20_certificate_type[];

extern const value_string ssl_31_content_type[];

extern const value_string ssl_versions[];

extern const value_string ssl_31_change_cipher_spec[];

extern const value_string ssl_31_alert_level[];

extern const value_string ssl_31_alert_description[];

extern const value_string ssl_31_handshake_type[];

extern const value_string tls_heartbeat_type[];

extern const value_string tls_heartbeat_mode[];

extern const value_string ssl_31_compression_method[];

extern const value_string ssl_31_key_exchange_algorithm[];

extern const value_string ssl_31_signature_algorithm[];

extern const value_string ssl_31_client_certificate_type[];

extern const value_string ssl_31_public_value_encoding[];

extern value_string_ext ssl_31_ciphersuite_ext;

extern const value_string tls_hello_extension_types[];

extern const value_string tls_hash_algorithm[];

extern const value_string tls_signature_algorithm[];

extern const value_string tls13_signature_algorithm[];

extern const value_string tls_certificate_type[];

extern const value_string tls_cert_chain_type[];

extern const value_string tls_cert_status_type[];

extern const value_string ssl_extension_curves[];

extern const value_string ssl_extension_ec_point_formats[];

extern const value_string ssl_curve_types[];

extern const value_string tls_hello_ext_server_name_type_vs[];

extern const value_string tls_hello_ext_max_fragment_length[];

extern const value_string tls_hello_ext_psk_ke_mode[];

extern const value_string tls_hello_ext_trusted_ca_key_type[];

extern const value_string tls13_key_update_request[];

extern const value_string compress_certificate_algorithm_vals[];

extern const val64_string quic_transport_parameter_id[];

extern const range_string quic_version_vals[];

extern const val64_string quic_address_discovery_vals[];

extern const val64_string quic_enable_time_stamp_v2_vals[];

extern const val64_string quic_enable_multipath_vals[];

extern const value_string tls_hello_ext_ech_clienthello_types[];

extern const value_string kem_id_type_vals[];

extern const value_string kdf_id_type_vals[];

extern const value_string aead_id_type_vals[];

extern const value_string token_binding_key_parameter_vals[];

/* XXX Should we use GByteArray instead? */

typedef struct _StringInfo {

    unsigned char  *data;      /* Backing storage which may be larger than data_len */

    unsigned data_len;  /* Length of the meaningful part of data */

} StringInfo;

#define SSL_WRITE_KEY           1

#define SSL_VER_UNKNOWN         0

#define SSLV2_VERSION           0x0002 /* not in record layer, SSL_CLIENT_SERVER from

                                          http://www-archive.mozilla.org/projects/security/pki/nss/ssl/draft02.html */

#define SSLV3_VERSION          0x300

#define TLSV1_VERSION          0x301

#define TLCPV1_VERSION         0x101

#define TLSV1DOT1_VERSION      0x302

#define TLSV1DOT2_VERSION      0x303

#define TLSV1DOT3_VERSION      0x304

#define DTLSV1DOT0_VERSION     0xfeff

#define DTLSV1DOT0_OPENSSL_VERSION 0x100

#define DTLSV1DOT2_VERSION     0xfefd

#define DTLSV1DOT3_VERSION     0xfefc

/* Returns the TLS 1.3 draft version or 0 if not applicable. */

static inline uint8_t extract_tls13_draft_version(uint32_t version) {

    if ((version & 0xff00) == 0x7f00) {

        return (uint8_t) version;

    }

    return 0;

}

Unexecuted instantiation: packet-dtls.c:extract_tls13_draft_version

Unexecuted instantiation: packet-eap.c:extract_tls13_draft_version

Unexecuted instantiation: packet-enip.c:extract_tls13_draft_version

Unexecuted instantiation: packet-f5ethtrailer.c:extract_tls13_draft_version

Unexecuted instantiation: packet-ftp.c:extract_tls13_draft_version

Unexecuted instantiation: packet-hislip.c:extract_tls13_draft_version

Unexecuted instantiation: packet-imap.c:extract_tls13_draft_version

Unexecuted instantiation: packet-mysql.c:extract_tls13_draft_version

Unexecuted instantiation: packet-nbd.c:extract_tls13_draft_version

Unexecuted instantiation: packet-nntp.c:extract_tls13_draft_version

Unexecuted instantiation: packet-pcp.c:extract_tls13_draft_version

Unexecuted instantiation: packet-pgsql.c:extract_tls13_draft_version

Unexecuted instantiation: packet-pop.c:extract_tls13_draft_version

Unexecuted instantiation: packet-quic.c:extract_tls13_draft_version

Unexecuted instantiation: packet-reload.c:extract_tls13_draft_version

Unexecuted instantiation: packet-smtp.c:extract_tls13_draft_version

Unexecuted instantiation: packet-tcpcl.c:extract_tls13_draft_version

Unexecuted instantiation: packet-telnet.c:extract_tls13_draft_version

packet-tls-utils.c:extract_tls13_draft_version

Line

Count

Source

287

2.38k

static inline uint8_t extract_tls13_draft_version(uint32_t version) {

288

2.38k

    if ((version & 0xff00) == 0x7f00) {

289

77

        return (uint8_t) version;

290

77

    }

291

2.30k

    return 0;

292

2.38k

}

Unexecuted instantiation: packet-tls.c:extract_tls13_draft_version

Unexecuted instantiation: packet-ldap.c:extract_tls13_draft_version

Unexecuted instantiation: packet-xmpp-core.c:extract_tls13_draft_version

#define SSL_CLIENT_RANDOM       (1<<0)

#define SSL_SERVER_RANDOM       (1<<1)

#define SSL_CIPHER              (1<<2)

#define SSL_HAVE_SESSION_KEY    (1<<3)

#define SSL_VERSION             (1<<4)

#define SSL_MASTER_SECRET       (1<<5)

#define SSL_PRE_MASTER_SECRET   (1<<6)

#define SSL_CLIENT_EXTENDED_MASTER_SECRET (1<<7)

#define SSL_SERVER_EXTENDED_MASTER_SECRET (1<<8)

#define SSL_NEW_SESSION_TICKET  (1<<10)

#define SSL_ENCRYPT_THEN_MAC    (1<<11)

#define SSL_SEEN_0RTT_APPDATA   (1<<12)

#define SSL_QUIC_RECORD_LAYER   (1<<13) /* For QUIC (draft >= -13) */

#define SSL_EXTENDED_MASTER_SECRET_MASK (SSL_CLIENT_EXTENDED_MASTER_SECRET|SSL_SERVER_EXTENDED_MASTER_SECRET)

/* SSL Cipher Suite modes */

typedef enum {

    MODE_STREAM,    /* GenericStreamCipher */

    MODE_CBC,       /* GenericBlockCipher */

    MODE_GCM,       /* GenericAEADCipher */

    MODE_CCM,       /* AEAD_AES_{128,256}_CCM with 16 byte auth tag */

    MODE_CCM_8,     /* AEAD_AES_{128,256}_CCM with 8 byte auth tag */

    MODE_POLY1305,  /* AEAD_CHACHA20_POLY1305 with 16 byte auth tag (RFC 7905) */

    MODE_ECB, /* ECB: used to perform record seq number encryption in DTLSv1.3 */

} ssl_cipher_mode_t;

/* Explicit and implicit nonce length (RFC 5116 - Section 3.2.1) */

#define IMPLICIT_NONCE_LEN  4

#define EXPLICIT_NONCE_LEN  8

#define TLS13_AEAD_NONCE_LENGTH     12

/* TLS 1.3 Record type for selecting the appropriate secret. */

typedef enum {

    TLS_SECRET_0RTT_APP,

    TLS_SECRET_HANDSHAKE,

    TLS_SECRET_APP,

} TLSRecordType;

#define SSL_DEBUG_USE_STDERR "-"

#define SSLV2_MAX_SESSION_ID_LENGTH_IN_BYTES 16

/* Record fragment lengths MUST NOT exceed 2^14 (= 0x4000) */

#define TLS_MAX_RECORD_LENGTH 0x4000

typedef struct _SslCipherSuite {

    int number;

    int kex;

    int enc;

    int dig;

    ssl_cipher_mode_t mode;

} SslCipherSuite;

typedef struct _SslFlow {

    uint32_t byte_seq;

    uint16_t flags;

    wmem_tree_t *multisegment_pdus;

} SslFlow;

typedef struct _SslDecompress SslDecompress;

typedef struct _SslDecoder {

    const SslCipherSuite *cipher_suite;

    int compression;

    unsigned char _mac_key_or_write_iv[48];

    StringInfo mac_key; /* for block and stream ciphers */

    StringInfo write_iv; /* for AEAD ciphers (at least GCM, CCM) */

    SSL_CIPHER_CTX sn_evp; /* used to decrypt serial number in DTLSv1.3 */

    SSL_CIPHER_CTX evp;

    SslDecompress *decomp;

    uint64_t dtls13_epoch;

    uint64_t seq;    /**< Implicit (TLS) or explicit (DTLS) record sequence number. */

    StringInfo dtls13_aad;  /**< Additional Authenticated Data for DTLS 1.3. */

    uint16_t epoch;

    SslFlow *flow;

    StringInfo app_traffic_secret;  /**< TLS 1.3 application traffic secret (if applicable), wmem file scope. */

} SslDecoder;

#define KEX_DHE_DSS     0x10

#define KEX_DHE_PSK     0x11

#define KEX_DHE_RSA     0x12

#define KEX_DH_ANON     0x13

#define KEX_DH_DSS      0x14

#define KEX_DH_RSA      0x15

#define KEX_ECDHE_ECDSA 0x16

#define KEX_ECDHE_PSK   0x17

#define KEX_ECDHE_RSA   0x18

#define KEX_ECDH_ANON   0x19

#define KEX_ECDH_ECDSA  0x1a

#define KEX_ECDH_RSA    0x1b

#define KEX_KRB5        0x1c

#define KEX_PSK         0x1d

#define KEX_RSA         0x1e

#define KEX_RSA_PSK     0x1f

#define KEX_SRP_SHA     0x20

#define KEX_SRP_SHA_DSS 0x21

#define KEX_SRP_SHA_RSA 0x22

#define KEX_IS_DH(n)    ((n) >= KEX_DHE_DSS && (n) <= KEX_ECDH_RSA)

#define KEX_TLS13       0x23

#define KEX_ECJPAKE     0x24

#define KEX_ECDHE_SM2   0x25

#define KEX_ECC_SM2     0x26

#define KEX_IBSDH_SM9   0x27

#define KEX_IBC_SM9     0x28

/* Order is significant, must match "ciphers" array in packet-tls-utils.c */

#define ENC_START       0x30

#define ENC_DES         0x30

#define ENC_3DES        0x31

#define ENC_RC4         0x32

#define ENC_RC2         0x33

#define ENC_IDEA        0x34

#define ENC_AES         0x35

#define ENC_AES256      0x36

#define ENC_CAMELLIA128 0x37

#define ENC_CAMELLIA256 0x38

#define ENC_SEED        0x39

#define ENC_CHACHA20    0x3A

#define ENC_SM1         0x3B

#define ENC_SM4         0x3C

#define ENC_NULL        0x3D

#define DIG_MD5         0x40

#define DIG_SHA         0x41

#define DIG_SHA256      0x42

#define DIG_SHA384      0x43

#define DIG_SM3         0x44

#define DIG_NA          0x45 /* Not Applicable */

typedef struct {

    const char *name;

    unsigned len;

} SslDigestAlgo;

typedef struct _SslRecordInfo {

    unsigned char *plain_data;     /**< Decrypted data. */

    unsigned plain_data_len;       /**< Total length of decrypted data,

                                        including the content type and padding

                                        if the TLS version supports them. */

    unsigned content_len;   /**< Length of the part of the decrypted data

                                 corresponding to the record content. */

    int     id;             /**< Identifies the exact record within a frame

                                 (there can be multiple records in a frame). */

    ContentType type;       /**< Content type of the decrypted record data. */

    SslFlow *flow;          /**< Flow where this record fragment is a part of.

                                 Can be NULL if this record type may not be fragmented. */

    uint64_t record_seq;    /**< Implicit (TLS) or explicit (DTLS) record sequence number. */

    uint32_t seq;            /**< Data offset within the flow. */

    struct _SslRecordInfo* next;

} SslRecordInfo;

/**

 * Stored information about a part of a reassembled handshake message. A single

 * handshake record is uniquely identified by (record_id, reassembly_id).

 */

typedef struct _TlsHsFragment {

    unsigned   record_id;      /**< Identifies the exact record within a frame

                                 (there can be multiple records in a frame). */

    unsigned   reassembly_id;  /**< Identifies the reassembly that this fragment is part of. */

    uint32_t offset;         /**< Offset within a reassembly. */

    uint8_t type;           /**< Handshake type (first byte of the buffer). */

    int     is_last : 1;    /**< Whether this fragment completes the message. */

    struct _TlsHsFragment *next;

} TlsHsFragment;

typedef struct {

    SslRecordInfo *records; /**< Decrypted records within this frame. */

    TlsHsFragment *hs_fragments;    /**< Handshake records that are part of a reassembly. */

    uint32_t srcport;        /**< Used for Decode As */

    uint32_t destport;

    uint32_t stream;       /**< Used for Follow Stream */

    int cipher;            /**< Cipher at time of Key Exchange handshake message.

                                 Session cipher can change in renegotiation. */

} SslPacketInfo;

typedef struct _SslSession {

    int cipher;

    int compression;

    uint16_t version;

    unsigned char tls13_draft_version;

    unsigned char _client_random[32];

    int8_t client_cert_type;

    int8_t server_cert_type;

    uint32_t client_ccs_frame;

    uint32_t server_ccs_frame;

    uint32_t first_ch_ech_frame;

    StringInfo client_random;

    bool ech;

    bool hrr_ech_declined;

    unsigned char ech_confirmation[8];

    unsigned char hrr_ech_confirmation[8];

    unsigned char first_ech_auth_tag[16];

    /* The address/proto/port of the server as determined from heuristics

     * (e.g. ClientHello) or set externally (via ssl_set_master_secret()). */

    address srv_addr;

    port_type srv_ptype;

    unsigned srv_port;

    uint32_t stream;

    /* The Application layer protocol if known (for STARTTLS support) */

    dissector_handle_t   app_handle;

    const char          *alpn_name;

    /* The ALPN the client requested, not necessarily the one chosen */

    const char          *client_alpn_name;

    uint32_t             last_nontls_frame;

    bool                 is_session_resumed;

    /* First pass only: track an in-progress handshake reassembly (>0) */

    uint32_t    client_hs_reassembly_id;

    uint32_t    server_hs_reassembly_id;

    /* Connection ID extension

    struct {

        opaque cid<0..2^8-1>;

    } ConnectionId;

    */

    uint8_t *client_cid;

    uint8_t *server_cid;

    uint8_t client_cid_len;

    bool client_cid_len_present;

    uint8_t server_cid_len;

    bool server_cid_len_present;

    bool deprecated_cid; /* Set when handshake is using the deprecated CID extension type */

    uint64_t dtls13_current_epoch[2]; /* max epoch (for server and client respectively) */

    uint64_t dtls13_next_seq_num[2]; /* DTLSv1.3 next expected seq number (for server and client respectively) */

} SslSession;

/* RFC 5246, section 8.1 says that the master secret is always 48 bytes */

#define SSL_MASTER_SECRET_LENGTH        48

struct cert_key_id; /* defined in epan/secrets.h */

/* This holds state information for a SSL conversation */

typedef struct _SslDecryptSession {

    unsigned char _master_secret[SSL_MASTER_SECRET_LENGTH];

    unsigned char _session_id[256];

    unsigned char _client_random[32];

    unsigned char _server_random[32];

    StringInfo session_id;

    StringInfo session_ticket;

    StringInfo server_random;

    StringInfo client_random;

    StringInfo master_secret;

    StringInfo handshake_data;

    /* the data store for this StringInfo must be allocated explicitly with a capture lifetime scope */

    StringInfo pre_master_secret;

    unsigned char _server_data_for_iv[24];

    StringInfo server_data_for_iv;

    unsigned char _client_data_for_iv[24];

    StringInfo client_data_for_iv;

    int state;

    const SslCipherSuite *cipher_suite;

    SslDecoder *server;

    SslDecoder *client;

    SslDecoder *server_new;

    SslDecoder *client_new;

#if defined(HAVE_LIBGNUTLS)

    struct cert_key_id *cert_key_id;   /**< SHA-1 Key ID of public key in certificate. */

#endif

    StringInfo psk;

    StringInfo app_data_segment;

    SslSession session;

    bool       has_early_data;

    bool       has_psk;

    bool       has_key_share;

    StringInfo ech_transcript;

} SslDecryptSession;

/* RecordNumber - RFC 9147 section 4 */

typedef struct {

    uint64_t epoch;

    uint64_t sequence_number;

} SslRecordNumber;

/* User Access Table */

typedef struct _ssldecrypt_assoc_t {

    char* ipaddr;

    char* port;

    char* protocol;

    char* keyfile;

    char* password;

} ssldecrypt_assoc_t;

typedef struct ssl_common_options {

    const char         *psk;

    const char         *keylog_filename;

} ssl_common_options_t;

/** Map from something to a (pre-)master secret */

typedef struct {

    GHashTable *session;    /* Session ID (1-32 bytes) to master secret. */

    GHashTable *tickets;    /* Session Ticket to master secret. */

    GHashTable *crandom;    /* Client Random to master secret */

    GHashTable *pre_master; /* First 8 bytes of encrypted pre-master secret to

                               pre-master secret */

    GHashTable *pms;        /* Client Random to unencrypted pre-master secret */

    /* For TLS 1.3: maps Client Random to derived secret. */

    GHashTable *tls13_client_early;

    GHashTable *tls13_client_handshake;

    GHashTable *tls13_server_handshake;

    GHashTable *tls13_client_appdata;

    GHashTable *tls13_server_appdata;

    GHashTable *tls13_early_exporter;

    GHashTable *tls13_exporter;

    GHashTable *ech_secret;

    GHashTable *ech_config;

    /* The hash tables above store the static keylog file contents and secrets

     * from any DSB, not all of which may be used, in addition to any master

     * secrets derived at runtime ([D]TLS < 1.3). These store the used

     * Client Random for exporting master secrets and derived secrets in

     * TLS Export Sessions or adding a DSB.

     */

    GHashTable *used_crandom;

} ssl_master_key_map_t;

int ssl_get_keyex_alg(int cipher);

void quic_transport_parameter_id_base_custom(char *result, uint64_t parameter_id);

bool ssldecrypt_uat_fld_ip_chk_cb(void*, const char*, unsigned, const void*, const void*, char** err);

bool ssldecrypt_uat_fld_port_chk_cb(void*, const char*, unsigned, const void*, const void*, char** err);

bool ssldecrypt_uat_fld_fileopen_chk_cb(void*, const char*, unsigned, const void*, const void*, char** err);

bool ssldecrypt_uat_fld_password_chk_cb(void*, const char*, unsigned, const void*, const void*, char** err);

char* ssl_association_info(const char* dissector_table_name, const char* table_protocol);

/** Initialize the list of sessions with connection ID */

void ssl_init_cid_list(void);

/** Release resource allocated for the list of sessions with connection ID */

void ssl_cleanup_cid_list(void);

/** Add a session to the list of sessions using connection ID */

void ssl_add_session_by_cid(SslDecryptSession *ssl);

/**

 * Return a session with a matching connection ID

 * @param tvb a buffer containing a connection ID

 * @param offset offset of the connection ID in tvb

 */

SslDecryptSession *ssl_get_session_by_cid(tvbuff_t *tvb, uint32_t offset);

/** Retrieve a SslSession, creating it if it did not already exist.

 * @param conversation The SSL conversation.

 * @param tls_handle The dissector handle for SSL or DTLS.

 * @param curr_layer_num The current protocol layer number (for nested TLS support).

 */

extern SslDecryptSession *

ssl_get_session(conversation_t *conversation, dissector_handle_t tls_handle, uint8_t curr_layer_num);

/** Look up an existing SslDecryptSession for a conversation without creating one.

 * Used by functions that query session state (cipher info, ALPN, exporters, etc.)

 * but must not create a new session as a side effect.

 * @param conversation The SSL conversation (may be NULL, returns NULL in that case).

 * @param proto_ssl The protocol index for TLS/DTLS.

 * @param curr_layer_num [D]TLS layer nesting number.

 * @return The existing SslDecryptSession, or NULL if none is found.

 */

extern SslDecryptSession *

tls_get_session(conversation_t *conversation, int proto_ssl, uint8_t curr_layer_num);

/** Resets the decryption parameters for the next decoder. */

extern void

ssl_reset_session(SslSession *session, SslDecryptSession *ssl, bool is_client);

/** Set server address and port */

extern void

ssl_set_server(SslSession *session, address *addr, port_type ptype, uint32_t port);

/** Sets the application data protocol dissector. Intended to be called by

 * protocols that encapsulate TLS instead of switching to it using STARTTLS.

 * @param tls_handle The dissector handle for TLS or DTLS.

 * @param pinfo Packet Info.

 * @param app_handle Dissector handle for the protocol inside the decrypted

 * Application Data record.

 */

WS_DLL_PUBLIC void

tls_set_appdata_dissector(dissector_handle_t tls_handle, packet_info *pinfo,

                 dissector_handle_t app_handle);

/** Marks this packet as the last one before switching to SSL that is supposed

 * to encapsulate this protocol.

 * @param tls_handle The dissector handle for SSL or DTLS.

 * @param pinfo Packet Info.

 * @param app_handle Dissector handle for the protocol inside the decrypted

 * Application Data record.

 * @return 0 for the first STARTTLS acknowledgement (success) or if tls_handle

 * is NULL. >0 if STARTTLS was started before.

 */

WS_DLL_PUBLIC uint32_t

ssl_starttls_ack(dissector_handle_t tls_handle, packet_info *pinfo,

                 dissector_handle_t app_handle);

/** Marks this packet as belonging to an SSL conversation started with STARTTLS.

 * @param tls_handle The dissector handle for SSL or DTLS.

 * @param pinfo Packet Info.

 * @param app_handle Dissector handle for the protocol inside the decrypted

 * Application Data record.

 * @return 0 for the first STARTTLS acknowledgement (success) or if tls_handle

 * is NULL. >0 if STARTTLS was started before.

 */

WS_DLL_PUBLIC uint32_t

ssl_starttls_post_ack(dissector_handle_t tls_handle, packet_info *pinfo,

                 dissector_handle_t app_handle);

extern dissector_handle_t

ssl_find_appdata_dissector(const char *name);

/** set the data and len for the stringInfo buffer. buf should be big enough to

 * contain the provided data

 @param buf the buffer to update

 @param src the data source

 @param len the source data len */

extern void

ssl_data_set(StringInfo* buf, const unsigned char* src, unsigned len);

/** alloc the data with the specified len for the stringInfo buffer.

 @param str the data source

 @param len the source data len */

extern int

ssl_data_alloc(StringInfo* str, size_t len);

extern int

ssl_cipher_setiv(SSL_CIPHER_CTX *cipher, unsigned char* iv, int iv_len);

/** Search for the specified cipher suite id

 @param num the id of the cipher suite to be searched

 @return pointer to the cipher suite struct (or NULL if not found). */

extern const SslCipherSuite *

ssl_find_cipher(int num);

/** Returns the Libgcrypt cipher identifier or 0 if unavailable. */

int

ssl_get_cipher_algo(const SslCipherSuite *cipher_suite);

/** Obtains the block size for a CBC block cipher.

 * @param cipher_suite a cipher suite as returned by ssl_find_cipher().

 * @return the block size of a cipher or 0 if unavailable.

 */

unsigned

ssl_get_cipher_blocksize(const SslCipherSuite *cipher_suite);

bool

ssl_generate_pre_master_secret(SslDecryptSession *ssl_session,

                               uint32_t length, tvbuff_t *tvb, uint32_t offset,

                               const char *ssl_psk, packet_info *pinfo,

#ifdef HAVE_LIBGNUTLS

                               GHashTable *key_hash,

#endif

                               const ssl_master_key_map_t *mk_map);

/** Expand the pre_master_secret to generate all the session information

 * (master secret, session keys, ivs)

 @param ssl_session the store for all the session data

 @return 0 on success */

extern int

ssl_generate_keyring_material(SslDecryptSession*ssl_session);

extern void

ssl_change_cipher(SslDecryptSession *ssl_session, bool server);

/** Try to decrypt an ssl record

 @param allocator scope allocation of the decrypted data

 @param ssl ssl_session the store all the session data

 @param decoder the stream decoder to be used

 @param ct the content type of this ssl record

 @param record_version the version as contained in the record

 @param ignore_mac_failed whether to ignore MAC or authenticity failures

 @param in a pointer to the ssl record to be decrypted

 @param inl the record length

 @param cid a pointer to the connection ID to use in AEAD or NULL

 @param cidl the connection ID length or 0 if cid is NULL

 @param comp_str a pointer to the store the compression data

 @param out_str a pointer to the store for the decrypted data

 @param outl the decrypted data len

 @return 0 on success */

extern int

ssl_decrypt_record(wmem_allocator_t* allocator, SslDecryptSession *ssl, SslDecoder *decoder, uint8_t ct, uint16_t record_version,

        bool ignore_mac_failed,

        const unsigned char *in, uint16_t inl, const unsigned char *cid, uint8_t cidl,

        StringInfo *comp_str, StringInfo *out_str, unsigned *outl);

/* Common part between TLS and DTLS dissectors */

/* handling of association between tls/dtls ports and clear text protocol */

extern void

ssl_association_add(const char* dissector_table_name, dissector_handle_t main_handle, dissector_handle_t subdissector_handle, unsigned port, bool tcp);

extern void

ssl_association_remove(const char* dissector_table_name, dissector_handle_t main_handle, dissector_handle_t subdissector_handle, unsigned port, bool tcp);

extern int

ssl_packet_from_server(SslSession *session, dissector_table_t table, const packet_info *pinfo);

/* Obtain information about the current TLS layer. */

SslPacketInfo *

tls_add_packet_info(int proto, packet_info *pinfo, uint8_t curr_layer_num_ssl);

/* add to packet data a copy of the specified real data */

extern void

ssl_add_record_info(int proto, packet_info *pinfo,

                    const unsigned char *plain_data, int plain_data_len, int content_len,

                    int record_id, SslFlow *flow, ContentType type, uint8_t curr_layer_num_ssl,

                    uint64_t record_seq);

/* search in packet data for the specified id; return a newly created tvb for the associated data */

extern tvbuff_t*

ssl_get_record_info(tvbuff_t *parent_tvb, int proto, packet_info *pinfo, int record_id, uint8_t curr_layer_num_ssl, SslRecordInfo **matched_record);

/* initialize/reset per capture state data (ssl sessions cache) */

extern void

ssl_common_init(ssl_master_key_map_t *master_key_map,

                StringInfo *decrypted_data, StringInfo *compressed_data);

extern void

ssl_common_cleanup(ssl_master_key_map_t *master_key_map, FILE **ssl_keylog_file,

                   StringInfo *decrypted_data, StringInfo *compressed_data);

/**

 * Access to the keys in the TLS dissector, for use by the DTLS dissector.

 * (This is a transition function, it would be nice if the static keylog file

 * contents was separated from keys derived at runtime.)

 */

WS_DLL_PUBLIC ssl_master_key_map_t *

tls_get_master_key_map(bool load_secrets);

extern bool

tls_load_psk(SslDecryptSession *tls_session, const char *tls_psk);

/* Process lines from the TLS key log and populate the secrets map. */

extern void

tls_keylog_process_lines(const ssl_master_key_map_t *mk_map, const uint8_t *data, unsigned len);

/* tries to update the secrets cache from the given filename */

extern void

ssl_load_keyfile(const char *ssl_keylog_filename, FILE **keylog_file,

                 const ssl_master_key_map_t *mk_map);

#ifdef HAVE_LIBGNUTLS

/* parse ssl related preferences (private keys and ports association strings) */

extern void

ssl_parse_key_list(const ssldecrypt_assoc_t * uats, GHashTable *key_hash, const char* dissector_table_name, dissector_handle_t main_handle, bool tcp);

#endif

extern void

ssl_finalize_decryption(SslDecryptSession *ssl, ssl_master_key_map_t *mk_map);

/**

 * Mark a Client Random as used (not just present in the keylog file),

 * to enable "Export TLS Sessions Keys" or "Inject Secrets"

 */

extern void

tls_save_crandom(SslDecryptSession *ssl, ssl_master_key_map_t *mk_map);

extern bool

tls13_generate_keys(SslDecryptSession *ssl_session, const StringInfo *secret, bool is_from_server);

extern StringInfo *

tls13_load_secret(SslDecryptSession *ssl, ssl_master_key_map_t *mk_map,

                  bool is_from_server, TLSRecordType type);

extern void

tls13_change_key(SslDecryptSession *ssl, ssl_master_key_map_t *mk_map,

                 bool is_from_server, TLSRecordType type);

extern void

tls13_key_update(SslDecryptSession *ssl, bool is_from_server);

extern bool

ssl_is_valid_content_type(uint8_t type);

extern bool

ssl_is_valid_handshake_type(uint8_t hs_type, bool is_dtls);

extern bool

tls_scan_server_hello(tvbuff_t *tvb, uint32_t offset, uint32_t offset_end,

                      uint16_t *server_version, bool *is_hrr);

extern void

ssl_try_set_version(SslSession *session, SslDecryptSession *ssl,

                    uint8_t content_type, uint8_t handshake_type,

                    bool is_dtls, uint16_t version);

extern void

ssl_calculate_handshake_hash(SslDecryptSession *ssl_session, tvbuff_t *tvb, uint32_t offset, uint32_t length, uint8_t msg_type, bool is_from_server);

/* common header fields, subtrees and expert info for SSL and DTLS dissectors */

typedef struct ssl_common_dissect {

    struct {

        int change_cipher_spec;

        int hs_exts_len;

        int hs_ext_alpn_len;

        int hs_ext_alpn_list;

        int hs_ext_alpn_str;

        int hs_ext_alpn_str_len;

        int hs_ext_cert_url_item;

        int hs_ext_cert_url_padding;

        int hs_ext_cert_url_sha1;

        int hs_ext_cert_url_type;

        int hs_ext_cert_url_url;

        int hs_ext_cert_url_url_hash_list_len;

        int hs_ext_cert_url_url_len;

        int hs_ext_cert_status_type;

        int hs_ext_cert_status_request_len;

        int hs_ext_cert_status_responder_id_list_len;

        int hs_ext_cert_status_request_extensions_len;

        int hs_ext_cert_status_request_list_len;

        int hs_ocsp_response_list_len;

        int hs_ocsp_response_len;

        int hs_ext_cert_type;

        int hs_ext_cert_types;

        int hs_ext_cert_types_len;

        int hs_ext_data;

        int hs_ext_ec_point_format;

        int hs_ext_ec_point_formats;

        int hs_ext_ec_point_formats_len;

        int hs_ext_srp_len;

        int hs_ext_srp_username;

        int hs_ext_supported_group;

        int hs_ext_supported_groups;

        int hs_ext_supported_groups_len;

        int hs_ext_ech_outer_ext;

        int hs_ext_ech_outer_ext_len;

        int hs_ech_confirm;

        int hs_ech_confirm_compute;

        int hs_ext_heartbeat_mode;

        int hs_ext_len;

        int hs_ext_npn_str;

        int hs_ext_npn_str_len;

        int hs_ext_reneg_info_len;

        int hs_ext_reneg_info;

        int hs_ext_key_share_client_length;

        int hs_ext_key_share_group;

        int hs_ext_key_share_key_exchange_length;

        int hs_ext_key_share_key_exchange;

        int hs_ext_key_share_selected_group;

        int hs_ext_psk_identities_length;

        int hs_ext_psk_identity_identity_length;

        int hs_ext_psk_identity_identity;

        int hs_ext_psk_identity_obfuscated_ticket_age;

        int hs_ext_psk_binders_length;

        int hs_ext_psk_binders;

        int hs_ext_psk_binder;

        int hs_ext_psk_binder_binder_length;

        int hs_ext_psk_binder_binder;

        int hs_ext_psk_identity_selected;

        int hs_ext_session_ticket;

        int hs_ext_supported_versions_len;

        int hs_ext_supported_version;

        int hs_ext_cookie_len;

        int hs_ext_cookie;

        int hs_ext_server_name;

        int hs_ext_server_name_len;

        int hs_ext_server_name_list_len;

        int hs_ext_server_name_type;

        int hs_ext_max_fragment_length;

        int hs_ext_padding_data;

        int hs_ext;

        int hs_ext_type;

        int hs_ext_connection_id_length;

        int hs_ext_connection_id;

        int hs_ext_trusted_ca_keys_len;

        int hs_ext_trusted_ca_keys_list;

        int hs_ext_trusted_ca_key;

        int hs_ext_trusted_ca_key_type;

        int hs_ext_trusted_ca_key_hash;

        int hs_ext_trusted_ca_key_dname_len;

        int hs_ext_trusted_ca_key_dname;

        int hs_sig_hash_alg;

        int hs_sig_hash_alg_len;

        int hs_sig_hash_algs;

        int hs_sig_hash_hash;

        int hs_sig_hash_sig;

        int hs_client_keyex_epms_len;

        int hs_client_keyex_epms;

        int hs_server_keyex_modulus_len;

        int hs_server_keyex_exponent_len;

        int hs_server_keyex_sig_len;

        int hs_server_keyex_p_len;

        int hs_server_keyex_g_len;

        int hs_server_keyex_ys_len;

        int hs_client_keyex_yc_len;

        int hs_client_keyex_point_len;

        int hs_server_keyex_point_len;

        int hs_server_keyex_p;

        int hs_server_keyex_g;

        int hs_server_keyex_curve_type;

        int hs_server_keyex_named_curve;

        int hs_server_keyex_ys;

        int hs_client_keyex_yc;

        int hs_server_keyex_point;

        int hs_client_keyex_point;

        int hs_server_keyex_xs_len;

        int hs_client_keyex_xc_len;

        int hs_server_keyex_xs;

        int hs_client_keyex_xc;

        int hs_server_keyex_vs_len;

        int hs_client_keyex_vc_len;

        int hs_server_keyex_vs;

        int hs_client_keyex_vc;

        int hs_server_keyex_rs_len;

        int hs_client_keyex_rc_len;

        int hs_server_keyex_rs;

        int hs_client_keyex_rc;

        int hs_server_keyex_modulus;

        int hs_server_keyex_exponent;

        int hs_server_keyex_sig;

        int hs_server_keyex_hint_len;

        int hs_server_keyex_hint;

        int hs_client_keyex_identity_len;

        int hs_client_keyex_identity;

        int hs_certificates_len;

        int hs_certificates;

        int hs_certificate_len;

        int hs_certificate;

        int hs_cert_types_count;

        int hs_cert_types;

        int hs_cert_type;

        int hs_dnames_len;

        int hs_dnames;

        int hs_dnames_truncated;

        int hs_dname_len;

        int hs_dname;

        int hs_random;

        int hs_random_time;

        int hs_random_bytes;

        int hs_session_id;

        int hs_session_id_len;

        int hs_client_version;

        int hs_server_version;

        int hs_cipher_suites_len;

        int hs_cipher_suites;

        int hs_cipher_suite;

        int hs_comp_methods_len;

        int hs_comp_methods;

        int hs_comp_method;

        int hs_session_ticket_lifetime_hint;

        int hs_session_ticket_age_add;

        int hs_session_ticket_nonce_len;

        int hs_session_ticket_nonce;

        int hs_session_ticket_len;

        int hs_session_ticket;

        int hs_finished;

        int hs_client_cert_vrfy_sig_len;

        int hs_client_cert_vrfy_sig;

        int hs_ja3_full;

        int hs_ja3_hash;

        int hs_ja3s_full;

        int hs_ja3s_hash;

        int hs_ja4;

        int hs_ja4_r;

        /* TLS 1.3 */

        int hs_ext_psk_ke_modes_length;

        int hs_ext_psk_ke_mode;

        int hs_certificate_request_context_length;

        int hs_certificate_request_context;

        int hs_key_update_request_update;

        int sct_scts_length;

        int sct_sct_length;

        int sct_sct_version;

        int sct_sct_logid;

        int sct_sct_timestamp;

        int sct_sct_extensions_length;

        int sct_sct_extensions;

        int sct_sct_signature;

        int sct_sct_signature_length;

        int hs_ext_max_early_data_size;

        int hs_ext_oid_filters_length;

        int hs_ext_oid_filters_oid_length;

        int hs_ext_oid_filters_oid;

        int hs_ext_oid_filters_values_length;

        int hs_cred_valid_time;

        int hs_cred_pubkey;

        int hs_cred_pubkey_len;

        int hs_cred_signature;

        int hs_cred_signature_len;

        /* compress_certificate */

        int hs_ext_compress_certificate_algorithms_length;

        int hs_ext_compress_certificate_algorithm;

        int hs_ext_compress_certificate_uncompressed_length;

        int hs_ext_compress_certificate_compressed_certificate_message_length;

        int hs_ext_compress_certificate_compressed_certificate_message;