mdhash.h File Reference

Merkle-Damgård hash algorithms. More...

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

Go to the source code of this file.

Data Structures
union	mdhash_len
	Merkle-Damgård trailing bit-length count. More...
struct	mdhash_algorithm
	Merkle-Damgård hash algorithm. More...

Macros
#define	mdhash_dd_t(digestsize, blocksize)
	Merkle-Damgård hash algorithm digest and data block.
#define	mdhash_context_t(digestsize, blocksize)
	Merkle-Damgård hash algorithm context.
#define	MDHASH_DD_PTR(_dd)
	Merkle-Damgård hash algorithm digest and data block sample pointer.
#define	MDHASH_COMPRESS_PTR(_dd)
	Merkle-Damgård hash algorithm compression function sample pointer.
#define	MDHASH_DIGEST_SIZE(_dd)
	Merkle-Damgård hash algorithm digest size.
#define	MDHASH_TOGGLE(_dd, _byteorder)
	Merkle-Damgård hash algorithm data toggle.
#define	MDHASH_LEN_LEN(_dd)
	Merkle-Damgård hash algorithm length field length.
#define	MDHASH_LEN_TOGGLE(_dd, _byteorder)
	Merkle-Damgård hash algorithm length field toggle.
#define	MDHASH_BLOCK_SIZE(_dd)
	Merkle-Damgård hash algorithm block size.
#define	MDHASH_CTX_SIZE(_dd)
	Merkle-Damgård hash algorithm context size.
#define	MDHASH_ALGORITHM(_name, _digest, _compress, _byteorder, _dd, _init, _digestsize)
	Define a Merkle-Damgård hash algorithm.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
void	mdhash_init (struct digest_algorithm *digest, void *ctx)
	Initialise algorithm.
void	mdhash_update (struct digest_algorithm *digest, void *ctx, const void *src, size_t len)
	Accumulate data.
void	mdhash_final (struct digest_algorithm *digest, void *ctx, void *out)
	Generate digest.

Detailed Description

Merkle-Damgård hash algorithms.

Definition in file mdhash.h.

Macro Definition Documentation

mdhash_dd_t

#define mdhash_dd_t	(		digestsize,
			blocksize )

Value:

struct {                                                        \
        /** Digest of data already processed */                 \
        uint8_t digest[ (digestsize) ];                         \
        /** Accumulated data */                                 \
        uint8_t data[ (blocksize) ];                            \
} __attribute__ (( packed ))

Merkle-Damgård hash algorithm digest and data block.

Definition at line 19 of file mdhash.h.

#define mdhash_dd_t( digestsize, blocksize )                            \
        struct {                                                        \
                /** Digest of data already processed */                 \
                uint8_t digest[ (digestsize) ];                         \
                /** Accumulated data */                                 \
                uint8_t data[ (blocksize) ];                            \
        } __attribute__ (( packed ))

mdhash_context_t

#define mdhash_context_t	(		digestsize,
			blocksize )

Value:

struct {                                                        \
        /** Amount of accumulated data */                       \
        size_t len;                                             \
        /** Digest and accumulated data */                      \
        mdhash_dd_t ( (digestsize), (blocksize) ) dd;           \
}

Merkle-Damgård hash algorithm context.

Definition at line 28 of file mdhash.h.

#define mdhash_context_t( digestsize, blocksize )                       \
        struct {                                                        \
                /** Amount of accumulated data */                       \
                size_t len;                                             \
                /** Digest and accumulated data */                      \
                mdhash_dd_t ( (digestsize), (blocksize) ) dd;           \
        }

Referenced by mdhash_final(), mdhash_init(), and mdhash_update().

MDHASH_DD_PTR

#define MDHASH_DD_PTR

(

_dd

)

Value:

( ( typeof (_dd) * ) NULL )

Merkle-Damgård hash algorithm digest and data block sample pointer.

Definition at line 93 of file mdhash.h.

MDHASH_COMPRESS_PTR

#define MDHASH_COMPRESS_PTR

(

_dd

)

Value:

( ( void ( * )                                                  \
    ( _dd *, const typeof ( MDHASH_DD_PTR (_dd)->digest ) * ) ) \
  NULL )

Merkle-Damgård hash algorithm compression function sample pointer.

Definition at line 96 of file mdhash.h.

#define MDHASH_COMPRESS_PTR( _dd )                                      \
        ( ( void ( * )                                                  \
            ( _dd *, const typeof ( MDHASH_DD_PTR (_dd)->digest ) * ) ) \
          NULL )

MDHASH_DIGEST_SIZE

#define MDHASH_DIGEST_SIZE

(

_dd

)

Value:

( sizeof ( MDHASH_DD_PTR (_dd)->digest ) )

Merkle-Damgård hash algorithm digest size.

Definition at line 102 of file mdhash.h.

#define MDHASH_DIGEST_SIZE( _dd )                                       \
        ( sizeof ( MDHASH_DD_PTR (_dd)->digest ) )

MDHASH_TOGGLE

#define MDHASH_TOGGLE	(		_dd,
			_byteorder )

Value:

( ( (_byteorder) == __BYTE_ORDER ) ? 0 :                        \
  ( sizeof ( MDHASH_DD_PTR (_dd)->digest.h[0] ) - 1 ) )

Merkle-Damgård hash algorithm data toggle.

Definition at line 106 of file mdhash.h.

#define MDHASH_TOGGLE( _dd, _byteorder )                                \
        ( ( (_byteorder) == __BYTE_ORDER ) ? 0 :                        \
          ( sizeof ( MDHASH_DD_PTR (_dd)->digest.h[0] ) - 1 ) )

MDHASH_LEN_LEN

#define MDHASH_LEN_LEN

(

_dd

)

Value:

( sizeof ( MDHASH_DD_PTR (_dd)->data.final.len ) )

Merkle-Damgård hash algorithm length field length.

Definition at line 111 of file mdhash.h.

#define MDHASH_LEN_LEN( _dd )                                           \
        ( sizeof ( MDHASH_DD_PTR (_dd)->data.final.len ) )

MDHASH_LEN_TOGGLE

#define MDHASH_LEN_TOGGLE	(		_dd,
			_byteorder )

Value:

( ( ( (_byteorder) == __BYTE_ORDER ) ? 0 :                      \
    ( sizeof ( uint64_t ) - 1 ) ) |                             \
  ( sizeof ( MDHASH_DD_PTR (_dd)->data.final.len ) -            \
    sizeof ( uint64_t ) ) )

Merkle-Damgård hash algorithm length field toggle.

Definition at line 115 of file mdhash.h.

#define MDHASH_LEN_TOGGLE( _dd, _byteorder )                            \
        ( ( ( (_byteorder) == __BYTE_ORDER ) ? 0 :                      \
            ( sizeof ( uint64_t ) - 1 ) ) |                             \
          ( sizeof ( MDHASH_DD_PTR (_dd)->data.final.len ) -            \
            sizeof ( uint64_t ) ) )

MDHASH_BLOCK_SIZE

#define MDHASH_BLOCK_SIZE

(

_dd

)

Value:

( sizeof ( MDHASH_DD_PTR (_dd)->data ) )

Merkle-Damgård hash algorithm block size.

Definition at line 122 of file mdhash.h.

#define MDHASH_BLOCK_SIZE( _dd )                                        \
        ( sizeof ( MDHASH_DD_PTR (_dd)->data ) )

MDHASH_CTX_SIZE

#define MDHASH_CTX_SIZE

(

_dd

)

Value:

( sizeof ( mdhash_context_t ( MDHASH_DIGEST_SIZE (_dd),         \
                              MDHASH_BLOCK_SIZE (_dd) ) ) )

Merkle-Damgård hash algorithm context size.

Definition at line 126 of file mdhash.h.

#define MDHASH_CTX_SIZE( _dd )                                          \
        ( sizeof ( mdhash_context_t ( MDHASH_DIGEST_SIZE (_dd),         \
                                      MDHASH_BLOCK_SIZE (_dd) ) ) )

MDHASH_ALGORITHM

#define MDHASH_ALGORITHM	(		_name,
			_digest,
			_compress,
			_byteorder,
			_dd,
			_init,
			_digestsize )

Define a Merkle-Damgård hash algorithm.

Definition at line 137 of file mdhash.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

mdhash_init()

void mdhash_init ( struct digest_algorithm * digest, void * ctx )

extern

Initialise algorithm.

Parameters

digest	Digest algorithm
ctx	MD hash context

Definition at line 45 of file mdhash.c.

                                                                {
        const struct mdhash_algorithm *mdhash = digest->priv;
        size_t blocksize = digest->blocksize;
        size_t digestsize = mdhash->digestsize;
        mdhash_context_t ( digestsize, blocksize ) *context = ctx;
 
        /* Zero accumulated data length */
        context->len = 0;
 
        /* Copy initial digest values */
        memcpy ( &context->dd.digest, mdhash->init, digestsize );
}

References digest_algorithm::blocksize, ctx, digestsize, mdhash_algorithm::digestsize, mdhash_algorithm::init, mdhash_context_t, memcpy(), and digest_algorithm::priv.

mdhash_update()

void mdhash_update ( struct digest_algorithm * digest, void * ctx, const void * data, size_t len )

extern

Accumulate data.

Parameters

digest	Digest algorithm
ctx	MD hash context
data	Data
len	Length of data

Definition at line 66 of file mdhash.c.

                                                    {
        const struct mdhash_algorithm *mdhash = digest->priv;
        size_t blocksize = digest->blocksize;
        size_t digestsize = mdhash->digestsize;
        mdhash_context_t ( digestsize, blocksize ) *context = ctx;
        const uint8_t *byte = data;
        uint8_t copy[digestsize];
        unsigned int toggle;
        unsigned int mask;
        size_t offset;
 
        /* Accumulate data a byte at a time, swapping endianness as we
         * go and performing the digest whenever we fill the data
         * buffer.
         */
        toggle = mdhash->toggle;
        mask = ( blocksize - 1 );
        while ( len-- ) {
                offset = ( ( context->len++ ^ toggle ) & mask );
                context->dd.data[offset] = *(byte++);
                if ( ( context->len & mask ) == 0 ) {
                        DBGC2 ( digest, "MDHASH %s compressing:\n",
                                digest->name );
                        DBGC2_HDA ( digest, 0, &context->dd.digest,
                                    sizeof ( context->dd.digest ) );
                        DBGC2_HDA ( digest, 0, &context->dd.data,
                                    sizeof ( context->dd.data ) );
                        memcpy ( copy, &context->dd.digest, digestsize );
                        mdhash->compress ( &context->dd, copy );
                        DBGC2 ( digest, "MDHASH %s compressed:\n",
                                digest->name );
                        DBGC2_HDA ( digest, 0, &context->dd.digest,
                                    sizeof ( context->dd.digest ) );
                }
        }
}

References digest_algorithm::blocksize, mdhash_algorithm::compress, ctx, data, DBGC2, DBGC2_HDA, digestsize, mdhash_algorithm::digestsize, len, mdhash_context_t, memcpy(), digest_algorithm::name, offset, digest_algorithm::priv, and mdhash_algorithm::toggle.

Referenced by mdhash_final().

mdhash_final()

void mdhash_final ( struct digest_algorithm * digest, void * ctx, void * out )

extern

Generate digest.

Parameters

digest	Digest algorithm
ctx	MD hash context
out	Output buffer

Definition at line 111 of file mdhash.c.

                                                                            {
        const struct mdhash_algorithm *mdhash = digest->priv;
        size_t blocksize = digest->blocksize;
        size_t digestsize = mdhash->digestsize;
        mdhash_context_t ( digestsize, blocksize ) *context = ctx;
        uint8_t *byte = out;
        union mdhash_len len;
        unsigned int toggle;
        unsigned int mask;
        unsigned int stop;
        unsigned int i;
        uint8_t pad;
 
        /* Record length before pre-processing */
        len.qword.bits = ( ( ( uint64_t ) context->len ) * 8 );
        len.qword.pad = 0;
 
        /* Pad with a single "1" bit followed by as many "0" bits as required */
        mask = ( blocksize - 1 );
        stop = ( blocksize - mdhash->len_len );
        pad = 0x80;
        do {
                mdhash_update ( digest, ctx, &pad, sizeof ( pad ) );
                pad = 0x00;
        } while ( ( context->len & mask ) != stop );
 
        /* Append length (in bits) */
        toggle = mdhash->len_toggle;
        for ( i = 0 ; i < mdhash->len_len ; i++ ) {
                mdhash_update ( digest, ctx, &len.byte[ i ^ toggle ],
                                sizeof ( len.byte[ i ^ toggle ] ) );
        }
        assert ( ( context->len & mask ) == 0 );
 
        /* Copy out final digest */
        toggle = mdhash->toggle;
        for ( i = 0 ; i < digest->digestsize ; i++ )
                byte[i] = context->dd.digest[ i ^ toggle ];
        DBGC ( digest, "MDHASH %s digested:\n", digest->name );
        DBGC_HDA ( digest, 0, out, digest->digestsize );
}

References assert, digest_algorithm::blocksize, ctx, DBGC, DBGC_HDA, digest_algorithm::digestsize, digestsize, mdhash_algorithm::digestsize, len, mdhash_algorithm::len_len, mdhash_algorithm::len_toggle, mdhash_context_t, mdhash_update(), digest_algorithm::name, out, pad, digest_algorithm::priv, and mdhash_algorithm::toggle.