453 lines
16 KiB
C#
453 lines
16 KiB
C#
|
/*
|
||
|
|
|
||
|
|
This file contains an implementation of the MD4 hash algorithm.
|
||
|
|
The implementation was derived from the example source code that
|
||
|
|
is provided in RFC 1320 - "The MD4 Message-Digest Algorithm".
|
||
|
|
|
||
|
|
The code has been ported from C to C# by Arlie Davis (arlied), June 2006.
|
||
|
|
The original copyright is preserved here.
|
||
|
|
|
||
|
|
|
||
|
|
Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
|
||
|
|
rights reserved.
|
||
|
|
|
||
|
|
License to copy and use this software is granted provided that it
|
||
|
|
is identified as the "RSA Data Security, Inc. MD4 Message-Digest
|
||
|
|
Algorithm" in all material mentioning or referencing this software
|
||
|
|
or this function.
|
||
|
|
|
||
|
|
License is also granted to make and use derivative works provided
|
||
|
|
that such works are identified as "derived from the RSA Data
|
||
|
|
Security, Inc. MD4 Message-Digest Algorithm" in all material
|
||
|
|
mentioning or referencing the derived work.
|
||
|
|
|
||
|
|
RSA Data Security, Inc. makes no representations concerning either
|
||
|
|
the merchantability of this software or the suitability of this
|
||
|
|
software for any particular purpose. It is provided "as is"
|
||
|
|
without express or implied warranty of any kind.
|
||
|
|
|
||
|
|
These notices must be retained in any copies of any part of this
|
||
|
|
documentation and/or software.
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
using System;
|
||
|
|
using System.Diagnostics;
|
||
|
|
using System.Text;
|
||
|
|
|
||
|
|
namespace System.Security.Cryptography
|
||
|
|
{
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// This class implements the MD4 message digest algorithm.
|
||
|
|
/// The implementation is a C# port of the original RSA C implementation that is
|
||
|
|
/// provided in RFC 1320.
|
||
|
|
/// </summary>
|
||
|
|
public class MD4Context
|
||
|
|
{
|
||
|
|
public MD4Context()
|
||
|
|
{
|
||
|
|
Reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
public const int DigestLength = 16;
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// This field is "true" if GetDigest has been called.
|
||
|
|
/// It cannot be called again, unless Reset is called.
|
||
|
|
/// </summary>
|
||
|
|
bool _done;
|
||
|
|
|
||
|
|
public void Clear()
|
||
|
|
{
|
||
|
|
_state0 = 0;
|
||
|
|
_state1 = 0;
|
||
|
|
_state2 = 0;
|
||
|
|
_state3 = 0;
|
||
|
|
_count = 0;
|
||
|
|
for (int i = 0; i < 64; i++)
|
||
|
|
_buffer[i] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// This method can be used to reset the state of the MD4 context. After returning, the
|
||
|
|
/// state of the MD4Context is equivalent to its state immediately after the constructor
|
||
|
|
/// finished.
|
||
|
|
/// </summary>
|
||
|
|
public void Reset()
|
||
|
|
{
|
||
|
|
// Load magic initialization constants.
|
||
|
|
_count = 0;
|
||
|
|
_state0 = 0x67452301;
|
||
|
|
_state1 = 0xefcdab89;
|
||
|
|
_state2 = 0x98badcfe;
|
||
|
|
_state3 = 0x10325476;
|
||
|
|
_done = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
MD4 basic transformation. Transforms state based on block.
|
||
|
|
*/
|
||
|
|
void Transform(byte[]/*!*/ block, int offset)
|
||
|
|
{
|
||
|
|
if (offset < 0)
|
||
|
|
throw new ArgumentException("offset cannot be negative.");
|
||
|
|
|
||
|
|
Decode(_block, 0, block, offset, 64);
|
||
|
|
Transform(_block);
|
||
|
|
|
||
|
|
// Zeroize sensitive information.
|
||
|
|
// MD4_memset ((POINTER)x, 0, sizeof (x));
|
||
|
|
}
|
||
|
|
|
||
|
|
#region Constants for MD4Transform routine.
|
||
|
|
const int S11 = 3;
|
||
|
|
const int S12 = 7;
|
||
|
|
const int S13 = 11;
|
||
|
|
const int S14 = 19;
|
||
|
|
const int S21 = 3;
|
||
|
|
const int S22 = 5;
|
||
|
|
const int S23 = 9;
|
||
|
|
const int S24 = 13;
|
||
|
|
const int S31 = 3;
|
||
|
|
const int S32 = 9;
|
||
|
|
const int S33 = 11;
|
||
|
|
const int S34 = 15;
|
||
|
|
#endregion
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// This routine transforms the current MD4 context, using a block of input.
|
||
|
|
/// The input is 16 words, where each word is 32 unsigned bits. This method
|
||
|
|
/// is the core of the MD4 algorithm.
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="x">The message data to use to transform the context.</param>
|
||
|
|
void Transform(uint[] x)
|
||
|
|
{
|
||
|
|
uint a = _state0;
|
||
|
|
uint b = _state1;
|
||
|
|
uint c = _state2;
|
||
|
|
uint d = _state3;
|
||
|
|
|
||
|
|
/* Round 1 */
|
||
|
|
a = FF(a, b, c, d, x[00], S11); /* 1 */
|
||
|
|
d = FF(d, a, b, c, x[01], S12); /* 2 */
|
||
|
|
c = FF(c, d, a, b, x[02], S13); /* 3 */
|
||
|
|
b = FF(b, c, d, a, x[03], S14); /* 4 */
|
||
|
|
a = FF(a, b, c, d, x[04], S11); /* 5 */
|
||
|
|
d = FF(d, a, b, c, x[05], S12); /* 6 */
|
||
|
|
c = FF(c, d, a, b, x[06], S13); /* 7 */
|
||
|
|
b = FF(b, c, d, a, x[07], S14); /* 8 */
|
||
|
|
a = FF(a, b, c, d, x[08], S11); /* 9 */
|
||
|
|
d = FF(d, a, b, c, x[09], S12); /* 10 */
|
||
|
|
c = FF(c, d, a, b, x[10], S13); /* 11 */
|
||
|
|
b = FF(b, c, d, a, x[11], S14); /* 12 */
|
||
|
|
a = FF(a, b, c, d, x[12], S11); /* 13 */
|
||
|
|
d = FF(d, a, b, c, x[13], S12); /* 14 */
|
||
|
|
c = FF(c, d, a, b, x[14], S13); /* 15 */
|
||
|
|
b = FF(b, c, d, a, x[15], S14); /* 16 */
|
||
|
|
|
||
|
|
/* Round 2 */
|
||
|
|
a = GG(a, b, c, d, x[00], S21); /* 17 */
|
||
|
|
d = GG(d, a, b, c, x[04], S22); /* 18 */
|
||
|
|
c = GG(c, d, a, b, x[08], S23); /* 19 */
|
||
|
|
b = GG(b, c, d, a, x[12], S24); /* 20 */
|
||
|
|
a = GG(a, b, c, d, x[01], S21); /* 21 */
|
||
|
|
d = GG(d, a, b, c, x[05], S22); /* 22 */
|
||
|
|
c = GG(c, d, a, b, x[09], S23); /* 23 */
|
||
|
|
b = GG(b, c, d, a, x[13], S24); /* 24 */
|
||
|
|
a = GG(a, b, c, d, x[02], S21); /* 25 */
|
||
|
|
d = GG(d, a, b, c, x[06], S22); /* 26 */
|
||
|
|
c = GG(c, d, a, b, x[10], S23); /* 27 */
|
||
|
|
b = GG(b, c, d, a, x[14], S24); /* 28 */
|
||
|
|
a = GG(a, b, c, d, x[03], S21); /* 29 */
|
||
|
|
d = GG(d, a, b, c, x[07], S22); /* 30 */
|
||
|
|
c = GG(c, d, a, b, x[11], S23); /* 31 */
|
||
|
|
b = GG(b, c, d, a, x[15], S24); /* 32 */
|
||
|
|
|
||
|
|
/* Round 3 */
|
||
|
|
a = HH(a, b, c, d, x[00], S31); /* 33 */
|
||
|
|
d = HH(d, a, b, c, x[08], S32); /* 34 */
|
||
|
|
c = HH(c, d, a, b, x[04], S33); /* 35 */
|
||
|
|
b = HH(b, c, d, a, x[12], S34); /* 36 */
|
||
|
|
a = HH(a, b, c, d, x[02], S31); /* 37 */
|
||
|
|
d = HH(d, a, b, c, x[10], S32); /* 38 */
|
||
|
|
c = HH(c, d, a, b, x[06], S33); /* 39 */
|
||
|
|
b = HH(b, c, d, a, x[14], S34); /* 40 */
|
||
|
|
a = HH(a, b, c, d, x[01], S31); /* 41 */
|
||
|
|
d = HH(d, a, b, c, x[09], S32); /* 42 */
|
||
|
|
c = HH(c, d, a, b, x[05], S33); /* 43 */
|
||
|
|
b = HH(b, c, d, a, x[13], S34); /* 44 */
|
||
|
|
a = HH(a, b, c, d, x[03], S31); /* 45 */
|
||
|
|
d = HH(d, a, b, c, x[11], S32); /* 46 */
|
||
|
|
c = HH(c, d, a, b, x[07], S33); /* 47 */
|
||
|
|
b = HH(b, c, d, a, x[15], S34); /* 48 */
|
||
|
|
|
||
|
|
_state0 = unchecked(_state0 + a);
|
||
|
|
_state1 = unchecked(_state1 + b);
|
||
|
|
_state2 = unchecked(_state2 + c);
|
||
|
|
_state3 = unchecked(_state3 + d);
|
||
|
|
}
|
||
|
|
|
||
|
|
public const int BytesPerTransform = 64;
|
||
|
|
public const int WordsPerTransform = 16;
|
||
|
|
|
||
|
|
uint _state0; // state A
|
||
|
|
uint _state1; // state B
|
||
|
|
uint _state2; // state C
|
||
|
|
uint _state3; // state D
|
||
|
|
Int64 _count; // number of bits, modulo 2^64
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// This buffer holds data that was submitted using the Update method, but which
|
||
|
|
/// was too short to complete a full transform block (64 bytes).
|
||
|
|
/// </summary>
|
||
|
|
readonly byte[]/*!*/ _buffer = new byte[BytesPerTransform];
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// This buffer contains the current block (of message data) that is being transformed.
|
||
|
|
/// </summary>
|
||
|
|
readonly uint[]/*!*/ _block = new uint[WordsPerTransform];
|
||
|
|
|
||
|
|
static MD4Context()
|
||
|
|
{
|
||
|
|
PADDING = new byte[BytesPerTransform];
|
||
|
|
Array.Clear(PADDING, 0, 64);
|
||
|
|
PADDING[0] = 0x80;
|
||
|
|
}
|
||
|
|
|
||
|
|
static readonly byte[]/*!*/ PADDING;
|
||
|
|
/*
|
||
|
|
{
|
||
|
|
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||
|
|
};
|
||
|
|
*/
|
||
|
|
|
||
|
|
/* F, G and H are basic MD4 functions.
|
||
|
|
*/
|
||
|
|
static uint F(uint x, uint y, uint z) { return (x & y) | ((~x) & z); }
|
||
|
|
static uint G(uint x, uint y, uint z) { return (x & y) | (x & z) | (y & z); }
|
||
|
|
static uint H(uint x, uint y, uint z) { return x ^ y ^ z; }
|
||
|
|
|
||
|
|
/* ROTATE_LEFT rotates x left n bits.
|
||
|
|
*/
|
||
|
|
static uint RotateLeft(uint x, int n)
|
||
|
|
{
|
||
|
|
return (x << n) | (x >> (32 - n));
|
||
|
|
}
|
||
|
|
|
||
|
|
/* FF, GG and HH are transformations for rounds 1, 2 and 3 */
|
||
|
|
/* Rotation is separate from addition to prevent recomputation */
|
||
|
|
/* (Or at least it used to be, when these were C macros. */
|
||
|
|
|
||
|
|
static uint FF(uint a, uint b, uint c, uint d, uint x, int s)
|
||
|
|
{
|
||
|
|
a = unchecked(a + F(b, c, d) + x);
|
||
|
|
return RotateLeft(a, s);
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint GG(uint a, uint b, uint c, uint d, uint x, int s)
|
||
|
|
{
|
||
|
|
a = unchecked(a + G(b, c, d) + x + (uint)0x5a827999);
|
||
|
|
return RotateLeft(a, s);
|
||
|
|
}
|
||
|
|
|
||
|
|
static uint HH(uint a, uint b, uint c, uint d, uint x, int s)
|
||
|
|
{
|
||
|
|
a = unchecked(a + H(b, c, d) + x + (uint)0x6ed9eba1);
|
||
|
|
return RotateLeft(a, s);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* Decodes input (unsigned char) into output (uint). Assumes len is
|
||
|
|
a multiple of 4.
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
///
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="output"></param>
|
||
|
|
/// <param name="outputoffset"></param>
|
||
|
|
/// <param name="input"></param>
|
||
|
|
/// <param name="inputoffset"></param>
|
||
|
|
/// <param name="length">number of BYTES to transfer</param>
|
||
|
|
static void Decode(uint[]/*!*/ output, int outputoffset, byte[]/*!*/ input, int inputoffset, int length)
|
||
|
|
{
|
||
|
|
Debug.Assert(length % 4 == 0);
|
||
|
|
|
||
|
|
int outpos = outputoffset;
|
||
|
|
|
||
|
|
for (int j = 0; j < length; j += 4)
|
||
|
|
{
|
||
|
|
uint value = ((uint)input[inputoffset + j])
|
||
|
|
| (((uint)input[inputoffset + j + 1]) << 8)
|
||
|
|
| (((uint)input[inputoffset + j + 2]) << 16)
|
||
|
|
| (((uint)input[inputoffset + j + 3]) << 24);
|
||
|
|
output[outpos] = value;
|
||
|
|
|
||
|
|
outpos++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void EncodeLe(uint value, byte[]/*!*/ output, int pos)
|
||
|
|
{
|
||
|
|
output[pos] = (byte)(value & 0xff);
|
||
|
|
output[pos + 1] = (byte)((value >> 8) & 0xff);
|
||
|
|
output[pos + 2] = (byte)((value >> 16) & 0xff);
|
||
|
|
output[pos + 3] = (byte)((value >> 24) & 0xff);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// MD4 block update operation. Continues an MD4 message-digest operation,
|
||
|
|
/// processing another message block, and updating the context.
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="input">The buffer containing data to process.</param>
|
||
|
|
/// <param name="offset">The offset within the buffer where the data begins.</param>
|
||
|
|
/// <param name="length">The length of the data.</param>
|
||
|
|
public void Update(byte[]/*!*/ input, int offset, int length)
|
||
|
|
{
|
||
|
|
if (_done)
|
||
|
|
throw new InvalidOperationException("The hash context has been closed (GetDigest has been called). It cannot be reused until Reset is called.");
|
||
|
|
|
||
|
|
if (length == 0)
|
||
|
|
return;
|
||
|
|
|
||
|
|
/* Compute number of bytes mod 64 */
|
||
|
|
int index = (int)((_count >> 3) & 0x3F);
|
||
|
|
_count += length << 3;
|
||
|
|
|
||
|
|
int partLen = 64 - index;
|
||
|
|
|
||
|
|
/* Transform as many times as possible.
|
||
|
|
*/
|
||
|
|
int i;
|
||
|
|
if (length >= partLen)
|
||
|
|
{
|
||
|
|
// MD4_memcpy((POINTER)&buffer_pinned[index], (POINTER)&input[offset], partLen);
|
||
|
|
Array.Copy(input, offset, _buffer, index, partLen);
|
||
|
|
Transform(_buffer, 0);
|
||
|
|
|
||
|
|
for (i = partLen; i + 63 < length; i += 64)
|
||
|
|
Transform(input, offset + i);
|
||
|
|
|
||
|
|
index = 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
i = 0;
|
||
|
|
|
||
|
|
/* Buffer remaining input */
|
||
|
|
// MD4_memcpy((POINTER)&_buffer[index], (POINTER)&input[i], inputLen-i);
|
||
|
|
// MD4_memcpy((POINTER)&buffer_pinned[index], (POINTER)&input[offset + i], inputLen-i);
|
||
|
|
Array.Copy(input, offset + i, _buffer, index, length - i);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
public static MD4Digest GetDigest(byte[]/*!*/ buffer)
|
||
|
|
{
|
||
|
|
return GetDigest(buffer, 0, buffer.Length);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MD4Digest GetDigest(byte[]/*!*/ buffer, int offset, int length)
|
||
|
|
{
|
||
|
|
MD4Context context = new MD4Context();
|
||
|
|
context.Update(buffer, offset, length);
|
||
|
|
return context.GetDigest();
|
||
|
|
}
|
||
|
|
|
||
|
|
/* MD4 finalization. Ends an MD4 message-digest operation, writing the
|
||
|
|
the message digest and zeroizing the context.
|
||
|
|
*/
|
||
|
|
public MD4Digest GetDigest()
|
||
|
|
{
|
||
|
|
if (_done)
|
||
|
|
throw new InvalidOperationException("GetDigest cannot be called twice for a single hash sequence. Call Reset() to reset the context.");
|
||
|
|
|
||
|
|
byte[]/*!*/ bits = new byte[8];
|
||
|
|
|
||
|
|
/* Save number of bits */
|
||
|
|
EncodeLe((uint)(_count & 0xffffffffu), bits, 0);
|
||
|
|
EncodeLe((uint)(_count >> 32), bits, 4);
|
||
|
|
|
||
|
|
// Pad out to 56 mod 64.
|
||
|
|
int index = (int)((_count >> 3) & 0x3f);
|
||
|
|
int padLen = (index < 56) ? (56 - index) : (120 - index);
|
||
|
|
Update(PADDING, 0, padLen);
|
||
|
|
|
||
|
|
// Append length (before padding)
|
||
|
|
Update(bits, 0, 8);
|
||
|
|
|
||
|
|
// Store state in digest
|
||
|
|
|
||
|
|
MD4Digest digest;
|
||
|
|
digest.state0 = _state0;
|
||
|
|
digest.state1 = _state1;
|
||
|
|
digest.state2 = _state2;
|
||
|
|
digest.state3 = _state3;
|
||
|
|
|
||
|
|
Clear();
|
||
|
|
|
||
|
|
_done = true;
|
||
|
|
|
||
|
|
return digest;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public struct MD4Digest
|
||
|
|
{
|
||
|
|
public uint state0;
|
||
|
|
public uint state1;
|
||
|
|
public uint state2;
|
||
|
|
public uint state3;
|
||
|
|
|
||
|
|
static void PackLe(byte[]/*!*/ dest, int offset, uint value)
|
||
|
|
{
|
||
|
|
dest[offset + 0] = (byte)((value) & 0xff);
|
||
|
|
dest[offset + 1] = (byte)((value >> 8) & 0xff);
|
||
|
|
dest[offset + 2] = (byte)((value >> 16) & 0xff);
|
||
|
|
dest[offset + 3] = (byte)((value >> 24) & 0xff);
|
||
|
|
}
|
||
|
|
|
||
|
|
public const int DigestLength = 16;
|
||
|
|
|
||
|
|
public byte[]/*!*/ ToArray()
|
||
|
|
{
|
||
|
|
byte[] result = new byte[DigestLength];
|
||
|
|
ToArray(result);
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void ToArray(byte[]/*!*/ result)
|
||
|
|
{
|
||
|
|
if (result.Length < 0x10)
|
||
|
|
throw new ArgumentException("Input array is too short.");
|
||
|
|
|
||
|
|
PackLe(result, 0, state0);
|
||
|
|
PackLe(result, 4, state1);
|
||
|
|
PackLe(result, 8, state2);
|
||
|
|
PackLe(result, 12, state3);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static implicit operator byte[]/*!*/(MD4Digest digest)
|
||
|
|
{
|
||
|
|
return digest.ToArray();
|
||
|
|
}
|
||
|
|
|
||
|
|
override public string/*!*/ ToString()
|
||
|
|
{
|
||
|
|
string hex = "0123456789abcdef";
|
||
|
|
byte[] arr = ToArray();
|
||
|
|
StringBuilder buffer = new StringBuilder(DigestLength * 2);
|
||
|
|
for (int i = 0; i < 0x10; i++)
|
||
|
|
{
|
||
|
|
byte b = arr[i];
|
||
|
|
buffer.Append(hex[b >> 4]);
|
||
|
|
buffer.Append(hex[b & 0xf]);
|
||
|
|
}
|
||
|
|
return buffer.ToString();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|