MD4 algorithm. More...

#include <stdint.h>
#include <string.h>
#include <byteswap.h>
#include <assert.h>
#include <ipxe/rotate.h>
#include <ipxe/crypto.h>
#include <ipxe/md4.h>

Data Structures
struct	md4_variables
	MD4 variables. More...

struct	md4_step
	An MD4 step function. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)

struct md4_variables	__attribute__ ((packed))

static uint32_t	md4_f_0_15 (struct md4_variables *v, unsigned int i)
	f(b,c,d,w) for steps 0 to 15 More...

static uint32_t	md4_f_16_31 (struct md4_variables *v, unsigned int i)
	f(b,c,d,w) for steps 16 to 31 More...

static uint32_t	md4_f_32_47 (struct md4_variables *v, unsigned int i)
	f(b,c,d,w) for steps 32 to 47 More...

static void	md4_init (void *ctx)
	Initialise MD4 algorithm. More...

static void	md4_digest (struct md4_context *context)
	Calculate MD4 digest of accumulated data. More...

static void	md4_update (void ctx, const void data, size_t len)
	Accumulate data with MD4 algorithm. More...

static void	md4_final (void ctx, void out)
	Generate MD4 digest. More...

Variables
uint32_t	a

uint32_t	b

uint32_t	c

uint32_t	d

uint32_t	w [16]

static const uint8_t	r [3][4]
	MD4 shift amounts. More...

struct md4_step	__attribute__

static struct md4_step	md4_steps [4]
	MD4 steps. More...

struct digest_algorithm	md4_algorithm
	MD4 algorithm. More...

Detailed Description

MD4 algorithm.

Definition in file md4.c.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ attribute()

struct md4_variables __attribute__ ( (packed) )

◆ md4_f_0_15()

static uint32_t md4_f_0_15	(	struct md4_variables *	v,
		unsigned int	i
	)

static

f(b,c,d,w) for steps 0 to 15

Parameters

v	MD4 variables
i	Index within round

Return values

f	f(b,c,d,w)

Definition at line 66 of file md4.c.

                                                                        {
         return ( ( ( v->b & v->c ) | ( ~v->b & v->d ) ) + v->w[i] );
 }

References md4_variables::b, md4_variables::c, md4_variables::d, and md4_variables::w.

◆ md4_f_16_31()

static uint32_t md4_f_16_31	(	struct md4_variables *	v,
		unsigned int	i
	)

static

f(b,c,d,w) for steps 16 to 31

Parameters

v	MD4 variables
i	Index within round

Return values

f	f(b,c,d,w)

Definition at line 77 of file md4.c.

                                                                         {
         return ( ( ( v->b & v->c ) | ( v->b & v->d ) | ( v->c & v->d ) ) +
                  v->w[ ( ( i << 2 ) | ( i >> 2 ) ) % 16 ] );
 }

References md4_variables::b, md4_variables::c, md4_variables::d, and md4_variables::w.

◆ md4_f_32_47()

static uint32_t md4_f_32_47	(	struct md4_variables *	v,
		unsigned int	i
	)

static

f(b,c,d,w) for steps 32 to 47

Parameters

v	MD4 variables
i	Index within round

Return values

f	f(b,c,d,w)

Definition at line 89 of file md4.c.

                                                                         {
         static const uint8_t reverse[16] = {
                 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15
         };
         return ( ( v->b ^ v->c ^ v->d ) + v->w[reverse[i]] );
 }

References md4_variables::b, md4_variables::c, md4_variables::d, and md4_variables::w.

◆ md4_init()

static void md4_init ( void * ctx )

static

Initialise MD4 algorithm.

Parameters

ctx	MD4 context

Definition at line 125 of file md4.c.

                                    {
         struct md4_context *context = ctx;
 
         context->ddd.dd.digest.h[0] = cpu_to_le32 ( 0x67452301 );
         context->ddd.dd.digest.h[1] = cpu_to_le32 ( 0xefcdab89 );
         context->ddd.dd.digest.h[2] = cpu_to_le32 ( 0x98badcfe );
         context->ddd.dd.digest.h[3] = cpu_to_le32 ( 0x10325476 );
         context->len = 0;
 }

References cpu_to_le32, ctx, md4_digest_data_dwords::dd, md4_context::ddd, md4_digest_data::digest, md4_digest::h, and md4_context::len.

◆ md4_digest()

static void md4_digest ( struct md4_context * context )

static

Calculate MD4 digest of accumulated data.

Parameters

context MD4 context

Definition at line 140 of file md4.c.

                                                        {
         union {
                 union md4_digest_data_dwords ddd;
                 struct md4_variables v;
         } u;
         uint32_t *a = &u.v.a;
         uint32_t *b = &u.v.b;
         uint32_t *c = &u.v.c;
         uint32_t *d = &u.v.d;
         uint32_t *w = u.v.w;
         uint32_t f;
         uint32_t temp;
         struct md4_step *step;
         unsigned int round;
         unsigned int i;
 
         /* Sanity checks */
         assert ( ( context->len % sizeof ( context->ddd.dd.data ) ) == 0 );
         linker_assert ( &u.ddd.dd.digest.h[0] == a, md4_bad_layout );
         linker_assert ( &u.ddd.dd.digest.h[1] == b, md4_bad_layout );
         linker_assert ( &u.ddd.dd.digest.h[2] == c, md4_bad_layout );
         linker_assert ( &u.ddd.dd.digest.h[3] == d, md4_bad_layout );
         linker_assert ( &u.ddd.dd.data.dword[0] == w, md4_bad_layout );
 
         DBGC ( context, "MD4 digesting:\n" );
         DBGC_HDA ( context, 0, &context->ddd.dd.digest,
                    sizeof ( context->ddd.dd.digest ) );
         DBGC_HDA ( context, context->len, &context->ddd.dd.data,
                    sizeof ( context->ddd.dd.data ) );
 
         /* Convert h[0..3] to host-endian, and initialise a, b, c, d,
          * and x[0..15]
          */
         for ( i = 0 ; i < ( sizeof ( u.ddd.dword ) /
                             sizeof ( u.ddd.dword[0] ) ) ; i++ ) {
                 le32_to_cpus ( &context->ddd.dword[i] );
                 u.ddd.dword[i] = context->ddd.dword[i];
         }
 
         /* Main loop */
         for ( i = 0 ; i < 48 ; i++ ) {
                 round = ( i / 16 );
                 step = &md4_steps[round];
                 f = step->f ( &u.v, ( i % 16 ) );
                 temp = *d;
                 *d = *c;
                 *c = *b;
                 *b = rol32 ( ( *a + f + step->constant ), r[round][ i % 4 ] );
                 *a = temp;
                 DBGC2 ( context, "%2d : %08x %08x %08x %08x\n",
                         i, *a, *b, *c, *d );
         }
 
         /* Add chunk to hash and convert back to little-endian */
         for ( i = 0 ; i < 4 ; i++ ) {
                 context->ddd.dd.digest.h[i] =
                         cpu_to_le32 ( context->ddd.dd.digest.h[i] +
                                       u.ddd.dd.digest.h[i] );
         }
 
         DBGC ( context, "MD4 digested:\n" );
         DBGC_HDA ( context, 0, &context->ddd.dd.digest,
                    sizeof ( context->ddd.dd.digest ) );
 }

References a, assert(), b, c, cpu_to_le32, d, md4_digest_data::data, DBGC, DBGC2, DBGC_HDA, md4_digest_data_dwords::dd, md4_context::ddd, md4_digest_data::digest, md4_digest_data_dwords::dword, f, md4_digest::h, le32_to_cpus, md4_context::len, linker_assert, md4_steps, r, rol32(), step(), u, and w.

Referenced by md4_update().

◆ md4_update()

static void md4_update	(	void *	ctx,
		const void *	data,
		size_t	len
	)

static

Accumulate data with MD4 algorithm.

Parameters

ctx	MD4 context
data	Data
len	Length of data

Definition at line 212 of file md4.c.

                                                                    {
         struct md4_context *context = ctx;
         const uint8_t *byte = data;
         size_t offset;
 
         /* Accumulate data a byte at a time, performing the digest
          * whenever we fill the data buffer
          */
         while ( len-- ) {
                 offset = ( context->len % sizeof ( context->ddd.dd.data ) );
                 context->ddd.dd.data.byte[offset] = *(byte++);
                 context->len++;
                 if ( ( context->len % sizeof ( context->ddd.dd.data ) ) == 0 )
                         md4_digest ( context );
         }
 }

References md4_block::byte, ctx, data, md4_digest_data::data, md4_digest_data_dwords::dd, md4_context::ddd, len, md4_context::len, md4_digest(), and offset.

Referenced by md4_final().

◆ md4_final()

static void md4_final	(	void *	ctx,
		void *	out
	)

static

Generate MD4 digest.

Parameters

ctx	MD4 context
out	Output buffer

Definition at line 235 of file md4.c.

                                                {
         struct md4_context *context = ctx;
         uint64_t len_bits;
         uint8_t pad;
 
         /* Record length before pre-processing */
         len_bits = cpu_to_le64 ( ( ( uint64_t ) context->len ) * 8 );
 
         /* Pad with a single "1" bit followed by as many "0" bits as required */
         pad = 0x80;
         do {
                 md4_update ( ctx, &pad, sizeof ( pad ) );
                 pad = 0x00;
         } while ( ( context->len % sizeof ( context->ddd.dd.data ) ) !=
                   offsetof ( typeof ( context->ddd.dd.data ), final.len ) );
 
         /* Append length (in bits) */
         md4_update ( ctx, &len_bits, sizeof ( len_bits ) );
         assert ( ( context->len % sizeof ( context->ddd.dd.data ) ) == 0 );
 
         /* Copy out final digest */
         memcpy ( out, &context->ddd.dd.digest,
                  sizeof ( context->ddd.dd.digest ) );
 }

References assert(), cpu_to_le64, ctx, md4_digest_data::data, md4_digest_data_dwords::dd, md4_context::ddd, md4_digest_data::digest, md4_context::len, md4_update(), memcpy(), offsetof, out, pad, and typeof().

Variable Documentation

◆ a

uint32_t a

Definition at line 28 of file md4.c.

Referenced by ar9287_eeprom_olpc_set_pdadcs(), arbel_setup_mpt(), intf_plug_plug(), md4_digest(), pcnet32_chip_detect(), png_paeth_predictor(), setting_cmp(), stack_check(), TLan_HashFunc(), tls_p_hash_va(), and xor().

◆ b

uint32_t b

Definition at line 29 of file md4.c.

Referenced by gdbstub_to_hex_digit(), intf_plug_plug(), md4_digest(), png_paeth_predictor(), setting_cmp(), and xor().

◆ c

static __always_inline off_t off_t int c

Definition at line 30 of file md4.c.

Referenced by _printw_handler(), _wgetc(), _wputc(), a3c90x_hw_start(), ansiesc_process(), ansiscr_putc(), arbel_fill_mlx_send_wqe(), ath5k_eeprom_read_pcal_info_5112(), ath5k_hw_post(), ath5k_hw_rf2425_channel(), ath5k_hw_rf5112_channel(), ath9k_hw_getnf(), cputchar(), dns_encode(), efi_printf_sputc(), eth_probe(), ftp_check_string(), ftp_control_deliver(), hermon_fill_eth_send_wqe(), hermon_fill_mlx_send_wqe(), hermon_fill_nop_send_wqe(), hermon_fill_rc_send_wqe(), hermon_fill_ud_send_wqe(), http_token(), kbd_getc(), linux_args_parse(), md4_digest(), memsetw(), ne_probe(), ntlm_append_string(), ntlm_key(), peerdist_discovery_reply_values(), png_paeth_predictor(), png_pixels_pass(), print_user_string(), printf_putchar(), printf_sputc(), reparse_options(), syslog_fix_name(), trivial_memchr_user(), trivial_memset_user(), uri_character_escaped(), uri_decode(), uri_encode(), wgetch(), and wgetnstr().

◆ d

uint32_t d

◆ w

uint32_t w[16]

Definition at line 32 of file md4.c.

Referenced by md4_digest(), sis190_get_mac_addr_from_eeprom(), and sis900_init_rxfilter().

◆ r

const uint8_t r[3][4]

static

Initial value:

= {
        {  3,  7, 11, 19 },
        {  3,  5,  9, 13 },
        {  3,  9, 11, 15 },
}

MD4 shift amounts.

Definition at line 53 of file md4.c.

Referenced by __ath9k_hw_init(), __attribute__(), ar5008_write_rf_array(), ath9k_hw_channel_change(), ath9k_hw_reset(), ath9k_hw_write_array(), ath9k_start(), ath_radio_disable(), ath_reset(), ath_set_channel(), bcom_phy_init(), fls(), genesis_mac_init(), gma_write16(), md4_digest(), xm_write16(), and xm_write32().

◆ attribute

struct md4_step __attribute__

◆ md4_steps

struct md4_step md4_steps[4]

static

Initial value:

= {
        
        { .f = md4_f_0_15,      .constant = 0x00000000UL },
        
        { .f = md4_f_16_31,     .constant = 0x5a827999UL },
        
        { .f = md4_f_32_47,     .constant = 0x6ed9eba1UL },
}

MD4 steps.

Definition at line 111 of file md4.c.

Referenced by md4_digest().

◆ md4_algorithm

struct digest_algorithm md4_algorithm

Initial value:

= {
        .name           = "md4",
        .ctxsize        = sizeof ( struct md4_context ),
        .blocksize      = sizeof ( union md4_block ),
        .digestsize     = sizeof ( struct md4_digest ),
        .init           = md4_init,
        .update         = md4_update,
        .final          = md4_final,
}

MD4 algorithm.

Definition at line 261 of file md4.c.

Referenced by md4_test_exec(), and ntlm_key().

Data Structures

Functions

Variables

Detailed Description

Function Documentation

◆ FILE_LICENCE()

◆ __attribute__()

◆ md4_f_0_15()

◆ md4_f_16_31()

◆ md4_f_32_47()

◆ md4_init()

◆ md4_digest()

◆ md4_update()

◆ md4_final()

Variable Documentation

◆ a

◆ b

◆ c

◆ d

◆ w

◆ r

◆ __attribute__

◆ md4_steps

◆ md4_algorithm

◆ attribute()

◆ attribute