Hash functions

Learn hash functions and digest extraction.

Hash functions

A hash function turns data of any size into a fixed-size digest. A good hash is deterministic (same input always yields same output), one-way (you cannot recover the input from the output) and has an avalanche effect (a small input change produces a large output change).

The digest is used for data integrity: file downloads, password storage, digital signatures. In C you can write a simple hash; but for production you use a standard algorithm like SHA-256. In this lesson we will write a simple hash that sums character codes; we will see what the digest looks like.

Writing a simple hash

A simple hash: sum the character codes. Define unsigned int hash(const char *s); loop with while (*s) { h += (unsigned char)*s; s++; }. The return is h. This hash is weak but shows the concept.

For testing, print printf("digest: %u\n", hash("hello") % 100). The "hello" characters sum to 104+101+108+108+111 = 532; 532 % 100 = 32. So the output is digest: 32. This is deterministic. In production SHA-256 is used; there the digest is 32 bytes.

Exercise Write a simple hash

Define a function unsigned int hash(const char *s). Inside: unsigned int h = 0;, while (*s) { h += (unsigned char)*s; s++; }, return h;. In main call printf("digest: %u\n", hash("hello") % 100);.

Show example solution

#include <stdio.h>
#include <string.h>

unsigned int hash(const char *s) {
    unsigned int h = 0;
    while (*s) {
        h += (unsigned char)*s;
        s++;
    }
    return h;
}

int main(void) {
    printf("digest: %u\n", hash("hello") % 100);
    return 0;
}

Test yourself

How does a good hash function behave?
- Reversible
- Variable size output
- Same input same output
- Input similar to output
Show answer

Same input same output — Being deterministic is the core property of a good hash.

Hash call

unsigned int h = hash("____");

Show answer

unsigned int h = hash("merhaba");

Match hash concepts

digest

Fixed size
deterministic

Same input same output
one-way

No reverse
avalanche

Small change big diff

Next lesson: SHA-256

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies