TLS data formats. More...

#include <stdint.h>
#include <stddef.h>
#include <ipxe/asn1.h>

Data Structures
struct	tls_cursor
	A TLS variable-length data cursor. More...
union	tls_ptr_len
	A pointer/length value. More...
struct	tls_certificate
	Certificate descriptor. More...
struct	tls_certificate_entry
	CertificateEntry descriptor. More...
struct	tls_client_hello
	ClientHello descriptor. More...
struct	tls_client_key_exchange_dhe
	ClientKeyExchange descriptor (for DHE). More...
struct	tls_client_key_exchange_ecdhe
	ClientKeyExchange descriptor (for ECDHE). More...
struct	tls_client_key_exchange_pubkey
	ClientKeyExchange descriptor (for key transport). More...
union	tls_client_key_exchange
	ClientKeyExchange descriptor (unified). More...
struct	tls_digitally_signed
	DigitallySigned descriptor. More...
struct	tls_extension
	Extension descriptor. More...
struct	tls_hello_request
	HelloRequest descriptor. More...
struct	tls_key_share_client_hello
	KeyShareClientHello descriptor. More...
struct	tls_key_share_entry
	KeyShareEntry descriptor. More...
struct	tls_key_share_hello_retry_request
	KeyShareHelloRetryRequest descriptor. More...
struct	tls_key_share_server_hello
	KeyShareServerHello descriptor. More...
union	tls_key_share_server
	KeyShareServerHello/KeyShareHelloRetryRequest combined descriptor. More...
struct	tls_max_fragment_length
	MaxFragmentLength descriptor. More...
struct	tls_named_group_list
	NamedGroupList descriptor. More...
struct	tls_new_session_ticket
	NewSessionTicket descriptor. More...
struct	tls_psk_key_exchange_modes
	PskKeyExchangeModes descriptor. More...
struct	tls_renegotiation_info
	RenegotiationInfo descriptor. More...
struct	tls_server_hello
	ServerHello descriptor. More...
struct	tls_server_hello_done
	ServerHelloDone descriptor. More...
struct	tls_server_key_exchange_dhe
	ServerKeyExchange descriptor (for DHE). More...
struct	tls_server_key_exchange_ecdhe
	ServerKeyExchange descriptor (for ECDHE). More...
struct	tls_server_name
	ServerName descriptor. More...
struct	tls_server_name_list
	ServerNameList descriptor. More...
struct	tls_signature_scheme_list
	SignatureSchemeList descriptor. More...
struct	tls_supported_version
	SupportedVersions descriptor (in ServerHello). More...
struct	tls_supported_versions
	SupportedVersions descriptor (in ClientHello). More...

Macros
#define	TLS_VERSION_TLS_1_1 0x0302
	TLS version 1.1.
#define	TLS_VERSION_TLS_1_2 0x0303
	TLS version 1.2.
#define	TLS_VERSION_TLS_1_3 0x0304
	TLS version 1.3.
#define	TLS_VERSION_BASE TLS_VERSION_TLS_1_1
	Lowest configurable supported version.
#define	TLS_DESCR_COUNT(desc)
	Number of pointer/length values in a descriptor structure.
#define	TLS_DESCR_MAPPING(desc)
	Binary encoding of a descriptor structure mapping.
#define	TLS_MAPSZ(desc)
	Describe size of a descriptor mapping.
#define	TLS_INDEX(desc, field)
	Index of descriptor field.
#define	TLS_EXTNS(desc, field)
	Number of extensions of interest within an extension descriptor.
#define	TLS_FIXED(desc, version, field)
	Describe a fixed-length field.
#define	TLS_VARIABLE(desc, version, field, bits, extns)
	Describe a variable-length field.
#define	TLS_EXTRA(desc, version, field)
	Describe a variable-length field that captures all remaining data.
#define	TLS_VAR08(desc, version, field)
	Describe a variable-length field with an 8-bit length.
#define	TLS_VAR16(desc, version, field)
	Describe a variable-length field with a 16-bit length.
#define	TLS_VAR24(desc, version, field)
	Describe a variable-length field with a 24-bit length.
#define	TLS_EXT16(desc, version, field)
	Describe a variable-length field containing extensions.
#define	TLS_EXTND(desc, extension, field)
	Describe a variable-length field containing an extension of interest.
#define	TLS_MAP_MIN(byte)
	Interpret minimum version from an llllllvv byte.
#define	TLS_MAP_FIXED(byte)
	Interpret fixed length from an llllllvv byte.
#define	TLS_MAP_LEN_LEN(byte)
	Interpret number of length bytes from an xxxxxxnn byte.
#define	TLS_MAP_LEN_LEN_MAX 3
	Maximum number of length bytes.
#define	TLS_MAP_EXTENSIONS(byte)
	Interpret number of extensions from an xxxxxxnn byte.
#define	tls_parse(type, version, cursor, desc)
	Parse TLS data structure.
#define	tls_parse_opt(type, version, cursor, desc)
	Parse optional TLS data structure.
#define	tls_build(type, version, desc, cursor)
	Build TLS data structure.
#define	tls_size(type, version, desc, cursor)
	Calculate length of TLS data structure.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static const struct asn1_cursor *	tls_asn1 (const struct tls_cursor *cursor)
	Get ASN.1 cursor from TLS cursor.
int	tls_parse_map (const uint8_t map, unsigned int version, const struct tls_cursor cursor, union tls_ptr_len *desc)
	Parse TLS data structure.
int	tls_parse_opt_map (const uint8_t map, unsigned int version, const struct tls_cursor cursor, union tls_ptr_len *desc)
	Parse optional TLS data structure.
int	tls_build_map (const uint8_t map, unsigned int version, union tls_ptr_len desc, struct tls_cursor *cursor)
	Build TLS data structure.
int	tls_size_map (const uint8_t map, unsigned int version, union tls_ptr_len desc, struct tls_cursor *cursor)
	Calculate length of TLS data structure.
	TLS_DESCR_MAPPING (tls_certificate)
	TLS_DESCR_MAPPING (tls_certificate_entry)
	TLS_DESCR_MAPPING (tls_client_hello)
	TLS_DESCR_MAPPING (tls_client_key_exchange_dhe)
	TLS_DESCR_MAPPING (tls_client_key_exchange_ecdhe)
	TLS_DESCR_MAPPING (tls_client_key_exchange_pubkey)
	TLS_DESCR_MAPPING (tls_digitally_signed)
	TLS_DESCR_MAPPING (tls_extension)
	TLS_DESCR_MAPPING (tls_hello_request)
	TLS_DESCR_MAPPING (tls_key_share_client_hello)
	TLS_DESCR_MAPPING (tls_key_share_entry)
	TLS_DESCR_MAPPING (tls_key_share_hello_retry_request)
	TLS_DESCR_MAPPING (tls_key_share_server_hello)
	TLS_DESCR_MAPPING (tls_max_fragment_length)
	TLS_DESCR_MAPPING (tls_named_group_list)
	TLS_DESCR_MAPPING (tls_new_session_ticket)
	TLS_DESCR_MAPPING (tls_psk_key_exchange_modes)
	TLS_DESCR_MAPPING (tls_renegotiation_info)
	TLS_DESCR_MAPPING (tls_server_hello)
	TLS_DESCR_MAPPING (tls_server_hello_done)
	TLS_DESCR_MAPPING (tls_server_key_exchange_dhe)
	TLS_DESCR_MAPPING (tls_server_key_exchange_ecdhe)
	TLS_DESCR_MAPPING (tls_server_name)
	TLS_DESCR_MAPPING (tls_server_name_list)
	TLS_DESCR_MAPPING (tls_signature_scheme_list)
	TLS_DESCR_MAPPING (tls_supported_version)
	TLS_DESCR_MAPPING (tls_supported_versions)

Detailed Description

TLS data formats.

TLS uses an ad hoc mixture of fixed-length and variable-length fields. Variable-length fields are preceded by a length field that may be one, two, or three bytes depending on the maximum length defined by the structure.

To avoid open-coding a very large number of bounds checks, we define an abstraction for decomposing the component parts of a TLS data structure into a sequence of field data pointers and lengths (for variable-length fields), along with an efficient binary encoding that can describe the mapping between the decomposition and the raw data structure.

A fixed-length field is described using a simple pointer to the appropriate fixed-length data type. A variable-length field is described using a cursor structure that comprises a void pointer followed by a length. TLS extensions are always variable-length and so are represented in the same way as variable-length fields.

For example, the start of a ServerHello could be described using:

struct tls_server_hello {
    uint16_t *version;
    struct tls_random *random;
    struct tls_cursor session_id;
    uint16_t *suite;
    uint8_t *compression;
    struct {
        struct tls_cursor all;
        struct tls_cursor renegotiation;
        struct tls_cursor extended_master_secret;
    } ext;
};

Note that the fixed-length fields are all typed pointers, whereas the variable-length session ID uses a TLS cursor (i.e. a void pointer and a length). Since pointer values and length values are necessarily the same size, we can meaningfully treat this descriptor structure as an array ptrlen[] of pointer/length values.

We create a binary encoding to allow us to define the mapping between this descriptor structure and the raw TLS data structure using a static byte array constructed at build time. The same binary encoding may be used both for parsing and for building a TLS data structure.

Starting at index N=1 within the byte array map[]:

Interpret map[0] as the length of the map[] array. A zero array length is invalid and is treated as a fatal error.
- Upon reaching the end of the mapping (i.e. N==map[0]), stop processing.
Interpret map[N] as the eight bits llllllvv, where:
- V = vv is the minimal TLS version that includes this field (encoded as a delta from the lowest version currently supported by the codebase).
- L = llllll is one plus the length of the corresponding fixed-length data structure. An empty fixed-length data structure is pointless, and so we choose a zero fixed length (i.e. L==1) to represent a variable-length data structure. A negative fixed length (i.e. L==0) is invalid and is treated as a fatal error.
For a fixed-length data structure (with L>1):
- When parsing: store the pointer to the start of the fixed-length data as ptrlen[N-1].
- When building: append a copy of the data from ptrlen[N-1] with length L-1.
For a variable-length data structure (with L==1), interpret map[N+1] as the eight bits xxxxxxnn, where:
- N = nn is the length of the length header that precedes the variable-length data structure. A zero-byte length header is invalid, and so we choose N==0 to represent a field that covers all remaining data.
- X = xxxxxx is one plus the number of TLS extension types that immediately follow map[N+1] and that represent extensions of interest that may be present within this field. A negative number of extensions (i.e. X==0) is impossible and so we choose this to represent a field that is not used to contain extensions.
- When parsing: store the pointer to the start of the variable-length data as ptrlen[N-1], and store the decoded length of the variable-length data as ptrlen[N].
- When building: append a copy of the data from ptrlen[N-1] (with the correct N-byte length header). Take the length of the variable-length data to be X ? 0 : ptrlen[N] (i.e. always build fields that contain extensions as being empty).
For each 1<=k<=(X-1) in a variable-length data structure that is used to contain extensions (i.e. that has X>0), interpret T = map[N+2k]:map[N+2k+1] as the inverse of a TLS extension type (in network-endian order):
- If T==0, then terminate processing with a fatal error.
- When parsing: for each matching extension type ~T that is found, store the pointer to the start of the extension data as ptrlen[N+2k-1], and store the decoded length of the variable-length extension data as ptrlen[N+2k].
- When building: if ptrlen[N+2k-1] is set, then append a copy of the data from ptrlen[N+2k-1] with length ptrlen[N+2k] as an extension with type ~T (with the correct extension header, and updating the length of the containing field accordingly).
Increment N to the next uninterpreted byte, and loop.

Any parsing failure (e.g. insufficient remaining space to contain the fixed-length or variable-length structure) will be treated as a fatal error. Missing extensions of interest will not be treated as errors, and the corresponding ptrlen entries will be zeroed to indicate that the extension was not found. Duplicate extensions of interest will be treated as a fatal error. (Any extensions that are not of interest will be ignored, even if duplicated.)

The encoding allows for fixed-length fields of up to 62 bytes. Longer fixed-length fields must be expressed as a sequence of smaller fixed-length fields.

All fields must be represented using data structures that are packed and that allow for arbitrary byte alignment.

A variable-length field that covers all remaining data (i.e. with N==0) may be used for incremental parsing, as required for the variable number of entries in structures such as a TLS extension list. If no such variable-length field exists, then any leftover data will be treated as a fatal parsing error.

Up to four consecutive versions of TLS may be supported by the encoding. Experience shows that at most three versions of TLS will be supported by the codebase at any one time, and so this is likely to be sufficient in practice.

The encoding is designed to allow for efficient population of the byte array using preprocessor macros (with compile-time checks to ensure that the byte array matches the descriptor structure). A missing populator macro will leave an erroneous zero byte within the byte array, and the encoding has been designed so that stray zero bytes will fail safe: map[0]==0 is treated as a fatal error, L==0 or T==0 are treated as fatal errors, and N==0 would capture all remaining data (and so cause parsing to fail on the subsequent byte).

Definition in file tlsfmt.h.

Macro Definition Documentation

◆ TLS_VERSION_TLS_1_1

#define TLS_VERSION_TLS_1_1 0x0302

TLS version 1.1.

Definition at line 174 of file tlsfmt.h.

Referenced by tls_new_server_hello(), tls_version_name(), and tlsfmt_test_exec().

◆ TLS_VERSION_TLS_1_2

#define TLS_VERSION_TLS_1_2 0x0303

TLS version 1.2.

Definition at line 177 of file tlsfmt.h.

Referenced by TLS_DESCR_MAPPING(), tls_select_cipher(), tls_send_certificate_verify(), tls_set_digest(), tls_verify_signature(), tls_version_name(), and tlsfmt_test_exec().

◆ TLS_VERSION_TLS_1_3

#define TLS_VERSION_TLS_1_3 0x0304

TLS version 1.3.

Definition at line 180 of file tlsfmt.h.

Referenced by tls_build_map(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), tls_has_inner(), tls_keysize_is_variable(), tls_new_change_cipher(), tls_new_ciphertext(), tls_new_finished(), tls_new_server_hello(), tls_new_session_ticket(), tls_parse_map(), tls_send_finished(), tls_send_record(), tls_set_digest(), tls_validator_done(), tls_version_name(), and tlsfmt_test_exec().

◆ TLS_VERSION_BASE

#define TLS_VERSION_BASE TLS_VERSION_TLS_1_1

Lowest configurable supported version.

Definition at line 183 of file tlsfmt.h.

◆ TLS_DESCR_COUNT

#define TLS_DESCR_COUNT ( desc )

Value:

( /* Calculate count */                                         \
  ( sizeof ( struct desc ) / sizeof ( union tls_ptr_len ) ) +   \
  /* Check alignment */                                         \
  ( 0 * sizeof ( int[ -( sizeof ( struct desc ) %               \
                         sizeof ( union tls_ptr_len ) ) ] ) ) )

Number of pointer/length values in a descriptor structure.

Parameters

desc	Descriptor structure name

Return values

count Number of pointer/length values

Definition at line 207 of file tlsfmt.h.

#define TLS_DESCR_COUNT( desc )                                         \
        ( /* Calculate count */                                         \
          ( sizeof ( struct desc ) / sizeof ( union tls_ptr_len ) ) +   \
          /* Check alignment */                                         \
          ( 0 * sizeof ( int[ -( sizeof ( struct desc ) %               \
                                 sizeof ( union tls_ptr_len ) ) ] ) ) )

◆ TLS_DESCR_MAPPING

#define TLS_DESCR_MAPPING ( desc )

Value:

const uint8_t desc ## _map [ 1 /* Mapping size byte */ + \

TLS_DESCR_COUNT ( desc ) ]

uint8_t

unsigned char uint8_t

Definition stdint.h:10

Binary encoding of a descriptor structure mapping.

Parameters

desc	Descriptor structure name

Return values

map	Binary encoding of the descriptor structure mapping

Definition at line 220 of file tlsfmt.h.

#define TLS_DESCR_MAPPING( desc )                                       \
        const uint8_t desc ## _map [ 1 /* Mapping size byte */ +        \
                                     TLS_DESCR_COUNT ( desc ) ]

◆ TLS_MAPSZ

#define TLS_MAPSZ ( desc )

Value:

[0] = ( 1 /* Mapping size byte */ + TLS_DESCR_COUNT ( desc ) )

TLS_DESCR_COUNT

#define TLS_DESCR_COUNT(desc)

Number of pointer/length values in a descriptor structure.

Definition tlsfmt.h:207

Describe size of a descriptor mapping.

Parameters

desc	Descriptor stucture name

Definition at line 229 of file tlsfmt.h.

229#define TLS_MAPSZ( desc ) \

230 [0] = ( 1 /* Mapping size byte */ + TLS_DESCR_COUNT ( desc ) )

◆ TLS_INDEX

#define TLS_INDEX	(		desc,
			field )

Value:

( /* Skip mapping size byte */                                  \
  1 +                                                           \
  /* Index within ptr/len array */                              \
  ( offsetof ( struct desc, field ) /                           \
    sizeof ( union tls_ptr_len ) ) +                            \
  /* Check alignment */                                         \
  ( 0 * sizeof ( int[ -( offsetof ( struct desc, field ) %      \
                         sizeof ( union tls_ptr_len ) ) ] ) ) )

Index of descriptor field.

Parameters

desc	Descriptor structure name
field	Field name within descriptor structure

Return values

index Index within byte array or ptr/len array

Definition at line 239 of file tlsfmt.h.

#define TLS_INDEX( desc, field )                                        \
        ( /* Skip mapping size byte */                                  \
          1 +                                                           \
          /* Index within ptr/len array */                              \
          ( offsetof ( struct desc, field ) /                           \
            sizeof ( union tls_ptr_len ) ) +                            \
          /* Check alignment */                                         \
          ( 0 * sizeof ( int[ -( offsetof ( struct desc, field ) %      \
                                 sizeof ( union tls_ptr_len ) ) ] ) ) )

◆ TLS_EXTNS

#define TLS_EXTNS	(		desc,
			field )

Value:

( ( sizeof ( ( ( struct desc * ) NULL )->field ) -              \
    sizeof ( ( ( struct desc * ) NULL )->field.all ) )          \
  / sizeof ( struct tls_cursor ) )

Number of extensions of interest within an extension descriptor.

Parameters

desc	Descriptor structure name
field	Field name within descriptor structure

Return values

extns Number of extensions of interest within this field

Definition at line 256 of file tlsfmt.h.

#define TLS_EXTNS( desc, field )                                        \
        ( ( sizeof ( ( ( struct desc * ) NULL )->field ) -              \
            sizeof ( ( ( struct desc * ) NULL )->field.all ) )          \
          / sizeof ( struct tls_cursor ) )

◆ TLS_FIXED

#define TLS_FIXED	(	desc,
		version,
		field )

Value:

/* Encoded `llllllvv` */                                        \
[ TLS_INDEX ( desc, field ) ] =                                 \
        ( ( (version) - TLS_VERSION_BASE ) +                    \
          ( ( sizeof ( *( ( ( struct desc * ) NULL )->field ) ) \
              + 1 ) << 2 ) )

Describe a fixed-length field.

Parameters

desc	Descriptor structure name
version	Minimum TLS version that includes this field
field	Field name within descriptor structure

Definition at line 268 of file tlsfmt.h.

#define TLS_FIXED( desc, version, field )                               \
        /* Encoded `llllllvv` */                                        \
        [ TLS_INDEX ( desc, field ) ] =                                 \
                ( ( (version) - TLS_VERSION_BASE ) +                    \
                  ( ( sizeof ( *( ( ( struct desc * ) NULL )->field ) ) \
                      + 1 ) << 2 ) )

Referenced by TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), and TLS_DESCR_MAPPING().

◆ TLS_VARIABLE

#define TLS_VARIABLE	(	desc,
		version,
		field,
		bits,
		extns )

Value:

/* Encoded `000001vv` */                                        \
[ TLS_INDEX ( desc, field ) ] =                                 \
        ( ( (version) - TLS_VERSION_BASE ) + ( 1 << 2 ) ),      \
/* Encoded `xxxxxxnn` */                                        \
[ TLS_INDEX ( desc, field ) + 1 ] =                             \
        ( ( ( (bits) + 7 ) / 8 ) + ( (extns) << 2 ) )

Describe a variable-length field.

Parameters

desc	Descriptor structure name
version	Minimum TLS version that includes this field
field	Field name within descriptor structure
bits	Number of bits used to encode field length
extns	Number of extensions of interest plus one (if any)

Definition at line 284 of file tlsfmt.h.

