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."); }
public void PrivateKeyParameterIsEmpty() { DsaPrivateKeyParameters modifiedPrivateKey = (DsaPrivateKeyParameters)PrivateKeyFactory.CreateKey(keyPair.PrivateKey.Content); var privateKey = GetModifiedPrivateKey(BigInteger.Zero, modifiedPrivateKey.Parameters); Assert.IsFalse(keyProvider.VerifyKeyPair(new AsymmetricKeyPair(privateKey, keyPair.PublicKey))); }
public void PrivateKeyIsNotValid() { DsaPrivateKeyParameters modifiedPrivateKey = (DsaPrivateKeyParameters)PrivateKeyFactory.CreateKey(keyPair.PrivateKey.Content); var privateKey = GetModifiedPrivateKey(modifiedPrivateKey.X.Add(BigInteger.One), modifiedPrivateKey.Parameters); Assert.IsFalse(keyProvider.VerifyKeyPair(new AsymmetricKeyPair(privateKey, keyPair.PublicKey))); }
/** * 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(DsaPrivateKeyParameters other) { if (x.Equals(other.x)) { 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)); }
/// <summary> /// reads private key portion of OpenSSH formatted key blob from stream and /// creates a key pair /// </summary> /// <returns>key pair</returns> /// <remarks> /// intended to be called immediately after ParseSsh2PublicKeyData /// </remarks> public AsymmetricCipherKeyPair ReadSsh2KeyData( AsymmetricKeyParameter publicKeyParameter) { if (publicKeyParameter is RsaKeyParameters) { var rsaD = new BigInteger(1, ReadBlob()); var rsaIQMP = new BigInteger(1, ReadBlob()); var rsaP = new BigInteger(1, ReadBlob()); var rsaQ = new BigInteger(1, ReadBlob()); /* compute missing parameters */ var rsaDP = rsaD.Remainder(rsaP.Subtract(BigInteger.One)); var rsaDQ = rsaD.Remainder(rsaQ.Subtract(BigInteger.One)); var rsaPublicKeyParams = publicKeyParameter as RsaKeyParameters; var rsaPrivateKeyParams = new RsaPrivateCrtKeyParameters( rsaPublicKeyParams.Modulus, rsaPublicKeyParams.Exponent, rsaD, rsaP, rsaQ, rsaDP, rsaDQ, rsaIQMP); return(new AsymmetricCipherKeyPair(rsaPublicKeyParams, rsaPrivateKeyParams)); } else if (publicKeyParameter is DsaPublicKeyParameters) { var dsaX = new BigInteger(1, ReadBlob()); // private key var dsaPublicKeyParams = publicKeyParameter as DsaPublicKeyParameters; DsaPrivateKeyParameters dsaPrivateKeyParams = new DsaPrivateKeyParameters(dsaX, dsaPublicKeyParams.Parameters); return(new AsymmetricCipherKeyPair(dsaPublicKeyParams, dsaPrivateKeyParams)); } else if (publicKeyParameter is ECPublicKeyParameters) { var ecdsaPrivate = new BigInteger(1, ReadBlob()); var ecPublicKeyParams = publicKeyParameter as ECPublicKeyParameters; ECPrivateKeyParameters ecPrivateKeyParams = new ECPrivateKeyParameters(ecdsaPrivate, ecPublicKeyParams.Parameters); return(new AsymmetricCipherKeyPair(ecPublicKeyParams, ecPrivateKeyParams)); } else if (publicKeyParameter is Ed25519PublicKeyParameter) { var ed25519Signature = ReadBlob(); var ed25519PrivateKey = new Ed25519PrivateKeyParameter(ed25519Signature); return(new AsymmetricCipherKeyPair(publicKeyParameter, ed25519PrivateKey)); } else { // unsupported encryption algorithm throw new Exception("Unsupported algorithm"); } }
private IAsymmetricKey GetModifiedPrivateKey(BigInteger X, DsaParameters domainParameters) { var modifiedPrivateKey = new DsaPrivateKeyParameters(X, domainParameters); byte[] privateKeyContent = PrivateKeyInfoFactory.CreatePrivateKeyInfo(modifiedPrivateKey) .ToAsn1Object() .GetDerEncoded(); var privateKey = new DsaKey(privateKeyContent, AsymmetricKeyType.Private, modifiedPrivateKey.Parameters.P.BitLength); return(privateKey); }
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)); }
/// <summary> /// Gets the signing stream. /// </summary> /// <returns></returns> public HashingStream GetSigningStream(Keyczar keyczar) { var digest = PublicKey.GetDigest(); var signer = new DsaDigestSigner(new DsaSigner(), digest); var param = new DsaPrivateKeyParameters(X.ToBouncyBigInteger(), new DsaParameters(PublicKey.P.ToBouncyBigInteger(), PublicKey.Q.ToBouncyBigInteger(), PublicKey.G.ToBouncyBigInteger())); signer.Init(forSigning: true, parameters: new ParametersWithRandom(param, Secure.Random)); return(new DigestStream(signer)); }
public override bool Equals(object obj) { if (obj == this) { return(true); } DsaPrivateKeyParameters dsaPrivateKeyParameters = obj as DsaPrivateKeyParameters; if (dsaPrivateKeyParameters == null) { return(false); } return(Equals(dsaPrivateKeyParameters)); }
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)); }
private Key KeyFromBouncyCastle(DsaPrivateKeyParameters keyParam) { return(new DsaPrivateKey() { X = keyParam.X.ToSystemBigInteger(), PublicKey = new DsaPublicKey { Y = keyParam.Parameters.G.ModPow(keyParam.X, keyParam.Parameters.P).ToSystemBigInteger(), G = keyParam.Parameters.G.ToSystemBigInteger(), P = keyParam.Parameters.P.ToSystemBigInteger(), Q = keyParam.Parameters.Q.ToSystemBigInteger(), Size = keyParam.Parameters.P.BitLength }, Size = keyParam.Parameters.P.BitLength }); }
/// <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; }
static AsymmetricAlgorithm GetAsymmetricAlgorithm(DsaPrivateKeyParameters key, DsaPublicKeyParameters pub) { var parameters = GetDSAParameters(key); parameters.X = key.X.ToByteArrayUnsigned(); if (pub != null) { parameters.Y = pub.Y.ToByteArrayUnsigned(); } var dsa = new DSACryptoServiceProvider(); dsa.ImportParameters(parameters); return(dsa); }
static AsymmetricAlgorithm GetAsymmetricAlgorithm(DsaPrivateKeyParameters key, DsaPublicKeyParameters pub) { var parameters = GetDSAParameters(key); parameters.X = GetPaddedByteArray(key.X, parameters.Q.Length); if (pub != null) { parameters.Y = GetPaddedByteArray(pub.Y, parameters.P.Length); } var dsa = new DSACryptoServiceProvider(); dsa.ImportParameters(parameters); return(dsa); }
static AsymmetricAlgorithm GetAsymmetricAlgorithm(DsaPrivateKeyParameters key, DsaPublicKeyParameters pub) { var parameters = GetDSAParameters(key); parameters.X = key.X.ToByteArrayUnsigned(); if (pub != null) { parameters.Y = pub.Y.ToByteArrayUnsigned(); } #if NET45 || NET46 || NETSTANDARD2_0 || __MOBILE__ var dsa = new DSACryptoServiceProvider(); #else var dsa = new DSACng(); #endif dsa.ImportParameters(parameters); return(dsa); }
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 object ReadPrivateKey(PemObject pemObject) { string text = pemObject.Type.Substring(0, pemObject.Type.Length - "PRIVATE KEY".Length).Trim(); byte[] array = pemObject.Content; IDictionary dictionary = Platform.CreateHashtable(); foreach (PemHeader pemHeader in pemObject.Headers) { dictionary[pemHeader.Name] = pemHeader.Value; } string a = (string)dictionary["Proc-Type"]; if (a == "4,ENCRYPTED") { if (this.pFinder == null) { throw new PasswordException("No password finder specified, but a password is required"); } char[] password = this.pFinder.GetPassword(); if (password == null) { throw new PasswordException("Password is null, but a password is required"); } string text2 = (string)dictionary["DEK-Info"]; string[] array2 = text2.Split(new char[] { ',' }); string dekAlgName = array2[0].Trim(); byte[] iv = Hex.Decode(array2[1].Trim()); array = PemUtilities.Crypt(false, array, password, dekAlgName, iv); } object result; try { Asn1Sequence instance = Asn1Sequence.GetInstance(array); string a2; if ((a2 = text) != null) { AsymmetricKeyParameter asymmetricKeyParameter; AsymmetricKeyParameter publicParameter; if (!(a2 == "RSA")) { if (!(a2 == "DSA")) { if (!(a2 == "EC")) { if (!(a2 == "ENCRYPTED")) { if (!(a2 == "")) { goto IL_356; } result = PrivateKeyFactory.CreateKey(PrivateKeyInfo.GetInstance(instance)); return(result); } else { char[] password2 = this.pFinder.GetPassword(); if (password2 == null) { throw new PasswordException("Password is null, but a password is required"); } result = PrivateKeyFactory.DecryptKey(password2, EncryptedPrivateKeyInfo.GetInstance(instance)); return(result); } } else { ECPrivateKeyStructure eCPrivateKeyStructure = new ECPrivateKeyStructure(instance); AlgorithmIdentifier algID = new AlgorithmIdentifier(X9ObjectIdentifiers.IdECPublicKey, eCPrivateKeyStructure.GetParameters()); PrivateKeyInfo keyInfo = new PrivateKeyInfo(algID, eCPrivateKeyStructure.ToAsn1Object()); asymmetricKeyParameter = PrivateKeyFactory.CreateKey(keyInfo); DerBitString publicKey = eCPrivateKeyStructure.GetPublicKey(); if (publicKey != null) { SubjectPublicKeyInfo keyInfo2 = new SubjectPublicKeyInfo(algID, publicKey.GetBytes()); publicParameter = PublicKeyFactory.CreateKey(keyInfo2); } else { publicParameter = ECKeyPairGenerator.GetCorrespondingPublicKey((ECPrivateKeyParameters)asymmetricKeyParameter); } } } else { if (instance.Count != 6) { throw new PemException("malformed sequence in DSA private key"); } DerInteger derInteger = (DerInteger)instance[1]; DerInteger derInteger2 = (DerInteger)instance[2]; DerInteger derInteger3 = (DerInteger)instance[3]; DerInteger derInteger4 = (DerInteger)instance[4]; DerInteger derInteger5 = (DerInteger)instance[5]; DsaParameters parameters = new DsaParameters(derInteger.Value, derInteger2.Value, derInteger3.Value); asymmetricKeyParameter = new DsaPrivateKeyParameters(derInteger5.Value, parameters); publicParameter = new DsaPublicKeyParameters(derInteger4.Value, parameters); } } else { if (instance.Count != 9) { throw new PemException("malformed sequence in RSA private key"); } RsaPrivateKeyStructure instance2 = RsaPrivateKeyStructure.GetInstance(instance); publicParameter = new RsaKeyParameters(false, instance2.Modulus, instance2.PublicExponent); asymmetricKeyParameter = new RsaPrivateCrtKeyParameters(instance2.Modulus, instance2.PublicExponent, instance2.PrivateExponent, instance2.Prime1, instance2.Prime2, instance2.Exponent1, instance2.Exponent2, instance2.Coefficient); } result = new AsymmetricCipherKeyPair(publicParameter, asymmetricKeyParameter); return(result); } IL_356: throw new ArgumentException("Unknown key type: " + text, "type"); } catch (IOException ex) { throw ex; } catch (Exception ex2) { throw new PemException("problem creating " + text + " private key: " + ex2.ToString()); } return(result); }
/** * Read a Key Pair */ private object ReadPrivateKey(PemObject pemObject) { // // extract the key // Debug.Assert(pemObject.Type.EndsWith("PRIVATE KEY")); string type = pemObject.Type.Substring(0, pemObject.Type.Length - "PRIVATE KEY".Length).Trim(); byte[] keyBytes = pemObject.Content; IDictionary fields = Platform.CreateHashtable(); foreach (PemHeader header in pemObject.Headers) { fields[header.Name] = header.Value; } string procType = (string)fields["Proc-Type"]; if (procType == "4,ENCRYPTED") { if (pFinder == null) { throw new PasswordException("No password finder specified, but a password is required"); } char[] password = pFinder.GetPassword(); if (password == null) { throw new PasswordException("Password is null, but a password is required"); } string dekInfo = (string)fields["DEK-Info"]; string[] tknz = dekInfo.Split(','); string dekAlgName = tknz[0].Trim(); byte[] iv = Hex.Decode(tknz[1].Trim()); keyBytes = PemUtilities.Crypt(false, keyBytes, password, dekAlgName, iv); } try { AsymmetricKeyParameter pubSpec, privSpec; Asn1Sequence seq = (Asn1Sequence)Asn1Object.FromByteArray(keyBytes); switch (type) { case "RSA": { if (seq.Count != 9) { throw new PemException("malformed sequence in RSA private key"); } 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); break; } case "DSA": { if (seq.Count != 6) { throw new PemException("malformed sequence in DSA private key"); } // 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); break; } case "EC": { ECPrivateKeyStructure pKey = new ECPrivateKeyStructure(seq); AlgorithmIdentifier algId = new AlgorithmIdentifier( X9ObjectIdentifiers.IdECPublicKey, pKey.GetParameters()); PrivateKeyInfo privInfo = new PrivateKeyInfo(algId, pKey.ToAsn1Object()); // TODO Are the keys returned here ECDSA, as Java version forces? privSpec = PrivateKeyFactory.CreateKey(privInfo); DerBitString pubKey = pKey.GetPublicKey(); if (pubKey != null) { SubjectPublicKeyInfo pubInfo = new SubjectPublicKeyInfo(algId, pubKey.GetBytes()); // TODO Are the keys returned here ECDSA, as Java version forces? pubSpec = PublicKeyFactory.CreateKey(pubInfo); } else { pubSpec = ECKeyPairGenerator.GetCorrespondingPublicKey( (ECPrivateKeyParameters)privSpec); } break; } case "ENCRYPTED": { char[] password = pFinder.GetPassword(); if (password == null) { throw new PasswordException("Password is null, but a password is required"); } return(PrivateKeyFactory.DecryptKey(password, EncryptedPrivateKeyInfo.GetInstance(seq))); } case "": { return(PrivateKeyFactory.CreateKey(PrivateKeyInfo.GetInstance(seq))); } default: throw new ArgumentException("Unknown key type: " + type, "type"); } return(new AsymmetricCipherKeyPair(pubSpec, privSpec)); } catch (IOException e) { throw e; } catch (Exception e) { throw new PemException( "problem creating " + type + " private key: " + e.ToString()); } }
public void TestDsa2Parameters() { byte[] seed = Hex.Decode("4783081972865EA95D43318AB2EAF9C61A2FC7BBF1B772A09017BDF5A58F4FF0"); //AlgorithmParameterGenerator a = AlgorithmParameterGenerator.getInstance("DSA", "BC"); //a.init(2048, new DSATestSecureRandom(seed)); DsaParametersGenerator a = new DsaParametersGenerator(new Sha256Digest()); a.Init(new DsaParameterGenerationParameters(2048, 256, 80, new DsaTestSecureRandom(seed))); //AlgorithmParameters parameters = a.generateParameters(); //DSAParameterSpec dsaP = (DSAParameterSpec)parameters.getParameterSpec(DSAParameterSpec.class); DsaParameters dsaP = a.GenerateParameters(); if (!dsaP.Q.Equals(new BigInteger("C24ED361870B61E0D367F008F99F8A1F75525889C89DB1B673C45AF5867CB467", 16))) { Fail("Q incorrect"); } if (!dsaP.P.Equals(new BigInteger( "F56C2A7D366E3EBDEAA1891FD2A0D099" + "436438A673FED4D75F594959CFFEBCA7BE0FC72E4FE67D91" + "D801CBA0693AC4ED9E411B41D19E2FD1699C4390AD27D94C" + "69C0B143F1DC88932CFE2310C886412047BD9B1C7A67F8A2" + "5909132627F51A0C866877E672E555342BDF9355347DBD43" + "B47156B2C20BAD9D2B071BC2FDCF9757F75C168C5D9FC431" + "31BE162A0756D1BDEC2CA0EB0E3B018A8B38D3EF2487782A" + "EB9FBF99D8B30499C55E4F61E5C7DCEE2A2BB55BD7F75FCD" + "F00E48F2E8356BDB59D86114028F67B8E07B127744778AFF" + "1CF1399A4D679D92FDE7D941C5C85C5D7BFF91BA69F9489D" + "531D1EBFA727CFDA651390F8021719FA9F7216CEB177BD75", 16))) { Fail("P incorrect"); } if (!dsaP.G.Equals(new BigInteger( "8DC6CC814CAE4A1C05A3E186A6FE27EA" + "BA8CDB133FDCE14A963A92E809790CBA096EAA26140550C1" + "29FA2B98C16E84236AA33BF919CD6F587E048C52666576DB" + "6E925C6CBE9B9EC5C16020F9A44C9F1C8F7A8E611C1F6EC2" + "513EA6AA0B8D0F72FED73CA37DF240DB57BBB27431D61869" + "7B9E771B0B301D5DF05955425061A30DC6D33BB6D2A32BD0" + "A75A0A71D2184F506372ABF84A56AEEEA8EB693BF29A6403" + "45FA1298A16E85421B2208D00068A5A42915F82CF0B858C8" + "FA39D43D704B6927E0B2F916304E86FB6A1B487F07D8139E" + "428BB096C6D67A76EC0B8D4EF274B8A2CF556D279AD267CC" + "EF5AF477AFED029F485B5597739F5D0240F67C2D948A6279", 16))) { Fail("G incorrect"); } //KeyPairGenerator g = KeyPairGenerator.getInstance("DSA", "BC"); IAsymmetricCipherKeyPairGenerator g = GeneratorUtilities.GetKeyPairGenerator("DSA"); //g.initialize(dsaP, FixedSecureRandom.From(Hex.Decode("0CAF2EF547EC49C4F3A6FE6DF4223A174D01F2C115D49A6F73437C29A2A8458C"))); g.Init(new DsaKeyGenerationParameters(FixedSecureRandom.From(Hex.Decode("0CAF2EF547EC49C4F3A6FE6DF4223A174D01F2C115D49A6F73437C29A2A8458C")), dsaP)); //KeyPair p = g.generateKeyPair(); AsymmetricCipherKeyPair p = g.GenerateKeyPair(); //DSAPrivateKey sKey = (DSAPrivateKey)p.getPrivate(); //DSAPublicKey vKey = (DSAPublicKey)p.getPublic(); DsaPrivateKeyParameters sKey = (DsaPrivateKeyParameters)p.Private; DsaPublicKeyParameters vKey = (DsaPublicKeyParameters)p.Public; if (!vKey.Y.Equals(new BigInteger( "2828003D7C747199143C370FDD07A286" + "1524514ACC57F63F80C38C2087C6B795B62DE1C224BF8D1D" + "1424E60CE3F5AE3F76C754A2464AF292286D873A7A30B7EA" + "CBBC75AAFDE7191D9157598CDB0B60E0C5AA3F6EBE425500" + "C611957DBF5ED35490714A42811FDCDEB19AF2AB30BEADFF" + "2907931CEE7F3B55532CFFAEB371F84F01347630EB227A41" + "9B1F3F558BC8A509D64A765D8987D493B007C4412C297CAF" + "41566E26FAEE475137EC781A0DC088A26C8804A98C23140E" + "7C936281864B99571EE95C416AA38CEEBB41FDBFF1EB1D1D" + "C97B63CE1355257627C8B0FD840DDB20ED35BE92F08C49AE" + "A5613957D7E5C7A6D5A5834B4CB069E0831753ECF65BA02B", 16))) { Fail("Y value incorrect"); } if (!sKey.X.Equals( new BigInteger("0CAF2EF547EC49C4F3A6FE6DF4223A174D01F2C115D49A6F73437C29A2A8458C", 16))) { Fail("X value incorrect"); } //byte[] encodeParams = parameters.getEncoded(); byte[] encodeParams = new DsaParameter(dsaP.P, dsaP.Q, dsaP.G).GetDerEncoded(); //AlgorithmParameters a2 = AlgorithmParameters.getInstance("DSA", "BC"); //a2.init(encodeParams); DsaParameter dsaP2 = DsaParameter.GetInstance(Asn1Object.FromByteArray(encodeParams)); DsaParameters p2 = new DsaParameters(dsaP.P, dsaP.Q, dsaP.G); // a and a2 should be equivalent! //byte[] encodeParams_2 = a2.GetEncoded(); byte[] encodeParams_2 = new DsaParameter(p2.P, p2.Q, p2.G).GetDerEncoded(); if (!AreEqual(encodeParams, encodeParams_2)) { Fail("encode/decode parameters failed"); } ISigner s = SignerUtilities.GetSigner("DSA"); byte[] data = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 }; s.Init(true, sKey); s.BlockUpdate(data, 0, data.Length); byte[] sigBytes = s.GenerateSignature(); s = SignerUtilities.GetSigner("DSA"); s.Init(false, vKey); s.BlockUpdate(data, 0, data.Length); if (!s.VerifySignature(sigBytes)) { Fail("DSA verification failed"); } }
public void TestCreationDSA() { 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(); ord.Add(X509Name.C); ord.Add(X509Name.O); ord.Add(X509Name.L); ord.Add(X509Name.ST); ord.Add(X509Name.E); IList values = new ArrayList(); values.Add("AU"); values.Add("The Legion of the Bouncy Castle"); values.Add("Melbourne"); values.Add("Victoria"); values.Add("*****@*****.**"); 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); // Assert.IsTrue((cert.IsValidNow && cert.Verify(dsaPub)), "Certificate failed to be valid (DSA Test)"); cert.CheckValidity(); cert.Verify(dsaPub); //ISet dummySet = cert.GetNonCriticalExtensionOids(); //if (dummySet != null) //{ // foreach (string key in dummySet) // { // Console.WriteLine("\t{0}:\t{1}", key); // } //} //Console.WriteLine(); //dummySet = cert.GetNonCriticalExtensionOids(); //if (dummySet != null) //{ // foreach (string key in dummySet) // { // Console.WriteLine("\t{0}:\t{1}", key); // } //} //Console.WriteLine(); }
private void Dsa2Test3() { byte[] seed = Hex.Decode("4783081972865EA95D43318AB2EAF9C61A2FC7BBF1B772A09017BDF5A58F4FF0"); DsaParametersGenerator pGen = new DsaParametersGenerator(new Sha256Digest()); pGen.Init(new DsaParameterGenerationParameters(2048, 256, 80, new DsaTestSecureRandom(seed))); DsaParameters parameters = pGen.GenerateParameters(); DsaValidationParameters pv = parameters.ValidationParameters; if (pv.Counter != 12) { Fail("counter incorrect"); } if (!AreEqual(seed, pv.GetSeed())) { Fail("seed incorrect"); } if (!parameters.Q.Equals(new BigInteger("C24ED361870B61E0D367F008F99F8A1F75525889C89DB1B673C45AF5867CB467", 16))) { Fail("Q incorrect"); } if (!parameters.P.Equals(new BigInteger( "F56C2A7D366E3EBDEAA1891FD2A0D099" + "436438A673FED4D75F594959CFFEBCA7BE0FC72E4FE67D91" + "D801CBA0693AC4ED9E411B41D19E2FD1699C4390AD27D94C" + "69C0B143F1DC88932CFE2310C886412047BD9B1C7A67F8A2" + "5909132627F51A0C866877E672E555342BDF9355347DBD43" + "B47156B2C20BAD9D2B071BC2FDCF9757F75C168C5D9FC431" + "31BE162A0756D1BDEC2CA0EB0E3B018A8B38D3EF2487782A" + "EB9FBF99D8B30499C55E4F61E5C7DCEE2A2BB55BD7F75FCD" + "F00E48F2E8356BDB59D86114028F67B8E07B127744778AFF" + "1CF1399A4D679D92FDE7D941C5C85C5D7BFF91BA69F9489D" + "531D1EBFA727CFDA651390F8021719FA9F7216CEB177BD75", 16))) { Fail("P incorrect"); } if (!parameters.G.Equals(new BigInteger( "8DC6CC814CAE4A1C05A3E186A6FE27EA" + "BA8CDB133FDCE14A963A92E809790CBA096EAA26140550C1" + "29FA2B98C16E84236AA33BF919CD6F587E048C52666576DB" + "6E925C6CBE9B9EC5C16020F9A44C9F1C8F7A8E611C1F6EC2" + "513EA6AA0B8D0F72FED73CA37DF240DB57BBB27431D61869" + "7B9E771B0B301D5DF05955425061A30DC6D33BB6D2A32BD0" + "A75A0A71D2184F506372ABF84A56AEEEA8EB693BF29A6403" + "45FA1298A16E85421B2208D00068A5A42915F82CF0B858C8" + "FA39D43D704B6927E0B2F916304E86FB6A1B487F07D8139E" + "428BB096C6D67A76EC0B8D4EF274B8A2CF556D279AD267CC" + "EF5AF477AFED029F485B5597739F5D0240F67C2D948A6279", 16))) { Fail("G incorrect"); } DsaKeyPairGenerator kpGen = new DsaKeyPairGenerator(); kpGen.Init(new DsaKeyGenerationParameters( FixedSecureRandom.From(Hex.Decode("0CAF2EF547EC49C4F3A6FE6DF4223A174D01F2C115D49A6F73437C29A2A8458C")), parameters)); AsymmetricCipherKeyPair kp = kpGen.GenerateKeyPair(); DsaPublicKeyParameters pub = (DsaPublicKeyParameters)kp.Public; DsaPrivateKeyParameters priv = (DsaPrivateKeyParameters)kp.Private; if (!pub.Y.Equals(new BigInteger( "2828003D7C747199143C370FDD07A286" + "1524514ACC57F63F80C38C2087C6B795B62DE1C224BF8D1D" + "1424E60CE3F5AE3F76C754A2464AF292286D873A7A30B7EA" + "CBBC75AAFDE7191D9157598CDB0B60E0C5AA3F6EBE425500" + "C611957DBF5ED35490714A42811FDCDEB19AF2AB30BEADFF" + "2907931CEE7F3B55532CFFAEB371F84F01347630EB227A41" + "9B1F3F558BC8A509D64A765D8987D493B007C4412C297CAF" + "41566E26FAEE475137EC781A0DC088A26C8804A98C23140E" + "7C936281864B99571EE95C416AA38CEEBB41FDBFF1EB1D1D" + "C97B63CE1355257627C8B0FD840DDB20ED35BE92F08C49AE" + "A5613957D7E5C7A6D5A5834B4CB069E0831753ECF65BA02B", 16))) { Fail("Y value incorrect"); } if (!priv.X.Equals( new BigInteger("0CAF2EF547EC49C4F3A6FE6DF4223A174D01F2C115D49A6F73437C29A2A8458C", 16))) { Fail("X value incorrect"); } DsaSigner signer = new DsaSigner(); signer.Init(true, new ParametersWithRandom(kp.Private, FixedSecureRandom.From(Hex.Decode("0CAF2EF547EC49C4F3A6FE6DF4223A174D01F2C115D49A6F73437C29A2A8458C")))); byte[] msg = Hex.Decode("BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD"); BigInteger[] sig = signer.GenerateSignature(msg); if (!sig[0].Equals(new BigInteger("315C875DCD4850E948B8AC42824E9483A32D5BA5ABE0681B9B9448D444F2BE3C", 16))) { Fail("R value incorrect"); } if (!sig[1].Equals(new BigInteger("89718D12E54A8D9ED066E4A55F7ED5A2229CD23B9A3CEE78F83ED6AA61F6BCB9", 16))) { Fail("S value incorrect"); } signer.Init(false, kp.Public); if (!signer.VerifySignature(msg, sig[0], sig[1])) { Fail("signature not verified"); } }
private void Dsa2Test2() { byte[] seed = Hex.Decode("5AFCC1EFFC079A9CCA6ECA86D6E3CC3B18642D9BE1CC6207C84002A9"); DsaParametersGenerator pGen = new DsaParametersGenerator(new Sha224Digest()); pGen.Init(new DsaParameterGenerationParameters(2048, 224, 80, new DsaTestSecureRandom(seed))); DsaParameters parameters = pGen.GenerateParameters(); DsaValidationParameters pv = parameters.ValidationParameters; if (pv.Counter != 21) { Fail("counter incorrect"); } if (!AreEqual(seed, pv.GetSeed())) { Fail("seed incorrect"); } if (!parameters.Q.Equals(new BigInteger("90EAF4D1AF0708B1B612FF35E0A2997EB9E9D263C9CE659528945C0D", 16))) { Fail("Q incorrect"); } if (!parameters.P.Equals(new BigInteger( "C196BA05AC29E1F9C3C72D56DFFC6154" + "A033F1477AC88EC37F09BE6C5BB95F51C296DD20D1A28A06" + "7CCC4D4316A4BD1DCA55ED1066D438C35AEBAABF57E7DAE4" + "28782A95ECA1C143DB701FD48533A3C18F0FE23557EA7AE6" + "19ECACC7E0B51652A8776D02A425567DED36EABD90CA33A1" + "E8D988F0BBB92D02D1D20290113BB562CE1FC856EEB7CDD9" + "2D33EEA6F410859B179E7E789A8F75F645FAE2E136D252BF" + "FAFF89528945C1ABE705A38DBC2D364AADE99BE0D0AAD82E" + "5320121496DC65B3930E38047294FF877831A16D5228418D" + "E8AB275D7D75651CEFED65F78AFC3EA7FE4D79B35F62A040" + "2A1117599ADAC7B269A59F353CF450E6982D3B1702D9CA83", 16))) { Fail("P incorrect"); } if (!parameters.G.Equals(new BigInteger( "A59A749A11242C58C894E9E5A91804E8" + "FA0AC64B56288F8D47D51B1EDC4D65444FECA0111D78F35F" + "C9FDD4CB1F1B79A3BA9CBEE83A3F811012503C8117F98E50" + "48B089E387AF6949BF8784EBD9EF45876F2E6A5A495BE64B" + "6E770409494B7FEE1DBB1E4B2BC2A53D4F893D418B715959" + "2E4FFFDF6969E91D770DAEBD0B5CB14C00AD68EC7DC1E574" + "5EA55C706C4A1C5C88964E34D09DEB753AD418C1AD0F4FDF" + "D049A955E5D78491C0B7A2F1575A008CCD727AB376DB6E69" + "5515B05BD412F5B8C2F4C77EE10DA48ABD53F5DD498927EE" + "7B692BBBCDA2FB23A516C5B4533D73980B2A3B60E384ED20" + "0AE21B40D273651AD6060C13D97FD69AA13C5611A51B9085", 16))) { Fail("G incorrect"); } DsaKeyPairGenerator kpGen = new DsaKeyPairGenerator(); kpGen.Init(new DsaKeyGenerationParameters( FixedSecureRandom.From(Hex.Decode("00D0F09ED3E2568F6CADF9224117DA2AEC5A4300E009DE1366023E17")), parameters)); AsymmetricCipherKeyPair kp = kpGen.GenerateKeyPair(); DsaPublicKeyParameters pub = (DsaPublicKeyParameters)kp.Public; DsaPrivateKeyParameters priv = (DsaPrivateKeyParameters)kp.Private; if (!pub.Y.Equals(new BigInteger( "70035C9A3B225B258F16741F3941FBF0" + "6F3D056CD7BD864604CBB5EE9DD85304EE8E8E4ABD5E9032" + "11DDF25CE149075510ACE166970AFDC7DF552B7244F342FA" + "02F7A621405B754909D757F97290E1FE5036E904CF593446" + "0C046D95659821E1597ED9F2B1F0E20863A6BBD0CE74DACB" + "A5D8C68A90B29C2157CDEDB82EC12B81EE3068F9BF5F7F34" + "6ECA41ED174CCCD7D154FA4F42F80FFE1BF46AE9D8125DEB" + "5B4BA08A72BDD86596DBEDDC9550FDD650C58F5AE5133509" + "A702F79A31ECB490F7A3C5581631F7C5BE4FF7F9E9F27FA3" + "90E47347AD1183509FED6FCF198BA9A71AB3335B4F38BE8D" + "15496A00B6DC2263E20A5F6B662320A3A1EC033AA61E3B68", 16))) { Fail("Y value incorrect"); } if (!priv.X.Equals( new BigInteger("00D0F09ED3E2568F6CADF9224117DA2AEC5A4300E009DE1366023E17", 16))) { Fail("X value incorrect"); } DsaSigner signer = new DsaSigner(); signer.Init(true, new ParametersWithRandom(kp.Private, FixedSecureRandom.From(Hex.Decode("735959CC4463B8B440E407EECA8A473BF6A6D1FE657546F67D401F05")))); byte[] msg = Hex.Decode("23097D223405D8228642A477BDA255B32AADBCE4BDA0B3F7E36C9DA7"); BigInteger[] sig = signer.GenerateSignature(msg); if (!sig[0].Equals(new BigInteger("4400138D05F9639CAF54A583CAAF25D2B76D0C3EAD752CE17DBC85FE", 16))) { Fail("R value incorrect"); } if (!sig[1].Equals(new BigInteger("874D4F12CB13B61732D398445698CFA9D92381D938AA57EE2C9327B3", 16))) { Fail("S value incorrect"); } signer.Init(false, kp.Public); if (!signer.VerifySignature(msg, sig[0], sig[1])) { Fail("signature not verified"); } }
private void Dsa2Test1() { byte[] seed = Hex.Decode("ED8BEE8D1CB89229D2903CBF0E51EE7377F48698"); DsaParametersGenerator pGen = new DsaParametersGenerator(); pGen.Init(new DsaParameterGenerationParameters(1024, 160, 80, new DsaTestSecureRandom(seed))); DsaParameters parameters = pGen.GenerateParameters(); DsaValidationParameters pv = parameters.ValidationParameters; if (pv.Counter != 5) { Fail("counter incorrect"); } if (!AreEqual(seed, pv.GetSeed())) { Fail("seed incorrect"); } if (!parameters.Q.Equals(new BigInteger("E950511EAB424B9A19A2AEB4E159B7844C589C4F", 16))) { Fail("Q incorrect"); } if (!parameters.P.Equals(new BigInteger( "E0A67598CD1B763B" + "C98C8ABB333E5DDA0CD3AA0E5E1FB5BA8A7B4EABC10BA338" + "FAE06DD4B90FDA70D7CF0CB0C638BE3341BEC0AF8A7330A3" + "307DED2299A0EE606DF035177A239C34A912C202AA5F83B9" + "C4A7CF0235B5316BFC6EFB9A248411258B30B839AF172440" + "F32563056CB67A861158DDD90E6A894C72A5BBEF9E286C6B", 16))) { Fail("P incorrect"); } if (!parameters.G.Equals(new BigInteger( "D29D5121B0423C27" + "69AB21843E5A3240FF19CACC792264E3BB6BE4F78EDD1B15" + "C4DFF7F1D905431F0AB16790E1F773B5CE01C804E509066A" + "9919F5195F4ABC58189FD9FF987389CB5BEDF21B4DAB4F8B" + "76A055FFE2770988FE2EC2DE11AD92219F0B351869AC24DA" + "3D7BA87011A701CE8EE7BFE49486ED4527B7186CA4610A75", 16))) { Fail("G incorrect"); } DsaKeyPairGenerator kpGen = new DsaKeyPairGenerator(); kpGen.Init(new DsaKeyGenerationParameters(FixedSecureRandom.From(Hex.Decode("D0EC4E50BB290A42E9E355C73D8809345DE2E139")), parameters)); AsymmetricCipherKeyPair kp = kpGen.GenerateKeyPair(); DsaPublicKeyParameters pub = (DsaPublicKeyParameters)kp.Public; DsaPrivateKeyParameters priv = (DsaPrivateKeyParameters)kp.Private; if (!pub.Y.Equals(new BigInteger( "25282217F5730501" + "DD8DBA3EDFCF349AAFFEC20921128D70FAC44110332201BB" + "A3F10986140CBB97C726938060473C8EC97B4731DB004293" + "B5E730363609DF9780F8D883D8C4D41DED6A2F1E1BBBDC97" + "9E1B9D6D3C940301F4E978D65B19041FCF1E8B518F5C0576" + "C770FE5A7A485D8329EE2914A2DE1B5DA4A6128CEAB70F79", 16))) { Fail("Y value incorrect"); } if (!priv.X.Equals( new BigInteger("D0EC4E50BB290A42E9E355C73D8809345DE2E139", 16))) { Fail("X value incorrect"); } DsaSigner signer = new DsaSigner(); signer.Init(true, new ParametersWithRandom(kp.Private, FixedSecureRandom.From(Hex.Decode("349C55648DCF992F3F33E8026CFAC87C1D2BA075")))); byte[] msg = Hex.Decode("A9993E364706816ABA3E25717850C26C9CD0D89D"); BigInteger[] sig = signer.GenerateSignature(msg); if (!sig[0].Equals(new BigInteger("636155AC9A4633B4665D179F9E4117DF68601F34", 16))) { Fail("R value incorrect"); } if (!sig[1].Equals(new BigInteger("6C540B02D9D4852F89DF8CFC99963204F4347704", 16))) { Fail("S value incorrect"); } signer.Init(false, kp.Public); if (!signer.VerifySignature(msg, sig[0], sig[1])) { Fail("signature not verified"); } }
public void TestAlgorithms() { // // RSA parameters // BigInteger rsaMod = new BigInteger("a7295693155b1813bb84877fb45343556e0568043de5910872a3a518cc11e23e2db74eaf4545068c4e3d258a2718fbacdcc3eafa457695b957e88fbf110aed049a992d9c430232d02f3529c67a3419935ea9b569f85b1bcd37de6b899cd62697e843130ff0529d09c97d813cb15f293751ff56f943fbdabb63971cc7f4f6d5bff1594416b1f5907bde5a84a44f9802ef29b43bda1960f948f8afb8766c1ab80d32eec88ed66d0b65aebe44a6d0b3c5e0ab051aaa1b912fbcc17b8e751ddecc5365b6db6dab0020c3057db4013a51213a5798a3aab67985b0f4d88627a54a0f3f0285fbcb4afdfeb65cb153af66825656d43238b75503231500753f4e421e3c57", 16); BigInteger rsaPubExp = new BigInteger("10001", 16); BigInteger rsaPrivExp = new BigInteger("65dad56ac7df7abb434e4cb5eeadb16093aa6da7f0033aad3815289b04757d32bfee6ade7749c8e4a323b5050a2fb9e2a99e23469e1ed4ba5bab54336af20a5bfccb8b3424cc6923db2ffca5787ed87aa87aa614cd04cedaebc8f623a2d2063017910f436dff18bb06f01758610787f8b258f0a8efd8bd7de30007c47b2a1031696c7d6523bc191d4d918927a7e0b09584ed205bd2ff4fc4382678df82353f7532b3bbb81d69e3f39070aed3fb64fce032a089e8e64955afa5213a6eb241231bd98d702fba725a9b205952fda186412d9e0d9344d2998c455ad8c2bae85ee672751466d5288304032b5b7e02f7e558c7af82c7fbf58eea0bb4ef0f001e6cd0a9", 16); BigInteger rsaPrivP = new BigInteger("d4fd9ac3474fb83aaf832470643609659e511b322632b239b688f3cd2aad87527d6cf652fb9c9ca67940e84789444f2e99b0cb0cfabbd4de95396106c865f38e2fb7b82b231260a94df0e01756bf73ce0386868d9c41645560a81af2f53c18e4f7cdf3d51d80267372e6e0216afbf67f655c9450769cca494e4f6631b239ce1b", 16); BigInteger rsaPrivQ = new BigInteger("c8eaa0e2a1b3a4412a702bccda93f4d150da60d736c99c7c566fdea4dd1b401cbc0d8c063daaf0b579953d36343aa18b33dbf8b9eae94452490cc905245f8f7b9e29b1a288bc66731a29e1dd1a45c9fd7f8238ff727adc49fff73991d0dc096206b9d3a08f61e7462e2b804d78cb8c5eccdb9b7fbd2ad6a8fea46c1053e1be75", 16); BigInteger rsaPrivDP = new BigInteger("10edcb544421c0f9e123624d1099feeb35c72a8b34e008ac6fa6b90210a7543f293af4e5299c8c12eb464e70092805c7256e18e5823455ba0f504d36f5ccacac1b7cd5c58ff710f9c3f92646949d88fdd1e7ea5fed1081820bb9b0d2a8cd4b093fecfdb96dabd6e28c3a6f8c186dc86cddc89afd3e403e0fcf8a9e0bcb27af0b", 16); BigInteger rsaPrivDQ = new BigInteger("97fc25484b5a415eaa63c03e6efa8dafe9a1c8b004d9ee6e80548fefd6f2ce44ee5cb117e77e70285798f57d137566ce8ea4503b13e0f1b5ed5ca6942537c4aa96b2a395782a4cb5b58d0936e0b0fa63b1192954d39ced176d71ef32c6f42c84e2e19f9d4dd999c2151b032b97bd22aa73fd8c5bcd15a2dca4046d5acc997021", 16); BigInteger rsaPrivQinv = new BigInteger("4bb8064e1eff7e9efc3c4578fcedb59ca4aef0993a8312dfdcb1b3decf458aa6650d3d0866f143cbf0d3825e9381181170a0a1651eefcd7def786b8eb356555d9fa07c85b5f5cbdd74382f1129b5e36b4166b6cc9157923699708648212c484958351fdc9cf14f218dbe7fbf7cbd93a209a4681fe23ceb44bab67d66f45d1c9d", 16); RsaKeyParameters rsaPublic = new RsaKeyParameters(false, rsaMod, rsaPubExp); RsaPrivateCrtKeyParameters rsaPrivate = new RsaPrivateCrtKeyParameters( rsaMod, rsaPubExp, rsaPrivExp, rsaPrivP, rsaPrivQ, rsaPrivDP, rsaPrivDQ, rsaPrivQinv); // // ECDSA parameters // BigInteger ECParraGX = new BigInteger(Base64.Decode("D/qWPNyogWzMM7hkK+35BcPTWFc9Pyf7vTs8uaqv")); BigInteger ECParraGY = new BigInteger(Base64.Decode("AhQXGxb1olGRv6s1LPRfuatMF+cx3ZTGgzSE/Q5R")); BigInteger ECParraH = new BigInteger(Base64.Decode("AQ==")); BigInteger ECParraN = new BigInteger(Base64.Decode("f///////////////f///nl6an12QcfvRUiaIkJ0L")); BigInteger ECPubQX = new BigInteger(Base64.Decode("HWWi17Yb+Bm3PYr/DMjLOYNFhyOwX1QY7ZvqqM+l")); BigInteger ECPubQY = new BigInteger(Base64.Decode("JrlJfxu3WGhqwtL/55BOs/wsUeiDFsvXcGhB8DGx")); BigInteger ECPrivD = new BigInteger(Base64.Decode("GYQmd/NF1B+He1iMkWt3by2Az6Eu07t0ynJ4YCAo")); FpCurve curve = new FpCurve( new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839"), // q new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16)); // b ECDomainParameters ecDomain = new ECDomainParameters(curve, new FpPoint(curve, curve.FromBigInteger(ECParraGX), curve.FromBigInteger(ECParraGY)), ECParraN); ECPublicKeyParameters ecPub = new ECPublicKeyParameters( new FpPoint(curve, curve.FromBigInteger(ECPubQX), curve.FromBigInteger(ECPubQY)), ecDomain); ECPrivateKeyParameters ecPriv = new ECPrivateKeyParameters(ECPrivD, ecDomain); // // DSA parameters // 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); // // GOST3410 parameters // IAsymmetricCipherKeyPairGenerator gostKpg = GeneratorUtilities.GetKeyPairGenerator("GOST3410"); gostKpg.Init( new Gost3410KeyGenerationParameters( new SecureRandom(), CryptoProObjectIdentifiers.GostR3410x94CryptoProA)); AsymmetricCipherKeyPair gostPair = gostKpg.GenerateKeyPair(); // // signer loop // byte[] shortMsg = new byte[] { 1, 4, 5, 6, 8, 8, 4, 2, 1, 3 }; byte[] longMsg = new byte[100]; new SecureRandom().NextBytes(longMsg); foreach (string algorithm in SignerUtilities.Algorithms) { ISigner signer = SignerUtilities.GetSigner(algorithm); string upper = algorithm.ToUpper(CultureInfo.InvariantCulture); int withPos = upper.LastIndexOf("WITH"); string cipherName = withPos < 0 ? upper : upper.Substring(withPos + "WITH".Length); ICipherParameters signParams = null, verifyParams = null; if (cipherName == "RSA" || cipherName == "RSAANDMGF1") { signParams = rsaPrivate; verifyParams = rsaPublic; } else if (cipherName == "ECDSA") { signParams = ecPriv; verifyParams = ecPub; } else if (cipherName == "DSA") { signParams = dsaPriv; verifyParams = dsaPub; } else if (cipherName == "ECGOST3410") { AsymmetricCipherKeyPair ecGostPair = GetEcCipherKeyPair( "ECGOST3410", CryptoProObjectIdentifiers.GostR3410x2001CryptoProA); signParams = ecGostPair.Private; verifyParams = ecGostPair.Public; } else if (cipherName == "GOST3410") { signParams = gostPair.Private; verifyParams = gostPair.Public; } else if (cipherName == "GOST3410_2012_256") { AsymmetricCipherKeyPair gost2012_256Pair = GetEcCipherKeyPair( "GOST3410_2012_256", RosstandartObjectIdentifiers.id_tc26_gost_3410_12_256_paramSetA); signParams = gost2012_256Pair.Private; verifyParams = gost2012_256Pair.Public; } else if (cipherName == "GOST3410_2012_512") { AsymmetricCipherKeyPair gost2012_512Pair = GetEcCipherKeyPair( "GOST3410_2012_512", RosstandartObjectIdentifiers.id_tc26_gost_3410_12_512_paramSetA); signParams = gost2012_512Pair.Private; verifyParams = gost2012_512Pair.Public; } else { Assert.Fail("Unknown algorithm encountered: " + cipherName); } signer.Init(true, signParams); foreach (byte b in shortMsg) { signer.Update(b); } signer.BlockUpdate(longMsg, 0, longMsg.Length); byte[] sig = signer.GenerateSignature(); signer.Init(false, verifyParams); foreach (byte b in shortMsg) { signer.Update(b); } signer.BlockUpdate(longMsg, 0, longMsg.Length); Assert.IsTrue(signer.VerifySignature(sig), cipherName + " signer " + algorithm + " failed."); } }
public static PrivateKeyInfo CreatePrivateKeyInfo( AsymmetricKeyParameter key) { if (key == null) { throw new ArgumentNullException("key"); } if (!key.IsPrivate) { throw new ArgumentException("Public key passed - private key expected", "key"); } if (key is ElGamalPrivateKeyParameters) { ElGamalPrivateKeyParameters _key = (ElGamalPrivateKeyParameters)key; return(new PrivateKeyInfo( new AlgorithmIdentifier( OiwObjectIdentifiers.ElGamalAlgorithm, new ElGamalParameter( _key.Parameters.P, _key.Parameters.G).ToAsn1Object()), new DerInteger(_key.X))); } if (key is DsaPrivateKeyParameters) { DsaPrivateKeyParameters _key = (DsaPrivateKeyParameters)key; return(new PrivateKeyInfo( new AlgorithmIdentifier( X9ObjectIdentifiers.IdDsa, new DsaParameter( _key.Parameters.P, _key.Parameters.Q, _key.Parameters.G).ToAsn1Object()), new DerInteger(_key.X))); } if (key is DHPrivateKeyParameters) { DHPrivateKeyParameters _key = (DHPrivateKeyParameters)key; DHParameter p = new DHParameter( _key.Parameters.P, _key.Parameters.G, _key.Parameters.L); return(new PrivateKeyInfo( new AlgorithmIdentifier(_key.AlgorithmOid, p.ToAsn1Object()), new DerInteger(_key.X))); } if (key is RsaKeyParameters) { AlgorithmIdentifier algID = new AlgorithmIdentifier( PkcsObjectIdentifiers.RsaEncryption, DerNull.Instance); RsaPrivateKeyStructure keyStruct; if (key is RsaPrivateCrtKeyParameters) { RsaPrivateCrtKeyParameters _key = (RsaPrivateCrtKeyParameters)key; keyStruct = new RsaPrivateKeyStructure( _key.Modulus, _key.PublicExponent, _key.Exponent, _key.P, _key.Q, _key.DP, _key.DQ, _key.QInv); } else { RsaKeyParameters _key = (RsaKeyParameters)key; keyStruct = new RsaPrivateKeyStructure( _key.Modulus, BigInteger.Zero, _key.Exponent, BigInteger.Zero, BigInteger.Zero, BigInteger.Zero, BigInteger.Zero, BigInteger.Zero); } return(new PrivateKeyInfo(algID, keyStruct.ToAsn1Object())); } if (key is ECPrivateKeyParameters) { ECPrivateKeyParameters priv = (ECPrivateKeyParameters)key; ECDomainParameters dp = priv.Parameters; int orderBitLength = dp.N.BitLength; AlgorithmIdentifier algID; ECPrivateKeyStructure ec; if (priv.AlgorithmName == "ECGOST3410") { if (priv.PublicKeyParamSet == null) { throw Platform.CreateNotImplementedException("Not a CryptoPro parameter set"); } Gost3410PublicKeyAlgParameters gostParams = new Gost3410PublicKeyAlgParameters( priv.PublicKeyParamSet, CryptoProObjectIdentifiers.GostR3411x94CryptoProParamSet); algID = new AlgorithmIdentifier(CryptoProObjectIdentifiers.GostR3410x2001, gostParams); // TODO Do we need to pass any parameters here? ec = new ECPrivateKeyStructure(orderBitLength, priv.D); } else { X962Parameters x962; if (priv.PublicKeyParamSet == null) { X9ECParameters ecP = new X9ECParameters(dp.Curve, dp.G, dp.N, dp.H, dp.GetSeed()); x962 = new X962Parameters(ecP); } else { x962 = new X962Parameters(priv.PublicKeyParamSet); } // TODO Possible to pass the publicKey bitstring here? ec = new ECPrivateKeyStructure(orderBitLength, priv.D, x962); algID = new AlgorithmIdentifier(X9ObjectIdentifiers.IdECPublicKey, x962); } return(new PrivateKeyInfo(algID, ec)); } if (key is Gost3410PrivateKeyParameters) { Gost3410PrivateKeyParameters _key = (Gost3410PrivateKeyParameters)key; if (_key.PublicKeyParamSet == null) { throw Platform.CreateNotImplementedException("Not a CryptoPro parameter set"); } byte[] keyEnc = _key.X.ToByteArrayUnsigned(); byte[] keyBytes = new byte[keyEnc.Length]; for (int i = 0; i != keyBytes.Length; i++) { keyBytes[i] = keyEnc[keyEnc.Length - 1 - i]; // must be little endian } Gost3410PublicKeyAlgParameters algParams = new Gost3410PublicKeyAlgParameters( _key.PublicKeyParamSet, CryptoProObjectIdentifiers.GostR3411x94CryptoProParamSet, null); AlgorithmIdentifier algID = new AlgorithmIdentifier( CryptoProObjectIdentifiers.GostR3410x94, algParams.ToAsn1Object()); return(new PrivateKeyInfo(algID, new DerOctetString(keyBytes))); } throw new ArgumentException("Class provided is not convertible: " + Platform.GetTypeName(key)); }
private void Dsa2Test4() { byte[] seed = Hex.Decode("193AFCA7C1E77B3C1ECC618C81322E47B8B8B997C9C83515C59CC446C2D9BD47"); DsaParametersGenerator pGen = new DsaParametersGenerator(new Sha256Digest()); pGen.Init(new DsaParameterGenerationParameters(3072, 256, 80, new DsaTestSecureRandom(seed))); DsaParameters parameters = pGen.GenerateParameters(); DsaValidationParameters pv = parameters.ValidationParameters; if (pv.Counter != 20) { Fail("counter incorrect"); } if (!AreEqual(seed, pv.GetSeed())) { Fail("seed incorrect"); } if (!parameters.Q.Equals(new BigInteger("CFA0478A54717B08CE64805B76E5B14249A77A4838469DF7F7DC987EFCCFB11D", 16))) { Fail("Q incorrect"); } if (!parameters.P.Equals(new BigInteger( "90066455B5CFC38F9CAA4A48B4281F292C260FEEF01FD610" + "37E56258A7795A1C7AD46076982CE6BB956936C6AB4DCFE0" + "5E6784586940CA544B9B2140E1EB523F009D20A7E7880E4E" + "5BFA690F1B9004A27811CD9904AF70420EEFD6EA11EF7DA1" + "29F58835FF56B89FAA637BC9AC2EFAAB903402229F491D8D" + "3485261CD068699B6BA58A1DDBBEF6DB51E8FE34E8A78E54" + "2D7BA351C21EA8D8F1D29F5D5D15939487E27F4416B0CA63" + "2C59EFD1B1EB66511A5A0FBF615B766C5862D0BD8A3FE7A0" + "E0DA0FB2FE1FCB19E8F9996A8EA0FCCDE538175238FC8B0E" + "E6F29AF7F642773EBE8CD5402415A01451A840476B2FCEB0" + "E388D30D4B376C37FE401C2A2C2F941DAD179C540C1C8CE0" + "30D460C4D983BE9AB0B20F69144C1AE13F9383EA1C08504F" + "B0BF321503EFE43488310DD8DC77EC5B8349B8BFE97C2C56" + "0EA878DE87C11E3D597F1FEA742D73EEC7F37BE43949EF1A" + "0D15C3F3E3FC0A8335617055AC91328EC22B50FC15B941D3" + "D1624CD88BC25F3E941FDDC6200689581BFEC416B4B2CB73", 16))) { Fail("P incorrect"); } if (!parameters.G.Equals(new BigInteger( "5E5CBA992E0A680D885EB903AEA78E4A45A469103D448EDE" + "3B7ACCC54D521E37F84A4BDD5B06B0970CC2D2BBB715F7B8" + "2846F9A0C393914C792E6A923E2117AB805276A975AADB52" + "61D91673EA9AAFFEECBFA6183DFCB5D3B7332AA19275AFA1" + "F8EC0B60FB6F66CC23AE4870791D5982AAD1AA9485FD8F4A" + "60126FEB2CF05DB8A7F0F09B3397F3937F2E90B9E5B9C9B6" + "EFEF642BC48351C46FB171B9BFA9EF17A961CE96C7E7A7CC" + "3D3D03DFAD1078BA21DA425198F07D2481622BCE45969D9C" + "4D6063D72AB7A0F08B2F49A7CC6AF335E08C4720E31476B6" + "7299E231F8BD90B39AC3AE3BE0C6B6CACEF8289A2E2873D5" + "8E51E029CAFBD55E6841489AB66B5B4B9BA6E2F784660896" + "AFF387D92844CCB8B69475496DE19DA2E58259B090489AC8" + "E62363CDF82CFD8EF2A427ABCD65750B506F56DDE3B98856" + "7A88126B914D7828E2B63A6D7ED0747EC59E0E0A23CE7D8A" + "74C1D2C2A7AFB6A29799620F00E11C33787F7DED3B30E1A2" + "2D09F1FBDA1ABBBFBF25CAE05A13F812E34563F99410E73B", 16))) { Fail("G incorrect"); } DsaKeyPairGenerator kpGen = new DsaKeyPairGenerator(); kpGen.Init(new DsaKeyGenerationParameters( FixedSecureRandom.From(Hex.Decode("3ABC1587297CE7B9EA1AD6651CF2BC4D7F92ED25CABC8553F567D1B40EBB8764")), parameters)); AsymmetricCipherKeyPair kp = kpGen.GenerateKeyPair(); DsaPublicKeyParameters pub = (DsaPublicKeyParameters)kp.Public; DsaPrivateKeyParameters priv = (DsaPrivateKeyParameters)kp.Private; if (!pub.Y.Equals(new BigInteger( "8B891C8692D3DE875879390F2698B26FBECCA6B075535DCE" + "6B0C862577F9FA0DEF6074E7A7624121224A595896ABD4CD" + "A56B2CEFB942E025D2A4282FFAA98A48CDB47E1A6FCB5CFB" + "393EF35AF9DF913102BB303C2B5C36C3F8FC04ED7B8B69FE" + "FE0CF3E1FC05CFA713B3435B2656E913BA8874AEA9F93600" + "6AEB448BCD005D18EC3562A33D04CF25C8D3D69844343442" + "FA3DB7DE618C5E2DA064573E61E6D5581BFB694A23AC87FD" + "5B52D62E954E1376DB8DDB524FFC0D469DF978792EE44173" + "8E5DB05A7DC43E94C11A2E7A4FBE383071FA36D2A7EC8A93" + "88FE1C4F79888A99D3B6105697C2556B79BB4D7E781CEBB3" + "D4866AD825A5E830846072289FDBC941FA679CA82F5F78B7" + "461B2404DB883D215F4E0676CF5493950AC5591697BFEA8D" + "1EE6EC016B89BA51CAFB5F9C84C989FA117375E94578F28B" + "E0B34CE0545DA46266FD77F62D8F2CEE92AB77012AFEBC11" + "008985A821CD2D978C7E6FE7499D1AAF8DE632C21BB48CA5" + "CBF9F31098FD3FD3854C49A65D9201744AACE540354974F9", 16))) { Fail("Y value incorrect"); } if (!priv.X.Equals( new BigInteger("3ABC1587297CE7B9EA1AD6651CF2BC4D7F92ED25CABC8553F567D1B40EBB8764", 16))) { Fail("X value incorrect"); } DsaSigner signer = new DsaSigner(); signer.Init(true, new ParametersWithRandom(kp.Private, FixedSecureRandom.From(Hex.Decode("A6902C1E6E3943C5628061588A8B007BCCEA91DBF12915483F04B24AB0678BEE")))); byte[] msg = Hex.Decode("BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD"); BigInteger[] sig = signer.GenerateSignature(msg); if (!sig[0].Equals(new BigInteger("5F184E645A38BE8FB4A6871B6503A9D12924C7ABE04B71410066C2ECA6E3BE3E", 16))) { Fail("R value incorrect"); } if (!sig[1].Equals(new BigInteger("91EB0C7BA3D4B9B60B825C3D9F2CADA8A2C9D7723267B033CBCDCF8803DB9C18", 16))) { Fail("S value incorrect"); } signer.Init(false, kp.Public); if (!signer.VerifySignature(msg, sig[0], sig[1])) { Fail("signature not verified"); } }