mdhash.c File Reference

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

#include <stdint.h>
#include <string.h>
#include <assert.h>
#include <ipxe/crypto.h>
#include <ipxe/mdhash.h>

Go to the source code of this file.

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 *data, 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.c.

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 )

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 )

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 )

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.