#define TLS_VARIABLE( desc, version, field, bits, extns )               \
        /* Encoded `000001vv` */                                        \
        [ TLS_INDEX ( desc, field ) ] =                                 \
                ( ( (version) - TLS_VERSION_BASE ) + ( 1 << 2 ) ),      \
        /* Encoded `xxxxxxnn` */                                        \
        [ TLS_INDEX ( desc, field ) + 1 ] =                             \
                ( ( ( (bits) + 7 ) / 8 ) + ( (extns) << 2 ) )

◆ TLS_EXTRA

#define TLS_EXTRA	(	desc,
		version,
		field )

Value:

TLS_VARIABLE ( desc, version, field, 0, 0 )

TLS_VARIABLE

#define TLS_VARIABLE(desc, version, field, bits, extns)

Describe a variable-length field.

Definition tlsfmt.h:284

Describe a variable-length field that captures all remaining data.

Parameters

desc	Descriptor structure name
version	Minimum TLS version that includes this field
field	Field name within descriptor structure

Definition at line 299 of file tlsfmt.h.

299#define TLS_EXTRA( desc, version, field ) \

300 TLS_VARIABLE ( desc, version, field, 0, 0 )

Referenced by TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), and TLS_DESCR_MAPPING().

◆ TLS_VAR08

#define TLS_VAR08	(	desc,
		version,
		field )

Value:

TLS_VARIABLE ( desc, (version), field, 8, 0 )

Describe a variable-length field with an 8-bit length.

Parameters

desc	Descriptor structure name
version	Minimum TLS version that includes this field
field	Field name within descriptor structure

Definition at line 309 of file tlsfmt.h.

309#define TLS_VAR08( desc, version, field ) \

310 TLS_VARIABLE ( desc, (version), field, 8, 0 )

Referenced by TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), and TLS_DESCR_MAPPING().

◆ TLS_VAR16

#define TLS_VAR16	(	desc,
		version,
		field )

Value:

TLS_VARIABLE ( desc, (version), field, 16, 0 )

Describe a variable-length field with a 16-bit length.

Parameters

desc	Descriptor structure name
version	Minimum TLS version that includes this field
field	Field name within descriptor structure

Definition at line 319 of file tlsfmt.h.

319#define TLS_VAR16( desc, version, field ) \

320 TLS_VARIABLE ( desc, (version), field, 16, 0 )

Referenced by TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), and TLS_DESCR_MAPPING().

◆ TLS_VAR24

#define TLS_VAR24	(	desc,
		version,
		field )

Value:

TLS_VARIABLE ( desc, (version), field, 24, 0 )

Describe a variable-length field with a 24-bit length.

Parameters

desc	Descriptor structure name
version	Minimum TLS version that includes this field
field	Field name within descriptor structure

Definition at line 329 of file tlsfmt.h.

329#define TLS_VAR24( desc, version, field ) \

330 TLS_VARIABLE ( desc, (version), field, 24, 0 )

Referenced by TLS_DESCR_MAPPING(), and TLS_DESCR_MAPPING().

◆ TLS_EXT16

#define TLS_EXT16	(	desc,
		version,
		field )

Value:

TLS_VARIABLE ( desc, (version), field.all, 16, \

( TLS_EXTNS ( desc, field ) + 1 ) )

TLS_EXTNS

#define TLS_EXTNS(desc, field)

Number of extensions of interest within an extension descriptor.

Definition tlsfmt.h:256

Describe a variable-length field containing extensions.

Parameters

desc	Descriptor structure name
version	Minimum TLS version that includes this field
field	Field name within descriptor structure

Definition at line 339 of file tlsfmt.h.

#define TLS_EXT16( desc, version, field )                               \
        TLS_VARIABLE ( desc, (version), field.all, 16,                  \
                       ( TLS_EXTNS ( desc, field ) + 1 ) )

Referenced by TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), TLS_DESCR_MAPPING(), and TLS_DESCR_MAPPING().

◆ TLS_EXTND

#define TLS_EXTND	(	desc,
		extension,
		field )

Value:

[ TLS_INDEX ( desc, field ) ] =                                 \
        ( ( (extension) >> 8 ) ^ 0xff ),                        \
[ TLS_INDEX ( desc, field ) + 1 ] =                             \
        ( ( (extension) & 0xff ) ^ 0xff )

Describe a variable-length field containing an extension of interest.

Parameters

desc	Descriptor structure name
extension	Extension type
field	Field name within descriptor structure

Definition at line 350 of file tlsfmt.h.

#define TLS_EXTND( desc, extension, field )                             \
        [ TLS_INDEX ( desc, field ) ] =                                 \
                ( ( (extension) >> 8 ) ^ 0xff ),                        \
        [ TLS_INDEX ( desc, field ) + 1 ] =                             \
                ( ( (extension) & 0xff ) ^ 0xff )

Referenced by TLS_DESCR_MAPPING(), and TLS_DESCR_MAPPING().

◆ TLS_MAP_MIN

#define TLS_MAP_MIN ( byte )

Value:

( TLS_VERSION_BASE + ( (byte) & 0x03 ) )

byte

unsigned char byte

Definition smc9000.h:38

Interpret minimum version from an llllllvv byte.

Parameters

byte	Mapping byte

Return values

min	Minimum TLS version that includes this field

Definition at line 362 of file tlsfmt.h.

Referenced by tls_build_map(), and tls_parse_map().

◆ TLS_MAP_FIXED

#define TLS_MAP_FIXED ( byte )

Value:

( ( (byte) >> 2 ) - 1 )

Interpret fixed length from an llllllvv byte.

Parameters

byte	Mapping byte

Return values

fixed Fixed length

Definition at line 370 of file tlsfmt.h.

Referenced by tls_build_map(), and tls_parse_map().

◆ TLS_MAP_LEN_LEN

#define TLS_MAP_LEN_LEN ( byte )

Value:

( (byte) & 0x03 )

Interpret number of length bytes from an xxxxxxnn byte.

Parameters

byte	Mapping byte

Return values

len_len Number of length bytes

Definition at line 378 of file tlsfmt.h.

Referenced by tls_build_map(), and tls_parse_map().

◆ TLS_MAP_LEN_LEN_MAX

#define TLS_MAP_LEN_LEN_MAX 3

Maximum number of length bytes.

Definition at line 381 of file tlsfmt.h.

Referenced by tls_build_map().

◆ TLS_MAP_EXTENSIONS

#define TLS_MAP_EXTENSIONS ( byte )

Value:

( ( (byte) >> 2 ) - 1 )

Interpret number of extensions from an xxxxxxnn byte.

Parameters

byte	Mapping byte

Return values

extensions Number of extensions

Definition at line 389 of file tlsfmt.h.

Referenced by tls_build_map(), and tls_parse_map().

◆ tls_parse

#define tls_parse	(	type,
		version,
		cursor,
		desc )

Value:

tls_parse_map ( type ## _map, (version), (cursor),              \
                ( ( union tls_ptr_len * )                       \
                  ( (desc) == ( ( struct type * ) NULL ) ?      \
                    (desc) : (desc) ) ) )

Parse TLS data structure.

Parameters

type	Descriptor structure name
version	Protocol version
cursor	Cursor containing TLS data structure
desc	Data structure descriptor to fill in

Return values

rc	Return status code

Definition at line 733 of file tlsfmt.h.

#define tls_parse( type, version, cursor, desc )                        \
        tls_parse_map ( type ## _map, (version), (cursor),              \
                        ( ( union tls_ptr_len * )                       \
                          ( (desc) == ( ( struct type * ) NULL ) ?      \
                            (desc) : (desc) ) ) )

Referenced by tls_new_certificate(), tls_new_hello_request(), tls_new_server_hello(), tls_new_server_hello_done(), tls_new_session_ticket(), tls_parse_dhe(), tls_parse_ecdhe(), tls_parse_extensions(), tls_verify_signature(), and tlsfmt_test_exec().

◆ tls_parse_opt

#define tls_parse_opt	(	type,
		version,
		cursor,
		desc )

Value:

tls_parse_opt_map ( type ## _map, (version), (cursor),          \
                    ( ( union tls_ptr_len * )                   \
                      ( (desc) == ( ( struct type * ) NULL ) ?  \
                        (desc) : (desc) ) ) )

Parse optional TLS data structure.

Parameters

type	Descriptor structure name
version	Protocol version
cursor	Cursor containing TLS data structure
desc	Data structure descriptor to fill in

Return values

rc	Return status code

Definition at line 748 of file tlsfmt.h.

#define tls_parse_opt( type, version, cursor, desc )                    \
        tls_parse_opt_map ( type ## _map, (version), (cursor),          \
                            ( ( union tls_ptr_len * )                   \
                              ( (desc) == ( ( struct type * ) NULL ) ?  \
                                (desc) : (desc) ) ) )

Referenced by tls_new_server_hello().

◆ tls_build

#define tls_build	(	type,
		version,
		desc,
		cursor )

Value:

tls_build_map ( type ## _map, (version),                        \
                ( ( union tls_ptr_len * )                       \
                  ( (desc) == ( ( struct type * ) NULL ) ?      \
                    (desc) : (desc) ) ), (cursor) )

Build TLS data structure.

Parameters

type	Descriptor structure name
version	Protocol version
desc	Data structure descriptor to fill in
cursor	Cursor to contain TLS data structure

Return values

rc	Return status code

Definition at line 763 of file tlsfmt.h.

#define tls_build( type, version, desc, cursor )                        \
        tls_build_map ( type ## _map, (version),                        \
                        ( ( union tls_ptr_len * )                       \
                          ( (desc) == ( ( struct type * ) NULL ) ?      \
                            (desc) : (desc) ) ), (cursor) )

Referenced by tls_build_extensions(), tls_client_hello(), tls_send_certificate(), tls_send_certificate_verify(), and tlsfmt_test_exec().

◆ tls_size

#define tls_size	(	type,
		version,
		desc,
		cursor )

Value:

tls_size_map ( type ## _map, (version),                         \
               ( ( union tls_ptr_len * )                        \
                 ( (desc) == ( ( struct type * ) NULL ) ?       \
                   (desc) : (desc) ) ), (cursor) )

Calculate length of TLS data structure.

Parameters

type	Descriptor structure name
version	Protocol version
desc	Data structure descriptor to fill in
cursor	Cursor to contain TLS data structure

Return values

rc	Return status code

Definition at line 778 of file tlsfmt.h.

#define tls_size( type, version, desc, cursor )                         \
        tls_size_map ( type ## _map, (version),                         \
                       ( ( union tls_ptr_len * )                        \
                         ( (desc) == ( ( struct type * ) NULL ) ?       \
                           (desc) : (desc) ) ), (cursor) )

Referenced by tls_client_hello(), tls_send_certificate(), tls_send_certificate_verify(), and tlsfmt_test_exec().

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ FILE_SECBOOT()

FILE_SECBOOT ( PERMITTED )

◆ tls_asn1()

const struct asn1_cursor * tls_asn1 ( const struct tls_cursor * cursor )

inlinestatic

Get ASN.1 cursor from TLS cursor.

Parameters

cursor TLS cursor

Return values

asn1	ASN.1 object cursor

Definition at line 698 of file tlsfmt.h.

                                             {
        union {
                const struct tls_cursor tls;
                const struct asn1_cursor asn1;
        } *u = container_of ( cursor, typeof ( *u ), tls );
 
        /* Sanity check */
        build_assert ( ( ( const void * ) &u->tls.data ) == &u->asn1.data );
        build_assert ( &u->tls.len == &u->asn1.len );
 
        return &u->asn1;
}

References build_assert, container_of, typeof(), and u.

Referenced by tls_verify_signature(), and tlsfmt_test_exec().

◆ tls_parse_map()

int tls_parse_map	(	const uint8_t *	map,
		unsigned int	version,
		const struct tls_cursor *	cursor,
		union tls_ptr_len *	desc )

extern

Parse TLS data structure.

Parameters

map	Data structure descriptor mapping
version	Protocol version
cursor	Cursor containing TLS data structure
desc	Data structure descriptor to fill in

Return values

rc	Return status code

