tlsfmt.c File Reference

TLS data formats. More...

#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/tls.h>
#include <ipxe/tlsfmt.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static const char *	tls_map_name (const uint8_t *map)
	Get data structure descriptor mapping name (for debugging).
static int	tls_parse_extensions (const uint8_t *map, unsigned int index, struct tls_cursor *fields, unsigned int count)
	Parse TLS extensions within a data structure.
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.
static int	tls_build_extensions (const uint8_t *map, unsigned int index, struct tls_cursor *fields, unsigned int count)
	Build TLS extensions within a 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.
	TLS_DESCR_MAPPING (tls_certificate)
	Certificate descriptor mapping.
	TLS_DESCR_MAPPING (tls_certificate_entry)
	CertificateEntry descriptor mapping.
	TLS_DESCR_MAPPING (tls_digitally_signed)
	DigitallySigned descriptor mapping.
	TLS_DESCR_MAPPING (tls_extension)
	Extension descriptor mapping.
	TLS_DESCR_MAPPING (tls_hello_request)
	HelloRequest descriptor mapping.
	TLS_DESCR_MAPPING (tls_key_share_entry)
	KeyShareEntry descriptor mapping.
	TLS_DESCR_MAPPING (tls_new_session_ticket)
	NewSessionTicket descriptor mapping.
	TLS_DESCR_MAPPING (tls_renegotiation_info)
	RenegotiationInfo descriptor mapping.
	TLS_DESCR_MAPPING (tls_server_hello)
	ServerHello descriptor mapping.
	TLS_DESCR_MAPPING (tls_server_hello_done)
	ServerHello descriptor mapping.
	TLS_DESCR_MAPPING (tls_server_key_exchange_dhe)
	ServerKeyExchange descriptor mapping (for DHE).
	TLS_DESCR_MAPPING (tls_server_key_exchange_ecdhe)
	ServerKeyExchange descriptor mapping (for EcDHE).
	TLS_DESCR_MAPPING (tls_supported_version)
	SupportedVersions descriptor mapping (in ServerHello).
	TLS_DESCR_MAPPING (tls_supported_versions)
	SupportedVersions descriptor mapping (in ClientHello).

Detailed Description

TLS data formats.

Definition in file tlsfmt.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

tls_map_name()

const char * tls_map_name ( const uint8_t * map )

static

Get data structure descriptor mapping name (for debugging).

Parameters

map	Data structure descriptor mapping

Return values

name	Data structure name

Definition at line 45 of file tlsfmt.c.

                                                        {
 
        if ( map == tls_certificate_map ) {
                return "Certificate";
        } else if ( map == tls_certificate_entry_map ) {
                return "CertificateEntry";
        } else if ( map == tls_digitally_signed_map ) {
                return "DigitallySigned";
        } else if ( map == tls_extension_map ) {
                return "Extension";
        } else if ( map == tls_hello_request_map ) {
                return "HelloRequest";
        } else if ( map == tls_key_share_entry_map ) {
                return "KeyShareEntry";
        } else if ( map == tls_new_session_ticket_map ) {
                return "NewSessionTicket";
        } else if ( map == tls_renegotiation_info_map ) {
                return "RenegotiationInfo";
        } else if ( map == tls_server_hello_map ) {
                return "ServerHello";
        } else if ( map == tls_server_hello_done_map ) {
                return "ServerHelloDone";
        } else if ( ( map == tls_server_key_exchange_dhe_map ) ||
                    ( map == tls_server_key_exchange_ecdhe_map ) ) {
                return "ServerKeyExchange";
        } else if ( ( map == tls_supported_versions_map ) ||
                    ( map == tls_supported_version_map ) ) {
                return "SupportedVersions";
        } else {
                return "<UNKNOWN>";
        }
}

References map.

Referenced by tls_build_extensions(), tls_build_map(), tls_parse_extensions(), tls_parse_map(), and tls_parse_opt_map().

tls_parse_extensions()

int tls_parse_extensions ( const uint8_t * map, unsigned int index, struct tls_cursor * fields, unsigned int count )

static

Parse TLS extensions within a data structure.

Parameters

map	Data structure descriptor mapping
index	Current index within mapping
fields	Extensions data fields
count	Number of extensions

Return values

rc	Return status code

Definition at line 87 of file tlsfmt.c.

                                                       {
        const uint16_t __attribute__ (( aligned ( 1 ) )) *invtypes;
        const struct tls_cursor *cursor = &fields[0];
        struct tls_extension extension;
        unsigned int i;
        uint16_t type;
        int rc;
 
        /* Extension types are encoded as inverted */
        invtypes = ( ( const void * ) &map[index] );
        for ( i = 1 ; i <= count ; i++ ) {
                if ( ! invtypes[i] ) {
                        DBGC ( map, "TLSFMT %s #%d mapping missing extension "
                               "%d\n", tls_map_name ( map ), index, i );
                        return -EINVAL;
                }
        }
 
        /* Parse extensions */
        for ( ; cursor->len ; cursor = &extension.next ) {
 
                /* Parse next extension */
                if ( ( rc = tls_parse ( tls_extension, TLS_VERSION_BASE,
                                        cursor, &extension ) ) != 0 )
                        return rc;
 
                /* Scan for matching extensions */
                for ( i = 1 ; i <= count ; i++ ) {
                        type = ~invtypes[i];
                        if ( type != *(extension.type) )
                                continue;
                        if ( fields[i].data ) {
                                DBGC ( map, "TLSFMT %s #%d has duplicate "
                                       "extension %#04x\n",
                                       tls_map_name ( map ), index,
                                       ntohs ( type ) );
                                return -EPROTO;
                        }
                        fields[i].data = extension.data.data;
                        fields[i].len = extension.data.len;
                        DBGC2 ( map, "TLSFMT %s #%d extension %#04x len "
                                "%zd\n", tls_map_name ( map ), index,
                                ntohs ( type ), fields[i].len );
                        DBGC2_HDA ( map, 0, fields[i].data, fields[i].len );
                }
        }
 
        return 0;
}

References __attribute__, count, data, tls_cursor::data, tls_extension::data, DBGC, DBGC2, DBGC2_HDA, EINVAL, EPROTO, index, len, tls_cursor::len, map, tls_extension::next, ntohs, rc, tls_map_name(), tls_parse, TLS_VERSION_BASE, tls_extension::type, and type.

Referenced by tls_parse_map().

tls_parse_map()

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.

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

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 319 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.

tls_build_extensions()

int tls_build_extensions ( const uint8_t * map, unsigned int index, struct tls_cursor * fields, unsigned int count )

static

Build TLS extensions within a data structure.

Parameters

map	Data structure descriptor mapping
index	Current index within mapping
fields	Extensions data fields
count	Number of extensions

Return values

rc	Return status code

Definition at line 356 of file tlsfmt.c.

                                                       {
        const uint16_t __attribute__ (( aligned ( 1 ) )) *invtypes;
        struct tls_cursor *cursor = &fields[0];
        struct tls_cursor *subcursor;
        struct tls_extension extension;
        unsigned int i;
        uint16_t type;
        int rc;
 
        /* Prepare per-extension subcursor */
        subcursor = &extension.next;
        subcursor->data = cursor->data;
        cursor->len = 0;
 
        /* Extension types are encoded as inverted */
        invtypes = ( ( const void * ) &map[index] );
        for ( i = 1 ; i <= count ; i++ ) {
                if ( ! invtypes[i] ) {
                        DBGC ( map, "TLSFMT %s #%d mapping missing extension "
                               "%d\n", tls_map_name ( map ), index, i );
                        return -EINVAL;
                }
        }
 
        /* Build extensions */
        for ( i = 1 ; i <= count ; i++ ) {
 
                /* Skip extensions that will not be included */
                if ( ! ( fields[i].data || fields[i].len ) )
                        continue;
 
                /* Build extension */
                type = ~invtypes[i];
                extension.type = &type;
                extension.data = fields[i];
                extension.next.len = 0;
                if ( ( rc = tls_build ( tls_extension, TLS_VERSION_BASE,
                                        &extension, subcursor ) ) != 0 ) {
                        return rc;
                }
                fields[i].len = extension.data.len;
                DBGC2 ( map, "TLSFMT %s #%d extension %#04x len %zd\n",
                        tls_map_name ( map ), index, ntohs ( type ),
                        fields[i].len );
                cursor->len += subcursor->len;
                if ( cursor->data ) {
                        fields[i].data = extension.data.data;
                        DBGC2_HDA ( map, 0, fields[i].data, fields[i].len );
                }
        }
 
        return 0;
}

References __attribute__, count, data, tls_cursor::data, tls_extension::data, DBGC, DBGC2, DBGC2_HDA, EINVAL, index, len, tls_cursor::len, map, tls_extension::next, ntohs, rc, tls_build, tls_map_name(), TLS_VERSION_BASE, tls_extension::type, and type.

Referenced by tls_build_map().

tls_build_map()

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

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 444 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, cursor->data, 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_size_map().

TLS_DESCR_MAPPING() [1/14]

TLS_DESCR_MAPPING

(

tls_certificate

)

Certificate descriptor mapping.

References TLS_MAPSZ, TLS_VAR08, TLS_VAR24, TLS_VERSION_BASE, and TLS_VERSION_TLS_1_3.

TLS_DESCR_MAPPING() [2/14]

TLS_DESCR_MAPPING

(

tls_certificate_entry

)

CertificateEntry descriptor mapping.

References ext, next, TLS_EXT16, TLS_EXTRA, TLS_MAPSZ, TLS_VAR24, TLS_VERSION_BASE, and TLS_VERSION_TLS_1_3.

TLS_DESCR_MAPPING() [3/14]

TLS_DESCR_MAPPING

(

tls_digitally_signed

)

DigitallySigned descriptor mapping.

References sig, TLS_FIXED, TLS_MAPSZ, TLS_VAR16, TLS_VERSION_BASE, and TLS_VERSION_TLS_1_2.

TLS_DESCR_MAPPING() [4/14]

TLS_DESCR_MAPPING

(

tls_extension

)

Extension descriptor mapping.

References data, next, TLS_EXTRA, TLS_FIXED, TLS_MAPSZ, TLS_VAR16, TLS_VERSION_BASE, and type.

TLS_DESCR_MAPPING() [5/14]

TLS_DESCR_MAPPING

(

tls_hello_request

)

HelloRequest descriptor mapping.

References TLS_MAPSZ.

TLS_DESCR_MAPPING() [6/14]

TLS_DESCR_MAPPING

(

tls_key_share_entry

)

KeyShareEntry descriptor mapping.

References group, next, TLS_EXTRA, TLS_FIXED, TLS_MAPSZ, TLS_VAR16, and TLS_VERSION_BASE.

TLS_DESCR_MAPPING() [7/14]

TLS_DESCR_MAPPING

(

tls_new_session_ticket

)

NewSessionTicket descriptor mapping.

References age, ext, lifetime, nonce, TLS_EXT16, TLS_FIXED, TLS_MAPSZ, TLS_VAR08, TLS_VAR16, TLS_VERSION_BASE, and TLS_VERSION_TLS_1_3.

TLS_DESCR_MAPPING() [8/14]

TLS_DESCR_MAPPING

(

tls_renegotiation_info

)

RenegotiationInfo descriptor mapping.

References TLS_MAPSZ, TLS_VAR08, and TLS_VERSION_BASE.

TLS_DESCR_MAPPING() [9/14]

TLS_DESCR_MAPPING

(

tls_server_hello

)

ServerHello descriptor mapping.

References ext, TLS_EXT16, TLS_EXTENDED_MASTER_SECRET, TLS_EXTND, TLS_FIXED, TLS_KEY_SHARE, TLS_MAPSZ, TLS_RENEGOTIATION_INFO, TLS_SUPPORTED_VERSIONS, TLS_VAR08, and TLS_VERSION_BASE.

TLS_DESCR_MAPPING() [10/14]

TLS_DESCR_MAPPING

(

tls_server_hello_done

)

ServerHello descriptor mapping.

References TLS_MAPSZ.

TLS_DESCR_MAPPING() [11/14]

TLS_DESCR_MAPPING

(

tls_server_key_exchange_dhe

)

ServerKeyExchange descriptor mapping (for DHE).

References TLS_EXTRA, TLS_MAPSZ, TLS_VAR16, and TLS_VERSION_BASE.

TLS_DESCR_MAPPING() [12/14]

TLS_DESCR_MAPPING

(

tls_server_key_exchange_ecdhe

)

ServerKeyExchange descriptor mapping (for EcDHE).

References TLS_EXTRA, TLS_FIXED, TLS_MAPSZ, TLS_VAR08, and TLS_VERSION_BASE.

TLS_DESCR_MAPPING() [13/14]

TLS_DESCR_MAPPING

(

tls_supported_version

)

SupportedVersions descriptor mapping (in ServerHello).

References TLS_FIXED, TLS_MAPSZ, and TLS_VERSION_BASE.

TLS_DESCR_MAPPING() [14/14]

TLS_DESCR_MAPPING

(

tls_supported_versions

)

SupportedVersions descriptor mapping (in ClientHello).

References TLS_MAPSZ, TLS_VAR08, TLS_VERSION_BASE, and versions.