Files
mono/mcs/class/corlib/System.Security.Cryptography/HashAlgorithm.cs
T
Ravi Pratap M 76218d8771 2002-01-05 Ravi Pratap <[email protected]>
* CryptoAPITransform.cs, DESCryptoProvider.cs : MonoTODO attribute
	decoration.

	* HashAlgorithm.cs, MD5.cs, SHA1.cs, SHA256.cs, SHA384.cs : Ditto.

	* SHA512.cs, SymmetricAlgorithm.cs, ToBase64Transform.cs,
	AsymmetricAlgorithm.cs, CryptoStream.cs, DSA.cs, DSASignatureDeformatter.cs,
	DSASignatureFormatter.cs, SignatureDescription.cs : Ditto.

svn path=/trunk/mcs/; revision=1848
2002-01-05 06:10:24 +00:00

158 lines
4.6 KiB
C#

//
// System.Security.Cryptography HashAlgorithm Class implementation
//
// Authors:
// Matthew S. Ford ([email protected])
//
// Copyright 2001 by Matthew S. Ford.
//
using System.Security.Cryptography;
namespace System.Security.Cryptography {
public abstract class HashAlgorithm : ICryptoTransform {
protected byte[] HashValue; // Caches the hash after it is calculated. Accessed through the Hash property.
protected int HashSizeValue; // The size of the hash in bits.
protected int State; // nonzero when in use; zero when not in use
/// <summary>
/// Called from constructor of derived class.
/// </summary>
protected HashAlgorithm () {
}
/// <summary>
/// FIXME: Always true for hashes?
/// Get whether or not the hash can transform multiple blocks at a time.
/// </summary>
[MonoTODO]
public virtual bool CanTransformMultipleBlocks {
get {
return true;
}
}
/// <summary>
/// Computes the entire hash of all the bytes in the byte array.
/// </summary>
public virtual byte[] ComputeHash (byte[] input) {
// inputData = input.Clone();
HashCore (input, 0, input.Length);
HashValue = HashFinal ();
Initialize ();
return HashValue;
}
/// <summary>
/// Creates the default implementation of the default hash algorithm (SHA1).
/// </summary>
public static HashAlgorithm Create () {
return SHA1.Create ();
}
/// <summary>
/// Creates a specific implementation of the general hash idea.
/// </summary>
/// <param name="st">FIXME: No clue. Specifies which derived class to create.</param>
[MonoTODO]
public static HashAlgorithm Create (string st) {
return Create ();
}
/// <summary>
/// Gets the previously computed hash.
/// </summary>
public virtual byte[] Hash {
get {
return HashValue;
}
}
/// <summary>
/// When overridden in a derived class, drives the hashing function.
/// </summary>
/// <param name="rgb"></param>
/// <param name="start"></param>
/// <param name="size"></param>
protected abstract void HashCore (byte[] rgb, int start, int size);
/// <summary>
/// When overridden in a derived class, this pads and hashes whatever data might be left in the buffers and then returns the hash created.
/// </summary>
protected abstract byte[] HashFinal ();
/// <summary>
/// Returns the size in bits of the hash.
/// </summary>
public virtual int HashSize {
get {
return HashSizeValue;
}
}
/// <summary>
/// When overridden in a derived class, initializes the object to prepare for hashing.
/// </summary>
public abstract void Initialize ();
/// <summary>
/// FIXME: Not quire valid for the hashes? Returns 1?
/// </summary>
[MonoTODO]
public virtual int InputBlockSize {
get {
return 1;
}
}
/// <summary>
/// FIXME: Not quire valid for the hashes? Returns 1?
/// </summary>
[MonoTODO]
public virtual int OutputBlockSize {
get {
return 1;
}
}
/// <summary>
/// Used for stream chaining. Computes hash as data passes through it.
/// </summary>
/// <param name="inputBuffer">The buffer from which to grab the data to be copied.</param>
/// <param name="inputOffset">The offset into the input buffer to start reading at.</param>
/// <param name="inputCount">The number of bytes to be copied.</param>
/// <param name="outputBuffer">The buffer to write the copied data to.</param>
/// <param name="outputOffset">At what point in the outputBuffer to write the data at.</param>
public int TransformBlock (byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset) {
Buffer.BlockCopy (inputBuffer, inputOffset, outputBuffer, outputOffset, inputCount);
HashCore (inputBuffer, inputOffset, inputCount);
return inputCount;
}
/// <summary>
/// Used for stream chaining. Computes hash as data passes through it. Finishes off the hash.
/// </summary>
/// <param name="inputBuffer">The buffer from which to grab the data to be copied.</param>
/// <param name="inputOffset">The offset into the input buffer to start reading at.</param>
/// <param name="inputCount">The number of bytes to be copied.</param>
public byte[] TransformFinalBlock (byte[] inputBuffer, int inputOffset, int inputCount) {
byte[] outputBuffer = new byte[inputCount];
Buffer.BlockCopy (inputBuffer, inputOffset, outputBuffer, 0, inputCount);
HashCore (inputBuffer, inputOffset, inputCount);
HashValue = HashFinal ();
Initialize ();
return outputBuffer;
}
}
}