What is a Hash Algorithm?
A hash algorithm is a function that takes input data (of any size) and produces a fixed-size
string of characters, which is typically a hexadecimal number. This output is called a "hash
value" or "digest."
Hash algorithms are commonly used for:
1. Data integrity checks: To ensure data hasn't been tampered with.
2. Storing passwords securely: Only the hash of the password is stored, not the
actual password.
3. Efficient data retrieval: Hash tables use hashes to quickly look up values.
Key Characteristics of a Good Hash Algorithm
1. Deterministic: The same input will always produce the same output.
2. Fast: It should compute the hash value quickly.
3. Non-reversible: It should be nearly impossible to reconstruct the original input from
its hash value.
4. Collision-resistant: It should be hard to find two different inputs that produce the
same hash.
Simple Example of a Hash Function in C
Here’s a basic implementation of a simple hash function. This is not cryptographic-grade but
demonstrates how a hash algorithm can work.
#include <stdio.h>
#include <string.h>
#define HASH_SIZE 256 // The hash value will be between 0 and 255
// A simple hash function
unsigned int simpleHash(const char *str) {
unsigned int hash = 0;
while (*str) {
hash = (hash + *str) % HASH_SIZE; // Add ASCII value of character and take modulo
str++;
}
return hash;
}
int main() {
const char *input = "Hello, World!";
unsigned int hashValue = simpleHash(input);
printf("Input: %s\n", input);
printf("Hash Value: %u\n", hashValue);
return 0;
}
Explanation of the Code
1. Input String: The function takes a string (e.g., "Hello, World!") as input.
2. Loop Through Characters: The while (*str) loop iterates through each
character in the string.
3. ASCII Sum Modulo Operation:
○
It adds the ASCII value of each character to a running total (hash).
The % HASH_SIZE ensures the hash value stays within a fixed range (0–
○
255).
4. Output the Hash Value: The result is the hash value, a number that represents the
input string.
Running the Code
For the input Hello, World!, the ASCII sum might look like this:
● 'H' = 72
● 'e' = 101
● 'l' = 108
Summing all characters and taking % 256 produces a hash value.
Real Cryptographic Hash Function Example
For real-world scenarios, use a library like OpenSSL to implement secure hash functions
(e.g., MD5, SHA-256).
Example with SHA-256:
#include <openssl/sha.h>
#include <stdio.h>
#include <string.h>
void hashString(const char *str) {
unsigned char hash[SHA256_DIGEST_LENGTH];
SHA256((unsigned char*)str, strlen(str), hash);
printf("SHA-256 Hash: ");
for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
printf("%02x", hash[i]); // Print each byte in hexadecimal
}
printf("\n");
}
int main() {
const char *input = "Hello, World!";
hashString(input);
return 0;
}
Explanation of SHA-256 Example
1. OpenSSL Library: The SHA256 function computes the secure hash of the input
string.
2. Fixed-Size Output: The hash value is always 256 bits (32 bytes), regardless of input
size.
3. Hexadecimal Formatting: Each byte of the hash is printed as two hexadecimal
characters.
Use Cases
● Simple Hash: Great for educational purposes or lightweight applications.
● Cryptographic Hash: Essential for security-related tasks, e.g., password hashing or
digital signatures.
