md5.h File Reference

Calculate the MD5 checksum of a buffer. More...

#include <stdint.h>
#include <stdio.h>

Include dependency graph for md5.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	Md5Ctx
	Cursor for the MD5 hashing. More...

Typedefs
typedef uint32_t	md5_uint32

Functions
void *	mutt_md5 (const char *str, void *buf)
	Calculate the MD5 hash of a NULL-terminated string.
void *	mutt_md5_bytes (const void *buffer, size_t len, void *resbuf)
	Calculate the MD5 hash of a buffer.
void *	mutt_md5_finish_ctx (struct Md5Ctx *md5ctx, void *resbuf)
	Process the remaining bytes in the buffer.
void	mutt_md5_init_ctx (struct Md5Ctx *md5ctx)
	Initialise the MD5 computation.
void	mutt_md5_process (const char *str, struct Md5Ctx *md5ctx)
	Process a NULL-terminated string.
void	mutt_md5_process_bytes (const void *buf, size_t buflen, struct Md5Ctx *md5ctx)
	Process a block of data.
void	mutt_md5_toascii (const void *digest, char *resbuf)
	Convert a binary MD5 digest into ASCII Hexadecimal.

Detailed Description

Calculate the MD5 checksum of a buffer.

Authors

• Free Software Foundation, Inc.

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file md5.h.

Typedef Documentation

md5_uint32

typedef uint32_t md5_uint32

Definition at line 29 of file md5.h.

Function Documentation

mutt_md5()

void * mutt_md5	(	const char *	str,
		void *	buf
	)

Calculate the MD5 hash of a NULL-terminated string.

Parameters

str	String to hash
buf	Buffer for result

Return values

ptr	Results buffer

Definition at line 317 of file md5.c.

