private bool VerifyEcDsa(IDigest digest, X9ECParameters curveParameter, byte[] buffer, int length, byte[] signature) { int digestSize = digest.GetDigestSize(); ECDomainParameters dParams = new ECDomainParameters( curveParameter.Curve, curveParameter.G, curveParameter.N, curveParameter.H, curveParameter.GetSeed()); ECPoint q = dParams.Curve.CreatePoint(new BigInteger(1, PublicKey, 0, digestSize), new BigInteger(1, PublicKey, digestSize, digestSize), false); ECPublicKeyParameters parameters = new ECPublicKeyParameters(q, dParams); var signer = new ECDsaSigner(); signer.Init(false, parameters); digest.BlockUpdate(buffer, 0, length); byte[] hash = new byte[digest.GetDigestSize()]; digest.DoFinal(hash, 0); return(signer.VerifySignature(hash, new BigInteger(1, signature, 0, digestSize), new BigInteger(1, signature, digestSize, digestSize))); }
public static bool BouncyCastleVerify(byte[] hash, byte[] signature, byte[] publicKey) { Asn1InputStream asn1 = new Asn1InputStream(signature); try { ECDsaSigner signer = new ECDsaSigner(); signer.Init(false, new ECPublicKeyParameters(curve.Curve.DecodePoint(publicKey), domain)); Asn1Sequence seq = (Asn1Sequence)asn1.ReadObject(); DerInteger r = DerInteger.GetInstance(seq[0]); DerInteger s = DerInteger.GetInstance(seq[1]); return(signer.VerifySignature(hash, r.PositiveValue, s.PositiveValue)); } catch (Exception e) { return(false); } finally { try { asn1.Close(); } catch (IOException) { } } }
public bool Verify(byte[] hash, ECDSASignature sig) { var signer = new ECDsaSigner(); signer.Init(false, GetPublicKeyParameters()); return(signer.VerifySignature(hash, sig.R, sig.S)); }
public void TestECDsaP256Sha256WithGeneratedKey() { var secureRandom = new SecureRandom(); X9ECParameters p = NistNamedCurves.GetByName("P-256"); var parameters = new ECDomainParameters(p.Curve, p.G, p.N, p.H); var ecParams = new ECKeyGenerationParameters(parameters, secureRandom); var ecGen = new ECKeyPairGenerator("ECDSA"); ecGen.Init(ecParams); var pairKey = ecGen.GenerateKeyPair(); var priKey = pairKey.Private as ECPrivateKeyParameters; byte[] m = Hex.Decode("1BD4ED430B0F384B4E8D458EFF1A8A553286D7AC21CB2F6806172EF5F94A06AD"); var dsa = new ECDsaSigner(); dsa.Init(true, new ParametersWithRandom(priKey, secureRandom)); IBigInteger[] sig = dsa.GenerateSignature(m); // Verify the signature var pubKey = pairKey.Public as ECPublicKeyParameters; dsa.Init(false, pubKey); if (!dsa.VerifySignature(m, sig[0], sig[1])) { Fail("signature fails"); } }
public bool Verify(byte[] hash, ECDSASignature sig) { var signer = new ECDsaSigner(); signer.Init(false, _pubKey); return(signer.VerifySignature(hash, sig.R, sig.S)); }
public void TestECDsa239BitPrime() { IBigInteger r = new BigInteger("308636143175167811492622547300668018854959378758531778147462058306432176"); IBigInteger s = new BigInteger("323813553209797357708078776831250505931891051755007842781978505179448783"); byte[] kData = BigIntegers.AsUnsignedByteArray( new BigInteger("700000017569056646655505781757157107570501575775705779575555657156756655")); SecureRandom k = FixedSecureRandom.From(kData); var curve = new FPCurve( new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839"), // q new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16)); // b var parameters = new ECDomainParameters( curve, curve.DecodePoint(Hex.Decode("020ffa963cdca8816ccc33b8642bedf905c3d358573d3f27fbbd3b3cb9aaaf")), // G new BigInteger("883423532389192164791648750360308884807550341691627752275345424702807307")); // n var priKey = new ECPrivateKeyParameters( "ECDSA", new BigInteger("876300101507107567501066130761671078357010671067781776716671676178726717"), // d parameters); var ecdsa = new ECDsaSigner(); var param = new ParametersWithRandom(priKey, k); ecdsa.Init(true, param); byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray(); IBigInteger[] sig = ecdsa.GenerateSignature(message); if (!r.Equals(sig[0])) { Fail("r component wrong." + NewLine + " expecting: " + r + NewLine + " got : " + sig[0]); } if (!s.Equals(sig[1])) { Fail("s component wrong." + NewLine + " expecting: " + s + NewLine + " got : " + sig[1]); } // Verify the signature var pubKey = new ECPublicKeyParameters( "ECDSA", curve.DecodePoint(Hex.Decode("025b6dc53bc61a2548ffb0f671472de6c9521a9d2d2534e65abfcbd5fe0c70")), // Q parameters); ecdsa.Init(false, pubKey); if (!ecdsa.VerifySignature(message, sig[0], sig[1])) { Fail("signature fails"); } }
public void TestECDsaP521Sha512() { X9ECParameters p = NistNamedCurves.GetByName("P-521"); var parameters = new ECDomainParameters(p.Curve, p.G, p.N, p.H); var priKey = new ECPrivateKeyParameters( new BigInteger( "617573726813476282316253885608633222275541026607493641741273231656161177732180358888434629562647985511298272498852936680947729040673640492310550142822667389"), // d parameters); SecureRandom k = FixedSecureRandom.From( BigIntegers.AsUnsignedByteArray( new BigInteger( "6806532878215503520845109818432174847616958675335397773700324097584974639728725689481598054743894544060040710846048585856076812050552869216017728862957612913"))); byte[] m = Hex.Decode( "6893B64BD3A9615C39C3E62DDD269C2BAAF1D85915526083183CE14C2E883B48B193607C1ED871852C9DF9C3147B574DC1526C55DE1FE263A676346A20028A66"); var dsa = new ECDsaSigner(); dsa.Init(true, new ParametersWithRandom(priKey, k)); IBigInteger[] sig = dsa.GenerateSignature(m); IBigInteger r = new BigInteger( "1368926195812127407956140744722257403535864168182534321188553460365652865686040549247096155740756318290773648848859639978618869784291633651685766829574104630"); IBigInteger s = new BigInteger( "1624754720348883715608122151214003032398685415003935734485445999065609979304811509538477657407457976246218976767156629169821116579317401249024208611945405790"); if (!r.Equals(sig[0])) { Fail("r component wrong." + NewLine + " expecting: " + r + NewLine + " got : " + sig[0]); } if (!s.Equals(sig[1])) { Fail("s component wrong." + NewLine + " expecting: " + s + NewLine + " got : " + sig[1]); } // Verify the signature var pubKey = new ECPublicKeyParameters( parameters.Curve.DecodePoint( Hex.Decode( "020145E221AB9F71C5FE740D8D2B94939A09E2816E2167A7D058125A06A80C014F553E8D6764B048FB6F2B687CEC72F39738F223D4CE6AFCBFF2E34774AA5D3C342CB3")), // Q parameters); dsa.Init(false, pubKey); if (!dsa.VerifySignature(m, sig[0], sig[1])) { Fail("signature fails"); } }
public bool Verify(byte[] hash, ECDSASignature signatrue) { var signer = new ECDsaSigner(); signer.Init(false, PublicKeyParameter); return signer.VerifySignature(hash, signatrue.R, signatrue.S); }
public void TestECDsa191bitBinary() { BigInteger r = new BigInteger("87194383164871543355722284926904419997237591535066528048"); BigInteger s = new BigInteger("308992691965804947361541664549085895292153777025772063598"); byte[] kData = BigIntegers.AsUnsignedByteArray(new BigInteger("1542725565216523985789236956265265265235675811949404040041")); SecureRandom k = FixedSecureRandom.From(kData); F2mCurve curve = new F2mCurve( 191, // m 9, //k new BigInteger("2866537B676752636A68F56554E12640276B649EF7526267", 16), // a new BigInteger("2E45EF571F00786F67B0081B9495A3D95462F5DE0AA185EC", 16)); // b ECDomainParameters parameters = new ECDomainParameters( curve, curve.DecodePoint(Hex.Decode("0436B3DAF8A23206F9C4F299D7B21A9C369137F2C84AE1AA0D765BE73433B3F95E332932E70EA245CA2418EA0EF98018FB")), // G new BigInteger("1569275433846670190958947355803350458831205595451630533029"), // n BigInteger.Two); // h ECPrivateKeyParameters priKey = new ECPrivateKeyParameters( "ECDSA", new BigInteger("1275552191113212300012030439187146164646146646466749494799"), // d parameters); ECDsaSigner ecdsa = new ECDsaSigner(); ParametersWithRandom param = new ParametersWithRandom(priKey, k); ecdsa.Init(true, param); byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray(); BigInteger[] sig = ecdsa.GenerateSignature(message); if (!r.Equals(sig[0])) { Fail("r component wrong." + SimpleTest.NewLine + " expecting: " + r + SimpleTest.NewLine + " got : " + sig[0]); } if (!s.Equals(sig[1])) { Fail("s component wrong." + SimpleTest.NewLine + " expecting: " + s + SimpleTest.NewLine + " got : " + sig[1]); } // Verify the signature ECPublicKeyParameters pubKey = new ECPublicKeyParameters( "ECDSA", curve.DecodePoint(Hex.Decode("045DE37E756BD55D72E3768CB396FFEB962614DEA4CE28A2E755C0E0E02F5FB132CAF416EF85B229BBB8E1352003125BA1")), // Q parameters); ecdsa.Init(false, pubKey); if (!ecdsa.VerifySignature(message, sig[0], sig[1])) { Fail("signature fails"); } }
internal bool Verify(uint256 hash, ECDSASignature sig) { var signer = new ECDsaSigner(); signer.Init(false, GetPublicKeyParameters()); return(signer.VerifySignature(hash.ToBytes(), sig.R, sig.S)); }
public void TestECDsa239bitBinary() { BigInteger r = new BigInteger("21596333210419611985018340039034612628818151486841789642455876922391552"); BigInteger s = new BigInteger("197030374000731686738334997654997227052849804072198819102649413465737174"); byte[] kData = BigIntegers.AsUnsignedByteArray(new BigInteger("171278725565216523967285789236956265265265235675811949404040041670216363")); SecureRandom k = FixedSecureRandom.From(kData); F2mCurve curve = new F2mCurve( 239, // m 36, //k new BigInteger("32010857077C5431123A46B808906756F543423E8D27877578125778AC76", 16), // a new BigInteger("790408F2EEDAF392B012EDEFB3392F30F4327C0CA3F31FC383C422AA8C16", 16)); // b ECDomainParameters parameters = new ECDomainParameters( curve, curve.DecodePoint(Hex.Decode("0457927098FA932E7C0A96D3FD5B706EF7E5F5C156E16B7E7C86038552E91D61D8EE5077C33FECF6F1A16B268DE469C3C7744EA9A971649FC7A9616305")), // G new BigInteger("220855883097298041197912187592864814557886993776713230936715041207411783"), // n BigInteger.ValueOf(4)); // h ECPrivateKeyParameters priKey = new ECPrivateKeyParameters( "ECDSA", new BigInteger("145642755521911534651321230007534120304391871461646461466464667494947990"), // d parameters); ECDsaSigner ecdsa = new ECDsaSigner(); ParametersWithRandom param = new ParametersWithRandom(priKey, k); ecdsa.Init(true, param); byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray(); BigInteger[] sig = ecdsa.GenerateSignature(message); if (!r.Equals(sig[0])) { Fail("r component wrong." + SimpleTest.NewLine + " expecting: " + r + SimpleTest.NewLine + " got : " + sig[0]); } if (!s.Equals(sig[1])) { Fail("s component wrong." + SimpleTest.NewLine + " expecting: " + s + SimpleTest.NewLine + " got : " + sig[1]); } // Verify the signature ECPublicKeyParameters pubKey = new ECPublicKeyParameters( "ECDSA", curve.DecodePoint(Hex.Decode("045894609CCECF9A92533F630DE713A958E96C97CCB8F5ABB5A688A238DEED6DC2D9D0C94EBFB7D526BA6A61764175B99CB6011E2047F9F067293F57F5")), // Q parameters); ecdsa.Init(false, pubKey); if (!ecdsa.VerifySignature(message, sig[0], sig[1])) { Fail("signature fails"); } }
public bool IsValid(Transaction transaction) { ECDomainParameters ecSpec = new ECDomainParameters(CryptoUtil.Curve.Curve, CryptoUtil.Curve.G, CryptoUtil.Curve.N, CryptoUtil.Curve.H); IDsaKCalculator kCalculator = new HMacDsaKCalculator(new Sha256Digest()); var point = DecodeECPointPublicKey(transaction.SenderPublicKey); ECPublicKeyParameters keyParameters = new ECPublicKeyParameters(point, ecSpec); ECDsaSigner signer = new ECDsaSigner(kCalculator); signer.Init(false, keyParameters); var pubKey1 = new BigInteger(transaction.Signature[0], 16); var pubKey2 = new BigInteger(transaction.Signature[1], 16); TransactionRaw transactionRaw = new TransactionRaw() { FromAddress = transaction.FromAddress, ToAddress = transaction.ToAddress, Amount = transaction.Amount, DateCreated = transaction.DateCreated }; string tranJson = JsonConvert.SerializeObject(transactionRaw); byte[] tranHash = CryptoUtil.CalcSHA256(tranJson); return(signer.VerifySignature(tranHash, pubKey1, pubKey2)); }
public bool Verify( HashDigest <T> messageHash, byte[] signature, PublicKey publicKey) { try { Asn1Sequence asn1Sequence = (Asn1Sequence)Asn1Object.FromByteArray(signature); var rs = new[] { ((DerInteger)asn1Sequence[0]).Value, ((DerInteger)asn1Sequence[1]).Value, }; var verifier = new ECDsaSigner(); verifier.Init(false, publicKey.KeyParam); return(verifier.VerifySignature(messageHash.ToByteArray(), rs[0], rs[1])); } catch (IOException) { return(false); } catch (Asn1ParsingException) { return(false); } }
public static Boolean VerifyHashed(byte[][] signature, byte[] publicKey, byte[] message) { var list = new List <byte[]>(); var arr = signature.ToArray(); foreach (var sigVal in arr) { list.Add(sigVal); } var sigR = list[0]; //r var sigS = list[1]; //s try { X9ECParameters spec = ECNamedCurveTable.GetByName("secp256k1"); ECDomainParameters domain = new ECDomainParameters(spec.Curve, spec.G, spec.N); ECPublicKeyParameters publicKeyParams = new ECPublicKeyParameters(spec.Curve.DecodePoint(publicKey), domain); ECDsaSigner signer = new ECDsaSigner(); signer.Init(false, publicKeyParams); return(signer.VerifySignature(message, new BigInteger(1, sigR), new BigInteger(1, sigS))); } catch { return(false); } }
public void TestECDsa192bitPrime() { BigInteger r = new BigInteger("3342403536405981729393488334694600415596881826869351677613"); BigInteger s = new BigInteger("5735822328888155254683894997897571951568553642892029982342"); byte[] kData = BigIntegers.AsUnsignedByteArray(new BigInteger("6140507067065001063065065565667405560006161556565665656654")); SecureRandom k = FixedSecureRandom.From(kData); FpCurve curve = new FpCurve( new BigInteger("6277101735386680763835789423207666416083908700390324961279"), // q new BigInteger("fffffffffffffffffffffffffffffffefffffffffffffffc", 16), // a new BigInteger("64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1", 16)); // b ECDomainParameters parameters = new ECDomainParameters( curve, curve.DecodePoint(Hex.Decode("03188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012")), // G new BigInteger("6277101735386680763835789423176059013767194773182842284081")); // n ECPrivateKeyParameters priKey = new ECPrivateKeyParameters( "ECDSA", new BigInteger("651056770906015076056810763456358567190100156695615665659"), // d parameters); ParametersWithRandom param = new ParametersWithRandom(priKey, k); ECDsaSigner ecdsa = new ECDsaSigner(); ecdsa.Init(true, param); byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray(); BigInteger[] sig = ecdsa.GenerateSignature(message); if (!r.Equals(sig[0])) { Fail("r component wrong." + SimpleTest.NewLine + " expecting: " + r + SimpleTest.NewLine + " got : " + sig[0]); } if (!s.Equals(sig[1])) { Fail("s component wrong." + SimpleTest.NewLine + " expecting: " + s + SimpleTest.NewLine + " got : " + sig[1]); } // Verify the signature ECPublicKeyParameters pubKey = new ECPublicKeyParameters( "ECDSA", curve.DecodePoint(Hex.Decode("0262b12d60690cdcf330babab6e69763b471f994dd702d16a5")), // Q parameters); ecdsa.Init(false, pubKey); if (!ecdsa.VerifySignature(message, sig[0], sig[1])) { Fail("verification fails"); } }
public static bool VerifySignature(byte[] data, byte[] signature, ECKeyPair publicKey) { var signer = new ECDsaSigner(); var params1 = new ECPublicKeyParameters(publicKey.PublicKeyParameters.Q, DomainParams); signer.Init(false, params1); return(signer.VerifySignature(data, new BigInteger(1, signature.Take(32).ToArray()), new BigInteger(1, signature.Skip(32).ToArray()))); }
public bool VerifySignature(byte[] hash, byte[] signature) { ECDsaSigner signer = new ECDsaSigner(); ECDSASignature parsedSignature = ECDSASignature.FromDER(signature); signer.Init(false, key); return(signer.VerifySignature(hash, parsedSignature.R, parsedSignature.S)); }
/// <summary> /// Verifies the given ECDSA signature against the message bytes using the public key bytes. /// </summary> public static bool Verify(byte[] data, EcdsaSignature signature, byte[] pubkey) { var signer = new ECDsaSigner(); var q = X9EcParameters.Curve.DecodePoint(pubkey); var ecp = new ECPublicKeyParameters("EC", q, EcParams); signer.Init(false, ecp); return(signer.VerifySignature(data, signature.R, signature.S)); }
public bool VerifySignature(byte[] message, BigInteger r, BigInteger s) { if (_verifier == null) { throw new NotImplementedException(); } return(_verifier.VerifySignature(message, r, s)); }
public static bool VerifySignature(ECPublicKeyParameters keyParameters, BigInteger[] signature, byte[] msg) { IDsaKCalculator kCalculator = new HMacDsaKCalculator(new Sha256Digest()); var signer = new ECDsaSigner(kCalculator); signer.Init(false, keyParameters); return(signer.VerifySignature(msg, signature[0], signature[1])); }
public bool VerifySignature(byte[] publicKey, byte[] message, ECSignature signature) { var ecPoint = CurveParameters.Curve.DecodePoint(publicKey); var publicKeyParameters = new ECPublicKeyParameters("EC", ecPoint, DomainParameters); var ecdsaSigner = new ECDsaSigner(new HMacDsaKCalculator(DigestAlgorithm)); ecdsaSigner.Init(false, publicKeyParameters); return(ecdsaSigner.VerifySignature(message, signature.R, signature.S)); }
internal bool Verify(uint256 hash, ECDSASignature sig) { var signer = new ECDsaSigner(); signer.Init(false, GetPublicKeyParameters()); #pragma warning disable 618 return(signer.VerifySignature(hash.ToBytes(), sig.R, sig.S)); #pragma warning restore 618 }
public void InvalidData() { var message = Encoders.ASCII.GetBytes("hola"); var isValid = ECDsaSigner.VerifySignature(message, 0, 0, ECPoint.Infinity); Assert.IsFalse(isValid); isValid = ECDsaSigner.VerifySignature(message, Secp256k1.N + 1, Secp256k1.N + 1, ECPoint.Infinity); Assert.IsFalse(isValid); }
/// <summary> /// Verifies a hash was signed correctly given the r and s signature components. /// </summary> /// <param name="hash">The hash which was signed.</param> /// <param name="r">The ECDSA signature component r.</param> /// <param name="s">The ECDSA signature component s.</param> /// <returns>Returns a boolean indicating whether the data was properly signed.</returns> public override bool VerifyData(Span <byte> hash, BigInteger r, BigInteger s) { // Initialize a bouncy castle ECDSA signer. ECDsaSigner provider = new ECDsaSigner(); provider.Init(false, PublicKey); // Verify our R and S signature components given the hash we signed. return(provider.VerifySignature(hash.ToArray(), r.ToBouncyCastleBigInteger(), s.ToBouncyCastleBigInteger())); }
public static void SignatureVerify(List <Dictionary <string, object> > signatures) { foreach (var s in signatures) { var verifier = new ECDsaSigner(); verifier.Init(false, (ECPublicKeyParameters)s["publicKey"]); var signature = (BigInteger[])s["signature"]; Debug.Assert(verifier.VerifySignature((byte[])s["messageHash"], signature[0], signature[1])); } }
public static Boolean VerifySignature(byte[] message, BigInteger messageHash, BigInteger messageSignature, byte[] publicKey) { ECPublicKeyParameters publicKeyParameters = new ECPublicKeyParameters(domain.Curve.DecodePoint(publicKey), domain); ECDsaSigner ecdsa = new ECDsaSigner(); ecdsa.Init(false, publicKeyParameters); return(ecdsa.VerifySignature(message, messageHash, messageSignature)); }
public override bool VerifyData(ProtocolVersion version, byte[] data, HashAlgorithm hashAlgorithm, CertificatePublicKey publicKey, byte[] signature) { if (!CertificateKeyAlgorithm.Equals(publicKey.Oid)) { throw new Exception("ECDSA signature verification requires ECDSA public key"); } // Decode the public key parameters string curveOid = DER2OID(publicKey.Parameters); if (curveOid == null) { throw new Exception("Unsupported ECDSA public key parameters"); } // Get parameters from the curve OID X9ECParameters ecParams = SecNamedCurves.GetByOid(new DerObjectIdentifier(curveOid)); if (ecParams == null) { throw new Exception("Unsupported ECC curve type OID: " + curveOid); } // Construct domain parameters ECDomainParameters domainParameters = new ECDomainParameters(ecParams.Curve, ecParams.G, ecParams.N, ecParams.H, ecParams.GetSeed()); // Decode the public key data byte[] ecPointData = publicKey.KeyValue; if (ecPointData[0] != 0x04) { throw new Exception("Only uncompressed ECDSA keys supported, format: " + ecPointData[0]); } ECPoint ecPoint = domainParameters.Curve.DecodePoint(ecPointData); ECPublicKeyParameters theirPublicKey = new ECPublicKeyParameters(ecPoint, domainParameters); // Hash input data buffer byte[] dataHash; if (hashAlgorithm == null) { dataHash = TLSv1HashData(data); } else { dataHash = hashAlgorithm.ComputeHash(data); } // Actually verify the signature BigInteger[] sig = DERDecodeSignature(signature); ECDsaSigner signer = new ECDsaSigner(); signer.Init(false, theirPublicKey); return(signer.VerifySignature(dataHash, sig[0], sig[1])); }
public static bool VerifySignature( byte[] hash, ECDSASignature signature, ECPublicKeyParameters parameters) { IDsaKCalculator kCalculator = new HMacDsaKCalculator(new Sha256Digest()); var signer = new ECDsaSigner(kCalculator); signer.Init(false, parameters); return(signer.VerifySignature(hash, signature.R, signature.S)); }
public virtual bool VerifyECSignature(ECPublicKey publicKey, ECSignature signature, byte[] data) { var curve = ECNamedCurveTable.GetByName(CURVEALGO); var domainParams = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H, curve.GetSeed()); ECDsaSigner verifier = new ECDsaSigner(); verifier.Init(false, new ECPublicKeyParameters(domainParams.Curve.DecodePoint(publicKey.Base64Array), domainParams)); return(verifier.VerifySignature(data, signature.GetR(), signature.GetS())); }
public Boolean verifySignature(Byte[] data, Byte[] sig) { ECDsaSigner signer = new ECDsaSigner(); signer.Init(false, new ECPublicKeyParameters(ecParams.Curve.DecodePoint(pubKey), ecParams)); using (Asn1InputStream asn1stream = new Asn1InputStream(sig)) { Asn1Sequence seq = (Asn1Sequence)asn1stream.ReadObject(); return(signer.VerifySignature(data, ((DerInteger)seq[0]).PositiveValue, ((DerInteger)seq[1]).PositiveValue)); } }