public static bool DoVerifyDsaSha1(IEnumerable <BufLen> bufs, I2PSigningPublicKey key, I2PSignature signed)
{
if (!SupportedSignatureType(signed.Certificate.SignatureType))
{
throw new NotImplementedException();
}
var sha = new Sha1Digest();
foreach (var buf in bufs)
{
sha.BlockUpdate(buf.BaseArray, buf.BaseArrayOffset, buf.Length);
}
var hash = new byte[sha.GetDigestSize()];
sha.DoFinal(hash, 0);
var dsa = new Org.BouncyCastle.Crypto.Signers.DsaSigner();
var sigsize = signed.Certificate.SignatureLength;
var r = new BigInteger(1, signed.Sig.BaseArray, signed.Sig.BaseArrayOffset + 0, sigsize / 2);
var s = new BigInteger(1, signed.Sig.BaseArray, signed.Sig.BaseArrayOffset + sigsize / 2, sigsize / 2);
var dsaparams =
new DsaPublicKeyParameters(
key.ToBigInteger(),
new DsaParameters(
I2PConstants.DsaP,
I2PConstants.DsaQ,
I2PConstants.DsaG));
dsa.Init(false, dsaparams);
return(dsa.VerifySignature(hash, r, s));
}
public void PublicKeyIsEmpty()
{
DsaPublicKeyParameters keyParameters = (DsaPublicKeyParameters)PublicKeyFactory.CreateKey(keyPair.PublicKey.Content);
DsaKey publicKey = GetModifiedPublicKey(BigInteger.Zero, keyParameters.Parameters.G, keyParameters.Parameters.P, keyParameters.Parameters.Q);
Assert.IsFalse(keyProvider.VerifyKeyPair(new AsymmetricKeyPair(keyPair.PrivateKey, publicKey)));
}
public void DomainParameterPAreNotEqual()
{
DsaPublicKeyParameters keyParameters = (DsaPublicKeyParameters)PublicKeyFactory.CreateKey(keyPair.PublicKey.Content);
DsaKey publicKey = GetModifiedPublicKey(keyParameters.Y, keyParameters.Parameters.G, keyParameters.Parameters.P.Add(BigInteger.One), keyParameters.Parameters.Q);
Assert.IsFalse(keyProvider.VerifyKeyPair(new AsymmetricKeyPair(keyPair.PrivateKey, publicKey)));
}
public void TestDSA()
{
BigInteger DSAParaG = new BigInteger(Base64.Decode("AL0fxOTq10OHFbCf8YldyGembqEu08EDVzxyLL29Zn/t4It661YNol1rnhPIs+cirw+yf9zeCe+KL1IbZ/qIMZM="));
BigInteger DSAParaP = new BigInteger(Base64.Decode("AM2b/UeQA+ovv3dL05wlDHEKJ+qhnJBsRT5OB9WuyRC830G79y0R8wuq8jyIYWCYcTn1TeqVPWqiTv6oAoiEeOs="));
BigInteger DSAParaQ = new BigInteger(Base64.Decode("AIlJT7mcKL6SUBMmvm24zX1EvjNx"));
BigInteger DSAPublicY = new BigInteger(Base64.Decode("TtWy2GuT9yGBWOHi1/EpCDa/bWJCk2+yAdr56rAcqP0eHGkMnA9s9GJD2nGU8sFjNHm55swpn6JQb8q0agrCfw=="));
BigInteger DsaPrivateX = new BigInteger(Base64.Decode("MMpBAxNlv7eYfxLTZ2BItJeD31A="));
DsaParameters para = new DsaParameters(DSAParaP, DSAParaQ, DSAParaG);
DsaPrivateKeyParameters dsaPriv = new DsaPrivateKeyParameters(DsaPrivateX, para);
DsaPublicKeyParameters dsaPub = new DsaPublicKeyParameters(DSAPublicY, para);
SubjectPublicKeyInfo subInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(dsaPub);
DsaKeyParameters testResult = (DsaKeyParameters)PublicKeyFactory.CreateKey(subInfo);
// check RSA public key.
Assert.IsFalse(!testResult.Equals(dsaPub), "DSA: test failed on public key to info and back to public key.");
PrivateKeyInfo privInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(dsaPriv);
testResult = (DsaPrivateKeyParameters)PrivateKeyFactory.CreateKey(privInfo);
Assert.IsFalse(!testResult.Equals(dsaPriv), "DSA: private key to info back to private key.");
Assert.IsTrue(true, "DSATest worked.");
}
/**
* Read a Key Pair
*/
private AsymmetricCipherKeyPair ReadKeyPair(
string type,
string endMarker)
{
//
// extract the key
//
IDictionary fields = new Hashtable();
byte[] keyBytes = ReadBytesAndFields(endMarker, fields);
string procType = (string)fields["Proc-Type"];
if (procType == "4,ENCRYPTED")
{
string dekInfo = (string)fields["DEK-Info"];
keyBytes = DecryptBytes(keyBytes, dekInfo);
}
try
{
AsymmetricKeyParameter pubSpec, privSpec;
Asn1Sequence seq = (Asn1Sequence)Asn1Object.FromByteArray(keyBytes);
if (type == "RSA")
{
RsaPrivateKeyStructure rsa = new RsaPrivateKeyStructure(seq);
pubSpec = new RsaKeyParameters(false, rsa.Modulus, rsa.PublicExponent);
privSpec = new RsaPrivateCrtKeyParameters(
rsa.Modulus, rsa.PublicExponent, rsa.PrivateExponent,
rsa.Prime1, rsa.Prime2, rsa.Exponent1, rsa.Exponent2,
rsa.Coefficient);
}
else // "DSA"
{
// TODO Create an ASN1 object somewhere for this?
// DerInteger v = (DerInteger)seq[0];
DerInteger p = (DerInteger)seq[1];
DerInteger q = (DerInteger)seq[2];
DerInteger g = (DerInteger)seq[3];
DerInteger y = (DerInteger)seq[4];
DerInteger x = (DerInteger)seq[5];
DsaParameters parameters = new DsaParameters(p.Value, q.Value, g.Value);
privSpec = new DsaPrivateKeyParameters(x.Value, parameters);
pubSpec = new DsaPublicKeyParameters(y.Value, parameters);
}
return(new AsymmetricCipherKeyPair(pubSpec, privSpec));
}
catch (Exception e)
{
throw new IOException(
"problem creating " + type + " private key: " + e.ToString());
}
}
protected bool Equals(DsaPublicKeyParameters other)
{
if (y.Equals(other.y))
{
return(Equals((DsaKeyParameters)other));
}
return(false);
}
public static AsymmetricCipherKeyPair GetDsaKeyPair(DSAParameters dp)
{
DsaValidationParameters parameters = ((dp.Seed != null) ? new DsaValidationParameters(dp.Seed, dp.Counter) : null);
DsaParameters parameters2 = new DsaParameters(new BigInteger(1, dp.P), new BigInteger(1, dp.Q), new BigInteger(1, dp.G), parameters);
DsaPublicKeyParameters publicParameter = new DsaPublicKeyParameters(new BigInteger(1, dp.Y), parameters2);
DsaPrivateKeyParameters privateParameter = new DsaPrivateKeyParameters(new BigInteger(1, dp.X), parameters2);
return(new AsymmetricCipherKeyPair(publicParameter, privateParameter));
}
private DsaPublicKeyParameters GetInheritedKey(DsaPublicKeyParameters dsaPubKey)
{
X509Certificate cert = new X509CertificateParser().ReadCertificate(
GetRfc4134Data("CarlDSSSelf.cer"));
DsaParameters dsaParams = ((DsaPublicKeyParameters)cert.GetPublicKey()).Parameters;
return(new DsaPublicKeyParameters(dsaPubKey.Y, dsaParams));
}
private Key KeyFromBouncyCastle(DsaPublicKeyParameters keyParam)
{
return(new DsaPublicKey
{
Y = keyParam.Y.ToSystemBigInteger(),
G = keyParam.Parameters.G.ToSystemBigInteger(),
P = keyParam.Parameters.P.ToSystemBigInteger(),
Q = keyParam.Parameters.Q.ToSystemBigInteger(),
Size = keyParam.Parameters.P.BitLength
});
}
static AsymmetricAlgorithm GetAsymmetricAlgorithm(DsaPublicKeyParameters key)
{
var parameters = GetDSAParameters(key);
parameters.Y = key.Y.ToByteArrayUnsigned();
var dsa = new DSACryptoServiceProvider();
dsa.ImportParameters(parameters);
return(dsa);
}
public static AsymmetricCipherKeyPair GetDsaKeyPair(DSAParameters dp)
{
DsaValidationParameters validationParameters = (dp.Seed != null) ? new DsaValidationParameters(dp.Seed, dp.Counter) : null;
var parameters = new DsaParameters(new BigInteger(1, dp.P), new BigInteger(1, dp.Q), new BigInteger(1, dp.G), validationParameters);
var pubKey = new DsaPublicKeyParameters(new BigInteger(1, dp.Y), parameters);
var privKey = new DsaPrivateKeyParameters(new BigInteger(1, dp.X), parameters);
return(new AsymmetricCipherKeyPair(pubKey, privKey));
}
public void Setup()
{
keyPair = keyProvider.CreateKeyPair(2048);
publicKeyParameters = (DsaPublicKeyParameters)PublicKeyFactory.CreateKey(keyPair.PublicKey.Content);
p = publicKeyParameters.Parameters.P.ToByteArray();
q = publicKeyParameters.Parameters.Q.ToByteArray();
g = publicKeyParameters.Parameters.G.ToByteArray();
y = publicKeyParameters.Y.ToByteArray();
result = keyProvider.GetPublicKey(p, q, g, y);
}
/**
* Return the next working key inheriting DSA parameters if necessary.
* <p>
* This methods inherits DSA parameters from the indexed certificate or
* previous certificates in the certificate chain to the returned
* <code>PublicKey</code>. The list is searched upwards, meaning the end
* certificate is at position 0 and previous certificates are following.
* </p>
* <p>
* If the indexed certificate does not contain a DSA key this method simply
* returns the public key. If the DSA key already contains DSA parameters
* the key is also only returned.
* </p>
*
* @param certs The certification path.
* @param index The index of the certificate which contains the public key
* which should be extended with DSA parameters.
* @return The public key of the certificate in list position
* <code>index</code> extended with DSA parameters if applicable.
* @throws Exception if DSA parameters cannot be inherited.
*/
internal static AsymmetricKeyParameter GetNextWorkingKey(
IList certs,
int index)
{
//Only X509Certificate
X509Certificate cert = (X509Certificate)certs[index];
AsymmetricKeyParameter pubKey = cert.GetPublicKey();
if (!(pubKey is DsaPublicKeyParameters))
{
return(pubKey);
}
DsaPublicKeyParameters dsaPubKey = (DsaPublicKeyParameters)pubKey;
if (dsaPubKey.Parameters != null)
{
return(dsaPubKey);
}
for (int i = index + 1; i < certs.Count; i++)
{
X509Certificate parentCert = (X509Certificate)certs[i];
pubKey = parentCert.GetPublicKey();
if (!(pubKey is DsaPublicKeyParameters))
{
throw new PkixCertPathValidatorException(
"DSA parameters cannot be inherited from previous certificate.");
}
DsaPublicKeyParameters prevDSAPubKey = (DsaPublicKeyParameters)pubKey;
if (prevDSAPubKey.Parameters == null)
{
continue;
}
DsaParameters dsaParams = prevDSAPubKey.Parameters;
try
{
return(new DsaPublicKeyParameters(dsaPubKey.Y, dsaParams));
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
throw new PkixCertPathValidatorException("DSA parameters cannot be inherited from previous certificate.");
}
static void GetAsymmetricKeyParameters(DSA dsa, bool publicOnly, out AsymmetricKeyParameter pub, out AsymmetricKeyParameter key)
{
var dp = dsa.ExportParameters(!publicOnly);
var validationParameters = dp.Seed != null ? new DsaValidationParameters(dp.Seed, dp.Counter) : null;
var parameters = new DsaParameters(
new BigInteger(1, dp.P),
new BigInteger(1, dp.Q),
new BigInteger(1, dp.G),
validationParameters);
pub = new DsaPublicKeyParameters(new BigInteger(1, dp.Y), parameters);
key = publicOnly ? null : new DsaPrivateKeyParameters(new BigInteger(1, dp.X), parameters);
}
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
DsaPublicKeyParameters dsaPublicKeyParameters = obj as DsaPublicKeyParameters;
if (dsaPublicKeyParameters == null)
{
return(false);
}
return(Equals(dsaPublicKeyParameters));
}
/// <summary>
/// Create a PgpPublicKey from the passed in lightweight one.
/// </summary>
/// <remarks>
/// Note: the time passed in affects the value of the key's keyId, so you probably only want
/// to do this once for a lightweight key, or make sure you keep track of the time you used.
/// </remarks>
/// <param name="algorithm">Asymmetric algorithm type representing the public key.</param>
/// <param name="pubKey">Actual public key to associate.</param>
/// <param name="time">Date of creation.</param>
/// <exception cref="ArgumentException">If <c>pubKey</c> is not public.</exception>
/// <exception cref="PgpException">On key creation problem.</exception>
public PgpPublicKey(
PublicKeyAlgorithmTag algorithm,
AsymmetricKeyParameter pubKey,
DateTime time)
{
if (pubKey.IsPrivate)
{
throw new ArgumentException("Expected a public key", "pubKey");
}
IBcpgKey bcpgKey;
if (pubKey is RsaKeyParameters)
{
RsaKeyParameters rK = (RsaKeyParameters)pubKey;
bcpgKey = new RsaPublicBcpgKey(rK.Modulus, rK.Exponent);
}
else if (pubKey is DsaPublicKeyParameters)
{
DsaPublicKeyParameters dK = (DsaPublicKeyParameters)pubKey;
DsaParameters dP = dK.Parameters;
bcpgKey = new DsaPublicBcpgKey(dP.P, dP.Q, dP.G, dK.Y);
}
else if (pubKey is ElGamalPublicKeyParameters)
{
ElGamalPublicKeyParameters eK = (ElGamalPublicKeyParameters)pubKey;
ElGamalParameters eS = eK.Parameters;
bcpgKey = new ElGamalPublicBcpgKey(eS.P, eS.G, eK.Y);
}
else
{
throw new PgpException("unknown key class");
}
this.publicPk = new PublicKeyPacket(algorithm, time, bcpgKey);
this.ids = Platform.CreateArrayList();
this.idSigs = Platform.CreateArrayList();
try
{
Init();
}
catch (IOException e)
{
throw new PgpException("exception calculating keyId", e);
}
}
private DsaKey GetModifiedPublicKey(BigInteger Y, BigInteger G, BigInteger P, BigInteger Q)
{
var modifiedParameters = new DsaParameters(P, Q, G);
var keyParameters = new DsaPublicKeyParameters(Y, modifiedParameters);
byte[] publicKeyContent = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyParameters)
.ToAsn1Object()
.GetDerEncoded();
var publicKey = new DsaKey(publicKeyContent, AsymmetricKeyType.Public, keyParameters.Parameters.P.BitLength);
return(publicKey);
}
public DsaKey GetPublicKey(byte[] p, byte[] q, byte[] g, byte[] y)
{
var pValue = new BigInteger(p);
var qValue = new BigInteger(q);
var gValue = new BigInteger(g);
var yValue = new BigInteger(y);
var dsaParameters = new DsaParameters(pValue, qValue, gValue);
var dsaPublicKeyParameters = new DsaPublicKeyParameters(yValue, dsaParameters);
byte[] publicKeyContent = GetPublicKey(dsaPublicKeyParameters);
int keySize = GetKeyLength(dsaPublicKeyParameters);
return(new DsaKey(publicKeyContent, AsymmetricKeyType.Public, keySize));
}
static AsymmetricCipherKeyPair GetBouncyCastleDsaKeyPair(DSA dsa)
{
var dp = dsa.ExportParameters(true);
var validationParameters = dp.Seed != null ?
new DsaValidationParameters(dp.Seed, dp.Counter) : null;
var parameters = new DsaParameters(
new BigInteger(1, dp.P),
new BigInteger(1, dp.Q),
new BigInteger(1, dp.G),
validationParameters);
var pubKey = new DsaPublicKeyParameters(new BigInteger(1, dp.Y), parameters);
var privKey = new DsaPrivateKeyParameters(new BigInteger(1, dp.X), parameters);
return(new AsymmetricCipherKeyPair(pubKey, privKey));
}
static AsymmetricAlgorithm GetAsymmetricAlgorithm(DsaPublicKeyParameters key)
{
var parameters = GetDSAParameters(key);
parameters.Y = key.Y.ToByteArrayUnsigned();
#if NET45 || NET46 || NETSTANDARD2_0 || __MOBILE__
var dsa = new DSACryptoServiceProvider();
#else
var dsa = new DSACng();
#endif
dsa.ImportParameters(parameters);
return(dsa);
}
/// <summary>
/// Generate a new DSA key pair.
/// </summary>
/// <returns>A new AsymmetricKeyPair containing a DSA key pair.</returns>
public override AsymmetricKeyPair <AsymmetricDsaPublicKey, AsymmetricDsaPrivateKey> GenerateKeyPair()
{
AsymmetricCipherKeyPair kp = engine.GenerateKeyPair();
DsaPublicKeyParameters pubKey = (DsaPublicKeyParameters)kp.Public;
DsaPrivateKeyParameters prvKey = (DsaPrivateKeyParameters)kp.Private;
FipsAlgorithm algorithm = this.Parameters.Algorithm;
// FSM_STATE:5.3, "DSA PAIRWISE CONSISTENCY TEST", "The module is performing DSA Pairwise Consistency self-test"
// FSM_TRANS:5.DSA.0,"CONDITIONAL TEST", "DSA PAIRWISE CONSISTENCY TEST", "Invoke DSA Pairwise Consistency test"
validateKeyPair(kp);
// FSM_TRANS:5.DSA.1,"DSA PAIRWISE CONSISTENCY TEST", "CONDITIONAL TEST", "DSA Pairwise Consistency test successful"
return(new AsymmetricKeyPair <AsymmetricDsaPublicKey, AsymmetricDsaPrivateKey>(new AsymmetricDsaPublicKey(algorithm, domainParameters, pubKey.Y), new AsymmetricDsaPrivateKey(algorithm, domainParameters, prvKey.X)));
}
public void TestX509CertificateConversion()
{
BigInteger DSAParaG = new BigInteger(Base64.Decode("AL0fxOTq10OHFbCf8YldyGembqEu08EDVzxyLL29Zn/t4It661YNol1rnhPIs+cirw+yf9zeCe+KL1IbZ/qIMZM="));
BigInteger DSAParaP = new BigInteger(Base64.Decode("AM2b/UeQA+ovv3dL05wlDHEKJ+qhnJBsRT5OB9WuyRC830G79y0R8wuq8jyIYWCYcTn1TeqVPWqiTv6oAoiEeOs="));
BigInteger DSAParaQ = new BigInteger(Base64.Decode("AIlJT7mcKL6SUBMmvm24zX1EvjNx"));
BigInteger DSAPublicY = new BigInteger(Base64.Decode("TtWy2GuT9yGBWOHi1/EpCDa/bWJCk2+yAdr56rAcqP0eHGkMnA9s9GJD2nGU8sFjNHm55swpn6JQb8q0agrCfw=="));
BigInteger DsaPrivateX = new BigInteger(Base64.Decode("MMpBAxNlv7eYfxLTZ2BItJeD31A="));
DsaParameters para = new DsaParameters(DSAParaP, DSAParaQ, DSAParaG);
DsaPrivateKeyParameters dsaPriv = new DsaPrivateKeyParameters(DsaPrivateX, para);
DsaPublicKeyParameters dsaPub = new DsaPublicKeyParameters(DSAPublicY, para);
IDictionary attrs = new Hashtable();
attrs[X509Name.C] = "AU";
attrs[X509Name.O] = "The Legion of the Bouncy Castle";
attrs[X509Name.L] = "Melbourne";
attrs[X509Name.ST] = "Victoria";
attrs[X509Name.E] = "*****@*****.**";
IList ord = new ArrayList(attrs.Keys);
X509V3CertificateGenerator certGen = new X509V3CertificateGenerator();
certGen.SetSerialNumber(BigInteger.One);
certGen.SetIssuerDN(new X509Name(ord, attrs));
certGen.SetNotBefore(DateTime.UtcNow.AddDays(-1));
certGen.SetNotAfter(DateTime.UtcNow.AddDays(1));
certGen.SetSubjectDN(new X509Name(ord, attrs));
certGen.SetPublicKey(dsaPub);
certGen.SetSignatureAlgorithm("SHA1WITHDSA");
X509Certificate cert = certGen.Generate(dsaPriv);
cert.CheckValidity();
cert.Verify(dsaPub);
SystemX509.X509Certificate dotNetCert = DotNetUtilities.ToX509Certificate(cert);
X509Certificate certCopy = DotNetUtilities.FromX509Certificate(dotNetCert);
Assert.AreEqual(cert, certCopy);
certCopy.CheckValidity();
certCopy.Verify(dsaPub);
}
private void InitKey()
{
_secure_random = new SecureRandom();
DsaParametersGenerator _dsa_param_gen = new DsaParametersGenerator();
DsaKeyPairGenerator _dsa_key_pair_gen = new DsaKeyPairGenerator();
_dsa_param_gen.Init(1024, 80, _secure_random);
DsaKeyGenerationParameters _dsa_key_gen_params = new DsaKeyGenerationParameters(_secure_random, _dsa_param_gen.GenerateParameters());
_dsa_key_pair_gen.Init(_dsa_key_gen_params);
_key_pair = _dsa_key_pair_gen.GenerateKeyPair();
_private_key_param = (DsaPrivateKeyParameters)_key_pair.Private;
_public_key_param = (DsaPublicKeyParameters)_key_pair.Public;
}
public void Complex()
{
KeyInfoName name = new KeyInfoName();
name.Value = "CoreFx::";
info.AddClause(name);
var keyDSA = new DsaPublicKeyParameters(y: new BigInteger(Convert.FromBase64String(dsaY)),
parameters: new DsaParameters(
p: new BigInteger(1, Convert.FromBase64String(dsaP)),
q: new BigInteger(1, Convert.FromBase64String(dsaQ)),
g: new BigInteger(1, Convert.FromBase64String(dsaG))
)
);
DSAKeyValue dsa = new DSAKeyValue(keyDSA);
info.AddClause(dsa);
var keyRSA = new RsaKeyParameters(
isPrivate: false,
modulus: new BigInteger(1, Convert.FromBase64String(rsaModulus)),
exponent: new BigInteger(1, Convert.FromBase64String(rsaExponent))
);
RSAKeyValue rsa = new RSAKeyValue(keyRSA);
info.AddClause(rsa);
KeyInfoRetrievalMethod retrieval = new KeyInfoRetrievalMethod();
retrieval.Uri = "https://github.com/dotnet/corefx";
info.AddClause(retrieval);
X509Certificate x509 = new X509CertificateParser().ReadCertificate(cert);
KeyInfoX509Data x509data = new KeyInfoX509Data(x509);
info.AddClause(x509data);
string s = "<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><KeyName>CoreFx::</KeyName><KeyValue xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><DSAKeyValue><P>rjxsMU368YOCTQejWkiuO9e/vUVwkLtq1jKiU3TtJ53hBJqjFRuTa228vZe+BH2su9RPn/vYFWfQDv6zgBYe3eNdu4Afw+Ny0FatX6dl3E77Ra6Tsd3MmLXBiGSQ1mMNd5G2XQGpbt9zsGlUaexXekeMLxIufgfZLwYp67M+2WM=</P><Q>tf0K9rMyvUrU4cIkwbCrDRhQAJk=</Q><G>S8Z+1pGCed00w6DtVcqZLKjfqlCJ7JsugEFIgSy/Vxtu9YGCMclV4ijGEbPo/jU8YOSMuD7E9M7UaopMRcmKQjoKZzoJjkgVFP48Ohxl1f08lERnButsxanx3+OstFwUGQ8XNaGg3KrIoZt1FUnfxN3RHHTvVhjzNSHxMGULGaU=</G><Y>LnrxxRGLYeV2XLtK3SYz8RQHlHFZYrtznDZyMotuRfO5uC5YODhSFyLXvb1qB3WeGtF4h3Eo4KzHgMgfN2ZMlffxFRhJgTtH3ctbL8lfQoDkjeiPPnYGhspdJxr0tyZmiy0gkjJG3vwHYrLnvZWx9Wm/unqiOlGBPNuxJ+hOeP8=</Y></DSAKeyValue></KeyValue>";
s += "<KeyValue xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><RSAKeyValue><Modulus>9DC4XNdQJwMRnz5pP2a6U51MHCODRilaIoVXqUPhCUb0lJdGroeqVYT84ZyIVrcarzD7Tqs3aEOIa3rKox0N1bxQpZPqayVQeLAkjLLtzJW/ScRJx3uEDJdgT1JnM1FH0GZTinmEdCUXdLc7+Y/c/qqIkTfbwHbRZjW0bBJyExM=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue></KeyValue>";
s += "<RetrievalMethod URI=\"https://github.com/dotnet/corefx\" />";
s += "<X509Data xmlns=\"http://www.w3.org/2000/09/xmldsig#\">";
s += "<X509Certificate>MIICHTCCAYYCARQwDQYJKoZIhvcNAQEEBQAwWDELMAkGA1UEBhMCQ0ExHzAdBgNVBAMTFktleXdpdG5lc3MgQ2FuYWRhIEluYy4xKDAmBgorBgEEASoCCwIBExhrZXl3aXRuZXNzQGtleXdpdG5lc3MuY2EwHhcNOTYwNTA3MDAwMDAwWhcNOTkwNTA3MDAwMDAwWjBYMQswCQYDVQQGEwJDQTEfMB0GA1UEAxMWS2V5d2l0bmVzcyBDYW5hZGEgSW5jLjEoMCYGCisGAQQBKgILAgETGGtleXdpdG5lc3NAa2V5d2l0bmVzcy5jYTCBnTANBgkqhkiG9w0BAQEFAAOBiwAwgYcCgYEAzSP6KuHtmPTp0JM+13qAAkzMwQKvXLYff/pXQm8w0SDFtSEHQCyphsLzZISuPYUu7YW9VLAYKO9q+BvnCxYfkyVPx/iOw7nKmIQOVdAv73h3xXIoX2C/GSvRcqK32D/glzRaAb0EnMh4Rc2TjRXydhARq7hbLp5S3YE+nGTIKZMCAQMwDQYJKoZIhvcNAQEEBQADgYEAMho1ur9DJ9a01Lh25eObTWzAhsl3NbprFi0TRkqwMlOhW1rpmeIMhogXTg3+gqxOR+/7/zms7jXI+lI3CkmtWa3iiqkcxl8f+G9zfs2gMegMvvVN2bKrihK2MHhoEXwN8UlNo/2y6f8d8JH6VIX/M5Dowb+km6RiRr1hElmYQYk=</X509Certificate></X509Data></KeyInfo>";
AssertCrypto.AssertXmlEquals("Complex", s, (info.GetXml().OuterXml));
Assert.Equal(5, info.Count);
}
private static DsaPublicKeyParameters GetDSAPublicKeyParams(byte[] dsa_p_mpi, byte[] dsa_q_mpi, byte[] dsa_g_mpi, byte[] dsa_y_mpi)
{
if (dsa_p_mpi == null || dsa_p_mpi.Length < 1)
{
throw new ArgumentException("GetDSAPublicKeyParams: DSA P Key parameter mpi byte array cannot be null/empty");
}
if (dsa_q_mpi == null || dsa_q_mpi.Length < 1)
{
throw new ArgumentException("GetDSAPublicKeyParams: DSA Q Key parameter mpi byte array cannot be null/empty");
}
if (dsa_g_mpi == null || dsa_g_mpi.Length < 1)
{
throw new ArgumentException("GetDSAPublicKeyParams: DSA G Key parameter mpi byte array cannot be null/empty");
}
if (dsa_y_mpi == null || dsa_y_mpi.Length < 1)
{
throw new ArgumentException("GetDSAPublicKeyParams: DSA Y Key parameter mpi byte array cannot be null/empty");
}
Org.BouncyCastle.Math.BigInteger _P = null;
Org.BouncyCastle.Math.BigInteger _Q = null;
Org.BouncyCastle.Math.BigInteger _G = null;
Org.BouncyCastle.Math.BigInteger _Y = null;
Utility.DecodeMpiFromBytes(dsa_p_mpi, 0, ref _P);
Utility.DecodeMpiFromBytes(dsa_q_mpi, 0, ref _Q);
Utility.DecodeMpiFromBytes(dsa_g_mpi, 0, ref _G);
Utility.DecodeMpiFromBytes(dsa_y_mpi, 0, ref _Y);
DsaParameters _dsa_param = new DsaParameters(_P, _Q, _G);
DsaPublicKeyParameters _public_key_param = new DsaPublicKeyParameters(_Y, _dsa_param);
return(_public_key_param);
}
public void DSAKeyValue()
{
var key = new DsaPublicKeyParameters(y: new BigInteger(1, Convert.FromBase64String(dsaY)),
parameters: new DsaParameters(
p: new BigInteger(1, Convert.FromBase64String(dsaP)),
q: new BigInteger(1, Convert.FromBase64String(dsaQ)),
g: new BigInteger(1, Convert.FromBase64String(dsaG))
));
DsaKeyValue dsa = new DsaKeyValue(key);
info.AddClause(dsa);
AssertCrypto.AssertXmlEquals("dsa",
"<KeyInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\"><KeyValue xmlns=\"http://www.w3.org/2000/09/xmldsig#\">" +
xmlDSA + "</KeyValue></KeyInfo>", (info.GetXml().OuterXml));
Assert.Equal(1, info.Count);
}
private void VerifySigner(SignerInformation signer, X509Certificate cert)
{
if (cert.GetPublicKey() is DsaPublicKeyParameters)
{
DsaPublicKeyParameters key = (DsaPublicKeyParameters)cert.GetPublicKey();
if (key.Parameters == null)
{
Assert.IsTrue(signer.Verify(GetInheritedKey(key)));
}
else
{
Assert.IsTrue(signer.Verify(cert));
}
}
else
{
Assert.IsTrue(signer.Verify(cert));
}
}
public static bool VerifySignature(DsaPublicKeyParameters public_key_param, byte[] data_to_sign_byte_array, byte[] r_byte_array, byte[] s_byte_array)
{
BigInteger _data_to_sign = new BigInteger(1, data_to_sign_byte_array);
BigInteger _r = new BigInteger(1, r_byte_array);
BigInteger _s = new BigInteger(1, s_byte_array);
DsaParameters _parameters = public_key_param.Parameters;
BigInteger zero = BigInteger.ValueOf(0);
/*
* if (IsValidPQLength(_parameters.P.BitLength, _parameters.Q.BitLength) == false)
* throw new InvalidDataException("VerifySignature: The Length of the DSA key P parameter does not correspond to that of the Q parameter");
*/
if (zero.CompareTo(_r) >= 0 || _parameters.Q.CompareTo(_r) <= 0)
{
return(false);
}
if (zero.CompareTo(_s) >= 0 || _parameters.Q.CompareTo(_s) <= 0)
{
return(false);
}
BigInteger _w = _s.ModInverse(_parameters.Q);
BigInteger _u1 = _data_to_sign.Multiply(_w).Mod(_parameters.Q);
BigInteger _u2 = _r.Multiply(_w).Mod(_parameters.Q);
_u1 = _parameters.G.ModPow(_u1, _parameters.P);
_u2 = public_key_param.Y.ModPow(_u2, _parameters.P);
BigInteger _v = _u1.Multiply(_u2).Mod(_parameters.P).Mod(_parameters.Q);
// Console.WriteLine("Size of Q:{0} \n Size of R:{1} \n Size of S:{2} ", _parameters.Q.BitLength/8, r_byte_array.Length, s_byte_array.Length);
return(_v.Equals(_r));
}
private void SetKey(BigInteger p, BigInteger q, BigInteger g, BigInteger x)
{
if (p == null)
{
throw new ArgumentException("The DSA key parameter P cannot be null");
}
if (q == null)
{
throw new ArgumentException("The DSA key parameter Q cannot be null");
}
if (g == null)
{
throw new ArgumentException("The DSA key parameter G cannot be null");
}
if (x == null)
{
throw new ArgumentException("The DSA key parameter X cannot be null");
}
_P = p;
_Q = q;
_G = g;
_X = x;
_Y = _G.ModPow(_X, _P);
DsaParameters _dsa_param = new DsaParameters(_P, _Q, _G);
_public_key_param = new DsaPublicKeyParameters(_Y, _dsa_param);
_private_key_param = new DsaPrivateKeyParameters(_X, _dsa_param);
SetPublicKeyEncodedMpi();
}
private static ICipherParameters GetPublicParameters(IKey key)
{
if (key is KeyWithRandom)
{
throw new ArgumentException("SecureRandom not required: " + Alg.Name);
}
AsymmetricDsaPublicKey dsaPublicKey = (AsymmetricDsaPublicKey)key;
DsaPublicKeyParameters publicKeyParameters = new DsaPublicKeyParameters(dsaPublicKey.Y, getDomainParams(dsaPublicKey.DomainParameters));
int effSizeInBits = publicKeyParameters.Parameters.P.BitLength;
if (CryptoServicesRegistrar.IsInApprovedOnlyMode())
{
if (effSizeInBits != 1024 && effSizeInBits != 2048 && effSizeInBits != 3072)
{
throw new CryptoUnapprovedOperationError("attempt to create verifier with unapproved keysize [" + effSizeInBits + "]", Alg);
}
}
return(publicKeyParameters);
}
