md5.h File Reference

#include <rz_types.h>
#include <string.h>

Go to the source code of this file.

Classes
struct	MD5Context

Macros
#define	RZ_HASH_MD5_DIGEST_SIZE   0x10
#define	RZ_HASH_MD5_BLOCK_LENGTH   0x40
#define	MD5_BLOCK_LENGTH   64
#define	MD5_DIGEST_LENGTH   16

Typedefs
typedef struct MD5Context	rz_MD5_CTX

Functions
RZ_IPI void	rz_MD5Init (rz_MD5_CTX *)
RZ_IPI void	rz_MD5Update (rz_MD5_CTX *, const ut8 *, size_t)
RZ_IPI void	rz_MD5Final (ut8[MD5_DIGEST_LENGTH], rz_MD5_CTX *)

Macro Definition Documentation

MD5_BLOCK_LENGTH

#define MD5_BLOCK_LENGTH   64

Definition at line 33 of file md5.h.

MD5_DIGEST_LENGTH

#define MD5_DIGEST_LENGTH   16

Definition at line 34 of file md5.h.

RZ_HASH_MD5_BLOCK_LENGTH

#define RZ_HASH_MD5_BLOCK_LENGTH   0x40

Definition at line 10 of file md5.h.

RZ_HASH_MD5_DIGEST_SIZE

#define RZ_HASH_MD5_DIGEST_SIZE   0x10

Definition at line 9 of file md5.h.

Typedef Documentation

rz_MD5_CTX

typedef struct MD5Context rz_MD5_CTX

Function Documentation

rz_MD5Final()

RZ_IPI void rz_MD5Final	(	ut8	digest[MD5_DIGEST_LENGTH],
		rz_MD5_CTX *	ctx
	)

Definition at line 218 of file md5.c.

                                                                                  {
    ut8 count[8];
    size_t padlen;
    int i;
 
    /* Convert count to 8 bytes in little endian order. */
    PUT_64BIT_LE(count, ctx->count);
 
    /* Pad out to 56 mod 64. */
    padlen = MD5_BLOCK_LENGTH -
        ((ctx->count[0] >> 3) & (MD5_BLOCK_LENGTH - 1));
    if (padlen < 1 + 8) {
        padlen += MD5_BLOCK_LENGTH;
    }
    rz_MD5Update(ctx, PADDING, padlen - 8); /* padlen - 8 <= 64 */
    rz_MD5Update(ctx, count, 8);
 
    if (digest != NULL) {
        for (i = 0; i < 4; i++) {
            rz_write_le32(digest + i * 4, ctx->state[i]);
        }
    }
    rz_mem_memzero(ctx, sizeof(*ctx)); /* in case it's sensitive */
}

References count, i, MD5_BLOCK_LENGTH, NULL, PADDING, PUT_64BIT_LE, rz_MD5Update(), rz_mem_memzero(), and rz_write_le32().

Referenced by plugin_md5_final(), and plugin_md5_small_block().

rz_MD5Init()

RZ_IPI void rz_MD5Init

(

rz_MD5_CTX *

ctx

)

Definition at line 163 of file md5.c.

                                        {
    ctx->count[0] = 0;
    ctx->count[1] = 0;
    ctx->state[0] = 0x67452301;
    ctx->state[1] = 0xefcdab89;
    ctx->state[2] = 0x98badcfe;
    ctx->state[3] = 0x10325476;
}

Referenced by plugin_md5_init(), and plugin_md5_small_block().

rz_MD5Update()

RZ_IPI void rz_MD5Update	(	rz_MD5_CTX *	ctx,
		const ut8 *	input,
		size_t	len
	)

Definition at line 176 of file md5.c.

                                                                                  {
    size_t have, need;
 
    /* Check how many bytes we already have and how many more we need. */
    have = (size_t)((ctx->count[0] >> 3) & (MD5_BLOCK_LENGTH - 1));
    need = MD5_BLOCK_LENGTH - have;
 
    /* Update bitcount */
    /*  ctx->count += (uint64_t)len << 3;*/
    if ((ctx->count[0] += ((ut32)len << 3)) < (ut32)len) {
        /* Overflowed ctx->count[0] */
        ctx->count[1]++;
    }
    ctx->count[1] += ((ut32)len >> 29);
 
    if (len >= need) {
        if (have != 0) {
            memcpy(ctx->buffer + have, input, need);
            MD5Transform(ctx->state, ctx->buffer);
            input += need;
            len -= need;
            have = 0;
        }
 
        /* Process data in MD5_BLOCK_LENGTH-byte chunks. */
        while (len >= MD5_BLOCK_LENGTH) {
            MD5Transform(ctx->state, input);
            input += MD5_BLOCK_LENGTH;
            len -= MD5_BLOCK_LENGTH;
        }
    }
 
    /* Handle any remaining bytes of data. */
    if (len != 0) {
        memcpy(ctx->buffer + have, input, len);
    }
}

References input(), len, MD5_BLOCK_LENGTH, MD5Transform(), and memcpy().

Referenced by plugin_md5_small_block(), plugin_md5_update(), and rz_MD5Final().