tls.c File Reference

Transport Layer Security Protocol. More...

#include <stdint.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <gpxe/hmac.h>
#include <gpxe/md5.h>
#include <gpxe/sha1.h>
#include <gpxe/aes.h>
#include <gpxe/rsa.h>
#include <gpxe/xfer.h>
#include <gpxe/open.h>
#include <gpxe/filter.h>
#include <gpxe/asn1.h>
#include <gpxe/x509.h>
#include <gpxe/tls.h>

Go to the source code of this file.

Defines
#define	tls_prf_label(tls, secret, secret_len, out, out_len, label,...)
	Generate secure pseudo-random data.
Functions
	FILE_LICENCE (GPL2_OR_LATER)
static int	tls_send_plaintext (struct tls_session *tls, unsigned int type, const void *data, size_t len)
	Send plaintext record.
static void	tls_clear_cipher (struct tls_session *tls, struct tls_cipherspec *cipherspec)
static unsigned long	tls_uint24 (uint8_t field24[3])
	Extract 24-bit field value.
static void	free_tls (struct refcnt *refcnt)
	Free TLS session.
static void	tls_close (struct tls_session *tls, int rc)
	Finish with TLS session.
static void	tls_generate_random (void *data, size_t len)
	Generate random data.
static void	tls_hmac_update_va (struct digest_algorithm *digest, void *digest_ctx, va_list args)
	Update HMAC with a list of ( data, len ) pairs.
static void	tls_p_hash_va (struct tls_session *tls, struct digest_algorithm *digest, void *secret, size_t secret_len, void *out, size_t out_len, va_list seeds)
	Generate secure pseudo-random data using a single hash function.
static void	tls_prf (struct tls_session *tls, void *secret, size_t secret_len, void *out, size_t out_len,...)
	Generate secure pseudo-random data.
static void	tls_generate_master_secret (struct tls_session *tls)
	Generate master secret.
static int	tls_generate_keys (struct tls_session *tls)
	Generate key material.
static void	tls_clear_cipher (struct tls_session *tls __unused, struct tls_cipherspec *cipherspec)
	Clear cipher suite.
static int	tls_set_cipher (struct tls_session *tls, struct tls_cipherspec *cipherspec, struct pubkey_algorithm *pubkey, struct cipher_algorithm *cipher, struct digest_algorithm *digest, size_t key_len)
	Set cipher suite.
static int	tls_select_cipher (struct tls_session *tls, unsigned int cipher_suite)
	Select next cipher suite.
static int	tls_change_cipher (struct tls_session *tls, struct tls_cipherspec *pending, struct tls_cipherspec *active)
	Activate next cipher suite.
static void	tls_add_handshake (struct tls_session *tls, const void *data, size_t len)
	Add handshake record to verification hash.
static void	tls_verify_handshake (struct tls_session *tls, void *out)
	Calculate handshake verification hash.
static int	tls_send_handshake (struct tls_session *tls, void *data, size_t len)
	Transmit Handshake record.
static int	tls_send_client_hello (struct tls_session *tls)
	Transmit Client Hello record.
static int	tls_send_client_key_exchange (struct tls_session *tls)
	Transmit Client Key Exchange record.
static int	tls_send_change_cipher (struct tls_session *tls)
	Transmit Change Cipher record.
static int	tls_send_finished (struct tls_session *tls)
	Transmit Finished record.
static int	tls_new_change_cipher (struct tls_session *tls, void *data, size_t len)
	Receive new Change Cipher record.
static int	tls_new_alert (struct tls_session *tls, void *data, size_t len)
	Receive new Alert record.
static int	tls_new_server_hello (struct tls_session *tls, void *data, size_t len)
	Receive new Server Hello handshake record.
static int	tls_new_certificate (struct tls_session *tls, void *data, size_t len)
	Receive new Certificate handshake record.
static int	tls_new_server_hello_done (struct tls_session *tls, void *data, size_t len)
	Receive new Server Hello Done handshake record.
static int	tls_new_finished (struct tls_session *tls, void *data, size_t len)
	Receive new Finished handshake record.
static int	tls_new_handshake (struct tls_session *tls, void *data, size_t len)
	Receive new Handshake record.
static int	tls_new_record (struct tls_session *tls, unsigned int type, void *data, size_t len)
	Receive new record.
static void	tls_hmac (struct tls_session *tls __unused, struct tls_cipherspec *cipherspec, uint64_t seq, struct tls_header *tlshdr, const void *data, size_t len, void *hmac)
	Calculate HMAC.
static void *__malloc	tls_assemble_stream (struct tls_session *tls, const void *data, size_t len, void *digest, size_t *plaintext_len)
	Allocate and assemble stream-ciphered record from data and MAC portions.
static void *	tls_assemble_block (struct tls_session *tls, const void *data, size_t len, void *digest, size_t *plaintext_len)
	Allocate and assemble block-ciphered record from data and MAC portions.
static int	tls_split_stream (struct tls_session *tls, void *plaintext, size_t plaintext_len, void **data, size_t *len, void **digest)
	Split stream-ciphered record into data and MAC portions.
static int	tls_split_block (struct tls_session *tls, void *plaintext, size_t plaintext_len, void **data, size_t *len, void **digest)
	Split block-ciphered record into data and MAC portions.
static int	tls_new_ciphertext (struct tls_session *tls, struct tls_header *tlshdr, void *ciphertext)
	Receive new ciphertext record.
static void	tls_plainstream_close (struct xfer_interface *xfer, int rc)
	Close interface.
static size_t	tls_plainstream_window (struct xfer_interface *xfer)
	Check flow control window.
static int	tls_plainstream_deliver_raw (struct xfer_interface *xfer, const void *data, size_t len)
	Deliver datagram as raw data.
static void	tls_cipherstream_close (struct xfer_interface *xfer, int rc)
	Close interface.
static int	tls_newdata_process_header (struct tls_session *tls)
	Handle received TLS header.
static int	tls_newdata_process_data (struct tls_session *tls)
	Handle received TLS data payload.
static int	tls_cipherstream_deliver_raw (struct xfer_interface *xfer, const void *data, size_t len)
	Receive new ciphertext.
static void	tls_step (struct process *process)
	TLS TX state machine.
int	add_tls (struct xfer_interface *xfer, struct xfer_interface **next)
Variables
static struct xfer_interface_operations	tls_plainstream_operations
	TLS plaintext stream operations.
static struct xfer_interface_operations	tls_cipherstream_operations
	TLS ciphertext stream operations.

---

Detailed Description

Transport Layer Security Protocol.

Definition in file tls.c.

---

Define Documentation

#define tls_prf_label	(	tls,
		secret,
		secret_len,
		out,
		out_len,
		label,
		...		)

Value:

tls_prf ( (tls), (secret), (secret_len), (out), (out_len),         \
                  label, ( sizeof ( label ) - 1 ), __VA_ARGS__, NULL )

Generate secure pseudo-random data.

Parameters:

	secret	Secret
	secret_len	Length of secret
	out	Output buffer
	out_len	Length of output buffer
	label	String literal label
	...	( data, len ) pairs of seed data

Definition at line 279 of file tls.c.

Referenced by tls_generate_keys(), tls_generate_master_secret(), and tls_send_finished().

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

static int tls_send_plaintext	(	struct tls_session *	tls,
		unsigned int	type,
		const void *	data,
		size_t	len
	)			[static]

Send plaintext record.

Parameters:

	tls	TLS session
	type	Record type
	data	Plaintext record
	len	Length of plaintext record

Return values:

rc

Return status code

Definition at line 1170 of file tls.c.

References tls_cipherspec::cipher, tls_cipherspec::cipher_ctx, cipher_encrypt, tls_cipherspec::cipher_next_ctx, tls_session::cipherstream, cipher_algorithm::ctxsize, DBGC, DBGC2, DBGC2_HD, tls_cipherspec::digest, digest_algorithm::digestsize, ENOMEM, free(), free_iob(), htons, iob_put, is_stream_cipher(), tls_header::length, memcpy, NULL, strerror(), tls_assemble_block(), tls_assemble_stream(), tls_hmac(), TLS_VERSION_TLS_1_0, tls_session::tx_cipherspec, tls_session::tx_seq, tls_header::type, tls_header::version, xfer_filter_half::xfer, xfer_alloc_iob(), and xfer_deliver_iob().

