# Calculating Elf-32 in C# and .NET

Because you can never have enough hashing algorithms at your disposal this one is compatible with the elf_hash function that forms part of the Executable and Linkable Format.

``````using System;
using System.Security.Cryptography;

public class Elf32 : HashAlgorithm {
private UInt32 hash;

public Elf32() {
Initialize();
}

public override void Initialize() {
hash = 0;
}

protected override void HashCore(byte[] buffer, int start, int length) {
hash = CalculateHash(hash, buffer, start, length);
}

protected override byte[] HashFinal() {
byte[] hashBuffer = UInt32ToBigEndianBytes(hash);
this.HashValue = hashBuffer;
return hashBuffer;
}

public override int HashSize { get { return 32; } }

public static UInt32 Compute(UInt32 polynomial, UInt32 seed, byte[] buffer) {
return CalculateHash(seed, buffer, 0, buffer.Length);
}

private static UInt32 CalculateHash(UInt32 seed, byte[] buffer, int start, int size) {
UInt32 hash = seed;

for (int i = start; i < size; i++)
unchecked {
hash = (hash << 4) + buffer[i];
UInt32 work = (hash & 0xf0000000);
if (work != 0)
hash ^= (work >> 24);
hash &= ~work;
}
return hash;
}

private byte[] UInt32ToBigEndianBytes(UInt32 x) {
return new byte[] {
(byte)((x >> 24) & 0xff),
(byte)((x >> 16) & 0xff),
(byte)((x >> 8) & 0xff),
(byte)(x & 0xff)
};
}
}
``````

[)amien

### 4 responses

1. if (work != 0) hash ^= (work >> 24);

Makes me wonder if it costs more to avoid this than to just do it anyway when work==0? As it has no effect on hash when work==0, and I'm almost certain it'll always be slower to branch.

bitRAKE December 4, 2007
2. hi Damien,

Can this algorithm duplicate?

``````private static uint GetELF(string str)
{
int i;
uint x;
uint result = 10;
byte[] b = ASCIIEncoding.Unicode.GetBytes(str);
for (i = 0; i < b.Length; i++)
{
unchecked
{
result = (result <> 24);
result &amp;= ~x;
}
}
return result;
}
``````

hash code of "mj9d" and "oj9f" is the same.

regards, Canh

QuangCanh October 20, 2008
3. All hash functions can return the same hash code for a different input sets. If they didn't they would instead be very effective compression algorithms.

Damien Guard October 20, 2008
4. 