Definition at line 172 of file tlsfmt.c.

                                              {
        struct tls_cursor *field;
        void *data;
        size_t remaining;
        unsigned int count;
        unsigned int index;
        unsigned int next;
        unsigned int byte;
        unsigned int minimum;
        unsigned int len_len;
        unsigned int len;
        int fixed;
        int exts;
        int rc;
 
        /* Read initial cursor (may overlap output data structure) */
        data = cursor->data;
        remaining = cursor->len;
        DBGC2 ( map, "TLSFMT %s parsing len %zd\n",
                tls_map_name ( map ), remaining );
        DBGC2_HDA ( map, 0, data, remaining );
 
        /* Get mapping length */
        count = map[0];
        if ( ! count ) {
                DBGC ( map, "TLSFMT %s mapping has no count\n",
                       tls_map_name ( map ) );
                return -EINVAL;
        }
 
        /* Clear data structure descriptor */
        memset ( desc, 0, ( ( count - 1 ) * sizeof ( desc[0] ) ) );
 
        /* Parse data via mapping */
        for ( index = 1 ; ( next = index ) < count ; index = next ) {
 
                /* Prepare to store field description */
                field = container_of ( &desc[ index - 1 ].data,
                                       struct tls_cursor, data );
 
                /* Interpret byte as `llllllvv` */
                byte = map[next++];
                minimum = TLS_MAP_MIN ( byte );
                fixed = TLS_MAP_FIXED ( byte );
                if ( fixed < 0 ) {
                        DBGC ( map, "TLSFMT %s #%d mapping missing\n",
                               tls_map_name ( map ), index );
                        return -EINVAL;
                }
                assert ( next <= count );
 
                /* Handle fixed-length fields */
                if ( fixed ) {
                        if ( version < minimum ) {
                                DBGC2 ( map, "TLSFMT %s #%d not in version "
                                        "%d.%d\n", tls_map_name ( map ),
                                        index, ( version >> 8 ),
                                        ( version & 0xff ) );
                                continue;
                        }
                        if ( ( ( size_t ) fixed ) > remaining ) {
                                DBGC ( map, "TLSFMT %s #%d too short for "
                                       "fixed length %d:\n",
                                       tls_map_name ( map ), index, fixed );
                                DBGC_HDA ( map, 0, data, remaining );
                                return -EPROTO;
                        }
                        field->data = data;
                        DBGC2 ( map, "TLSFMT %s #%d len %d\n",
                                tls_map_name ( map ), index, fixed );
                        DBGC2_HDA ( map, 0, field->data, fixed );
                        data += fixed;
                        remaining -= fixed;
                        continue;
                }
 
                /* Interpret next byte as `xxxxxxnn` */
                if ( next >= count ) {
                        DBGC ( map, "TLSFMT %s #%d mapping overrun\n",
                               tls_map_name ( map ), index );
                        return -EINVAL;
                }
                byte = map[next++];
                len_len = TLS_MAP_LEN_LEN ( byte );
                exts = TLS_MAP_EXTENSIONS ( byte );
                if ( exts >= 0 )
                        next += ( exts * 2 );
                if ( next > count ) {
                        DBGC ( map, "TLSFMT %s #%d mapping extensions "
                               "overrun\n", tls_map_name ( map ), index );
                        return -EINVAL;
                }
                if ( version < minimum ) {
                        DBGC2 ( map, "TLSFMT %s #%d not in version %d.%d\n",
                                tls_map_name ( map ), index, ( version >> 8 ),
                                ( version & 0xff ) );
                        continue;
                }
 
                /* Allow for optional extensions fields */
                if ( ( exts >= 0 ) && ( ! remaining ) &&
                     ( version < TLS_VERSION_TLS_1_3 ) ) {
                        DBGC2 ( map, "TLSFMT %s #%d optional in version "
                                "%d.%d\n", tls_map_name ( map ), index,
                                ( version >> 8 ), ( version & 0xff ) );
                        continue;
                }
 
                /* Handle variable-length fields */
                if ( remaining < len_len ) {
                        DBGC ( map, "TLSFMT %s #%d too short for %d-byte "
                               "variable length:\n", tls_map_name ( map ),
                               index, len_len );
                        DBGC_HDA ( map, 0, data, remaining );
                        return -EPROTO;
                }
                if ( len_len ) {
                        for ( len = 0 ; len_len ; len_len-- ) {
                                len <<= 8;
                                len |= *( ( const uint8_t * ) data++ );
                                remaining--;
                        }
                } else {
                        len = remaining;
                }
                if ( remaining < len ) {
                        DBGC ( map, "TLSFMT %s #%d too short for variable "
                               "length %d:\n",
                               tls_map_name ( map ), index, len );
                        DBGC_HDA ( map, 0, data, remaining );
                        return -EPROTO;
                }
                field->data = data;
                field->len = len;
                DBGC2 ( map, "TLSFMT %s #%d len %zd\n",
                        tls_map_name ( map ), index, field->len );
                DBGC2_HDA ( map, 0, field->data, field->len );
                data += len;
                remaining -= len;
                if ( exts < 0 )
                        continue;
 
                /* Handle fields containing extensions */
                if ( ( rc = tls_parse_extensions ( map, index, field,
                                                   exts ) ) != 0 ) {
                        return rc;
                }
        }
 
        /* Check that all data was consumed */
        if ( remaining ) {
                DBGC ( map, "TLSFMT %s has excess data:\n",
                       tls_map_name ( map ) );
                DBGC_HDA ( map, 0, data, remaining );
                return -EPROTO;
        }
 
        return 0;
}

References assert, container_of, count, data, tls_cursor::data, DBGC, DBGC2, DBGC2_HDA, DBGC_HDA, desc, EINVAL, EPROTO, fixed, index, len, tls_cursor::len, map, memset(), next, rc, TLS_MAP_EXTENSIONS, TLS_MAP_FIXED, TLS_MAP_LEN_LEN, TLS_MAP_MIN, tls_map_name(), tls_parse_extensions(), TLS_VERSION_TLS_1_3, and version.

Referenced by tls_parse_opt_map().

◆ tls_parse_opt_map()

int tls_parse_opt_map	(	const uint8_t *	map,
		unsigned int	version,
		const struct tls_cursor *	cursor,
		union tls_ptr_len *	desc )

extern

Parse optional TLS data structure.

Parameters

map	Data structure descriptor mapping
version	Protocol version
cursor	Cursor containing TLS data structure
desc	Data structure descriptor to fill in

Return values

rc	Return status code

Definition at line 343 of file tlsfmt.c.

                                                  {
        unsigned int count;
        int rc;
 
        /* Get mapping length */
        count = map[0];
        if ( ! count ) {
                DBGC ( map, "TLSFMT %s mapping has no count\n",
                       tls_map_name ( map ) );
                return -EINVAL;
        }
 
        /* Clear data structure descriptor */
        memset ( desc, 0, ( ( count - 1 ) * sizeof ( desc[0] ) ) );
 
        /* Do nothing if optional data structure is not present */
        if ( ! cursor->data )
                return 0;
 
        /* Parse data structure */
        if ( ( rc = tls_parse_map ( map, version, cursor, desc ) ) != 0 )
                return rc;
 
        return 0;
}

References count, tls_cursor::data, DBGC, desc, EINVAL, map, memset(), rc, tls_map_name(), tls_parse_map(), and version.

Referenced by tls_new_server_hello().

◆ tls_build_map()

int tls_build_map	(	const uint8_t *	map,
		unsigned int	version,
		union tls_ptr_len *	desc,
		struct tls_cursor *	cursor )

extern

Build TLS data structure.

Parameters

map	Data structure descriptor mapping
version	Protocol version
desc	Data structure descriptor
cursor	Cursor to contain TLS data structure

Return values

rc	Return status code

Build a TLS data structure at the cursor. The cursor's original length will be ignored and will be set to the overall length of the built data structure. The caller must ensure that sufficient space already exists (e.g. by calling tls_size() first to determine the required length).

The overall length will be calculated based on the variable lengths within the descriptor. The output content will be be copied from any non-NULL pointers within the descriptor (with any missing content initialised to zero).

Pointers within the descriptor will be updated to point to the appropriate location within the built data structure.

The caller must therefore fill in any variable lengths within the descriptor beforehand, but may freely choose to either fill in pointers within the descriptor beforehand or to write through the updated pointers afterwards.

A cursor with a NULL data pointer may be used to calculate the required length without copying in any data or updating any pointers within the descriptor.

Definition at line 468 of file tlsfmt.c.

                                                                         {
        struct tls_cursor *field;
        void *data;
        size_t len;
        size_t max;
        unsigned int count;
        unsigned int index;
        unsigned int next;
        unsigned int byte;
        unsigned int minimum;
        unsigned int len_len;
        int fixed;
        int exts;
        int rc;
 
        /* Read initial cursor (may overlap output data structure) */
        data = cursor->data;
        len = 0;
 
        /* Get mapping length */
        count = map[0];
        if ( ! count ) {
                DBGC ( map, "TLSFMT %s mapping has no count\n",
                       tls_map_name ( map ) );
                return -EINVAL;
        }
 
        /* Accumulate total length via mapping */
        for ( index = 1 ; ( next = index ) < count ; index = next ) {
 
                /* Prepare to read field description */
                field = container_of ( &desc[ index - 1 ].data,
                                       struct tls_cursor, data );
 
                /* Interpret byte as `llllllvv` */
                byte = map[next++];
                minimum = TLS_MAP_MIN ( byte );
                fixed = TLS_MAP_FIXED ( byte );
                if ( fixed < 0 ) {
                        DBGC ( map, "TLSFMT %s #%d mapping missing\n",
                               tls_map_name ( map ), index );
                        return -EINVAL;
                }
                assert ( next <= count );
 
                /* Handle fixed-length fields */
                if ( fixed ) {
                        if ( version < minimum ) {
                                DBGC2 ( map, "TLSFMT %s #%d not in version "
                                        "%d.%d\n", tls_map_name ( map ),
                                        index, ( version >> 8 ),
                                        ( version & 0xff ) );
                                continue;
                        }
                        DBGC2 ( map, "TLSFMT %s #%d len %d\n",
                                tls_map_name ( map ), index, fixed );
                        len += fixed;
                        if ( data ) {
                                if ( field->data ) {
                                        memcpy ( data, field->data, fixed );
                                } else {
                                        memset ( data, 0, fixed );
                                }
                                field->data = data;
                                data += fixed;
                                DBGC2_HDA ( map, 0, field->data, fixed );
                        }
                        continue;
                }
 
                /* Interpret next byte as `xxxxxxnn` */
                if ( next >= count ) {
                        DBGC ( map, "TLSFMT %s #%d mapping overrun\n",
                               tls_map_name ( map ), index );
                        return -EINVAL;
                }
                byte = map[next++];
                len_len = TLS_MAP_LEN_LEN ( byte );
                exts = TLS_MAP_EXTENSIONS ( byte );
                if ( exts >= 0 )
                        next += ( exts * 2 );
                if ( next > count ) {
                        DBGC ( map, "TLSFMT %s #%d mapping extensions "
                               "overrun\n", tls_map_name ( map ), index );
                        return -EINVAL;
                }
                if ( version < minimum ) {
                        DBGC2 ( map, "TLSFMT %s #%d not in version %d.%d\n",
                                tls_map_name ( map ), index, ( version >> 8 ),
                                ( version & 0xff ) );
                        continue;
                }
 
                /* Handle variable-length fields */
                max = ( len_len ? ( ( 1 << ( 8 * len_len ) ) - 1 ) :
                        ( ( 1 << ( 8 * TLS_MAP_LEN_LEN_MAX ) ) - 1 ) );
                if ( exts >= 0 ) {
                        field->data = ( data ? ( data + len_len ) : NULL );
                        if ( ( rc = tls_build_extensions ( map, index, field,
                                                           exts ) ) != 0 ) {
                                return rc;
                        }
                }
                if ( field->len > max ) {
                        DBGC ( map, "TLSFMT %s #%d len %zd too long\n",
                               tls_map_name ( map ), index, field->len );
                        return -ERANGE;
                }
 
                /* Allow for optional extensions fields */
                if ( ( exts >= 0 ) && ( ! field->len ) &&
                     ( version < TLS_VERSION_TLS_1_3 ) ) {
                        DBGC2 ( map, "TLSFMT %s #%d optional in version "
                                "%d.%d\n", tls_map_name ( map ), index,
                                ( version >> 8 ), ( version & 0xff ) );
                        continue;
                }
 
                /* Build field */
                DBGC2 ( map, "TLSFMT %s #%d len %zd\n",
                        tls_map_name ( map ), index, field->len );
                len += ( len_len + field->len );
                if ( data ) {
                        while ( len_len-- ) {
                                *( ( uint8_t * ) data++ ) =
                                        ( field->len >> ( 8 * len_len ) );
                        }
                        if ( exts < 0 ) {
                                if ( field->data ) {
                                        memcpy ( data, field->data,
                                                 field->len );
                                } else {
                                        memset ( data, 0, field->len );
                                }
                        }
                        field->data = data;
                        data += field->len;
                        DBGC2_HDA ( map, 0, field->data, field->len );
                }
        }
 
        /* Update cursor (may overlap output data structure) */
        cursor->len = len;
        DBGC2 ( map, "TLSFMT %s built len %zd\n",
                tls_map_name ( map ), cursor->len );
        if ( data )
                DBGC2_HDA ( map, 0, ( data - cursor->len ), cursor->len );
 
        return 0;
}

References assert, container_of, count, data, tls_cursor::data, DBGC, DBGC2, DBGC2_HDA, desc, EINVAL, ERANGE, fixed, index, len, tls_cursor::len, map, max, memcpy(), memset(), next, NULL, rc, tls_build_extensions(), TLS_MAP_EXTENSIONS, TLS_MAP_FIXED, TLS_MAP_LEN_LEN, TLS_MAP_LEN_LEN_MAX, TLS_MAP_MIN, tls_map_name(), TLS_VERSION_TLS_1_3, and version.

Referenced by tls_send_client_key_exchange(), and tls_size_map().

◆ tls_size_map()

int tls_size_map	(	const uint8_t *	map,
		unsigned int	version,
		union tls_ptr_len *	desc,
		struct tls_cursor *	cursor )

extern

Calculate length of TLS data structure.

Parameters

type	Descriptor structure name
version	Protocol version
desc	Data structure descriptor to fill in
cursor	Cursor to contain TLS data structure

Return values

rc	Return status code

The cursor size will be set to the overall length required to contain the TLS data structure, and the cursor data pointer will be set to NULL.

If this function returns successfully, then a subsequent call to tls_build() with the exact same inputs is guaranteed to succeed and need not be checked for an error return status. The data structure descriptor must not be modified in any way that would affect its length before calling tls_build(): the easiest way to ensure this is to not modify the data structure descriptor at all.

If this function fails, then the cursor length will be set to a value that is too large to be represented by a 24-bit length field. If the cursor itself lies within a containing data structure descriptor (e.g. if tls_size() is being used to calculate the size of an extension within a ClientHello descriptor), then this guarantees that a subsequent call to tls_size() on the containing descriptor will also fail. The caller therefore need only check the return status code from the call to tls_size() for the outermost descriptor.

Note that this optimisation applies only when the result cursor lies within a containing data structure descriptor and so is guaranteed to be consumed by a subsequent call to calculate the length of that containing TLS data structure. If a caller is using the result from tls_size() in any other way (e.g. to add up the lengths of a sequence of CertificateEntry structures), then the caller must check the return status code in the normal way.

