enum {...} ContentType;

enum {...} ExtensionType

uint8 CipherSuite[2];

enum {...} HandshakeType;

struct { NameType name_type; select (name_type) { case host_name: HostName; } name; } ServerName; enum { host_name(0), (255) } NameType; opaque Host

enum {...} NamedGroup

enum {...} SignatureScheme

Epochs for DTLS (also used for key phase labelling)

opaque ProtocolName<1..2^8-1>; struct { ProtocolName protocol_name_list<2..2^16-1> } ProtocolNameList;

opaque ASN1Cert<1..2^24-1>; struct { ASN1Cert cert_data; Extension extensions<0..2^16-1> } CertificateEntry; struct { opaque certificate_request_con

struct { opaque certificate_request_context<0..2^8-1>; Extension extensions<2..2^16-1>; } CertificateRequest;

struct { SignatureScheme algorithm; opaque signature<0..2^16-1>; } CertificateVerify;

struct { ProtocolVersion legacy_version = 0x0303; /* TLS v1.2 */ Random random; opaque legacy_session_id<0..32>; CipherSuite cipher_suites<2..2^16-2>;

Config is the struct used to pass configuration settings to a TLS client or server instance. The settings for client and server are pretty different,

Conn implements the net.Conn interface, as with "crypto/tls" * Read, Write, and Close are provided locally * LocalAddr, RemoteAddr, and Set*Deadline a

ConnectionOptions objects represent per-connection settings for a client initiating a connection

ConnectionParameters objects represent the parameters negotiated for a connection.

struct { opaque cookie<1..2^16-1>; } Cookie;

A CookieHandler can be used to give the application more fine-grained control over Cookies. Generate receives the Conn as an argument, so the CookieHa

CookieProtector is used to create and verify a cookie

The DefaultCookieProtector is a simple implementation for the CookieProtector.

struct { } EarlyDataIndication;

struct { Extension extensions<0..2^16-1>; } EncryptedExtensions; Marshal() and Unmarshal() are handled by ExtensionList

struct {} EndOfEarlyData;

struct { ExtensionType extension_type; opaque extension_data<0..2^16-1>; } Extension;

struct { opaque verify_data[verify_data_length]; } Finished; verifyDataLen is not a field in the TLS struct, but we add it here so that calling code

Marker interface for actions that an implementation should take based on state transitions.

Working state for the handshake.

struct { HandshakeType msg_type; /* handshake type */ uint24 length; /* bytes in message */ select (HandshakeType) { ... } body; } Hand

struct { NamedGroup group; opaque key_exchange<1..2^16-1>; } KeyShareEntry; struct { select (Handshake.msg_type) { case client_hello: KeyShareEntry c

enum { update_not_requested(0), update_requested(1), (255) } KeyUpdateRequest; struct { KeyUpdateRequest request_update; } KeyUpdate;

enum { update_not_requested(0), update_requested(1), (255) } KeyUpdateRequest;

A listener implements a network listener (net.Listener) for TLS connections.

Marshaler is the interface implemented by types that have a defined TLS encoding.

struct { uint32 ticket_lifetime; uint32 ticket_age_add; opaque ticket_nonce<1..255>; opaque ticket<1..2^16-1>; Extension extensions<0..2^16-2>; } N

struct { opaque identity<1..2^16-1>; uint32 obfuscated_ticket_age; } PskIdentity; opaque PskBinderEntry<32..255>; struct { select (Handshake.msg_typ

enum {...} PskKeyExchangeMode;

enum { psk_ke(0), psk_dhe_ke(1), (255) } PskKeyExchangeMode; struct { PskKeyExchangeMode ke_modes<1..255>; } PskKeyExchangeModes;

struct { ProtocolVersion legacy_version = 0x0303; /* TLS v1.2 */ Random random; opaque legacy_session_id_echo<0..32>; CipherSuite cipher_suite; uin

struct { SignatureScheme supported_signature_algorithms<2..2^16-2>; } SignatureSchemeList

struct { NamedGroup named_group_list<2..2^16-1>; } NamedGroupList;

struct { ProtocolVersion versions<2..254>; } SupportedVersions;

struct { ContentType type; ProtocolVersion record_version [0301 for CH, 0303 for others] uint16 length; opaque fragment[TLSPlaintext.length]; } TLSPla

struct { uint32 max_early_data_size; } TicketEarlyDataInfo;

Unmarshaler is the interface implemented by types that can unmarshal a TLS description of themselves. Note that unlike the JSON unmarshaler interface

Allow types to mark themselves as valid for TLS to marshal/unmarshal