Referenced by tls_plainstream_deliver_raw(), tls_send_change_cipher(), and tls_send_handshake().

                                                               {
        struct tls_header plaintext_tlshdr;
        struct tls_header *tlshdr;
        struct tls_cipherspec *cipherspec = &tls->tx_cipherspec;
        void *plaintext = NULL;
        size_t plaintext_len;
        struct io_buffer *ciphertext = NULL;
        size_t ciphertext_len;
        size_t mac_len = cipherspec->digest->digestsize;
        uint8_t mac[mac_len];
        int rc;

        /* Construct header */
        plaintext_tlshdr.type = type;
        plaintext_tlshdr.version = htons ( TLS_VERSION_TLS_1_0 );
        plaintext_tlshdr.length = htons ( len );

        /* Calculate MAC */
        tls_hmac ( tls, cipherspec, tls->tx_seq, &plaintext_tlshdr,
                   data, len, mac );

        /* Allocate and assemble plaintext struct */
        if ( is_stream_cipher ( cipherspec->cipher ) ) {
                plaintext = tls_assemble_stream ( tls, data, len, mac,
                                                  &plaintext_len );
        } else {
                plaintext = tls_assemble_block ( tls, data, len, mac,
                                                 &plaintext_len );
        }
        if ( ! plaintext ) {
                DBGC ( tls, "TLS %p could not allocate %zd bytes for "
                       "plaintext\n", tls, plaintext_len );
                rc = -ENOMEM;
                goto done;
        }

        DBGC2 ( tls, "Sending plaintext data:\n" );
        DBGC2_HD ( tls, plaintext, plaintext_len );

        /* Allocate ciphertext */
        ciphertext_len = ( sizeof ( *tlshdr ) + plaintext_len );
        ciphertext = xfer_alloc_iob ( &tls->cipherstream.xfer,
                                      ciphertext_len );
        if ( ! ciphertext ) {
                DBGC ( tls, "TLS %p could not allocate %zd bytes for "
                       "ciphertext\n", tls, ciphertext_len );
                rc = -ENOMEM;
                goto done;
        }

        /* Assemble ciphertext */
        tlshdr = iob_put ( ciphertext, sizeof ( *tlshdr ) );
        tlshdr->type = type;
        tlshdr->version = htons ( TLS_VERSION_TLS_1_0 );
        tlshdr->length = htons ( plaintext_len );
        memcpy ( cipherspec->cipher_next_ctx, cipherspec->cipher_ctx,
                 cipherspec->cipher->ctxsize );
        cipher_encrypt ( cipherspec->cipher, cipherspec->cipher_next_ctx,
                         plaintext, iob_put ( ciphertext, plaintext_len ),
                         plaintext_len );

        /* Free plaintext as soon as possible to conserve memory */
        free ( plaintext );
        plaintext = NULL;

        /* Send ciphertext */
        rc = xfer_deliver_iob ( &tls->cipherstream.xfer, ciphertext );
        ciphertext = NULL;
        if ( rc != 0 ) {
                DBGC ( tls, "TLS %p could not deliver ciphertext: %s\n",
                       tls, strerror ( rc ) );
                goto done;
        }

        /* Update TX state machine to next record */
        tls->tx_seq += 1;
        memcpy ( tls->tx_cipherspec.cipher_ctx,
                 tls->tx_cipherspec.cipher_next_ctx,
                 tls->tx_cipherspec.cipher->ctxsize );

 done:
        free ( plaintext );
        free_iob ( ciphertext );
        return rc;
}

static void tls_clear_cipher	(	struct tls_session *	tls,
		struct tls_cipherspec *	cipherspec
	)			[static]

Referenced by add_tls(), free_tls(), tls_change_cipher(), and tls_set_cipher().

static unsigned long tls_uint24

(

uint8_t

field24[3]

)

[static]

Extract 24-bit field value.

Parameters:

field24

24-bit field

Return values:

value

Field value

TLS uses 24-bit integers in several places, which are awkward to parse in C.

Definition at line 66 of file tls.c.

Referenced by tls_new_certificate(), and tls_new_handshake().

                                                       {
        return ( ( field24[0] << 16 ) + ( field24[1] << 8 ) + field24[2] );
}

static void free_tls

(

struct refcnt *

refcnt

)

[static]

Free TLS session.

Parameters:

refcnt

Reference counter

Definition at line 82 of file tls.c.

References container_of, free(), tls_session::rsa, tls_session::rx_cipherspec, tls_session::rx_cipherspec_pending, tls_session::rx_data, tls_clear_cipher(), tls_session::tx_cipherspec, tls_session::tx_cipherspec_pending, and x509_free_rsa_public_key().

Referenced by add_tls().

                                               {
        struct tls_session *tls =
                container_of ( refcnt, struct tls_session, refcnt );

        /* Free dynamically-allocated resources */
        tls_clear_cipher ( tls, &tls->tx_cipherspec );
        tls_clear_cipher ( tls, &tls->tx_cipherspec_pending );
        tls_clear_cipher ( tls, &tls->rx_cipherspec );
        tls_clear_cipher ( tls, &tls->rx_cipherspec_pending );
        x509_free_rsa_public_key ( &tls->rsa );
        free ( tls->rx_data );

        /* Free TLS structure itself */
        free ( tls );   
}

static void tls_close	(	struct tls_session *	tls,
		int	rc
	)			[static]

Finish with TLS session.

Parameters:

	tls	TLS session
	rc	Status code

Definition at line 104 of file tls.c.

References tls_session::cipherstream, tls_session::plainstream, tls_session::process, process_del(), xfer_filter_half::xfer, and xfer_close().

Referenced by tls_cipherstream_close(), tls_cipherstream_deliver_raw(), tls_plainstream_close(), and tls_step().

                                                          {

        /* Remove process */
        process_del ( &tls->process );
        
        /* Close ciphertext and plaintext streams */
        xfer_nullify ( &tls->cipherstream.xfer );
        xfer_close ( &tls->cipherstream.xfer, rc );
        xfer_nullify ( &tls->plainstream.xfer );
        xfer_close ( &tls->plainstream.xfer, rc );
}

static void tls_generate_random	(	void *	data,
		size_t	len
	)			[static]

Generate random data.

Parameters:

	data	Buffer to fill
	len	Length of buffer

Definition at line 129 of file tls.c.

References memset().

Referenced by add_tls().

                                                           {
        /* FIXME: Some real random data source would be nice... */
        memset ( data, 0x01, len );
}

static void tls_hmac_update_va	(	struct digest_algorithm *	digest,
		void *	digest_ctx,
		va_list	args
	)			[static]

Update HMAC with a list of ( data, len ) pairs.

Parameters:

	digest	Hash function to use
	digest_ctx	Digest context
	args	( data, len ) pairs of data, terminated by NULL

Definition at line 141 of file tls.c.

References hmac_update(), and va_arg.

Referenced by tls_p_hash_va().

                                                                  {
        void *data;
        size_t len;

        while ( ( data = va_arg ( args, void * ) ) ) {
                len = va_arg ( args, size_t );
                hmac_update ( digest, digest_ctx, data, len );
        }
}

static void tls_p_hash_va	(	struct tls_session *	tls,
		struct digest_algorithm *	digest,
		void *	secret,
		size_t	secret_len,
		void *	out,
		size_t	out_len,
		va_list	seeds
	)			[static]

Generate secure pseudo-random data using a single hash function.

Parameters:

	tls	TLS session
	digest	Hash function to use
	secret	Secret
	secret_len	Length of secret
	out	Output buffer
	out_len	Length of output buffer
	seeds	( data, len ) pairs of seed data, terminated by NULL

Definition at line 163 of file tls.c.

References digest_algorithm::ctxsize, DBGC2, DBGC2_HD, digest_algorithm::digestsize, hmac_final(), hmac_init(), hmac_update(), memcpy, digest_algorithm::name, tls_hmac_update_va(), va_copy, and va_end.

Referenced by tls_prf().

                                            {
        uint8_t secret_copy[secret_len];
        uint8_t digest_ctx[digest->ctxsize];
        uint8_t digest_ctx_partial[digest->ctxsize];
        uint8_t a[digest->digestsize];
        uint8_t out_tmp[digest->digestsize];
        size_t frag_len = digest->digestsize;
        va_list tmp;

        /* Copy the secret, in case HMAC modifies it */
        memcpy ( secret_copy, secret, secret_len );
        secret = secret_copy;
        DBGC2 ( tls, "TLS %p %s secret:\n", tls, digest->name );
        DBGC2_HD ( tls, secret, secret_len );

        /* Calculate A(1) */
        hmac_init ( digest, digest_ctx, secret, &secret_len );
        va_copy ( tmp, seeds );
        tls_hmac_update_va ( digest, digest_ctx, tmp );
        va_end ( tmp );
        hmac_final ( digest, digest_ctx, secret, &secret_len, a );
        DBGC2 ( tls, "TLS %p %s A(1):\n", tls, digest->name );
        DBGC2_HD ( tls, &a, sizeof ( a ) );

        /* Generate as much data as required */
        while ( out_len ) {
                /* Calculate output portion */
                hmac_init ( digest, digest_ctx, secret, &secret_len );
                hmac_update ( digest, digest_ctx, a, sizeof ( a ) );
                memcpy ( digest_ctx_partial, digest_ctx, digest->ctxsize );
                va_copy ( tmp, seeds );
                tls_hmac_update_va ( digest, digest_ctx, tmp );
                va_end ( tmp );
                hmac_final ( digest, digest_ctx,
                             secret, &secret_len, out_tmp );

                /* Copy output */
                if ( frag_len > out_len )
                        frag_len = out_len;
                memcpy ( out, out_tmp, frag_len );
                DBGC2 ( tls, "TLS %p %s output:\n", tls, digest->name );
                DBGC2_HD ( tls, out, frag_len );

                /* Calculate A(i) */
                hmac_final ( digest, digest_ctx_partial,
                             secret, &secret_len, a );
                DBGC2 ( tls, "TLS %p %s A(n):\n", tls, digest->name );
                DBGC2_HD ( tls, &a, sizeof ( a ) );

                out += frag_len;
                out_len -= frag_len;
        }
}

static void tls_prf	(	struct tls_session *	tls,
		void *	secret,
		size_t	secret_len,
		void *	out,
		size_t	out_len,
			...
	)			[static]

Generate secure pseudo-random data.

Parameters:

	tls	TLS session
	secret	Secret
	secret_len	Length of secret
	out	Output buffer
	out_len	Length of output buffer
	...	( data, len ) pairs of seed data, terminated by NULL

Definition at line 231 of file tls.c.

References md5_algorithm, sha1_algorithm, tls_p_hash_va(), va_copy, va_end, and va_start.

                                                       {
        va_list seeds;
        va_list tmp;
        size_t subsecret_len;
        void *md5_secret;
        void *sha1_secret;
        uint8_t out_md5[out_len];
        uint8_t out_sha1[out_len];
        unsigned int i;

        va_start ( seeds, out_len );

        /* Split secret into two, with an overlap of up to one byte */
        subsecret_len = ( ( secret_len + 1 ) / 2 );
        md5_secret = secret;
        sha1_secret = ( secret + secret_len - subsecret_len );

        /* Calculate MD5 portion */
        va_copy ( tmp, seeds );
        tls_p_hash_va ( tls, &md5_algorithm, md5_secret, subsecret_len,
                        out_md5, out_len, seeds );
        va_end ( tmp );

        /* Calculate SHA1 portion */
        va_copy ( tmp, seeds );
        tls_p_hash_va ( tls, &sha1_algorithm, sha1_secret, subsecret_len,
                        out_sha1, out_len, seeds );
        va_end ( tmp );

        /* XOR the two portions together into the final output buffer */
        for ( i = 0 ; i < out_len ; i++ ) {
                *( ( uint8_t * ) out + i ) = ( out_md5[i] ^ out_sha1[i] );
        }

        va_end ( seeds );
}

static void tls_generate_master_secret

(

struct tls_session *

tls

)

[static]

Generate master secret.

Parameters:

tls

TLS session

The pre-master secret and the client and server random values must already be known.

Definition at line 298 of file tls.c.

References tls_session::client_random, DBGC, DBGC_HD, tls_session::master_secret, tls_session::pre_master_secret, tls_session::server_random, and tls_prf_label.

Referenced by tls_new_server_hello().

                                                                   {
        DBGC ( tls, "TLS %p pre-master-secret:\n", tls );
        DBGC_HD ( tls, &tls->pre_master_secret,
                  sizeof ( tls->pre_master_secret ) );
        DBGC ( tls, "TLS %p client random bytes:\n", tls );
        DBGC_HD ( tls, &tls->client_random, sizeof ( tls->client_random ) );
        DBGC ( tls, "TLS %p server random bytes:\n", tls );
        DBGC_HD ( tls, &tls->server_random, sizeof ( tls->server_random ) );

        tls_prf_label ( tls, &tls->pre_master_secret,
                        sizeof ( tls->pre_master_secret ),
                        &tls->master_secret, sizeof ( tls->master_secret ),
                        "master secret",
                        &tls->client_random, sizeof ( tls->client_random ),
                        &tls->server_random, sizeof ( tls->server_random ) );

        DBGC ( tls, "TLS %p generated master secret:\n", tls );
        DBGC_HD ( tls, &tls->master_secret, sizeof ( tls->master_secret ) );
}

static int tls_generate_keys

(

struct tls_session *

tls

)

[static]

Generate key material.

Parameters:

tls

TLS session

The master secret must already be known.

Definition at line 325 of file tls.c.

References assert, cipher_algorithm::blocksize, tls_cipherspec::cipher, tls_cipherspec::cipher_ctx, cipher_setiv(), cipher_setkey(), tls_session::client_random, DBGC, DBGC_HD, tls_cipherspec::digest, digest_algorithm::digestsize, tls_cipherspec::key_len, tls_cipherspec::mac_secret, tls_session::master_secret, memcpy, tls_session::rx_cipherspec_pending, tls_session::server_random, strerror(), tls_prf_label, and tls_session::tx_cipherspec_pending.

Referenced by tls_new_server_hello().

                                                         {
        struct tls_cipherspec *tx_cipherspec = &tls->tx_cipherspec_pending;
        struct tls_cipherspec *rx_cipherspec = &tls->rx_cipherspec_pending;
        size_t hash_size = tx_cipherspec->digest->digestsize;
        size_t key_size = tx_cipherspec->key_len;
        size_t iv_size = tx_cipherspec->cipher->blocksize;
        size_t total = ( 2 * ( hash_size + key_size + iv_size ) );
        uint8_t key_block[total];
        uint8_t *key;
        int rc;

        /* Generate key block */
        tls_prf_label ( tls, &tls->master_secret, sizeof ( tls->master_secret ),
                        key_block, sizeof ( key_block ), "key expansion",
                        &tls->server_random, sizeof ( tls->server_random ),
                        &tls->client_random, sizeof ( tls->client_random ) );

        /* Split key block into portions */
        key = key_block;

        /* TX MAC secret */
        memcpy ( tx_cipherspec->mac_secret, key, hash_size );
        DBGC ( tls, "TLS %p TX MAC secret:\n", tls );
        DBGC_HD ( tls, key, hash_size );
        key += hash_size;

        /* RX MAC secret */
        memcpy ( rx_cipherspec->mac_secret, key, hash_size );
        DBGC ( tls, "TLS %p RX MAC secret:\n", tls );
        DBGC_HD ( tls, key, hash_size );
        key += hash_size;

        /* TX key */
        if ( ( rc = cipher_setkey ( tx_cipherspec->cipher,
                                    tx_cipherspec->cipher_ctx,
                                    key, key_size ) ) != 0 ) {
                DBGC ( tls, "TLS %p could not set TX key: %s\n",
                       tls, strerror ( rc ) );
                return rc;
        }
        DBGC ( tls, "TLS %p TX key:\n", tls );
        DBGC_HD ( tls, key, key_size );
        key += key_size;

        /* RX key */
        if ( ( rc = cipher_setkey ( rx_cipherspec->cipher,
                                    rx_cipherspec->cipher_ctx,
                                    key, key_size ) ) != 0 ) {
                DBGC ( tls, "TLS %p could not set TX key: %s\n",
                       tls, strerror ( rc ) );
                return rc;
        }
        DBGC ( tls, "TLS %p RX key:\n", tls );
        DBGC_HD ( tls, key, key_size );
        key += key_size;

        /* TX initialisation vector */
        cipher_setiv ( tx_cipherspec->cipher, tx_cipherspec->cipher_ctx, key );
        DBGC ( tls, "TLS %p TX IV:\n", tls );
        DBGC_HD ( tls, key, iv_size );
        key += iv_size;

        /* RX initialisation vector */
        cipher_setiv ( rx_cipherspec->cipher, rx_cipherspec->cipher_ctx, key );
        DBGC ( tls, "TLS %p RX IV:\n", tls );
        DBGC_HD ( tls, key, iv_size );
        key += iv_size;

        assert ( ( key_block + total ) == key );

        return 0;
}

static void tls_clear_cipher	(	struct tls_session *tls	__unused,
		struct tls_cipherspec *	cipherspec
	)			[static]

Clear cipher suite.

Parameters:

cipherspec

TLS cipher specification

Definition at line 410 of file tls.c.

References tls_cipherspec::cipher, cipher_null, tls_cipherspec::digest, digest_null, tls_cipherspec::dynamic, free(), memset(), tls_cipherspec::pubkey, and pubkey_null.

                                                                   {
        free ( cipherspec->dynamic );
        memset ( cipherspec, 0, sizeof ( cipherspec ) );
        cipherspec->pubkey = &pubkey_null;
        cipherspec->cipher = &cipher_null;
        cipherspec->digest = &digest_null;
}

static int tls_set_cipher	(	struct tls_session *	tls,
		struct tls_cipherspec *	cipherspec,
		struct pubkey_algorithm *	pubkey,
		struct cipher_algorithm *	cipher,
		struct digest_algorithm *	digest,
		size_t	key_len
	)			[static]

Set cipher suite.

Parameters:

	tls	TLS session
	cipherspec	TLS cipher specification
	pubkey	Public-key encryption elgorithm
	cipher	Bulk encryption cipher algorithm
	digest	MAC digest algorithm
	key_len	Key length

Return values:

rc

Return status code

Definition at line 430 of file tls.c.

References assert, tls_cipherspec::cipher, tls_cipherspec::cipher_ctx, tls_cipherspec::cipher_next_ctx, cipher_algorithm::ctxsize, pubkey_algorithm::ctxsize, DBGC, tls_cipherspec::digest, digest_algorithm::digestsize, tls_cipherspec::dynamic, ENOMEM, tls_cipherspec::key_len, tls_cipherspec::mac_secret, malloc(), memset(), tls_cipherspec::pubkey, tls_cipherspec::pubkey_ctx, and tls_clear_cipher().

Referenced by tls_select_cipher().

                                             {
        size_t total;
        void *dynamic;

        /* Clear out old cipher contents, if any */
        tls_clear_cipher ( tls, cipherspec );
        
        /* Allocate dynamic storage */
        total = ( pubkey->ctxsize + 2 * cipher->ctxsize + digest->digestsize );
        dynamic = malloc ( total );
        if ( ! dynamic ) {
                DBGC ( tls, "TLS %p could not allocate %zd bytes for crypto "
                       "context\n", tls, total );
                return -ENOMEM;
        }
        memset ( dynamic, 0, total );

        /* Assign storage */
        cipherspec->dynamic = dynamic;
        cipherspec->pubkey_ctx = dynamic;       dynamic += pubkey->ctxsize;
        cipherspec->cipher_ctx = dynamic;       dynamic += cipher->ctxsize;
        cipherspec->cipher_next_ctx = dynamic;  dynamic += cipher->ctxsize;
        cipherspec->mac_secret = dynamic;       dynamic += digest->digestsize;
        assert ( ( cipherspec->dynamic + total ) == dynamic );

        /* Store parameters */
        cipherspec->pubkey = pubkey;
        cipherspec->cipher = cipher;
        cipherspec->digest = digest;
        cipherspec->key_len = key_len;

        return 0;
}

static int tls_select_cipher	(	struct tls_session *	tls,
		unsigned int	cipher_suite
	)			[static]

Select next cipher suite.

Parameters:

	tls	TLS session
	cipher_suite	Cipher suite specification

Return values:

rc

Return status code

Definition at line 476 of file tls.c.

References aes_cbc_algorithm, cipher_null, DBGC, digest_null, ENOTSUP, htons, digest_algorithm::name, cipher_algorithm::name, pubkey_algorithm::name, ntohs, pubkey_null, tls_session::rx_cipherspec_pending, sha1_algorithm, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_256_CBC_SHA, tls_set_cipher(), and tls_session::tx_cipherspec_pending.

Referenced by tls_new_server_hello().

                                                           {
        struct pubkey_algorithm *pubkey = &pubkey_null;
        struct cipher_algorithm *cipher = &cipher_null;
        struct digest_algorithm *digest = &digest_null;
        unsigned int key_len = 0;
        int rc;

        switch ( cipher_suite ) {
        case htons ( TLS_RSA_WITH_AES_128_CBC_SHA ):
                key_len = ( 128 / 8 );
                cipher = &aes_cbc_algorithm;
                digest = &sha1_algorithm;
                break;
        case htons ( TLS_RSA_WITH_AES_256_CBC_SHA ):
                key_len = ( 256 / 8 );
                cipher = &aes_cbc_algorithm;
                digest = &sha1_algorithm;
                break;
        default:
                DBGC ( tls, "TLS %p does not support cipher %04x\n",
                       tls, ntohs ( cipher_suite ) );
                return -ENOTSUP;
        }

        /* Set ciphers */
        if ( ( rc = tls_set_cipher ( tls, &tls->tx_cipherspec_pending, pubkey,
                                     cipher, digest, key_len ) ) != 0 )
                return rc;
        if ( ( rc = tls_set_cipher ( tls, &tls->rx_cipherspec_pending, pubkey,
                                     cipher, digest, key_len ) ) != 0 )
                return rc;

        DBGC ( tls, "TLS %p selected %s-%s-%d-%s\n", tls,
               pubkey->name, cipher->name, ( key_len * 8 ), digest->name );

        return 0;
}

static int tls_change_cipher	(	struct tls_session *	tls,
		struct tls_cipherspec *	pending,
		struct tls_cipherspec *	active
	)			[static]

Activate next cipher suite.

Parameters:

	tls	TLS session
	pending	Pending cipher specification
	active	Active cipher specification to replace

Return values:

rc

Return status code

Definition at line 523 of file tls.c.

References tls_cipherspec::cipher, cipher_null, DBGC, tls_cipherspec::digest, digest_null, ENOTSUP, and tls_clear_cipher().

Referenced by tls_new_change_cipher(), and tls_step().

                                                               {

        /* Sanity check */
        if ( /* FIXME (when pubkey is not hard-coded to RSA):
              * ( pending->pubkey == &pubkey_null ) || */
             ( pending->cipher == &cipher_null ) ||
             ( pending->digest == &digest_null ) ) {
                DBGC ( tls, "TLS %p refusing to use null cipher\n", tls );
                return -ENOTSUP;
        }

        tls_clear_cipher ( tls, active );
        memswap ( active, pending, sizeof ( *active ) );
        return 0;
}

static void tls_add_handshake	(	struct tls_session *	tls,
		const void *	data,
		size_t	len
	)			[static]

Add handshake record to verification hash.

Parameters:

	tls	TLS session
	data	Handshake record
	len	Length of handshake record

Definition at line 555 of file tls.c.

References digest_update(), tls_session::handshake_md5_ctx, tls_session::handshake_sha1_ctx, md5_algorithm, and sha1_algorithm.

Referenced by tls_new_handshake(), and tls_send_handshake().

                                                               {

        digest_update ( &md5_algorithm, tls->handshake_md5_ctx, data, len );
        digest_update ( &sha1_algorithm, tls->handshake_sha1_ctx, data, len );
}

static void tls_verify_handshake	(	struct tls_session *	tls,
		void *	out
	)			[static]

Calculate handshake verification hash.

Parameters:

	tls	TLS session
	out	Output buffer

Calculates the MD5+SHA1 digest over all handshake messages seen so far.

Definition at line 571 of file tls.c.

References digest_algorithm::ctxsize, digest_final(), digest_algorithm::digestsize, tls_session::handshake_md5_ctx, tls_session::handshake_sha1_ctx, md5_algorithm, memcpy, and sha1_algorithm.

Referenced by tls_send_finished().

                                                                        {
        struct digest_algorithm *md5 = &md5_algorithm;
        struct digest_algorithm *sha1 = &sha1_algorithm;
        uint8_t md5_ctx[md5->ctxsize];
        uint8_t sha1_ctx[sha1->ctxsize];
        void *md5_digest = out;
        void *sha1_digest = ( out + md5->digestsize );

        memcpy ( md5_ctx, tls->handshake_md5_ctx, sizeof ( md5_ctx ) );
        memcpy ( sha1_ctx, tls->handshake_sha1_ctx, sizeof ( sha1_ctx ) );
        digest_final ( md5, md5_ctx, md5_digest );
        digest_final ( sha1, sha1_ctx, sha1_digest );
}

static int tls_send_handshake	(	struct tls_session *	tls,
		void *	data,
		size_t	len
	)			[static]

Transmit Handshake record.

Parameters:

	tls	TLS session
	data	Plaintext record
	len	Length of plaintext record

Return values:

rc

Return status code

Definition at line 600 of file tls.c.

References tls_add_handshake(), tls_send_plaintext(), and TLS_TYPE_HANDSHAKE.

Referenced by tls_send_client_hello(), tls_send_client_key_exchange(), and tls_send_finished().

                                                         {

        /* Add to handshake digest */
        tls_add_handshake ( tls, data, len );

        /* Send record */
        return tls_send_plaintext ( tls, TLS_TYPE_HANDSHAKE, data, len );
}

static int tls_send_client_hello

(

struct tls_session *

tls

)

[static]

Transmit Client Hello record.

Parameters:

tls

TLS session

Return values:

rc

Return status code

Definition at line 616 of file tls.c.

References __attribute__, tls_session::client_random, cpu_to_le32, htonl, htons, memcpy, memset(), packed, random(), TLS_CLIENT_HELLO, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_256_CBC_SHA, tls_send_handshake(), TLS_VERSION_TLS_1_0, and version.

Referenced by tls_step().

                                                             {
        struct {
                uint32_t type_length;
                uint16_t version;
                uint8_t random[32];
                uint8_t session_id_len;
                uint16_t cipher_suite_len;
                uint16_t cipher_suites[2];
                uint8_t compression_methods_len;
                uint8_t compression_methods[1];
        } __attribute__ (( packed )) hello;

        memset ( &hello, 0, sizeof ( hello ) );
        hello.type_length = ( cpu_to_le32 ( TLS_CLIENT_HELLO ) |
                              htonl ( sizeof ( hello ) -
                                      sizeof ( hello.type_length ) ) );
        hello.version = htons ( TLS_VERSION_TLS_1_0 );
        memcpy ( &hello.random, &tls->client_random, sizeof ( hello.random ) );
        hello.cipher_suite_len = htons ( sizeof ( hello.cipher_suites ) );
        hello.cipher_suites[0] = htons ( TLS_RSA_WITH_AES_128_CBC_SHA );
        hello.cipher_suites[1] = htons ( TLS_RSA_WITH_AES_256_CBC_SHA );
        hello.compression_methods_len = sizeof ( hello.compression_methods );

        return tls_send_handshake ( tls, &hello, sizeof ( hello ) );
}

static int tls_send_client_key_exchange

(

struct tls_session *

tls

)

[static]

Transmit Client Key Exchange record.

Parameters:

tls

TLS session

Return values:

rc

Return status code

Definition at line 648 of file tls.c.

References __attribute__, cpu_to_le32, DBGC, DBGC_HD, x509_rsa_public_key::exponent, x509_rsa_public_key::exponent_len, htonl, htons, memset(), x509_rsa_public_key::modulus, x509_rsa_public_key::modulus_len, RSA_CTX::num_octets, packed, tls_session::pre_master_secret, tls_session::rsa, RSA_encrypt(), RSA_free(), RSA_pub_key_new(), TLS_CLIENT_KEY_EXCHANGE, and tls_send_handshake().

Referenced by tls_step().

                                                                    {
        /* FIXME: Hack alert */
        RSA_CTX *rsa_ctx;
        RSA_pub_key_new ( &rsa_ctx, tls->rsa.modulus, tls->rsa.modulus_len,
                          tls->rsa.exponent, tls->rsa.exponent_len );
        struct {
                uint32_t type_length;
                uint16_t encrypted_pre_master_secret_len;
                uint8_t encrypted_pre_master_secret[rsa_ctx->num_octets];
        } __attribute__ (( packed )) key_xchg;

        memset ( &key_xchg, 0, sizeof ( key_xchg ) );
        key_xchg.type_length = ( cpu_to_le32 ( TLS_CLIENT_KEY_EXCHANGE ) |
                                 htonl ( sizeof ( key_xchg ) -
                                         sizeof ( key_xchg.type_length ) ) );
        key_xchg.encrypted_pre_master_secret_len
                = htons ( sizeof ( key_xchg.encrypted_pre_master_secret ) );

        /* FIXME: Hack alert */
        DBGC ( tls, "RSA encrypting plaintext, modulus, exponent:\n" );
        DBGC_HD ( tls, &tls->pre_master_secret,
                  sizeof ( tls->pre_master_secret ) );
        DBGC_HD ( tls, tls->rsa.modulus, tls->rsa.modulus_len );
        DBGC_HD ( tls, tls->rsa.exponent, tls->rsa.exponent_len );
        RSA_encrypt ( rsa_ctx, ( const uint8_t * ) &tls->pre_master_secret,
                      sizeof ( tls->pre_master_secret ),
                      key_xchg.encrypted_pre_master_secret, 0 );
        DBGC ( tls, "RSA encrypt done.  Ciphertext:\n" );
        DBGC_HD ( tls, &key_xchg.encrypted_pre_master_secret,
                  sizeof ( key_xchg.encrypted_pre_master_secret ) );
        RSA_free ( rsa_ctx );


        return tls_send_handshake ( tls, &key_xchg, sizeof ( key_xchg ) );
}

static int tls_send_change_cipher

(

struct tls_session *

tls

)

[static]

Transmit Change Cipher record.

Parameters:

tls

TLS session

Return values:

rc

Return status code

Definition at line 690 of file tls.c.

References tls_send_plaintext(), and TLS_TYPE_CHANGE_CIPHER.

Referenced by tls_step().

                                                              {
        static const uint8_t change_cipher[1] = { 1 };
        return tls_send_plaintext ( tls, TLS_TYPE_CHANGE_CIPHER,
                                    change_cipher, sizeof ( change_cipher ) );
}

static int tls_send_finished

(

struct tls_session *

tls

)

[static]

Transmit Finished record.

Parameters:

tls

TLS session

Return values:

rc

Return status code

Definition at line 702 of file tls.c.

References __attribute__, cpu_to_le32, htonl, tls_session::master_secret, MD5_DIGEST_SIZE, memset(), packed, SHA1_DIGEST_SIZE, TLS_FINISHED, tls_prf_label, tls_send_handshake(), and tls_verify_handshake().

Referenced by tls_step().

                                                         {
        struct {
                uint32_t type_length;
                uint8_t verify_data[12];
        } __attribute__ (( packed )) finished;
        uint8_t digest[MD5_DIGEST_SIZE + SHA1_DIGEST_SIZE];

        memset ( &finished, 0, sizeof ( finished ) );
        finished.type_length = ( cpu_to_le32 ( TLS_FINISHED ) |
                                 htonl ( sizeof ( finished ) -
                                         sizeof ( finished.type_length ) ) );
        tls_verify_handshake ( tls, digest );
        tls_prf_label ( tls, &tls->master_secret, sizeof ( tls->master_secret ),
                        finished.verify_data, sizeof ( finished.verify_data ),
                        "client finished", digest, sizeof ( digest ) );

        return tls_send_handshake ( tls, &finished, sizeof ( finished ) );
}

static int tls_new_change_cipher	(	struct tls_session *	tls,
		void *	data,
		size_t	len
	)			[static]

Receive new Change Cipher record.

Parameters:

	tls	TLS session
	data	Plaintext record
	len	Length of plaintext record

Return values:

rc

Return status code

Definition at line 729 of file tls.c.

References DBGC, DBGC_HD, EINVAL, tls_session::rx_cipherspec, tls_session::rx_cipherspec_pending, tls_session::rx_seq, strerror(), and tls_change_cipher().

Referenced by tls_new_record().

                                                            {
        int rc;

        if ( ( len != 1 ) || ( *( ( uint8_t * ) data ) != 1 ) ) {
                DBGC ( tls, "TLS %p received invalid Change Cipher\n", tls );
                DBGC_HD ( tls, data, len );
                return -EINVAL;
        }

        if ( ( rc = tls_change_cipher ( tls, &tls->rx_cipherspec_pending,
                                        &tls->rx_cipherspec ) ) != 0 ) {
                DBGC ( tls, "TLS %p could not activate RX cipher: %s\n",
                       tls, strerror ( rc ) );
                return rc;
        }
        tls->rx_seq = ~( ( uint64_t ) 0 );

        return 0;
}

static int tls_new_alert	(	struct tls_session *	tls,
		void *	data,
		size_t	len
	)			[static]

Receive new Alert record.

Parameters:

	tls	TLS session
	data	Plaintext record
	len	Length of plaintext record

Return values:

rc

Return status code

Definition at line 758 of file tls.c.

References __attribute__, alert(), DBGC, DBGC_HD, EINVAL, EIO, EPERM, packed, TLS_ALERT_FATAL, and TLS_ALERT_WARNING.

Referenced by tls_new_record().

                                                                             {
        struct {
                uint8_t level;
                uint8_t description;
                char next[0];
        } __attribute__ (( packed )) *alert = data;
        void *end = alert->next;

        /* Sanity check */
        if ( end != ( data + len ) ) {
                DBGC ( tls, "TLS %p received overlength Alert\n", tls );
                DBGC_HD ( tls, data, len );
                return -EINVAL;
        }

        switch ( alert->level ) {
        case TLS_ALERT_WARNING:
                DBGC ( tls, "TLS %p received warning alert %d\n",
                       tls, alert->description );
                return 0;
        case TLS_ALERT_FATAL:
                DBGC ( tls, "TLS %p received fatal alert %d\n",
                       tls, alert->description );
                return -EPERM;
        default:
                DBGC ( tls, "TLS %p received unknown alert level %d"
                       "(alert %d)\n", tls, alert->level, alert->description );
                return -EIO;
        }
}

static int tls_new_server_hello	(	struct tls_session *	tls,
		void *	data,
		size_t	len
	)			[static]

Receive new Server Hello handshake record.

Parameters:

	tls	TLS session
	data	Plaintext handshake record
	len	Length of plaintext handshake record

Return values:

rc

Return status code

Definition at line 797 of file tls.c.

References __attribute__, DBGC, DBGC_HD, EINVAL, ENOTSUP, memcpy, ntohs, packed, random(), tls_session::server_random, tls_generate_keys(), tls_generate_master_secret(), tls_select_cipher(), TLS_VERSION_TLS_1_0, and version.

Referenced by tls_new_handshake().

                                                           {
        struct {
                uint16_t version;
                uint8_t random[32];
                uint8_t session_id_len;
                char next[0];
        } __attribute__ (( packed )) *hello_a = data;
        struct {
                uint8_t session_id[hello_a->session_id_len];
                uint16_t cipher_suite;
                uint8_t compression_method;
                char next[0];
        } __attribute__ (( packed )) *hello_b = ( void * ) &hello_a->next;
        void *end = hello_b->next;
        int rc;

        /* Sanity check */
        if ( end != ( data + len ) ) {
                DBGC ( tls, "TLS %p received overlength Server Hello\n", tls );
                DBGC_HD ( tls, data, len );
                return -EINVAL;
        }

        /* Check protocol version */
        if ( ntohs ( hello_a->version ) < TLS_VERSION_TLS_1_0 ) {
                DBGC ( tls, "TLS %p does not support protocol version %d.%d\n",
                       tls, ( ntohs ( hello_a->version ) >> 8 ),
                       ( ntohs ( hello_a->version ) & 0xff ) );
                return -ENOTSUP;
        }

        /* Copy out server random bytes */
        memcpy ( &tls->server_random, &hello_a->random,
                 sizeof ( tls->server_random ) );

        /* Select cipher suite */
        if ( ( rc = tls_select_cipher ( tls, hello_b->cipher_suite ) ) != 0 )
                return rc;

        /* Generate secrets */
        tls_generate_master_secret ( tls );
        if ( ( rc = tls_generate_keys ( tls ) ) != 0 )
                return rc;

        return 0;
}

static int tls_new_certificate	(	struct tls_session *	tls,
		void *	data,
		size_t	len
	)			[static]

Receive new Certificate handshake record.

Parameters:

	tls	TLS session
	data	Plaintext handshake record
	len	Length of plaintext handshake record

Return values:

rc

Return status code

Definition at line 853 of file tls.c.

References __attribute__, asn1_cursor::data, DBGC, DBGC_HD, EINVAL, asn1_cursor::len, packed, tls_session::rsa, strerror(), and tls_uint24().

Referenced by tls_new_handshake().

                                                          {
        struct {
                uint8_t length[3];
                uint8_t certificates[0];
        } __attribute__ (( packed )) *certificate = data;
        struct {
                uint8_t length[3];
                uint8_t certificate[0];
        } __attribute__ (( packed )) *element =
                  ( ( void * ) certificate->certificates );
        size_t elements_len = tls_uint24 ( certificate->length );
        void *end = ( certificate->certificates + elements_len );
        struct asn1_cursor cursor;
        int rc;

        /* Sanity check */
        if ( end != ( data + len ) ) {
                DBGC ( tls, "TLS %p received overlength Server Certificate\n",
                       tls );
                DBGC_HD ( tls, data, len );
                return -EINVAL;
        }

        /* Traverse certificate chain */
        do {
                cursor.data = element->certificate;
                cursor.len = tls_uint24 ( element->length );
                if ( ( cursor.data + cursor.len ) > end ) {
                        DBGC ( tls, "TLS %p received corrupt Server "
                               "Certificate\n", tls );
                        DBGC_HD ( tls, data, len );
                        return -EINVAL;
                }

                // HACK
                if ( ( rc = x509_rsa_public_key ( &cursor,
                                                  &tls->rsa ) ) != 0 ) {
                        DBGC ( tls, "TLS %p cannot determine RSA public key: "
                               "%s\n", tls, strerror ( rc ) );
                        return rc;
                }
                return 0;

                element = ( cursor.data + cursor.len );
        } while ( element != end );

        return -EINVAL;
}

static int tls_new_server_hello_done	(	struct tls_session *	tls,
		void *	data,
		size_t	len
	)			[static]

Receive new Server Hello Done handshake record.

Parameters:

	tls	TLS session
	data	Plaintext handshake record
	len	Length of plaintext handshake record

Return values:

rc

Return status code

Definition at line 911 of file tls.c.

References __attribute__, DBGC, DBGC_HD, EINVAL, EIO, packed, TLS_TX_CLIENT_KEY_EXCHANGE, TLS_TX_NONE, and tls_session::tx_state.

Referenced by tls_new_handshake().

                                                                {
        struct {
                char next[0];
        } __attribute__ (( packed )) *hello_done = data;
        void *end = hello_done->next;

        /* Sanity check */
        if ( end != ( data + len ) ) {
                DBGC ( tls, "TLS %p received overlength Server Hello Done\n",
                       tls );
                DBGC_HD ( tls, data, len );
                return -EINVAL;
        }

        /* Check that we are ready to send the Client Key Exchange */
        if ( tls->tx_state != TLS_TX_NONE ) {
                DBGC ( tls, "TLS %p received Server Hello Done while in "
                       "TX state %d\n", tls, tls->tx_state );
                return -EIO;
        }

        /* Start sending the Client Key Exchange */
        tls->tx_state = TLS_TX_CLIENT_KEY_EXCHANGE;

        return 0;
}

