Hash algorithms

Files
file	hash_adler32.c
	32-bit Adler hash algorithm
file	hash_blake2b.c
	Blake2b cryptographic hash function
file	hash_crc32.c
	32-bit CRC hash algorithm
file	hash_djb2.c
	DJB2 hash algorithm
file	hash_sdbm.c
	SDBM hash algorithm
file	hash_xor8.c
	8-bit XOR hash algorithm for ASCII characters

Macros
#define	bb   128
	for asserts
#define	KK_MAX   64
	max key length for BLAKE2b
#define	NN_MAX   64
	max length of BLAKE2b digest in bytes
#define	CEIL(a, b)   (((a) / (b)) + ((a) % (b) != 0))
	ceiling division macro without floats
#define	MIN(a, b)   ((a) < (b) ? (a) : (b))
	returns minimum value
#define	MAX(a, b)   ((a) > (b) ? (a) : (b))
	returns maximum value
#define	ROTR64(n, offset)   (((n) >> (offset)) ^ ((n) << (64 - (offset))))
	macro to rotate 64-bit ints to the right Ripped from RFC 7693
#define	U128_ZERO
	zero-value initializer for u128 type

Typedefs
typedef uint64_t	u128[2]
	128-bit number represented as two uint64's
typedef uint64_t	block_t[bb/sizeof(uint64_t)]
	Padded input block containing bb bytes.

Functions
uint32_t	adler32 (const char *s)
	32-bit Adler algorithm implementation
void	test_adler32 ()
	Test function for adler32.
static void	u128_fill (u128 dest, size_t n)
	put value of n into dest
static void	u128_increment (u128 dest, uint64_t n)
	increment an 128-bit number by a given amount
static void	G (block_t v, uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint64_t x, uint64_t y)
	blake2b mixing function G
static void	F (uint64_t h[8], block_t m, u128 t, int f)
	compression function F
static int	BLAKE2B (uint8_t *dest, block_t *d, size_t dd, u128 ll, uint8_t kk, uint8_t nn)
	driver function to perform the hashing as described in specification
uint8_t *	blake2b (const uint8_t *message, size_t len, const uint8_t *key, uint8_t kk, uint8_t nn)
	blake2b hash function
uint32_t	crc32 (const char *s)
	32-bit CRC algorithm implementation
void	test_crc32 ()
	Test function for crc32.
uint64_t	djb2 (const char *s)
	DJB2 algorithm implementation.
void	test_djb2 (void)
	Test function for djb2.
uint64_t	sdbm (const char *s)
	SDBM algorithm implementation.
void	test_sdbm ()
	Test function for sdbm.
uint8_t	xor8 (const char *s)
	8-bit XOR algorithm implementation
void	test_xor8 ()
	Test function for xor8.

Variables
static const uint8_t	R1 = 32
	Rotation constant 1 for mixing function G.
static const uint8_t	R2 = 24
	Rotation constant 2 for mixing function G.
static const uint8_t	R3 = 16
	Rotation constant 3 for mixing function G.
static const uint8_t	R4 = 63
	Rotation constant 4 for mixing function G.
static const uint64_t	blake2b_iv [8]
	BLAKE2b Initialization vector blake2b_iv[i] = floor(2**64 * frac(sqrt(prime(i+1)))), where prime(i) is the i:th prime number.
static const uint8_t	blake2b_sigma [12][16]
	word schedule permutations for each round of the algorithm

Detailed Description

Macro Definition Documentation

bb

#define bb   128

for asserts

for fixed-width integer types e.g. uint64_t and uint8_t for IO for malloc, calloc, and free. As well as size_t

the size of a data block in bytes

CEIL

#define CEIL	(		a,
			b
	)		(((a) / (b)) + ((a) % (b) != 0))

ceiling division macro without floats

Parameters

a	dividend
b	divisor

U128_ZERO

#define U128_ZERO

Value:

    {             \
        0, 0      \
    }

zero-value initializer for u128 type

    {             \
        0, 0      \
    }

Function Documentation

adler32()

uint32_t adler32

(

const char *

s

)

32-bit Adler algorithm implementation

Parameters

s	NULL terminated ASCII string to hash

Returns

32-bit hash result

{
    uint32_t a = 1;
    uint32_t b = 0;
    const uint32_t MODADLER = 65521;
 
    size_t i = 0;
    while (s[i] != '\0')
    {
        a = (a + s[i]) % MODADLER;
        b = (b + a) % MODADLER;
        i++;
    }
    return (b << 16) | a;
}

blake2b()

uint8_t * blake2b	(	const uint8_t *	message,
		size_t	len,
		const uint8_t *	key,
		uint8_t	kk,
		uint8_t	nn
	)

