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_context_t(ctxsize)
	A GCM mode context.
#define	GCM_CIPHER(_gcm_name, _gcm_cipher, _raw_cipher, _raw_context, _blocksize)
	Create a GCM mode of behaviour of an existing cipher.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
int	gcm_setkey (struct cipher_algorithm *cipher, void *ctx, const void *key, size_t keylen)
	Set key.
int	gcm_setiv (struct cipher_algorithm *cipher, void *ctx, const void *iv, size_t ivlen)
	Set initialisation vector.
void	gcm_encrypt (struct cipher_algorithm *cipher, void *ctx, const void *src, void *dst, size_t len)
	Encrypt data.
void	gcm_decrypt (struct cipher_algorithm *cipher, void *ctx, const void *src, void *dst, size_t len)
	Decrypt data.
void	gcm_auth (struct cipher_algorithm *cipher, void *ctx, void *auth)
	Generate authentication tag.

Detailed Description

Galois/Counter Mode (GCM).

Definition in file gcm.h.

Macro Definition Documentation

gcm_context_t

#define gcm_context_t

(

ctxsize

)

Value:

struct {                                                        \
        struct gcm_context gcm;                                 \
        uint8_t raw[ (ctxsize) -                                \
                     sizeof ( struct gcm_context ) ];           \
}

A GCM mode context.

Definition at line 61 of file gcm.h.

#define gcm_context_t( ctxsize )                                        \
        struct {                                                        \
                struct gcm_context gcm;                                 \
                uint8_t raw[ (ctxsize) -                                \
                             sizeof ( struct gcm_context ) ];           \
        }

Referenced by gcm_auth(), gcm_decrypt(), gcm_encrypt(), gcm_process(), gcm_setiv(), and gcm_setkey().

GCM_CIPHER

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

Value:

static_assert ( _blocksize == sizeof ( union gcm_block ) );             \
struct cipher_algorithm _gcm_cipher = {                                 \
        .name           = #_gcm_name,                                   \
        .ctxsize        = ( sizeof ( struct gcm_context ) +             \
                            sizeof ( _raw_context ) ),                  \
        .blocksize      = 1,                                            \
        .alignsize      = sizeof ( union gcm_block ),                   \
        .authsize       = sizeof ( union gcm_block ),                   \
        .confidential   = 1,                                            \
        .setkey         = gcm_setkey,                                   \
        .setiv          = gcm_setiv,                                    \
        .encrypt        = gcm_encrypt,                                  \
        .decrypt        = gcm_decrypt,                                  \
        .auth           = gcm_auth,                                     \
        .priv           = &_raw_cipher,                                 \
};

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 88 of file gcm.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

gcm_setkey()

int gcm_setkey ( struct cipher_algorithm * cipher, void * ctx, const void * key, size_t keylen )

extern

Set key.

Parameters

cipher	Cipher algorithm
ctx	Context
key	Key
keylen	Key length

Return values

rc	Return status code

Definition at line 419 of file gcm.c.

                                                  {
        struct cipher_algorithm *raw_cipher = cipher->priv;
        gcm_context_t ( cipher->ctxsize ) *context = ctx;
        int rc;
 
        /* Initialise GCM context */
        memset ( &context->gcm, 0, sizeof ( context->gcm ) );
 
        /* Set underlying block cipher key */
        if ( ( rc = cipher_setkey ( raw_cipher, context->raw, key,
                                    keylen ) ) != 0 )
                return rc;
 
        /* Construct GCM hash key */
        cipher_encrypt ( raw_cipher, context->raw, &context->gcm.ctr,
                         &context->gcm.key, sizeof ( context->gcm.key ) );
        DBGC2 ( context, "GCM %p H:\n", context );
        DBGC2_HDA ( context, 0, &context->gcm.key,
                    sizeof ( context->gcm.key ) );
 
        /* Reset counter */
        context->gcm.ctr.ctr.value = cpu_to_be32 ( 1 );
 
        /* Construct cached tables */
        gcm_cache ( &context->gcm.key );
 
        return 0;
}

References cipher_encrypt, cipher_setkey(), cpu_to_be32, ctx, cipher_algorithm::ctxsize, DBGC2, DBGC2_HDA, gcm_cache(), gcm_context_t, key, memset(), cipher_algorithm::priv, and rc.

gcm_setiv()

int gcm_setiv ( struct cipher_algorithm * cipher, void * ctx, const void * iv, size_t ivlen )

extern

Set initialisation vector.

Parameters

cipher	Cipher algorithm
ctx	Context
iv	Initialisation vector
ivlen	Initialisation vector length

Return values

rc	Return status code

Definition at line 458 of file gcm.c.

                                               {
        gcm_context_t ( cipher->ctxsize ) *context = ctx;
 
        /* Reset non-key state */
        memset ( &context->gcm, 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 ) );
 
        /* Reset counter */
        context->gcm.ctr.ctr.value = cpu_to_be32 ( 1 );
 
        /* Process initialisation vector */
        if ( ivlen == sizeof ( context->gcm.ctr.ctr.iv ) ) {
 
                /* Initialisation vector is exactly 96 bits, use it as-is */
                memcpy ( context->gcm.ctr.ctr.iv, iv, ivlen );
 
        } else if ( ivlen ) {
 
                /* Calculate hash over initialisation vector */
                context->gcm.flags = GCM_FL_IV;
                gcm_process ( cipher, ctx, iv, NULL, ivlen );
                gcm_hash ( &context->gcm, &context->gcm.ctr );
                assert ( context->gcm.len.len.add == 0 );
 
                /* Reset non-key, non-counter state */
                memset ( &context->gcm, 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 ) );
 
        } else {
 
                /* Zero-length IVs are not permitted */
                return -ENOTSUP;
        }
 
        DBGC2 ( context, "GCM %p Y[0]:\n", context );
        DBGC2_HDA ( context, 0, &context->gcm.ctr,
                    sizeof ( context->gcm.ctr ) );
        return 0;
}

References assert, build_assert, cpu_to_be32, ctx, cipher_algorithm::ctxsize, DBGC2, DBGC2_HDA, ENOTSUP, gcm_context_t, GCM_FL_IV, gcm_hash(), gcm_offset, gcm_process(), hash, iv, key, len, memcpy(), memset(), and NULL.

gcm_encrypt()

void gcm_encrypt ( struct cipher_algorithm * cipher, void * ctx, const void * src, void * dst, size_t len )

extern

Encrypt data.

Parameters

cipher	Cipher algorithm
ctx	Context
src	Data to encrypt
dst	Buffer for encrypted data, or NULL for additional data
len	Length of data

Definition at line 512 of file gcm.c.

                                                            {
        gcm_context_t ( cipher->ctxsize ) *context = ctx;
 
        /* Process data */
        context->gcm.flags = GCM_FL_ENCRYPT;
        gcm_process ( cipher, ctx, src, dst, len );
}

References ctx, cipher_algorithm::ctxsize, gcm_context_t, GCM_FL_ENCRYPT, gcm_process(), len, and src.

gcm_decrypt()

void gcm_decrypt ( struct cipher_algorithm * cipher, void * ctx, const void * src, void * dst, size_t len )

extern

Decrypt data.

Parameters

cipher	Cipher algorithm
ctx	Context
src	Data to decrypt
dst	Buffer for decrypted data, or NULL for additional data
len	Length of data

Definition at line 530 of file gcm.c.

                                                            {
        gcm_context_t ( cipher->ctxsize ) *context = ctx;
 
        /* Process data */
        context->gcm.flags = 0;
        gcm_process ( cipher, ctx, src, dst, len );
}

References ctx, cipher_algorithm::ctxsize, gcm_context_t, gcm_process(), len, and src.

gcm_auth()

void gcm_auth ( struct cipher_algorithm * cipher, void * ctx, void * auth )

extern

Generate authentication tag.

Parameters

cipher	Cipher algorithm
ctx	Context
auth	Authentication tag

Definition at line 546 of file gcm.c.

                                                                         {
        struct cipher_algorithm *raw_cipher = cipher->priv;
        gcm_context_t ( cipher->ctxsize ) *context = ctx;
        union gcm_block *tag = auth;
        union gcm_block tmp;
        uint32_t offset;
 
        /* Construct hash */
        gcm_hash ( &context->gcm, tag );
 
        /* Construct encrypted initial counter value */
        memcpy ( &tmp, &context->gcm.ctr, sizeof ( tmp ) );
        offset = ( ( -context->gcm.len.len.data ) / ( 8 * sizeof ( tmp ) ) );
        gcm_count ( &tmp, offset );
        cipher_encrypt ( raw_cipher, &context->raw, &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, ctx, cipher_algorithm::ctxsize, DBGC2, DBGC2_HDA, gcm_context_t, gcm_count(), gcm_hash(), gcm_xor_block(), memcpy(), offset, cipher_algorithm::priv, tag, and tmp.