static int tls_new_finished	(	struct tls_session *	tls,
		void *	data,
		size_t	len
	)			[static]

Receive new Finished handshake record.

Parameters:

	tls	TLS session
	data	Plaintext handshake record
	len	Length of plaintext handshake record

Return values:

rc

Return status code

Definition at line 947 of file tls.c.

References TLS_TX_DATA, and tls_session::tx_state.

Referenced by tls_new_handshake().

                                                       {

        /* FIXME: Handle this properly */
        tls->tx_state = TLS_TX_DATA;
        ( void ) data;
        ( void ) len;
        return 0;
}

static int tls_new_handshake	(	struct tls_session *	tls,
		void *	data,
		size_t	len
	)			[static]

Receive new Handshake record.

Parameters:

	tls	TLS session
	data	Plaintext record
	len	Length of plaintext record

Return values:

rc

Return status code

Definition at line 965 of file tls.c.

References __attribute__, DBGC, DBGC_HD, EINVAL, packed, tls_add_handshake(), TLS_CERTIFICATE, TLS_FINISHED, TLS_HELLO_REQUEST, tls_new_certificate(), tls_new_finished(), tls_new_server_hello(), tls_new_server_hello_done(), TLS_SERVER_HELLO, TLS_SERVER_HELLO_DONE, and tls_uint24().

Referenced by tls_new_record().

                                                        {
        struct {
                uint8_t type;
                uint8_t length[3];
                uint8_t payload[0];
        } __attribute__ (( packed )) *handshake = data;
        void *payload = &handshake->payload;
        size_t payload_len = tls_uint24 ( handshake->length );
        void *end = ( payload + payload_len );
        int rc;

        /* Sanity check */
        if ( end != ( data + len ) ) {
                DBGC ( tls, "TLS %p received overlength Handshake\n", tls );
                DBGC_HD ( tls, data, len );
                return -EINVAL;
        }

        switch ( handshake->type ) {
        case TLS_SERVER_HELLO:
                rc = tls_new_server_hello ( tls, payload, payload_len );
                break;
        case TLS_CERTIFICATE:
                rc = tls_new_certificate ( tls, payload, payload_len );
                break;
        case TLS_SERVER_HELLO_DONE:
                rc = tls_new_server_hello_done ( tls, payload, payload_len );
                break;
        case TLS_FINISHED:
                rc = tls_new_finished ( tls, payload, payload_len );
                break;
        default:
                DBGC ( tls, "TLS %p ignoring handshake type %d\n",
                       tls, handshake->type );
                rc = 0;
                break;
        }

        /* Add to handshake digest (except for Hello Requests, which
         * are explicitly excluded).
         */
        if ( handshake->type != TLS_HELLO_REQUEST )
                tls_add_handshake ( tls, data, len );

        return rc;
}

static int tls_new_record	(	struct tls_session *	tls,
		unsigned int	type,
		void *	data,
		size_t	len
	)			[static]

Receive new record.

Parameters:

	tls	TLS session
	type	Record type
	data	Plaintext record
	len	Length of plaintext record

Return values:

rc

Return status code

Definition at line 1022 of file tls.c.

References DBGC, tls_session::plainstream, tls_new_alert(), tls_new_change_cipher(), tls_new_handshake(), TLS_TYPE_ALERT, TLS_TYPE_CHANGE_CIPHER, TLS_TYPE_DATA, TLS_TYPE_HANDSHAKE, xfer_filter_half::xfer, and xfer_deliver_raw().

Referenced by tls_new_ciphertext().

                                                                        {

        switch ( type ) {
        case TLS_TYPE_CHANGE_CIPHER:
                return tls_new_change_cipher ( tls, data, len );
        case TLS_TYPE_ALERT:
                return tls_new_alert ( tls, data, len );
        case TLS_TYPE_HANDSHAKE:
                return tls_new_handshake ( tls, data, len );
        case TLS_TYPE_DATA:
                return xfer_deliver_raw ( &tls->plainstream.xfer, data, len );
        default:
                /* RFC4346 says that we should just ignore unknown
                 * record types.
                 */
                DBGC ( tls, "TLS %p ignoring record type %d\n", tls, type );
                return 0;
        }
}

static void tls_hmac	(	struct tls_session *tls	__unused,
		struct tls_cipherspec *	cipherspec,
		uint64_t	seq,
		struct tls_header *	tlshdr,
		const void *	data,
		size_t	len,
		void *	hmac
	)			[static]

Calculate HMAC.

Parameters:

	tls	TLS session
	cipherspec	Cipher specification
	seq	Sequence number
	tlshdr	TLS header
	data	Data
	len	Length of data
	mac	HMAC to fill in

Definition at line 1061 of file tls.c.

References cpu_to_be64, digest_algorithm::ctxsize, tls_cipherspec::digest, digest_algorithm::digestsize, hmac_final(), hmac_init(), hmac_update(), and tls_cipherspec::mac_secret.

Referenced by tls_new_ciphertext(), and tls_send_plaintext().

                                                                  {
        struct digest_algorithm *digest = cipherspec->digest;
        uint8_t digest_ctx[digest->ctxsize];

        hmac_init ( digest, digest_ctx, cipherspec->mac_secret,
                    &digest->digestsize );
        seq = cpu_to_be64 ( seq );
        hmac_update ( digest, digest_ctx, &seq, sizeof ( seq ) );
        hmac_update ( digest, digest_ctx, tlshdr, sizeof ( *tlshdr ) );
        hmac_update ( digest, digest_ctx, data, len );
        hmac_final ( digest, digest_ctx, cipherspec->mac_secret,
                     &digest->digestsize, hmac );
}

static void* __malloc tls_assemble_stream	(	struct tls_session *	tls,
		const void *	data,
		size_t	len,
		void *	digest,
		size_t *	plaintext_len
	)			[static]

Allocate and assemble stream-ciphered record from data and MAC portions.

Parameters:

tls

TLS session

Return values:

	data	Data
	len	Length of data
	digest	MAC digest
	plaintext_len	Length of plaintext record
	plaintext	Allocated plaintext record

Definition at line 1088 of file tls.c.

References tls_cipherspec::digest, digest_algorithm::digestsize, malloc(), memcpy, NULL, and tls_session::tx_cipherspec.

Referenced by tls_send_plaintext().

                                                                          {
        size_t mac_len = tls->tx_cipherspec.digest->digestsize;
        void *plaintext;
        void *content;
        void *mac;

        /* Calculate stream-ciphered struct length */
        *plaintext_len = ( len + mac_len );

        /* Allocate stream-ciphered struct */
        plaintext = malloc ( *plaintext_len );
        if ( ! plaintext )
                return NULL;
        content = plaintext;
        mac = ( content + len );

        /* Fill in stream-ciphered struct */
        memcpy ( content, data, len );
        memcpy ( mac, digest, mac_len );

        return plaintext;
}

static void* tls_assemble_block	(	struct tls_session *	tls,
		const void *	data,
		size_t	len,
		void *	digest,
		size_t *	plaintext_len
	)			[static]

Allocate and assemble block-ciphered record from data and MAC portions.

Parameters:

tls

TLS session

Return values:

	data	Data
	len	Length of data
	digest	MAC digest
	plaintext_len	Length of plaintext record
	plaintext	Allocated plaintext record

Definition at line 1123 of file tls.c.

References cipher_algorithm::blocksize, digest_algorithm::blocksize, tls_cipherspec::cipher, tls_cipherspec::digest, digest_algorithm::digestsize, malloc(), memcpy, memset(), NULL, and tls_session::tx_cipherspec.

Referenced by tls_send_plaintext().

                                                                         {
        size_t blocksize = tls->tx_cipherspec.cipher->blocksize;
        size_t iv_len = blocksize;
        size_t mac_len = tls->tx_cipherspec.digest->digestsize;
        size_t padding_len;
        void *plaintext;
        void *iv;
        void *content;
        void *mac;
        void *padding;

        /* FIXME: TLSv1.1 has an explicit IV */
        iv_len = 0;

        /* Calculate block-ciphered struct length */
        padding_len = ( ( blocksize - 1 ) & -( iv_len + len + mac_len + 1 ) );
        *plaintext_len = ( iv_len + len + mac_len + padding_len + 1 );

        /* Allocate block-ciphered struct */
        plaintext = malloc ( *plaintext_len );
        if ( ! plaintext )
                return NULL;
        iv = plaintext;
        content = ( iv + iv_len );
        mac = ( content + len );
        padding = ( mac + mac_len );

        /* Fill in block-ciphered struct */
        memset ( iv, 0, iv_len );
        memcpy ( content, data, len );
        memcpy ( mac, digest, mac_len );
        memset ( padding, padding_len, ( padding_len + 1 ) );

        return plaintext;
}

static int tls_split_stream	(	struct tls_session *	tls,
		void *	plaintext,
		size_t	plaintext_len,
		void **	data,
		size_t *	len,
		void **	digest
	)			[static]

Split stream-ciphered record into data and MAC portions.

Parameters:

	tls	TLS session
	plaintext	Plaintext record
	plaintext_len	Length of record

Return values:

	data	Data
	len	Length of data
	digest	MAC digest
	rc	Return status code

Definition at line 1268 of file tls.c.

References DBGC, DBGC_HD, tls_cipherspec::digest, digest_algorithm::digestsize, EINVAL, and tls_session::rx_cipherspec.

Referenced by tls_new_ciphertext().

                                                                        {
        void *content;
        size_t content_len;
        void *mac;
        size_t mac_len;

        /* Decompose stream-ciphered data */
        mac_len = tls->rx_cipherspec.digest->digestsize;
        if ( plaintext_len < mac_len ) {
                DBGC ( tls, "TLS %p received underlength record\n", tls );
                DBGC_HD ( tls, plaintext, plaintext_len );
                return -EINVAL;
        }
        content_len = ( plaintext_len - mac_len );
        content = plaintext;
        mac = ( content + content_len );

        /* Fill in return values */
        *data = content;
        *len = content_len;
        *digest = mac;

        return 0;
}

static int tls_split_block	(	struct tls_session *	tls,
		void *	plaintext,
		size_t	plaintext_len,
		void **	data,
		size_t *	len,
		void **	digest
	)			[static]

Split block-ciphered record into data and MAC portions.

Parameters:

	tls	TLS session
	plaintext	Plaintext record
	plaintext_len	Length of record

Return values:

	data	Data
	len	Length of data
	digest	MAC digest
	rc	Return status code

Definition at line 1306 of file tls.c.

References cipher_algorithm::blocksize, tls_cipherspec::cipher, DBGC, DBGC_HD, tls_cipherspec::digest, digest_algorithm::digestsize, EINVAL, and tls_session::rx_cipherspec.

Referenced by tls_new_ciphertext().

                                             {
        void *iv;
        size_t iv_len;
        void *content;
        size_t content_len;
        void *mac;
        size_t mac_len;
        void *padding;
        size_t padding_len;
        unsigned int i;

        /* Decompose block-ciphered data */
        if ( plaintext_len < 1 ) {
                DBGC ( tls, "TLS %p received underlength record\n", tls );
                DBGC_HD ( tls, plaintext, plaintext_len );
                return -EINVAL;
        }
        iv_len = tls->rx_cipherspec.cipher->blocksize;

        /* FIXME: TLSv1.1 uses an explicit IV */
        iv_len = 0;

        mac_len = tls->rx_cipherspec.digest->digestsize;
        padding_len = *( ( uint8_t * ) ( plaintext + plaintext_len - 1 ) );
        if ( plaintext_len < ( iv_len + mac_len + padding_len + 1 ) ) {
                DBGC ( tls, "TLS %p received underlength record\n", tls );
                DBGC_HD ( tls, plaintext, plaintext_len );
                return -EINVAL;
        }
        content_len = ( plaintext_len - iv_len - mac_len - padding_len - 1 );
        iv = plaintext;
        content = ( iv + iv_len );
        mac = ( content + content_len );
        padding = ( mac + mac_len );

        /* Verify padding bytes */
        for ( i = 0 ; i < padding_len ; i++ ) {
                if ( *( ( uint8_t * ) ( padding + i ) ) != padding_len ) {
                        DBGC ( tls, "TLS %p received bad padding\n", tls );
                        DBGC_HD ( tls, plaintext, plaintext_len );
                        return -EINVAL;
                }
        }

        /* Fill in return values */
        *data = content;
        *len = content_len;
        *digest = mac;

        return 0;
}

static int tls_new_ciphertext	(	struct tls_session *	tls,
		struct tls_header *	tlshdr,
		void *	ciphertext
	)			[static]

Receive new ciphertext record.

Parameters:

	tls	TLS session
	tlshdr	Record header
	ciphertext	Ciphertext record

Return values:

rc

Return status code

Definition at line 1369 of file tls.c.

References tls_cipherspec::cipher, tls_cipherspec::cipher_ctx, cipher_decrypt, DBGC, DBGC2, DBGC2_HD, DBGC_HD, tls_cipherspec::digest, digest_algorithm::digestsize, ENOMEM, free(), htons, is_stream_cipher(), tls_header::length, malloc(), memcmp(), ntohs, NULL, tls_session::rx_cipherspec, tls_session::rx_seq, tls_hmac(), tls_new_record(), tls_split_block(), tls_split_stream(), tls_header::type, and tls_header::version.

Referenced by tls_newdata_process_data().

                                                                              {
        struct tls_header plaintext_tlshdr;
        struct tls_cipherspec *cipherspec = &tls->rx_cipherspec;
        size_t record_len = ntohs ( tlshdr->length );
        void *plaintext = NULL;
        void *data;
        size_t len;
        void *mac;
        size_t mac_len = cipherspec->digest->digestsize;
        uint8_t verify_mac[mac_len];
        int rc;

        /* Allocate buffer for plaintext */
        plaintext = malloc ( record_len );
        if ( ! plaintext ) {
                DBGC ( tls, "TLS %p could not allocate %zd bytes for "
                       "decryption buffer\n", tls, record_len );
                rc = -ENOMEM;
                goto done;
        }

        /* Decrypt the record */
        cipher_decrypt ( cipherspec->cipher, cipherspec->cipher_ctx,
                         ciphertext, plaintext, record_len );

        /* Split record into content and MAC */
        if ( is_stream_cipher ( cipherspec->cipher ) ) {
                if ( ( rc = tls_split_stream ( tls, plaintext, record_len,
                                               &data, &len, &mac ) ) != 0 )
                        goto done;
        } else {
                if ( ( rc = tls_split_block ( tls, plaintext, record_len,
                                              &data, &len, &mac ) ) != 0 )
                        goto done;
        }

        /* Verify MAC */
        plaintext_tlshdr.type = tlshdr->type;
        plaintext_tlshdr.version = tlshdr->version;
        plaintext_tlshdr.length = htons ( len );
        tls_hmac ( tls, cipherspec, tls->rx_seq, &plaintext_tlshdr,
                   data, len, verify_mac);
        if ( memcmp ( mac, verify_mac, mac_len ) != 0 ) {
                DBGC ( tls, "TLS %p failed MAC verification\n", tls );
                DBGC_HD ( tls, plaintext, record_len );
                goto done;
        }

        DBGC2 ( tls, "Received plaintext data:\n" );
        DBGC2_HD ( tls, data, len );

        /* Process plaintext record */
        if ( ( rc = tls_new_record ( tls, tlshdr->type, data, len ) ) != 0 )
                goto done;

        rc = 0;
 done:
        free ( plaintext );
        return rc;
}

static void tls_plainstream_close	(	struct xfer_interface *	xfer,
		int	rc
	)			[static]

Close interface.

Parameters:

	xfer	Plainstream data transfer interface
	rc	Reason for close

Definition at line 1444 of file tls.c.

References container_of, tls_session::plainstream, tls_close(), and xfer_filter_half::xfer.

                                                                          {
        struct tls_session *tls =
                container_of ( xfer, struct tls_session, plainstream.xfer );

        tls_close ( tls, rc );
}

static size_t tls_plainstream_window

(

struct xfer_interface *

xfer

)

[static]

Check flow control window.

Parameters:

xfer

Plainstream data transfer interface

Return values:

len

Length of window

Definition at line 1457 of file tls.c.

References container_of, filter_window(), tls_session::plainstream, TLS_TX_DATA, tls_session::tx_state, and xfer_filter_half::xfer.

                                                                     {
        struct tls_session *tls =
                container_of ( xfer, struct tls_session, plainstream.xfer );

        /* Block window unless we are ready to accept data */
        if ( tls->tx_state != TLS_TX_DATA )
                return 0;

        return filter_window ( xfer );
}

static int tls_plainstream_deliver_raw	(	struct xfer_interface *	xfer,
		const void *	data,
		size_t	len
	)			[static]

Deliver datagram as raw data.

Parameters:

	xfer	Plainstream data transfer interface
	data	Data buffer
	len	Length of data buffer

Return values:

rc

Return status code

Definition at line 1476 of file tls.c.

References container_of, ENOTCONN, tls_session::plainstream, tls_send_plaintext(), TLS_TX_DATA, TLS_TYPE_DATA, tls_session::tx_state, and xfer_filter_half::xfer.

                                                                        {
        struct tls_session *tls =
                container_of ( xfer, struct tls_session, plainstream.xfer );
        
        /* Refuse unless we are ready to accept data */
        if ( tls->tx_state != TLS_TX_DATA )
                return -ENOTCONN;

        return tls_send_plaintext ( tls, TLS_TYPE_DATA, data, len );
}

static void tls_cipherstream_close	(	struct xfer_interface *	xfer,
		int	rc
	)			[static]

Close interface.

Parameters:

	xfer	Plainstream data transfer interface
	rc	Reason for close

Definition at line 1511 of file tls.c.

References tls_session::cipherstream, container_of, tls_close(), and xfer_filter_half::xfer.

                                                                           {
        struct tls_session *tls =
                container_of ( xfer, struct tls_session, cipherstream.xfer );

        tls_close ( tls, rc );
}

static int tls_newdata_process_header

(

struct tls_session *

tls

)

[static]

Handle received TLS header.

Parameters:

tls

TLS session

Return values:

rc

Returned status code

Definition at line 1524 of file tls.c.

References assert, DBGC, ENOMEM, tls_header::length, malloc(), ntohs, NULL, tls_session::rx_data, tls_session::rx_header, tls_session::rx_state, and TLS_RX_DATA.

Referenced by tls_cipherstream_deliver_raw().

                                                                  {
        size_t data_len = ntohs ( tls->rx_header.length );

        /* Allocate data buffer now that we know the length */
        assert ( tls->rx_data == NULL );
        tls->rx_data = malloc ( data_len );
        if ( ! tls->rx_data ) {
                DBGC ( tls, "TLS %p could not allocate %zd bytes "
                       "for receive buffer\n", tls, data_len );
                return -ENOMEM;
        }

        /* Move to data state */
        tls->rx_state = TLS_RX_DATA;

        return 0;
}

static int tls_newdata_process_data

(

struct tls_session *

tls

)

[static]

Handle received TLS data payload.

Parameters:

tls

TLS session

Return values:

rc

Returned status code

Definition at line 1548 of file tls.c.

References free(), NULL, tls_session::rx_data, tls_session::rx_header, tls_session::rx_seq, tls_session::rx_state, tls_new_ciphertext(), and TLS_RX_HEADER.

Referenced by tls_cipherstream_deliver_raw().

                                                                {
        int rc;

        /* Process record */
        if ( ( rc = tls_new_ciphertext ( tls, &tls->rx_header,
                                         tls->rx_data ) ) != 0 )
                return rc;

        /* Increment RX sequence number */
        tls->rx_seq += 1;

        /* Free data buffer */
        free ( tls->rx_data );
        tls->rx_data = NULL;

        /* Return to header state */
        tls->rx_state = TLS_RX_HEADER;

        return 0;
}

static int tls_cipherstream_deliver_raw	(	struct xfer_interface *	xfer,
		const void *	data,
		size_t	len
	)			[static]

Receive new ciphertext.

Parameters:

	app	Stream application
	data	Data received
	len	Length of received data

Return values:

rc

Return status code

Definition at line 1577 of file tls.c.

References assert, tls_session::cipherstream, container_of, EINVAL, tls_header::length, memcpy, ntohs, tls_session::rx_data, tls_session::rx_header, tls_session::rx_rcvd, tls_session::rx_state, tls_close(), tls_newdata_process_data(), tls_newdata_process_header(), TLS_RX_DATA, TLS_RX_HEADER, and xfer_filter_half::xfer.

                                                                         {
        struct tls_session *tls = 
                container_of ( xfer, struct tls_session, cipherstream.xfer );
        size_t frag_len;
        void *buf;
        size_t buf_len;
        int ( * process ) ( struct tls_session *tls );
        int rc;

        while ( len ) {
                /* Select buffer according to current state */
                switch ( tls->rx_state ) {
                case TLS_RX_HEADER:
                        buf = &tls->rx_header;
                        buf_len = sizeof ( tls->rx_header );
                        process = tls_newdata_process_header;
                        break;
                case TLS_RX_DATA:
                        buf = tls->rx_data;
                        buf_len = ntohs ( tls->rx_header.length );
                        process = tls_newdata_process_data;
                        break;
                default:
                        assert ( 0 );
                        return -EINVAL;
                }

                /* Copy data portion to buffer */
                frag_len = ( buf_len - tls->rx_rcvd );
                if ( frag_len > len )
                        frag_len = len;
                memcpy ( ( buf + tls->rx_rcvd ), data, frag_len );
                tls->rx_rcvd += frag_len;
                data += frag_len;
                len -= frag_len;

                /* Process data if buffer is now full */
                if ( tls->rx_rcvd == buf_len ) {
                        if ( ( rc = process ( tls ) ) != 0 ) {
                                tls_close ( tls, rc );
                                return rc;
                        }
                        tls->rx_rcvd = 0;
                }
        }

        return 0;
}

static void tls_step

(

struct process *

process

)

[static]

TLS TX state machine.

Parameters:

process

TLS process

Definition at line 1649 of file tls.c.

References assert, tls_session::cipherstream, container_of, DBGC, strerror(), tls_change_cipher(), tls_close(), tls_send_change_cipher(), tls_send_client_hello(), tls_send_client_key_exchange(), tls_send_finished(), TLS_TX_CHANGE_CIPHER, TLS_TX_CLIENT_HELLO, TLS_TX_CLIENT_KEY_EXCHANGE, TLS_TX_DATA, TLS_TX_FINISHED, TLS_TX_NONE, tls_session::tx_cipherspec, tls_session::tx_cipherspec_pending, tls_session::tx_seq, tls_session::tx_state, xfer_filter_half::xfer, and xfer_window().

Referenced by add_tls().

                                                 {
        struct tls_session *tls =
                container_of ( process, struct tls_session, process );
        int rc;

        /* Wait for cipherstream to become ready */
        if ( ! xfer_window ( &tls->cipherstream.xfer ) )
                return;

        switch ( tls->tx_state ) {
        case TLS_TX_NONE:
                /* Nothing to do */
                break;
        case TLS_TX_CLIENT_HELLO:
                /* Send Client Hello */
                if ( ( rc = tls_send_client_hello ( tls ) ) != 0 ) {
                        DBGC ( tls, "TLS %p could not send Client Hello: %s\n",
                               tls, strerror ( rc ) );
                        goto err;
                }
                tls->tx_state = TLS_TX_NONE;
                break;
        case TLS_TX_CLIENT_KEY_EXCHANGE:
                /* Send Client Key Exchange */
                if ( ( rc = tls_send_client_key_exchange ( tls ) ) != 0 ) {
                        DBGC ( tls, "TLS %p could send Client Key Exchange: "
                               "%s\n", tls, strerror ( rc ) );
                        goto err;
                }
                tls->tx_state = TLS_TX_CHANGE_CIPHER;
                break;
        case TLS_TX_CHANGE_CIPHER:
                /* Send Change Cipher, and then change the cipher in use */
                if ( ( rc = tls_send_change_cipher ( tls ) ) != 0 ) {
                        DBGC ( tls, "TLS %p could not send Change Cipher: "
                               "%s\n", tls, strerror ( rc ) );
                        goto err;
                }
                if ( ( rc = tls_change_cipher ( tls,
                                                &tls->tx_cipherspec_pending,
                                                &tls->tx_cipherspec )) != 0 ){
                        DBGC ( tls, "TLS %p could not activate TX cipher: "
                               "%s\n", tls, strerror ( rc ) );
                        goto err;
                }
                tls->tx_seq = 0;
                tls->tx_state = TLS_TX_FINISHED;
                break;
        case TLS_TX_FINISHED:
                /* Send Finished */
                if ( ( rc = tls_send_finished ( tls ) ) != 0 ) {
                        DBGC ( tls, "TLS %p could not send Finished: %s\n",
                               tls, strerror ( rc ) );
                        goto err;
                }
                tls->tx_state = TLS_TX_NONE;
                break;
        case TLS_TX_DATA:
                /* Nothing to do */
                break;
        default:
                assert ( 0 );
        }

        return;

 err:
        tls_close ( tls, rc );
}

int add_tls	(	struct xfer_interface *	xfer,
		struct xfer_interface **	next
	)

Definition at line 1726 of file tls.c.

References tls_session::cipherstream, tls_session::client_random, digest_init(), ENOMEM, filter_init(), refcnt::free, free_tls(), tls_client_random::gmt_unix_time, tls_session::handshake_md5_ctx, tls_session::handshake_sha1_ctx, htons, malloc(), md5_algorithm, memset(), tls_session::plainstream, tls_session::pre_master_secret, tls_session::process, process_init(), tls_pre_master_secret::random, tls_client_random::random, ref_put(), tls_session::refcnt, tls_session::rx_cipherspec, tls_session::rx_cipherspec_pending, sha1_algorithm, tls_clear_cipher(), tls_generate_random(), tls_step(), TLS_TX_CLIENT_HELLO, TLS_VERSION_TLS_1_0, tls_session::tx_cipherspec, tls_session::tx_cipherspec_pending, tls_session::tx_state, tls_pre_master_secret::version, and xfer_filter_half::xfer.

Referenced by https_open().

                                                                          {
        struct tls_session *tls;

        /* Allocate and initialise TLS structure */
        tls = malloc ( sizeof ( *tls ) );
        if ( ! tls )
                return -ENOMEM;
        memset ( tls, 0, sizeof ( *tls ) );
        tls->refcnt.free = free_tls;
        filter_init ( &tls->plainstream, &tls_plainstream_operations,
                      &tls->cipherstream, &tls_cipherstream_operations,
                      &tls->refcnt );
        tls_clear_cipher ( tls, &tls->tx_cipherspec );
        tls_clear_cipher ( tls, &tls->tx_cipherspec_pending );
        tls_clear_cipher ( tls, &tls->rx_cipherspec );
        tls_clear_cipher ( tls, &tls->rx_cipherspec_pending );
        tls->client_random.gmt_unix_time = 0;
        tls_generate_random ( &tls->client_random.random,
                              ( sizeof ( tls->client_random.random ) ) );
        tls->pre_master_secret.version = htons ( TLS_VERSION_TLS_1_0 );
        tls_generate_random ( &tls->pre_master_secret.random,
                              ( sizeof ( tls->pre_master_secret.random ) ) );
        digest_init ( &md5_algorithm, tls->handshake_md5_ctx );
        digest_init ( &sha1_algorithm, tls->handshake_sha1_ctx );
        tls->tx_state = TLS_TX_CLIENT_HELLO;
        process_init ( &tls->process, tls_step, &tls->refcnt );

        /* Attach to parent interface, mortalise self, and return */
        xfer_plug_plug ( &tls->plainstream.xfer, xfer );
        *next = &tls->cipherstream.xfer;
        ref_put ( &tls->refcnt );
        return 0;
}

---

Variable Documentation

struct xfer_interface_operations tls_plainstream_operations [static]

Initial value:

 {
        .close          = tls_plainstream_close,
        .vredirect      = ignore_xfer_vredirect,
        .window         = tls_plainstream_window,
        .alloc_iob      = default_xfer_alloc_iob,
        .deliver_iob    = xfer_deliver_as_raw,
        .deliver_raw    = tls_plainstream_deliver_raw,
}

TLS plaintext stream operations.

Definition at line 1489 of file tls.c.

struct xfer_interface_operations tls_cipherstream_operations [static]

Initial value:

 {
        .close          = tls_cipherstream_close,
        .vredirect      = xfer_vreopen,
        .window         = filter_window,
        .alloc_iob      = default_xfer_alloc_iob,
        .deliver_iob    = xfer_deliver_as_raw,
        .deliver_raw    = tls_cipherstream_deliver_raw,
}

TLS ciphertext stream operations.

Definition at line 1628 of file tls.c.