blake2b hash function

This is the front-end function that sets up the argument for BLAKE2B().

Parameters

message	the message to be hashed
len	length of message (0 <= len < 2**128) (depends on sizeof(size_t) for this implementation)
key	optional secret key
kk	length of optional secret key (0 <= kk <= 64)
nn	length of output digest (1 <= nn < 64)

Returns

NULL if heap memory couldn't be allocated. Otherwise heap allocated memory nn bytes large

{
    uint8_t *dest = NULL;
    uint64_t long_hold;
    size_t dd, has_key, i;
    size_t block_index, word_in_block;
    u128 ll;
    block_t *blocks;
 
    if (message == NULL)
    {
        len = 0;
    }
    if (key == NULL)
    {
        kk = 0;
    }
 
    kk = MIN(kk, KK_MAX);
    nn = MIN(nn, NN_MAX);
 
    dd = MAX(CEIL(kk, bb) + CEIL(len, bb), 1);
 
    blocks = calloc(dd, sizeof(block_t));
    if (blocks == NULL)
    {
        return NULL;
    }
 
    dest = malloc(nn * sizeof(uint8_t));
    if (dest == NULL)
    {
        free(blocks);
        return NULL;
    }
 
    /* If there is a secret key it occupies the first block */
    for (i = 0; i < kk; i++)
    {
        long_hold = key[i];
        long_hold <<= 8 * (i % 8);
 
        word_in_block = (i % bb) / 8;
        /* block_index will always be 0 because kk <= 64 and bb = 128*/
        blocks[0][word_in_block] |= long_hold;
    }
 
    has_key = kk > 0 ? 1 : 0;
 
    for (i = 0; i < len; i++)
    {
        /* long_hold exists because the bit-shifting will overflow if we don't
         * store the value */
        long_hold = message[i];
        long_hold <<= 8 * (i % 8);
 
        block_index = has_key + (i / bb);
        word_in_block = (i % bb) / 8;
 
        blocks[block_index][word_in_block] |= long_hold;
    }
 
    u128_fill(ll, len);
 
    BLAKE2B(dest, blocks, dd, ll, kk, nn);
 
    free(blocks);
 
    return dest;
}

Here is the call graph for this function:

BLAKE2B()

static int BLAKE2B ( uint8_t *  dest, block_t *  d, size_t  dd, u128  ll, uint8_t  kk, uint8_t  nn  )

static

driver function to perform the hashing as described in specification

pseudocode: (credit to authors of RFC 7693 listed above) FUNCTION BLAKE2( d[0..dd-1], ll, kk, nn ) | | h[0..7] := IV[0..7] // Initialization Vector. | | // Parameter block p[0] | h[0] := h[0] ^ 0x01010000 ^ (kk << 8) ^ nn | | // Process padded key and data blocks | IF dd > 1 THEN | | FOR i = 0 TO dd - 2 DO | | | h := F( h, d[i], (i + 1) * bb, FALSE ) | | END FOR. | END IF. | | // Final block. | IF kk = 0 THEN | | h := F( h, d[dd - 1], ll, TRUE ) | ELSE | | h := F( h, d[dd - 1], ll + bb, TRUE ) | END IF. | | RETURN first "nn" bytes from little-endian word array h[]. | END FUNCTION.

Parameters

dest	destination of hashing digest
d	message blocks
dd	length of d
ll	128-bit length of message
kk	length of secret key
nn	length of hash digest

Returns

0 upon successful hash

{
    uint8_t bytes[8];
    uint64_t i, j;
    uint64_t h[8];
    u128 t = U128_ZERO;
 
    /* h[0..7] = IV[0..7] */
    for (i = 0; i < 8; i++)
    {
        h[i] = blake2b_iv[i];
    }
 
    h[0] ^= 0x01010000 ^ (kk << 8) ^ nn;
 
    if (dd > 1)
    {
        for (i = 0; i < dd - 1; i++)
        {
            u128_increment(t, bb);
            F(h, d[i], t, 0);
        }
    }
 
    if (kk != 0)
    {
        u128_increment(ll, bb);
    }
    F(h, d[dd - 1], ll, 1);
 
    /* copy bytes from h to destination buffer */
    for (i = 0; i < nn; i++)
    {
        if (i % sizeof(uint64_t) == 0)
        {
            /* copy values from uint64 to 8 u8's */
            for (j = 0; j < sizeof(uint64_t); j++)
            {
                uint16_t offset = 8 * j;
                uint64_t mask = 0xFF;
                mask <<= offset;
 
                bytes[j] = (h[i / 8] & (mask)) >> offset;
            }
        }
 
        dest[i] = bytes[i % 8];
    }
 
    return 0;
}

Here is the call graph for this function:

crc32()

uint32_t crc32

(

const char *

s

)

32-bit CRC algorithm implementation

Parameters

s	NULL terminated ASCII string to hash

Returns

32-bit hash result

{
    uint32_t crc = 0xffffffff;
    size_t i = 0;
    while (s[i] != '\0')
    {
        uint8_t byte = s[i];
        crc = crc ^ byte;
        for (uint8_t j = 8; j > 0; --j)
        {
            crc = (crc >> 1) ^ (0xEDB88320 & (-(crc & 1)));
        }
 
        i++;
    }
    return crc ^ 0xffffffff;
}

djb2()

uint64_t djb2

(

const char *

s

)

DJB2 algorithm implementation.

Parameters

s	NULL terminated string to hash

Returns

64-bit hash result

{
    uint64_t hash = 5381; /* init value */
    size_t i = 0;
    while (s[i] != '\0')
    {
        hash = ((hash << 5) + hash) + s[i];
        i++;
    }
    return hash;
}

F()

static void F ( uint64_t  h[8], block_t  m, u128  t, int  f  )

static

compression function F

Securely mixes the values in block m into the state vector h. Value at v[14] is also inverted if this is the final block to be compressed.

Parameters

h	the state vector
m	message vector to be compressed into h
t	128-bit offset counter
f	flag to indicate whether this is the final block

Returns

void

{
    int i;
    block_t v;
 
    /* v[0..7] := h[0..7] */
    for (i = 0; i < 8; i++)
    {
        v[i] = h[i];
    }
    /* v[8..15] := IV[0..7] */
    for (; i < 16; i++)
    {
        v[i] = blake2b_iv[i - 8];
    }
 
    v[12] ^= t[0]; /* v[12] ^ (t mod 2**w) */
    v[13] ^= t[1]; /* v[13] ^ (t >> w) */
 
    if (f)
    {
        v[14] = ~v[14];
    }
 
    for (i = 0; i < 12; i++)
    {
        const uint8_t *s = blake2b_sigma[i];
 
        G(v, 0, 4, 8, 12, m[s[0]], m[s[1]]);
        G(v, 1, 5, 9, 13, m[s[2]], m[s[3]]);
        G(v, 2, 6, 10, 14, m[s[4]], m[s[5]]);
        G(v, 3, 7, 11, 15, m[s[6]], m[s[7]]);
 
        G(v, 0, 5, 10, 15, m[s[8]], m[s[9]]);
        G(v, 1, 6, 11, 12, m[s[10]], m[s[11]]);
        G(v, 2, 7, 8, 13, m[s[12]], m[s[13]]);
        G(v, 3, 4, 9, 14, m[s[14]], m[s[15]]);
    }
 
    for (i = 0; i < 8; i++)
    {
        h[i] ^= v[i] ^ v[i + 8];
    }
}

Here is the call graph for this function:

G()

static void G ( block_t  v, uint8_t  a, uint8_t  b, uint8_t  c, uint8_t  d, uint64_t  x, uint64_t  y  )

static

blake2b mixing function G

Shuffles values in block v depending on provided indeces a, b, c, and d. x and y are also mixed into the block.

Parameters

v	array of words to be mixed
a	first index
b	second index
c	third index
d	fourth index
x	first word being mixed into v
y	second word being mixed into y

Returns

void

{
    v[a] += v[b] + x;
    v[d] = ROTR64(v[d] ^ v[a], R1);
    v[c] += v[d];
    v[b] = ROTR64(v[b] ^ v[c], R2);
    v[a] += v[b] + y;
    v[d] = ROTR64(v[d] ^ v[a], R3);
    v[c] += v[d];
    v[b] = ROTR64(v[b] ^ v[c], R4);
}

sdbm()

uint64_t sdbm

(

const char *

s

)

SDBM algorithm implementation.

Parameters

s	NULL terminated string to hash

Returns

64-bit hash result

{
    uint64_t hash = 0;
    size_t i = 0;
    while (s[i] != '\0')
    {
        hash = s[i] + (hash << 6) + (hash << 16) - hash;
        i++;
    }
    return hash;
}

test_adler32()

void test_adler32

(

)

Test function for adler32.

Returns

None

{
    assert(adler32("Hello World") == 403375133);
    assert(adler32("Hello World!") == 474547262);
    assert(adler32("Hello world") == 413860925);
    assert(adler32("Hello world!") == 487130206);
    printf("Tests passed\n");
}

Here is the call graph for this function:

test_crc32()

void test_crc32

(

)

Test function for crc32.

Returns

None

{
    assert(crc32("Hello World") == 1243066710);
    assert(crc32("Hello World!") == 472456355);
    assert(crc32("Hello world") == 2346098258);
    assert(crc32("Hello world!") == 461707669);
    printf("Tests passed\n");
}

Here is the call graph for this function:

test_djb2()

void test_djb2

(

void

)

Test function for djb2.

Returns

none

{
    assert(djb2("Hello World") == 13827776004929097857);
    assert(djb2("Hello World!") == 13594750393630990530);
    assert(djb2("Hello world") == 13827776004967047329);
    assert(djb2("Hello world!") == 13594750394883323106);
    printf("Tests passed\n");
}

Here is the call graph for this function:

test_sdbm()

void test_sdbm

(

)

Test function for sdbm.

Returns

None

{
    assert(sdbm("Hello World") == 12881824461405877380U);
    assert(sdbm("Hello World!") == 7903571203300273309);
    assert(sdbm("Hello world") == 15154913742888948900U);
    assert(sdbm("Hello world!") == 15254999417003201661U);
    printf("Tests passed\n");
}

Here is the call graph for this function:

test_xor8()

void test_xor8

(

)

Test function for xor8.

Returns

None

{
    assert(xor8("Hello World") == 228);
    assert(xor8("Hello World!") == 195);
    assert(xor8("Hello world") == 196);
    assert(xor8("Hello world!") == 163);
    printf("Tests passed\n");
}

Here is the call graph for this function:

u128_fill()

static void u128_fill ( u128  dest, size_t  n  )

inlinestatic

put value of n into dest

Parameters

dest	128-bit number to get copied from n
n	value put into dest

Returns

void

{
    dest[0] = n & UINT64_MAX;
 
    if (sizeof(n) > 8)
    {
        /* The C standard does not specify a maximum length for size_t,
         * although most machines implement it to be the same length as
         * uint64_t. On machines where size_t is 8 bytes long this will issue a
         * compiler warning, which is why it is suppressed. But on a machine
         * where size_t is greater than 8 bytes, this will work as normal. */
        dest[1] = n >> 64;
    }
    else
    {
        dest[1] = 0;
    }
}

u128_increment()

static void u128_increment ( u128  dest, uint64_t  n  )

inlinestatic

increment an 128-bit number by a given amount

Parameters

dest	the value being incremented
n	what dest is being increased by

Returns

void

{
    /* Check for overflow */
    if (UINT64_MAX - dest[0] <= n)
    {
        dest[1]++;
    }
 
    dest[0] += n;
}

xor8()

uint8_t xor8

(

const char *

s

)

8-bit XOR algorithm implementation

Parameters

s	NULL terminated ASCII string to hash

Returns

8-bit hash result

{
    uint8_t hash = 0;
    size_t i = 0;
    while (s[i] != '\0')
    {
        hash = (hash + s[i]) & 0xff;
        i++;
    }
    return (((hash ^ 0xff) + 1) & 0xff);
}

Variable Documentation

blake2b_iv

const uint64_t blake2b_iv[8]

static

Initial value:

= {
    0x6A09E667F3BCC908, 0xBB67AE8584CAA73B, 0x3C6EF372FE94F82B,
    0xA54FF53A5F1D36F1, 0x510E527FADE682D1, 0x9B05688C2B3E6C1F,
    0x1F83D9ABFB41BD6B, 0x5BE0CD19137E2179}

BLAKE2b Initialization vector blake2b_iv[i] = floor(2**64 * frac(sqrt(prime(i+1)))), where prime(i) is the i:th prime number.

                                      {
    0x6A09E667F3BCC908, 0xBB67AE8584CAA73B, 0x3C6EF372FE94F82B,
    0xA54FF53A5F1D36F1, 0x510E527FADE682D1, 0x9B05688C2B3E6C1F,
    0x1F83D9ABFB41BD6B, 0x5BE0CD19137E2179};  ///< BLAKE2b Initialization vector

blake2b_sigma

const uint8_t blake2b_sigma[12][16]

static

Initial value:

= {
    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
    {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3},
    {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4},
    {7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8},
    {9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13},
    {2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9},
    {12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11},
    {13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10},
    {6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5},
    {10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0},
    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
    {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5,
     3}}

word schedule permutations for each round of the algorithm

                                             {
    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
    {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3},
    {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4},
    {7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8},
    {9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13},
    {2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9},
    {12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11},
    {13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10},
    {6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5},
    {10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0},
    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
    {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5,
     3}};  ///< word schedule permutations for each round of the algorithm