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));
}
}