#include "postgres.h"
#include <sys/param.h>
#include "md5.h"

Include dependency graph for md5.c:

Defines
#define	SHIFT(X, s) (((X) << (s)) \| ((X) >> (32 - (s))))
#define	F(X, Y, Z) (((X) & (Y)) \| ((~X) & (Z)))
#define	G(X, Y, Z) (((X) & (Z)) \| ((Y) & (~Z)))
#define	H(X, Y, Z) ((X) ^ (Y) ^ (Z))
#define	I(X, Y, Z) ((Y) ^ ((X) \| (~Z)))
#define	ROUND1(a, b, c, d, k, s, i)
#define	ROUND2(a, b, c, d, k, s, i)
#define	ROUND3(a, b, c, d, k, s, i)
#define	ROUND4(a, b, c, d, k, s, i)
#define	Sa 7
#define	Sb 12
#define	Sc 17
#define	Sd 22
#define	Se 5
#define	Sf 9
#define	Sg 14
#define	Sh 20
#define	Si 4
#define	Sj 11
#define	Sk 16
#define	Sl 23
#define	Sm 6
#define	Sn 10
#define	So 15
#define	Sp 21
#define	MD5_A0 0x67452301
#define	MD5_B0 0xefcdab89
#define	MD5_C0 0x98badcfe
#define	MD5_D0 0x10325476
Functions
static void	md5_calc (uint8 , md5_ctxt )
void	md5_init (md5_ctxt *ctxt)
void	md5_loop (md5_ctxt ctxt, const uint8 input, unsigned len)
void	md5_pad (md5_ctxt *ctxt)
void	md5_result (uint8 digest, md5_ctxt ctxt)
Variables
static const uint32	T [65]
static const uint8	md5_paddat [MD5_BUFLEN]

Define Documentation

#define F	(	X,
		Y,
		Z
	)		(((X) & (Y)) \| ((~X) & (Z)))

Definition at line 42 of file md5.c.

#define G	(	X,
		Y,
		Z
	)		(((X) & (Z)) \| ((Y) & (~Z)))

Definition at line 43 of file md5.c.

#define H	(	X,
		Y,
		Z
	)		((X) ^ (Y) ^ (Z))

Definition at line 44 of file md5.c.

#define I	(	X,
		Y,
		Z
	)		((Y) ^ ((X) \| (~Z)))

Definition at line 45 of file md5.c.

#define MD5_A0 0x67452301

Definition at line 95 of file md5.c.

#define MD5_B0 0xefcdab89

Definition at line 96 of file md5.c.

#define MD5_C0 0x98badcfe

Definition at line 97 of file md5.c.

#define MD5_D0 0x10325476

Definition at line 98 of file md5.c.

#define ROUND1	(	a,
		b,
		c,
		d,
		k,
		s,
		i
	)

Value:

do { \
    (a) = (a) + F((b), (c), (d)) + X[(k)] + T[(i)]; \
    (a) = SHIFT((a), (s)); \
    (a) = (b) + (a); \
} while (0)

Definition at line 47 of file md5.c.

Referenced by md5_calc().

#define ROUND2	(	a,
		b,
		c,
		d,
		k,
		s,
		i
	)

Value:

do { \
    (a) = (a) + G((b), (c), (d)) + X[(k)] + T[(i)]; \
    (a) = SHIFT((a), (s)); \
    (a) = (b) + (a); \
} while (0)

Definition at line 54 of file md5.c.

Referenced by md5_calc().

#define ROUND3	(	a,
		b,
		c,
		d,
		k,
		s,
		i
	)

Value:

do { \
    (a) = (a) + H((b), (c), (d)) + X[(k)] + T[(i)]; \
    (a) = SHIFT((a), (s)); \
    (a) = (b) + (a); \
} while (0)

Definition at line 61 of file md5.c.

Referenced by md5_calc().

#define ROUND4	(	a,
		b,
		c,
		d,
		k,
		s,
		i
	)

Value:

do { \
    (a) = (a) + I((b), (c), (d)) + X[(k)] + T[(i)]; \
    (a) = SHIFT((a), (s)); \
    (a) = (b) + (a); \
} while (0)

Definition at line 68 of file md5.c.

Referenced by md5_calc().

#define Sa 7

Definition at line 75 of file md5.c.

Referenced by md5_calc().

#define Sb 12

Definition at line 76 of file md5.c.

Referenced by md5_calc().

#define Sc 17

Definition at line 77 of file md5.c.

Referenced by md5_calc().

#define Sd 22

Definition at line 78 of file md5.c.

Referenced by md5_calc().

#define Se 5

Definition at line 80 of file md5.c.

Referenced by md5_calc().

#define Sf 9

Definition at line 81 of file md5.c.

Referenced by md5_calc().

#define Sg 14

Definition at line 82 of file md5.c.

Referenced by md5_calc().

#define Sh 20

Definition at line 83 of file md5.c.

Referenced by md5_calc().

#define SHIFT	(	X,
		s
	)		(((X) << (s)) \| ((X) >> (32 - (s))))

Definition at line 40 of file md5.c.

#define Si 4

Definition at line 85 of file md5.c.

Referenced by md5_calc().

#define Sj 11

Definition at line 86 of file md5.c.

Referenced by md5_calc().

#define Sk 16

Definition at line 87 of file md5.c.

Referenced by md5_calc().

#define Sl 23

Definition at line 88 of file md5.c.

Referenced by md5_calc().

#define Sm 6

Definition at line 90 of file md5.c.

Referenced by md5_calc().

#define Sn 10

Definition at line 91 of file md5.c.

Referenced by md5_calc().

#define So 15

Definition at line 92 of file md5.c.

Referenced by md5_calc().

#define Sp 21

Definition at line 93 of file md5.c.

Referenced by md5_calc().

Function Documentation

static void md5_calc	(	uint8 *	b64,
		md5_ctxt *	ctxt
	)			`[static]`

Definition at line 245 of file md5.c.

References ROUND1, ROUND2, ROUND3, ROUND4, Sa, Sb, Sc, Sd, Se, Sf, Sg, Sh, Si, Sj, Sk, Sl, Sm, Sn, So, and Sp.

Referenced by md5_loop(), and md5_pad().

{
    uint32      A = ctxt->md5_sta;
    uint32      B = ctxt->md5_stb;
    uint32      C = ctxt->md5_stc;
    uint32      D = ctxt->md5_std;

#ifndef WORDS_BIGENDIAN
    uint32     *X = (uint32 *) b64;
#else
    /* 4 byte words */
    /* what a brute force but fast! */
    uint8      *y = (uint8 *) X;

    y[0] = b64[3];
    y[1] = b64[2];
    y[2] = b64[1];
    y[3] = b64[0];
    y[4] = b64[7];
    y[5] = b64[6];
    y[6] = b64[5];
    y[7] = b64[4];
    y[8] = b64[11];
    y[9] = b64[10];
    y[10] = b64[9];
    y[11] = b64[8];
    y[12] = b64[15];
    y[13] = b64[14];
    y[14] = b64[13];
    y[15] = b64[12];
    y[16] = b64[19];
    y[17] = b64[18];
    y[18] = b64[17];
    y[19] = b64[16];
    y[20] = b64[23];
    y[21] = b64[22];
    y[22] = b64[21];
    y[23] = b64[20];
    y[24] = b64[27];
    y[25] = b64[26];
    y[26] = b64[25];
    y[27] = b64[24];
    y[28] = b64[31];
    y[29] = b64[30];
    y[30] = b64[29];
    y[31] = b64[28];
    y[32] = b64[35];
    y[33] = b64[34];
    y[34] = b64[33];
    y[35] = b64[32];
    y[36] = b64[39];
    y[37] = b64[38];
    y[38] = b64[37];
    y[39] = b64[36];
    y[40] = b64[43];
    y[41] = b64[42];
    y[42] = b64[41];
    y[43] = b64[40];
    y[44] = b64[47];
    y[45] = b64[46];
    y[46] = b64[45];
    y[47] = b64[44];
    y[48] = b64[51];
    y[49] = b64[50];
    y[50] = b64[49];
    y[51] = b64[48];
    y[52] = b64[55];
    y[53] = b64[54];
    y[54] = b64[53];
    y[55] = b64[52];
    y[56] = b64[59];
    y[57] = b64[58];
    y[58] = b64[57];
    y[59] = b64[56];
    y[60] = b64[63];
    y[61] = b64[62];
    y[62] = b64[61];
    y[63] = b64[60];
#endif

    ROUND1(A, B, C, D, 0, Sa, 1);
    ROUND1(D, A, B, C, 1, Sb, 2);
    ROUND1(C, D, A, B, 2, Sc, 3);
    ROUND1(B, C, D, A, 3, Sd, 4);
    ROUND1(A, B, C, D, 4, Sa, 5);
    ROUND1(D, A, B, C, 5, Sb, 6);
    ROUND1(C, D, A, B, 6, Sc, 7);
    ROUND1(B, C, D, A, 7, Sd, 8);
    ROUND1(A, B, C, D, 8, Sa, 9);
    ROUND1(D, A, B, C, 9, Sb, 10);
    ROUND1(C, D, A, B, 10, Sc, 11);
    ROUND1(B, C, D, A, 11, Sd, 12);
    ROUND1(A, B, C, D, 12, Sa, 13);
    ROUND1(D, A, B, C, 13, Sb, 14);
    ROUND1(C, D, A, B, 14, Sc, 15);
    ROUND1(B, C, D, A, 15, Sd, 16);

    ROUND2(A, B, C, D, 1, Se, 17);
    ROUND2(D, A, B, C, 6, Sf, 18);
    ROUND2(C, D, A, B, 11, Sg, 19);
    ROUND2(B, C, D, A, 0, Sh, 20);
    ROUND2(A, B, C, D, 5, Se, 21);
    ROUND2(D, A, B, C, 10, Sf, 22);
    ROUND2(C, D, A, B, 15, Sg, 23);
    ROUND2(B, C, D, A, 4, Sh, 24);
    ROUND2(A, B, C, D, 9, Se, 25);
    ROUND2(D, A, B, C, 14, Sf, 26);
    ROUND2(C, D, A, B, 3, Sg, 27);
    ROUND2(B, C, D, A, 8, Sh, 28);
    ROUND2(A, B, C, D, 13, Se, 29);
    ROUND2(D, A, B, C, 2, Sf, 30);
    ROUND2(C, D, A, B, 7, Sg, 31);
    ROUND2(B, C, D, A, 12, Sh, 32);

    ROUND3(A, B, C, D, 5, Si, 33);
    ROUND3(D, A, B, C, 8, Sj, 34);
    ROUND3(C, D, A, B, 11, Sk, 35);
    ROUND3(B, C, D, A, 14, Sl, 36);
    ROUND3(A, B, C, D, 1, Si, 37);
    ROUND3(D, A, B, C, 4, Sj, 38);
    ROUND3(C, D, A, B, 7, Sk, 39);
    ROUND3(B, C, D, A, 10, Sl, 40);
    ROUND3(A, B, C, D, 13, Si, 41);
    ROUND3(D, A, B, C, 0, Sj, 42);
    ROUND3(C, D, A, B, 3, Sk, 43);
    ROUND3(B, C, D, A, 6, Sl, 44);
    ROUND3(A, B, C, D, 9, Si, 45);
    ROUND3(D, A, B, C, 12, Sj, 46);
    ROUND3(C, D, A, B, 15, Sk, 47);
    ROUND3(B, C, D, A, 2, Sl, 48);

    ROUND4(A, B, C, D, 0, Sm, 49);
    ROUND4(D, A, B, C, 7, Sn, 50);
    ROUND4(C, D, A, B, 14, So, 51);
    ROUND4(B, C, D, A, 5, Sp, 52);
    ROUND4(A, B, C, D, 12, Sm, 53);
    ROUND4(D, A, B, C, 3, Sn, 54);
    ROUND4(C, D, A, B, 10, So, 55);
    ROUND4(B, C, D, A, 1, Sp, 56);
    ROUND4(A, B, C, D, 8, Sm, 57);
    ROUND4(D, A, B, C, 15, Sn, 58);
    ROUND4(C, D, A, B, 6, So, 59);
    ROUND4(B, C, D, A, 13, Sp, 60);
    ROUND4(A, B, C, D, 4, Sm, 61);
    ROUND4(D, A, B, C, 11, Sn, 62);
    ROUND4(C, D, A, B, 2, So, 63);
    ROUND4(B, C, D, A, 9, Sp, 64);

    ctxt->md5_sta += A;
    ctxt->md5_stb += B;
    ctxt->md5_stc += C;
    ctxt->md5_std += D;
}

void md5_init ( md5_ctxt * ctxt )

Definition at line 138 of file md5.c.

References md5_ctxt::md5_buf, and md5_ctxt::md5_i.

{
    ctxt->md5_n = 0;
    ctxt->md5_i = 0;
    ctxt->md5_sta = MD5_A0;
    ctxt->md5_stb = MD5_B0;
    ctxt->md5_stc = MD5_C0;
    ctxt->md5_std = MD5_D0;
    memset(ctxt->md5_buf, 0, sizeof(ctxt->md5_buf));
}

void md5_loop	(	md5_ctxt *	ctxt,
		const uint8 *	input,
		unsigned	len
	)

Definition at line 150 of file md5.c.

References i, md5_ctxt::md5_buf, MD5_BUFLEN, md5_calc(), md5_ctxt::md5_i, and memmove.

{
    unsigned int gap,
                i;

    ctxt->md5_n += len * 8;     /* byte to bit */
    gap = MD5_BUFLEN - ctxt->md5_i;

    if (len >= gap)
    {
        memmove(ctxt->md5_buf + ctxt->md5_i, input, gap);
        md5_calc(ctxt->md5_buf, ctxt);

        for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN)
            md5_calc((uint8 *) (input + i), ctxt);

        ctxt->md5_i = len - i;
        memmove(ctxt->md5_buf, input + i, ctxt->md5_i);
    }
    else
    {
        memmove(ctxt->md5_buf + ctxt->md5_i, input, len);
        ctxt->md5_i += len;
    }
}

void md5_pad ( md5_ctxt * ctxt )

Definition at line 177 of file md5.c.

References md5_ctxt::md5_buf, MD5_BUFLEN, md5_calc(), md5_ctxt::md5_i, md5_paddat, and memmove.

{
    unsigned int gap;

    /* Don't count up padding. Keep md5_n. */
    gap = MD5_BUFLEN - ctxt->md5_i;
    if (gap > 8)
    {
        memmove(ctxt->md5_buf + ctxt->md5_i, md5_paddat,
                gap - sizeof(ctxt->md5_n));
    }
    else
    {
        /* including gap == 8 */
        memmove(ctxt->md5_buf + ctxt->md5_i, md5_paddat, gap);
        md5_calc(ctxt->md5_buf, ctxt);
        memmove(ctxt->md5_buf, md5_paddat + gap,
                MD5_BUFLEN - sizeof(ctxt->md5_n));
    }

    /* 8 byte word */
#ifndef WORDS_BIGENDIAN
    memmove(&ctxt->md5_buf[56], &ctxt->md5_n8[0], 8);
#else
    ctxt->md5_buf[56] = ctxt->md5_n8[7];
    ctxt->md5_buf[57] = ctxt->md5_n8[6];
    ctxt->md5_buf[58] = ctxt->md5_n8[5];
    ctxt->md5_buf[59] = ctxt->md5_n8[4];
    ctxt->md5_buf[60] = ctxt->md5_n8[3];
    ctxt->md5_buf[61] = ctxt->md5_n8[2];
    ctxt->md5_buf[62] = ctxt->md5_n8[1];
    ctxt->md5_buf[63] = ctxt->md5_n8[0];
#endif

    md5_calc(ctxt->md5_buf, ctxt);
}

void md5_result	(	uint8 *	digest,
		md5_ctxt *	ctxt
	)

Definition at line 215 of file md5.c.

References memmove.

{
    /* 4 byte words */
#ifndef WORDS_BIGENDIAN
    memmove(digest, &ctxt->md5_st8[0], 16);
#else
    digest[0] = ctxt->md5_st8[3];
    digest[1] = ctxt->md5_st8[2];
    digest[2] = ctxt->md5_st8[1];
    digest[3] = ctxt->md5_st8[0];
    digest[4] = ctxt->md5_st8[7];
    digest[5] = ctxt->md5_st8[6];
    digest[6] = ctxt->md5_st8[5];
    digest[7] = ctxt->md5_st8[4];
    digest[8] = ctxt->md5_st8[11];
    digest[9] = ctxt->md5_st8[10];
    digest[10] = ctxt->md5_st8[9];
    digest[11] = ctxt->md5_st8[8];
    digest[12] = ctxt->md5_st8[15];
    digest[13] = ctxt->md5_st8[14];
    digest[14] = ctxt->md5_st8[13];
    digest[15] = ctxt->md5_st8[12];
#endif
}

Variable Documentation

const uint8 md5_paddat[MD5_BUFLEN] [static]

Initial value:

 {
    0x80, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
}

Definition at line 124 of file md5.c.

Referenced by md5_pad().

const uint32 T[65] [static]

Initial value:

 {
    0,
    0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
    0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
    0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
    0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,

    0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
    0xd62f105d, 0x2441453, 0xd8a1e681, 0xe7d3fbc8,
    0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
    0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,

    0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
    0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
    0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x4881d05,
    0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,

    0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
    0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
    0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
    0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
}

Definition at line 101 of file md5.c.

Referenced by cost_bitmap_heap_scan(), and index_pages_fetched().

Header And Logo

md5.c File Reference

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation