gcm.h File Reference

Galois/Counter Mode (GCM) More...

#include <stdint.h>
#include <ipxe/crypto.h>

Go to the source code of this file.

Data Structures
struct	gcm_counter
	A GCM counter. More...
struct	gcm_lengths
	A GCM length pair. More...
union	gcm_block
	A GCM block. More...
struct	gcm_context
	GCM context. More...

Macros
#define	GCM_CIPHER(_gcm_name, _gcm_cipher, _raw_cipher, _raw_context, _blocksize)
	Create a GCM mode of behaviour of an existing cipher. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
void	gcm_tag (struct gcm_context *context, union gcm_block *tag)
	Construct tag. More...
int	gcm_setkey (struct gcm_context *context, const void *key, size_t keylen, struct cipher_algorithm *raw_cipher)
	Set key. More...
void	gcm_setiv (struct gcm_context *context, const void *iv, size_t ivlen)
	Set initialisation vector. More...
void	gcm_encrypt (struct gcm_context *context, const void *src, void *dst, size_t len)
	Encrypt data. More...
void	gcm_decrypt (struct gcm_context *context, const void *src, void *dst, size_t len)
	Decrypt data. More...

Detailed Description

Galois/Counter Mode (GCM)

Definition in file gcm.h.

Macro Definition Documentation

GCM_CIPHER

#define GCM_CIPHER	(		_gcm_name,
			_gcm_cipher,
			_raw_cipher,
			_raw_context,
			_blocksize
	)

Create a GCM mode of behaviour of an existing cipher.

Parameters

_cbc_name	Name for the new CBC cipher
_cbc_cipher	New cipher algorithm
_raw_cipher	Underlying cipher algorithm
_raw_context	Context structure for the underlying cipher
_blocksize	Cipher block size

Definition at line 80 of file gcm.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

gcm_tag()

void gcm_tag	(	struct gcm_context *	context,
		union gcm_block *	tag
	)

Construct tag.

Parameters

context	Context
tag	Tag

Definition at line 408 of file gcm.c.

                                                                   {
        union gcm_block tmp;
        uint32_t offset;

        /* Construct hash */
        gcm_hash ( context, tag );

        /* Construct encrypted initial counter value */
        memcpy ( &tmp, &context->ctr, sizeof ( tmp ) );
        offset = ( ( -context->len.len.data ) / ( 8 * sizeof ( tmp ) ) );
        gcm_count ( &tmp, offset );
        cipher_encrypt ( context->raw_cipher, &context->raw_ctx, &tmp,
                         &tmp, sizeof ( tmp ) );
        DBGC2 ( context, "GCM %p E(K,Y[0]):\n", context );
        DBGC2_HDA ( context, 0, &tmp, sizeof ( tmp ) );

        /* Construct tag */
        gcm_xor_block ( &tmp, tag );
        DBGC2 ( context, "GCM %p T:\n", context );
        DBGC2_HDA ( context, 0, tag, sizeof ( *tag ) );
}

References cipher_encrypt, gcm_context::ctr, gcm_lengths::data, DBGC2, DBGC2_HDA, gcm_count(), gcm_hash(), gcm_xor_block(), gcm_block::len, gcm_context::len, memcpy(), offset, gcm_context::raw_cipher, gcm_context::raw_ctx, tag, and tmp.

gcm_setkey()

int gcm_setkey	(	struct gcm_context *	context,
		const void *	key,
		size_t	keylen,
		struct cipher_algorithm *	raw_cipher
	)

Set key.

Parameters

context	Context
key	Key
keylen	Key length
raw_cipher	Underlying cipher

Return values

rc	Return status code

Definition at line 439 of file gcm.c.

                                                       {
        int rc;

        /* Initialise GCM context */
        memset ( context, 0, sizeof ( *context ) );
        context->raw_cipher = raw_cipher;

        /* Set underlying block cipher key */
        if ( ( rc = cipher_setkey ( raw_cipher, context->raw_ctx, key,
                                    keylen ) ) != 0 )
                return rc;

        /* Construct GCM hash key */
        cipher_encrypt ( raw_cipher, context->raw_ctx, &context->ctr,
                         &context->key, sizeof ( context->key ) );
        DBGC2 ( context, "GCM %p H:\n", context );
        DBGC2_HDA ( context, 0, &context->key, sizeof ( context->key ) );

        /* Reset counter */
        context->ctr.ctr.value = cpu_to_be32 ( 1 );

        /* Construct cached tables */
        gcm_cache ( &context->key );

        return 0;
}

References cipher_encrypt, cipher_setkey(), cpu_to_be32, gcm_context::ctr, gcm_block::ctr, DBGC2, DBGC2_HDA, gcm_cache(), key, gcm_context::key, memset(), gcm_context::raw_cipher, gcm_context::raw_ctx, rc, and gcm_counter::value.

gcm_setiv()

void gcm_setiv	(	struct gcm_context *	context,
		const void *	iv,
		size_t	ivlen
	)

Set initialisation vector.

Parameters

ctx	Context
iv	Initialisation vector
ivlen	Initialisation vector length

Definition at line 474 of file gcm.c.

                                                                             {

        /* Reset non-key state */
        memset ( context, 0, gcm_offset ( key ) );
        build_assert ( gcm_offset ( key ) > gcm_offset ( hash ) );
        build_assert ( gcm_offset ( key ) > gcm_offset ( len ) );
        build_assert ( gcm_offset ( key ) > gcm_offset ( ctr ) );
        build_assert ( gcm_offset ( key ) < gcm_offset ( raw_cipher ) );
        build_assert ( gcm_offset ( key ) < gcm_offset ( raw_ctx ) );

        /* Reset counter */
        context->ctr.ctr.value = cpu_to_be32 ( 1 );

        /* Process initialisation vector */
        if ( ivlen == sizeof ( context->ctr.ctr.iv ) ) {

                /* Initialisation vector is exactly 96 bits, use it as-is */
                memcpy ( context->ctr.ctr.iv, iv, ivlen );

        } else {

                /* Calculate hash over initialisation vector */
                gcm_process ( context, iv, NULL, ivlen, GCM_FL_IV );
                gcm_hash ( context, &context->ctr );
                assert ( context->len.len.add == 0 );

                /* Reset non-key, non-counter state */
                memset ( context, 0, gcm_offset ( ctr ) );
                build_assert ( gcm_offset ( ctr ) > gcm_offset ( hash ) );
                build_assert ( gcm_offset ( ctr ) > gcm_offset ( len ) );
                build_assert ( gcm_offset ( ctr ) < gcm_offset ( key ) );
                build_assert ( gcm_offset ( ctr ) < gcm_offset ( raw_cipher ) );
                build_assert ( gcm_offset ( ctr ) < gcm_offset ( raw_ctx ) );
        }

        DBGC2 ( context, "GCM %p Y[0]:\n", context );
        DBGC2_HDA ( context, 0, &context->ctr, sizeof ( context->ctr ) );
}

References gcm_lengths::add, assert(), build_assert, cpu_to_be32, gcm_context::ctr, gcm_block::ctr, DBGC2, DBGC2_HDA, GCM_FL_IV, gcm_hash(), gcm_offset, gcm_process(), hash, gcm_counter::iv, iv, key, gcm_context::len, gcm_block::len, len, memcpy(), memset(), NULL, and gcm_counter::value.

gcm_encrypt()

void gcm_encrypt	(	struct gcm_context *	context,
		const void *	src,
		void *	dst,
		size_t	len
	)

Encrypt data.

Parameters

context	Context
src	Data to encrypt
dst	Buffer for encrypted data, or NULL for additional data
len	Length of data

Definition at line 521 of file gcm.c.

                                {

        /* Process data */
        gcm_process ( context, src, dst, len, GCM_FL_ENCRYPT );
}

References GCM_FL_ENCRYPT, gcm_process(), len, and src.

gcm_decrypt()

void gcm_decrypt	(	struct gcm_context *	context,
		const void *	src,
		void *	dst,
		size_t	len
	)

Decrypt data.

Parameters

context	Context
src	Data to decrypt
dst	Buffer for decrypted data, or NULL for additional data
len	Length of data

Definition at line 536 of file gcm.c.

                                {

        /* Process data */
        gcm_process ( context, src, dst, len, 0 );
}

References gcm_process(), len, and src.