1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
//
// System.Security.Cryptography HashAlgorithm Class implementation
//
// Authors:
// Matthew S. Ford (Matthew.S.Ford@Rose-Hulman.Edu)
//
// 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 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;
}
}
}
|
