diff --git a/crypto/src/crypto/signers/DsaSigner.cs b/crypto/src/crypto/signers/DsaSigner.cs
index 419b1972e..fc0780a91 100644
--- a/crypto/src/crypto/signers/DsaSigner.cs
+++ b/crypto/src/crypto/signers/DsaSigner.cs
@@ -8,129 +8,126 @@ using Org.BouncyCastle.Crypto.Parameters;
namespace Org.BouncyCastle.Crypto.Signers
{
- /**
- * The Digital Signature Algorithm - as described in "Handbook of Applied
- * Cryptography", pages 452 - 453.
- */
- public class DsaSigner
- : IDsa
- {
- private DsaKeyParameters key;
- private SecureRandom random;
-
- public string AlgorithmName
- {
- get { return "DSA"; }
- }
-
- public void Init(
- bool forSigning,
- ICipherParameters parameters)
- {
- if (forSigning)
- {
- if (parameters is ParametersWithRandom)
- {
- ParametersWithRandom rParam = (ParametersWithRandom)parameters;
-
- this.random = rParam.Random;
- parameters = rParam.Parameters;
- }
- else
- {
- this.random = new SecureRandom();
- }
-
- if (!(parameters is DsaPrivateKeyParameters))
- throw new InvalidKeyException("DSA private key required for signing");
-
- this.key = (DsaPrivateKeyParameters) parameters;
- }
- else
- {
- if (!(parameters is DsaPublicKeyParameters))
- throw new InvalidKeyException("DSA public key required for verification");
-
- this.key = (DsaPublicKeyParameters) parameters;
- }
- }
-
- /**
- * Generate a signature for the given message using the key we were
- * initialised with. For conventional DSA the message should be a SHA-1
- * hash of the message of interest.
- *
- * @param message the message that will be verified later.
- */
- public BigInteger[] GenerateSignature(
- byte[] message)
- {
- DsaParameters parameters = key.Parameters;
- BigInteger q = parameters.Q;
- BigInteger m = calculateE(q, message);
- BigInteger k;
-
- do
- {
- k = new BigInteger(q.BitLength, random);
- }
- while (k.CompareTo(q) >= 0);
-
- BigInteger r = parameters.G.ModPow(k, parameters.P).Mod(q);
-
- k = k.ModInverse(q).Multiply(
- m.Add(((DsaPrivateKeyParameters)key).X.Multiply(r)));
-
- BigInteger s = k.Mod(q);
-
- return new BigInteger[]{ r, s };
- }
-
- /**
- * return true if the value r and s represent a DSA signature for
- * the passed in message for standard DSA the message should be a
- * SHA-1 hash of the real message to be verified.
- */
- public bool VerifySignature(
- byte[] message,
- BigInteger r,
- BigInteger s)
- {
- DsaParameters parameters = key.Parameters;
- BigInteger q = parameters.Q;
- BigInteger m = calculateE(q, message);
-
- if (r.SignValue <= 0 || q.CompareTo(r) <= 0)
- {
- return false;
- }
-
- if (s.SignValue <= 0 || q.CompareTo(s) <= 0)
- {
- return false;
- }
-
- BigInteger w = s.ModInverse(q);
-
- BigInteger u1 = m.Multiply(w).Mod(q);
- BigInteger u2 = r.Multiply(w).Mod(q);
-
- BigInteger p = parameters.P;
- u1 = parameters.G.ModPow(u1, p);
- u2 = ((DsaPublicKeyParameters)key).Y.ModPow(u2, p);
-
- BigInteger v = u1.Multiply(u2).Mod(p).Mod(q);
-
- return v.Equals(r);
- }
-
- private BigInteger calculateE(
- BigInteger n,
- byte[] message)
- {
- int length = System.Math.Min(message.Length, n.BitLength / 8);
-
- return new BigInteger(1, message, 0, length);
- }
- }
+ /**
+ * The Digital Signature Algorithm - as described in "Handbook of Applied
+ * Cryptography", pages 452 - 453.
+ */
+ public class DsaSigner
+ : IDsa
+ {
+ protected DsaKeyParameters key = null;
+ protected SecureRandom random = null;
+
+ public virtual string AlgorithmName
+ {
+ get { return "DSA"; }
+ }
+
+ public virtual void Init(bool forSigning, ICipherParameters parameters)
+ {
+ SecureRandom providedRandom = null;
+
+ if (forSigning)
+ {
+ if (parameters is ParametersWithRandom)
+ {
+ ParametersWithRandom rParam = (ParametersWithRandom)parameters;
+
+ providedRandom = rParam.Random;
+ parameters = rParam.Parameters;
+ }
+
+ if (!(parameters is DsaPrivateKeyParameters))
+ throw new InvalidKeyException("DSA private key required for signing");
+
+ this.key = (DsaPrivateKeyParameters)parameters;
+ }
+ else
+ {
+ if (!(parameters is DsaPublicKeyParameters))
+ throw new InvalidKeyException("DSA public key required for verification");
+
+ this.key = (DsaPublicKeyParameters)parameters;
+ }
+
+ this.random = InitSecureRandom(forSigning, providedRandom);
+ }
+
+ /**
+ * Generate a signature for the given message using the key we were
+ * initialised with. For conventional DSA the message should be a SHA-1
+ * hash of the message of interest.
+ *
+ * @param message the message that will be verified later.
+ */
+ public virtual BigInteger[] GenerateSignature(byte[] message)
+ {
+ DsaParameters parameters = key.Parameters;
+ BigInteger q = parameters.Q;
+ BigInteger m = CalculateE(q, message);
+ BigInteger k;
+
+ do
+ {
+ k = new BigInteger(q.BitLength, random);
+ }
+ while (k.CompareTo(q) >= 0);
+
+ BigInteger r = parameters.G.ModPow(k, parameters.P).Mod(q);
+
+ k = k.ModInverse(q).Multiply(
+ m.Add(((DsaPrivateKeyParameters)key).X.Multiply(r)));
+
+ BigInteger s = k.Mod(q);
+
+ return new BigInteger[]{ r, s };
+ }
+
+ /**
+ * return true if the value r and s represent a DSA signature for
+ * the passed in message for standard DSA the message should be a
+ * SHA-1 hash of the real message to be verified.
+ */
+ public virtual bool VerifySignature(byte[] message, BigInteger r, BigInteger s)
+ {
+ DsaParameters parameters = key.Parameters;
+ BigInteger q = parameters.Q;
+ BigInteger m = CalculateE(q, message);
+
+ if (r.SignValue <= 0 || q.CompareTo(r) <= 0)
+ {
+ return false;
+ }
+
+ if (s.SignValue <= 0 || q.CompareTo(s) <= 0)
+ {
+ return false;
+ }
+
+ BigInteger w = s.ModInverse(q);
+
+ BigInteger u1 = m.Multiply(w).Mod(q);
+ BigInteger u2 = r.Multiply(w).Mod(q);
+
+ BigInteger p = parameters.P;
+ u1 = parameters.G.ModPow(u1, p);
+ u2 = ((DsaPublicKeyParameters)key).Y.ModPow(u2, p);
+
+ BigInteger v = u1.Multiply(u2).Mod(p).Mod(q);
+
+ return v.Equals(r);
+ }
+
+ protected virtual BigInteger CalculateE(BigInteger n, byte[] message)
+ {
+ int length = System.Math.Min(message.Length, n.BitLength / 8);
+
+ return new BigInteger(1, message, 0, length);
+ }
+
+ protected virtual SecureRandom InitSecureRandom(bool needed, SecureRandom provided)
+ {
+ return !needed ? null : (provided != null) ? provided : new SecureRandom();
+ }
+ }
}
diff --git a/crypto/src/crypto/signers/ECDsaSigner.cs b/crypto/src/crypto/signers/ECDsaSigner.cs
index 508335149..867520535 100644
--- a/crypto/src/crypto/signers/ECDsaSigner.cs
+++ b/crypto/src/crypto/signers/ECDsaSigner.cs
@@ -15,44 +15,42 @@ namespace Org.BouncyCastle.Crypto.Signers
public class ECDsaSigner
: IDsa
{
- private ECKeyParameters key;
- private SecureRandom random;
+ protected ECKeyParameters key = null;
+ protected SecureRandom random = null;
- public string AlgorithmName
+ public virtual string AlgorithmName
{
get { return "ECDSA"; }
}
- public void Init(
- bool forSigning,
- ICipherParameters parameters)
+ public virtual void Init(bool forSigning, ICipherParameters parameters)
{
+ SecureRandom providedRandom = null;
+
if (forSigning)
{
if (parameters is ParametersWithRandom)
{
- ParametersWithRandom rParam = (ParametersWithRandom) parameters;
+ ParametersWithRandom rParam = (ParametersWithRandom)parameters;
- this.random = rParam.Random;
+ providedRandom = rParam.Random;
parameters = rParam.Parameters;
}
- else
- {
- this.random = new SecureRandom();
- }
if (!(parameters is ECPrivateKeyParameters))
throw new InvalidKeyException("EC private key required for signing");
- this.key = (ECPrivateKeyParameters) parameters;
+ this.key = (ECPrivateKeyParameters)parameters;
}
else
{
if (!(parameters is ECPublicKeyParameters))
throw new InvalidKeyException("EC public key required for verification");
- this.key = (ECPublicKeyParameters) parameters;
+ this.key = (ECPublicKeyParameters)parameters;
}
+
+ this.random = InitSecureRandom(forSigning, providedRandom);
}
// 5.3 pg 28
@@ -63,7 +61,7 @@ namespace Org.BouncyCastle.Crypto.Signers
*
* @param message the message that will be verified later.
*/
- public BigInteger[] GenerateSignature(byte[] message)
+ public virtual BigInteger[] GenerateSignature(byte[] message)
{
ECDomainParameters ec = key.Parameters;
BigInteger n = ec.N;
@@ -106,10 +104,7 @@ namespace Org.BouncyCastle.Crypto.Signers
* the passed in message (for standard DSA the message should be
* a SHA-1 hash of the real message to be verified).
*/
- public bool VerifySignature(
- byte[] message,
- BigInteger r,
- BigInteger s)
+ public virtual bool VerifySignature(byte[] message, BigInteger r, BigInteger s)
{
BigInteger n = key.Parameters.N;
@@ -156,5 +151,10 @@ namespace Org.BouncyCastle.Crypto.Signers
{
return new FixedPointCombMultiplier();
}
+
+ protected virtual SecureRandom InitSecureRandom(bool needed, SecureRandom provided)
+ {
+ return !needed ? null : (provided != null) ? provided : new SecureRandom();
+ }
}
}
|
