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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
|
using System;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Digests;
using Org.BouncyCastle.Crypto.Prng;
using Org.BouncyCastle.Utilities;
namespace Org.BouncyCastle.Security
{
public class SecureRandom
: Random
{
// Note: all objects of this class should be deriving their random data from
// a single generator appropriate to the digest being used.
private static readonly IRandomGenerator sha1Generator = new DigestRandomGenerator(new Sha1Digest());
private static readonly IRandomGenerator sha256Generator = new DigestRandomGenerator(new Sha256Digest());
private static readonly SecureRandom[] master = { null };
private static SecureRandom Master
{
get
{
if (master[0] == null)
{
IRandomGenerator gen = sha256Generator;
gen = new ReversedWindowGenerator(gen, 32);
SecureRandom sr = master[0] = new SecureRandom(gen);
sr.SetSeed(DateTime.Now.Ticks);
sr.SetSeed(new ThreadedSeedGenerator().GenerateSeed(24, true));
sr.GenerateSeed(1 + sr.Next(32));
}
return master[0];
}
}
public static SecureRandom GetInstance(
string algorithm)
{
// TODO Compared to JDK, we don't auto-seed if the client forgets - problem?
// TODO Support all digests more generally, by stripping PRNG and calling DigestUtilities?
string drgName = Platform.ToUpperInvariant(algorithm);
IRandomGenerator drg = null;
if (drgName == "SHA1PRNG")
{
drg = sha1Generator;
}
else if (drgName == "SHA256PRNG")
{
drg = sha256Generator;
}
if (drg != null)
{
return new SecureRandom(drg);
}
throw new ArgumentException("Unrecognised PRNG algorithm: " + algorithm, "algorithm");
}
public static byte[] GetSeed(
int length)
{
return Master.GenerateSeed(length);
}
protected IRandomGenerator generator;
public SecureRandom()
: this(sha1Generator)
{
SetSeed(GetSeed(8));
}
public SecureRandom(
byte[] inSeed)
: this(sha1Generator)
{
SetSeed(inSeed);
}
/// <summary>Use the specified instance of IRandomGenerator as random source.</summary>
/// <remarks>
/// This constructor performs no seeding of either the <c>IRandomGenerator</c> or the
/// constructed <c>SecureRandom</c>. It is the responsibility of the client to provide
/// proper seed material as necessary/appropriate for the given <c>IRandomGenerator</c>
/// implementation.
/// </remarks>
/// <param name="generator">The source to generate all random bytes from.</param>
public SecureRandom(
IRandomGenerator generator)
: base(0)
{
this.generator = generator;
}
public virtual byte[] GenerateSeed(
int length)
{
SetSeed(DateTime.Now.Ticks);
byte[] rv = new byte[length];
NextBytes(rv);
return rv;
}
public virtual void SetSeed(
byte[] inSeed)
{
generator.AddSeedMaterial(inSeed);
}
public virtual void SetSeed(
long seed)
{
generator.AddSeedMaterial(seed);
}
public override int Next()
{
for (;;)
{
int i = NextInt() & int.MaxValue;
if (i != int.MaxValue)
return i;
}
}
public override int Next(
int maxValue)
{
if (maxValue < 2)
{
if (maxValue < 0)
throw new ArgumentOutOfRangeException("maxValue", "cannot be negative");
return 0;
}
// Test whether maxValue is a power of 2
if ((maxValue & -maxValue) == maxValue)
{
int val = NextInt() & int.MaxValue;
long lr = ((long) maxValue * (long) val) >> 31;
return (int) lr;
}
int bits, result;
do
{
bits = NextInt() & int.MaxValue;
result = bits % maxValue;
}
while (bits - result + (maxValue - 1) < 0); // Ignore results near overflow
return result;
}
public override int Next(
int minValue,
int maxValue)
{
if (maxValue <= minValue)
{
if (maxValue == minValue)
return minValue;
throw new ArgumentException("maxValue cannot be less than minValue");
}
int diff = maxValue - minValue;
if (diff > 0)
return minValue + Next(diff);
for (;;)
{
int i = NextInt();
if (i >= minValue && i < maxValue)
return i;
}
}
public override void NextBytes(
byte[] buffer)
{
generator.NextBytes(buffer);
}
public virtual void NextBytes(
byte[] buffer,
int start,
int length)
{
generator.NextBytes(buffer, start, length);
}
private static readonly double DoubleScale = System.Math.Pow(2.0, 64.0);
public override double NextDouble()
{
return Convert.ToDouble((ulong) NextLong()) / DoubleScale;
}
public virtual int NextInt()
{
byte[] intBytes = new byte[4];
NextBytes(intBytes);
int result = 0;
for (int i = 0; i < 4; i++)
{
result = (result << 8) + (intBytes[i] & 0xff);
}
return result;
}
public virtual long NextLong()
{
return ((long)(uint) NextInt() << 32) | (long)(uint) NextInt();
}
}
}
|