Definition at line 658 of file tlsfmt.c.

                                                                        {
        int rc;
 
        /* Calculate length */
        cursor->data = NULL;
        if ( ( rc = tls_build_map ( map, version, desc, cursor ) ) != 0 ) {
                /* Set an uncontainable length on error */
                cursor->len = -1UL;
                return rc;
        }
 
        return 0;
}

References tls_cursor::data, desc, tls_cursor::len, map, NULL, rc, tls_build_map(), and version.

Referenced by tls_send_client_key_exchange().

◆ TLS_DESCR_MAPPING() [1/27]

TLS_DESCR_MAPPING ( tls_certificate )

extern

◆ TLS_DESCR_MAPPING() [2/27]

TLS_DESCR_MAPPING ( tls_certificate_entry )

extern

◆ TLS_DESCR_MAPPING() [3/27]

TLS_DESCR_MAPPING ( tls_client_hello )

extern

◆ TLS_DESCR_MAPPING() [4/27]

TLS_DESCR_MAPPING ( tls_client_key_exchange_dhe )

extern

◆ TLS_DESCR_MAPPING() [5/27]

TLS_DESCR_MAPPING ( tls_client_key_exchange_ecdhe )

extern

◆ TLS_DESCR_MAPPING() [6/27]

TLS_DESCR_MAPPING ( tls_client_key_exchange_pubkey )

extern

◆ TLS_DESCR_MAPPING() [7/27]

TLS_DESCR_MAPPING ( tls_digitally_signed )

extern

◆ TLS_DESCR_MAPPING() [8/27]

TLS_DESCR_MAPPING ( tls_extension )

extern

◆ TLS_DESCR_MAPPING() [9/27]

TLS_DESCR_MAPPING ( tls_hello_request )

extern

◆ TLS_DESCR_MAPPING() [10/27]

TLS_DESCR_MAPPING ( tls_key_share_client_hello )

extern

◆ TLS_DESCR_MAPPING() [11/27]

TLS_DESCR_MAPPING ( tls_key_share_entry )

extern

◆ TLS_DESCR_MAPPING() [12/27]

TLS_DESCR_MAPPING ( tls_key_share_hello_retry_request )

extern

◆ TLS_DESCR_MAPPING() [13/27]

TLS_DESCR_MAPPING ( tls_key_share_server_hello )

extern

◆ TLS_DESCR_MAPPING() [14/27]

TLS_DESCR_MAPPING ( tls_max_fragment_length )

extern

◆ TLS_DESCR_MAPPING() [15/27]

TLS_DESCR_MAPPING ( tls_named_group_list )

extern

◆ TLS_DESCR_MAPPING() [16/27]

TLS_DESCR_MAPPING ( tls_new_session_ticket )

extern

◆ TLS_DESCR_MAPPING() [17/27]

TLS_DESCR_MAPPING ( tls_psk_key_exchange_modes )

extern

◆ TLS_DESCR_MAPPING() [18/27]

TLS_DESCR_MAPPING ( tls_renegotiation_info )

extern

◆ TLS_DESCR_MAPPING() [19/27]

TLS_DESCR_MAPPING ( tls_server_hello )

extern

◆ TLS_DESCR_MAPPING() [20/27]

TLS_DESCR_MAPPING ( tls_server_hello_done )

extern

◆ TLS_DESCR_MAPPING() [21/27]

TLS_DESCR_MAPPING ( tls_server_key_exchange_dhe )

extern

◆ TLS_DESCR_MAPPING() [22/27]

TLS_DESCR_MAPPING ( tls_server_key_exchange_ecdhe )

extern

◆ TLS_DESCR_MAPPING() [23/27]

TLS_DESCR_MAPPING ( tls_server_name )

extern

◆ TLS_DESCR_MAPPING() [24/27]

TLS_DESCR_MAPPING ( tls_server_name_list )

extern

◆ TLS_DESCR_MAPPING() [25/27]

TLS_DESCR_MAPPING ( tls_signature_scheme_list )

extern

◆ TLS_DESCR_MAPPING() [26/27]

TLS_DESCR_MAPPING ( tls_supported_version )

extern

◆ TLS_DESCR_MAPPING() [27/27]

TLS_DESCR_MAPPING ( tls_supported_versions )

extern

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ TLS_VERSION_TLS_1_1

◆ TLS_VERSION_TLS_1_2

◆ TLS_VERSION_TLS_1_3

◆ TLS_VERSION_BASE

◆ TLS_DESCR_COUNT

◆ TLS_DESCR_MAPPING

◆ TLS_MAPSZ

◆ TLS_INDEX

◆ TLS_EXTNS

◆ TLS_FIXED

◆ TLS_VARIABLE

◆ TLS_EXTRA

◆ TLS_VAR08

◆ TLS_VAR16

◆ TLS_VAR24

◆ TLS_EXT16

◆ TLS_EXTND

◆ TLS_MAP_MIN

◆ TLS_MAP_FIXED

◆ TLS_MAP_LEN_LEN

◆ TLS_MAP_LEN_LEN_MAX

◆ TLS_MAP_EXTENSIONS

◆ tls_parse

◆ tls_parse_opt

◆ tls_build

◆ tls_size

Function Documentation

◆ FILE_LICENCE()

◆ FILE_SECBOOT()

◆ tls_asn1()

◆ tls_parse_map()

◆ tls_parse_opt_map()

◆ tls_build_map()

◆ tls_size_map()

◆ TLS_DESCR_MAPPING() [1/27]

◆ TLS_DESCR_MAPPING() [2/27]

◆ TLS_DESCR_MAPPING() [3/27]

◆ TLS_DESCR_MAPPING() [4/27]

◆ TLS_DESCR_MAPPING() [5/27]

◆ TLS_DESCR_MAPPING() [6/27]

◆ TLS_DESCR_MAPPING() [7/27]

◆ TLS_DESCR_MAPPING() [8/27]

◆ TLS_DESCR_MAPPING() [9/27]

◆ TLS_DESCR_MAPPING() [10/27]

◆ TLS_DESCR_MAPPING() [11/27]

◆ TLS_DESCR_MAPPING() [12/27]

◆ TLS_DESCR_MAPPING() [13/27]

◆ TLS_DESCR_MAPPING() [14/27]

◆ TLS_DESCR_MAPPING() [15/27]

◆ TLS_DESCR_MAPPING() [16/27]

◆ TLS_DESCR_MAPPING() [17/27]

◆ TLS_DESCR_MAPPING() [18/27]

◆ TLS_DESCR_MAPPING() [19/27]

◆ TLS_DESCR_MAPPING() [20/27]

◆ TLS_DESCR_MAPPING() [21/27]

◆ TLS_DESCR_MAPPING() [22/27]

◆ TLS_DESCR_MAPPING() [23/27]

◆ TLS_DESCR_MAPPING() [24/27]

◆ TLS_DESCR_MAPPING() [25/27]

◆ TLS_DESCR_MAPPING() [26/27]

◆ TLS_DESCR_MAPPING() [27/27]