# 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

# Calculating CRC-64 in C# and .NET

Seeing how the CRC-32 C# class I posted some time ago continues to get lots of Google hits I thought I’d post a CRC-64 version which will no doubt be far less popular being the more limited use. Again, do not use this as a secure message signature, it’s really for backward compatibility with legacy systems.

This is the ISO-3309 version of CRC-64 algorithm. It is not compatible with the ECMA-182 algorithm.

To use this or the CRC-32 class to compute the hash for a file simply:

``````Crc64 crc64 = new Crc64();
String hash = String.Empty;

using (FileStream fs = File.Open("c:\\myfile.txt", FileMode.Open))
foreach (byte b in crc64.ComputeHash(fs)) hash += b.ToString("x2").ToLower();

Console.WriteLine("CRC-64 is {0}", hash);
``````

Whilst writing this I considered if I should implement some more advanced hashing algorithms missing from .NET like RIPEMD320 only to stumble across The Legion of Bouncy Castles C# Cryptography APIs which also includes generating PKCS #12 files and a whole bunch of encryption algorithms (but nothing as weak as CRC-64 ;-)

[)amien

# Calculating CRC-32 in C# and .NET

Just a few days ago I found myself needing to calculate a CRC-32 in .NET. With so many facilities available I was a little shocked that there was nothing built-in to do it so knocked up something myself.

Because unsigned ints aren’t CLS compliant it won’t play well with VB.NET and implementing the `HashAlgorithm` might lead people to believe it’s suitable for signing – it isn’t. CRC-32’s are only any good for check-sums along the lines of WinZIP, RAR etc. and certainly shouldn’t come near a password and instead consider SHA-512 or similar.

As well as using it as a HashAlgorithm with block processing you can also access the static method Compute although there is an overhead with every call building the table with that. If neither option suits you needs cut ‘n splice it to something that does.

If using the `Compute` methods multiple times for the same hash you must XOR (~) the current hash when passing it in to the next subsequent call’s seed parameter.

To compute the hash for a file simply:

``````var crc32 = new Crc32();
var hash = String.Empty;

using (var fs = File.Open("c:\\myfile.txt", FileMode.Open))
foreach (byte b in crc32.ComputeHash(fs)) hash += b.ToString("x2").ToLower();

Console.WriteLine("CRC-32 is {0}", hash);
``````

[)amien