{
  if (!str)
    return NULL;
 
  return mutt_md5_bytes(str, strlen(str), buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_md5_bytes()

void * mutt_md5_bytes	(	const void *	buffer,
		size_t	len,
		void *	resbuf
	)

Calculate the MD5 hash of a buffer.

Parameters

buffer	Buffer to hash
len	Length of buffer
resbuf	Buffer for result

Return values

ptr	Results buffer

Compute MD5 message digest for LEN bytes beginning at Buffer. The result is always in little endian byte order, so that a byte-wise output yields to the wanted ASCII representation of the message digest.

Definition at line 336 of file md5.c.

{
  struct Md5Ctx md5ctx = { 0 };
 
  /* Initialize the computation context. */
  mutt_md5_init_ctx(&md5ctx);
 
  /* Process whole buffer but last len % 64 bytes. */
  mutt_md5_process_bytes(buffer, len, &md5ctx);
 
  /* Put result in desired memory area. */
  return mutt_md5_finish_ctx(&md5ctx, resbuf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_md5_finish_ctx()

void * mutt_md5_finish_ctx	(	struct Md5Ctx *	md5ctx,
		void *	resbuf
	)

Process the remaining bytes in the buffer.

Parameters

md5ctx	MD5 context
resbuf	Buffer for result

Return values

ptr	Results buffer

Process the remaining bytes in the internal buffer and the usual prologue according to the standard and write the result to RESBUF.

Definition at line 285 of file md5.c.

{
  if (!md5ctx)
    return NULL;
 
  /* Take yet unprocessed bytes into account. */
  md5_uint32 bytes = md5ctx->buflen;
  size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
 
  /* Now count remaining bytes. */
  md5ctx->total[0] += bytes;
  if (md5ctx->total[0] < bytes)
    md5ctx->total[1]++; // LCOV_EXCL_LINE
 
  /* Put the 64-bit file length in *bits* at the end of the buffer. */
  md5ctx->buffer[size - 2] = SWAP(md5ctx->total[0] << 3);
  md5ctx->buffer[size - 1] = SWAP((md5ctx->total[1] << 3) | (md5ctx->total[0] >> 29));
 
  memcpy(&((char *) md5ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
 
  /* Process last bytes. */
  mutt_md5_process_block(md5ctx->buffer, size * 4, md5ctx);
 
  return mutt_md5_read_ctx(md5ctx, resbuf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_md5_init_ctx()

void mutt_md5_init_ctx

(

struct Md5Ctx *

md5ctx

)

Initialise the MD5 computation.

Parameters

md5ctx

MD5 context

RFC1321, 3.3: Step 3

Definition at line 261 of file md5.c.

{
  if (!md5ctx)
    return;
 
  md5ctx->A = 0x67452301;
  md5ctx->B = 0xefcdab89;
  md5ctx->C = 0x98badcfe;
  md5ctx->D = 0x10325476;
 
  md5ctx->total[0] = 0;
  md5ctx->total[1] = 0;
  md5ctx->buflen = 0;
}

Here is the caller graph for this function:

mutt_md5_process()

void mutt_md5_process	(	const char *	str,
		struct Md5Ctx *	md5ctx
	)

Process a NULL-terminated string.

Parameters

str	String to process
md5ctx	MD5 context

Definition at line 355 of file md5.c.

{
  if (!str)
    return;
 
  mutt_md5_process_bytes(str, strlen(str), md5ctx);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_md5_process_bytes()

void mutt_md5_process_bytes	(	const void *	buf,
		size_t	buflen,
		struct Md5Ctx *	md5ctx
	)

Process a block of data.

Parameters

buf	Buffer to process
buflen	Length of buffer
md5ctx	MD5 context

Starting with the result of former calls of this function (or the initialization function update the context for the next BUFLEN bytes starting at Buffer. It is NOT required that BUFLEN is a multiple of 64.

Definition at line 373 of file md5.c.

{
  if (!buf || !md5ctx)
    return;
 
  /* When we already have some bits in our internal buffer concatenate both
   * inputs first. */
  if (md5ctx->buflen != 0)
  {
    size_t left_over = md5ctx->buflen;
    size_t add = ((128 - left_over) > buflen) ? buflen : (128 - left_over);
 
    memcpy(&((char *) md5ctx->buffer)[left_over], buf, add);
    md5ctx->buflen += add;
 
    if (md5ctx->buflen > 64)
    {
      mutt_md5_process_block(md5ctx->buffer, md5ctx->buflen & ~63, md5ctx);
 
      md5ctx->buflen &= 63;
      /* The regions in the following copy operation can't overlap. */
      memcpy(md5ctx->buffer, &((char *) md5ctx->buffer)[(left_over + add) & ~63],
             md5ctx->buflen);
    }
 
    buf = (const char *) buf + add;
    buflen -= add;
  }
 
  /* Process available complete blocks. */
  if (buflen >= 64)
  {
#if !defined(_STRING_ARCH_unaligned)
#define alignof(type)                                                          \
  offsetof(                                                                    \
      struct {                                                                 \
        char c;                                                                \
        type x;                                                                \
      },                                                                       \
      x)
#define UNALIGNED_P(p) (((size_t) p) % alignof(md5_uint32) != 0)
    if (UNALIGNED_P(buf))
    {
      while (buflen > 64)
      {
        mutt_md5_process_block(memcpy(md5ctx->buffer, buf, 64), 64, md5ctx);
        buf = (const char *) buf + 64;
        buflen -= 64;
      }
    }
    else
#endif
    {
      mutt_md5_process_block(buf, buflen & ~63, md5ctx);
      buf = (const char *) buf + (buflen & ~63);
      buflen &= 63;
    }
  }
 
  /* Move remaining bytes in internal buffer. */
  if (buflen > 0)
  {
    size_t left_over = md5ctx->buflen;
 
    memcpy(&((char *) md5ctx->buffer)[left_over], buf, buflen);
    left_over += buflen;
    if (left_over >= 64)
    { // LCOV_EXCL_START
      mutt_md5_process_block(md5ctx->buffer, 64, md5ctx);
      left_over -= 64;
      memmove(md5ctx->buffer, &md5ctx->buffer[16], left_over);
    } // LCOV_EXCL_STOP
    md5ctx->buflen = left_over;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_md5_toascii()

void mutt_md5_toascii	(	const void *	digest,
		char *	resbuf
	)

Convert a binary MD5 digest into ASCII Hexadecimal.

Parameters

digest	Binary MD5 digest
resbuf	Buffer for the ASCII result

Note

refbuf must be at least 33 bytes long.

Definition at line 456 of file md5.c.

{
  if (!digest || !resbuf)
    return;
 
  const unsigned char *c = digest;
  sprintf(resbuf, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
          c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7], c[8], c[9], c[10],
          c[11], c[12], c[13], c[14], c[15]);
}

Here is the caller graph for this function: