//public static string SignData(string msg, AsymmetricKeyParameter privKey) //public static byte[][] SignTransaction(byte[] data, byte[] privateKey) //{ // try // { // //byte[] msgBytes = Encoding.UTF8.GetBytes(msg); // //ISigner signer = SignerUtilities.GetSigner("SHA384withECDSA"); // //signer.Init(true, privKey); // //signer.BlockUpdate(msgBytes, 0, msgBytes.Length); // //byte[] sigBytes = signer.GenerateSignature(); // //return Convert.ToBase64String(sigBytes); // X9ECParameters spec = ECNamedCurveTable.GetByName("secp256k1"); // ECDsaSigner ecdsaSigner = new ECDsaSigner(); // ECDomainParameters domain = new ECDomainParameters(spec.Curve, spec.G, spec.N); // ECPrivateKeyParameters privateKeyParms = // new ECPrivateKeyParameters(new BigInteger(1, privateKey), domain); // ParametersWithRandom paramxs = new ParametersWithRandom(privateKeyParms); // ecdsaSigner.Init(true, paramxs); // BigInteger[] sig = ecdsaSigner.GenerateSignature(data); // LinkedList<byte[]> sigData = new LinkedList<byte[]>(); // byte[] publicKey = GetPublicKey(privateKey); // byte recoveryId = GetRecoveryId(sig[0].ToByteArray(), sig[1].ToByteArray(), data, publicKey); // foreach (var sigChunk in sig) // { // sigData.AddLast(sigChunk.ToByteArray()); // } // sigData.AddLast(new byte[] {recoveryId}); // return sigData.ToArray(); // } // catch (Exception exc) // { // Console.WriteLine("Signing Failed: " + exc); // return null; // } //} public static (byte[] r, byte[] s, byte[] v) SignTransaction(byte[] data, byte[] privateKey) { try { X9ECParameters spec = ECNamedCurveTable.GetByName("secp256k1"); ECDsaSigner ecdsaSigner = new ECDsaSigner(); ECDomainParameters domain = new ECDomainParameters(spec.Curve, spec.G, spec.N); ECPrivateKeyParameters privateKeyParms = new ECPrivateKeyParameters(new BigInteger(1, privateKey), domain); ParametersWithRandom paramxs = new ParametersWithRandom(privateKeyParms); ecdsaSigner.Init(true, paramxs); BigInteger[] sig = ecdsaSigner.GenerateSignature(data); LinkedList <byte[]> sigData = new LinkedList <byte[]>(); byte[] publicKey = GetPublicKey(privateKey); byte recoveryId = GetRecoveryId(sig[0].ToByteArray(), sig[1].ToByteArray(), data, publicKey); foreach (var sigChunk in sig) { sigData.AddLast(sigChunk.ToByteArray()); } sigData.AddLast(new byte[] { recoveryId }); return(sigData.ElementAt(0), sigData.ElementAt(1), sigData.ElementAt(2)); } catch (Exception exc) { Console.WriteLine("Signing Failed: " + exc); return(null, null, null); } }
static internal ECDomainParameters DecodeCurveParameters(AlgorithmIdentifier algId) { if (!algId.Algorithm.Equals(X9ObjectIdentifiers.IdECPublicKey)) { throw new ArgumentException("Unknown algorithm type: " + algId.Algorithm); } X962Parameters parameters = X962Parameters.GetInstance(algId.Parameters); X9ECParameters x9; if (parameters.IsNamedCurve) { DerObjectIdentifier oid = (DerObjectIdentifier)parameters.Parameters; x9 = CustomNamedCurves.GetByOid(oid); if (x9 == null) { x9 = ECNamedCurveTable.GetByOid(oid); } return(new NamedECDomainParameters(oid, x9.Curve, x9.G, x9.N, x9.H, x9.GetSeed())); } else if (!parameters.IsImplicitlyCA) { x9 = X9ECParameters.GetInstance(parameters.Parameters); return(new ECDomainParameters(x9.Curve, x9.G, x9.N, x9.H, x9.GetSeed())); } else { return(null); //return new ECImplicitDomainParameters(CryptoServicesRegistrar.<ECDomainParameters>getProperty(CryptoServicesRegistrar.Property.EC_IMPLICITLY_CA)); } }
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); } }
static AsymmetricCipherKeyPair GenerateKeyPair() { Console.WriteLine("Generating signature keys..."); var curve = ECNamedCurveTable.GetByName("secp256k1"); var domainParams = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H, curve.GetSeed()); var secureRandom = new SecureRandom(); var keyParams = new ECKeyGenerationParameters(domainParams, secureRandom); var generator = new ECKeyPairGenerator("ECDSA"); generator.Init(keyParams); var keyPair = generator.GenerateKeyPair(); var privateKey = keyPair.Private as ECPrivateKeyParameters; var publicKey = keyPair.Public as ECPublicKeyParameters; var strPrivKey = ToHex(privateKey.D.ToByteArrayUnsigned()); var strPubKey = ToHex(publicKey.Q.GetEncoded()); Console.WriteLine($"{strPrivKey.Length} bytes Private key: {strPrivKey}"); Console.WriteLine($"{strPubKey.Length} bytes Public key: {strPubKey}"); Console.WriteLine("Done generating signature keys!"); return(keyPair); }
public static ICipherParameters ConvertPubkeyBytesToCipherParams(byte[] pubKeyBytes) { X9ECParameters ecCurve = ECNamedCurveTable.GetByOid(ECCurveAlgo); ECPoint point = ecCurve.Curve.DecodePoint(pubKeyBytes); return(new ECPublicKeyParameters(KeyExchangeAlgorithm, point, ECCurveAlgo)); }
public static PemKeyPair GenerateKeyPair() { String privateKey = String.Empty; String publicKey = String.Empty; X9ECParameters ecParameters = ECNamedCurveTable.GetByName("secp256k1"); ECKeyPairGenerator keyGenerator = new ECKeyPairGenerator(); keyGenerator.Init(new ECKeyGenerationParameters(new ECDomainParameters(ecParameters.Curve, ecParameters.G, ecParameters.N, ecParameters.H), new SecureRandom())); AsymmetricCipherKeyPair keyPair = keyGenerator.GenerateKeyPair(); using (TextWriter writer = new StringWriter()) { PemWriter pemWriter = new PemWriter(writer); pemWriter.WriteObject(keyPair.Private); pemWriter.Writer.Flush(); privateKey = writer.ToString(); } using (TextWriter writer = new StringWriter()) { PemWriter pemWriter = new PemWriter(writer); pemWriter.WriteObject(keyPair.Public); pemWriter.Writer.Flush(); publicKey = writer.ToString(); } return(new PemKeyPair(publicKey, privateKey)); }
private void DoSignerTest(string curveName, IDigest d, string ident, string msg, string x, string nonce, string r, string s) { X9ECParameters x9 = ECNamedCurveTable.GetByName(curveName); ECDomainParameters domainParams = new ECDomainParameters(x9.Curve, x9.G, x9.N, x9.H, x9.GetSeed()); DoSignerTest(domainParams, d, ident, msg, x, nonce, r, s); }
public void TestMultiply() { ArrayList nameList = new ArrayList(); CollectionUtilities.AddRange(nameList, ECNamedCurveTable.Names); CollectionUtilities.AddRange(nameList, CustomNamedCurves.Names); string[] names = (string[])nameList.ToArray(typeof(string)); Array.Sort(names); ISet oids = new HashSet(); foreach (string name in names) { DerObjectIdentifier oid = ECNamedCurveTable.GetOid(name); if (oid == null) { oid = CustomNamedCurves.GetOid(name); } if (oid != null) { if (oids.Contains(oid)) { continue; } oids.Add(oid); } RandMult(name); } }
public List <ECPublicKeyParameters> GetCertificates(string country, byte[] kid) { List <ECPublicKeyParameters> publicKeys = new List <ECPublicKeyParameters>(); foreach (Key key in Jwks.Keys) { string kidStr = Convert.ToBase64String(kid) .Replace('+', '-') .Replace('/', '_') .Replace("=", "");; if (kid == null || key.Kid == null || key.Kid.Equals(kidStr)) { X9ECParameters x9 = ECNamedCurveTable.GetByName(key.Crv); ECPoint point = x9.Curve.CreatePoint(Base64UrlDecodeToBigInt(key.X), Base64UrlDecodeToBigInt(key.Y)); ECDomainParameters dParams = new ECDomainParameters(x9); ECPublicKeyParameters pubKey = new ECPublicKeyParameters(point, dParams); publicKeys.Add(pubKey); } } ECPublicKeyParameters bpubKey = (ECPublicKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey)); publicKeys.Add(bpubKey); return(publicKeys); }
public static ECDomainParameters GetParametersForNamedCurve(int namedCurve) { string curveName = GetNameOfNamedCurve(namedCurve); if (curveName == null) { return(null); } // Parameters are lazily created the first time a particular curve is accessed X9ECParameters ecP = CustomNamedCurves.GetByName(curveName); if (ecP == null) { ecP = ECNamedCurveTable.GetByName(curveName); if (ecP == null) { return(null); } } // It's a bit inefficient to do this conversion every time return(new ECDomainParameters(ecP.Curve, ecP.G, ecP.N, ecP.H, ecP.GetSeed())); }
/// <summary> /// Get curve parameters /// </summary> /// <param name="type"></param> /// <returns></returns> internal static X9ECParameters ToX9ECParameters(this CurveType type) { switch (type) { case CurveType.P256: return(ECNamedCurveTable.GetByName("P-256")); case CurveType.P384: return(ECNamedCurveTable.GetByName("P-384")); case CurveType.P521: return(ECNamedCurveTable.GetByName("P-521")); case CurveType.P256K: return(ECNamedCurveTable.GetByName("K-283")); case CurveType.Brainpool_P160r1: return(ECNamedCurveTable.GetByName("brainpoolP160r1")); case CurveType.Brainpool_P160t1: return(ECNamedCurveTable.GetByName("brainpoolP160t1")); case CurveType.Brainpool_P192r1: return(ECNamedCurveTable.GetByName("brainpoolP192r1")); case CurveType.Brainpool_P192t1: return(ECNamedCurveTable.GetByName("brainpoolP192t1")); case CurveType.Brainpool_P224r1: return(ECNamedCurveTable.GetByName("brainpoolP224r1")); case CurveType.Brainpool_P224t1: return(ECNamedCurveTable.GetByName("brainpoolP224t1")); case CurveType.Brainpool_P256r1: return(ECNamedCurveTable.GetByName("brainpoolP256r1")); case CurveType.Brainpool_P256t1: return(ECNamedCurveTable.GetByName("brainpoolP256t1")); case CurveType.Brainpool_P320r1: return(ECNamedCurveTable.GetByName("brainpoolP320r1")); case CurveType.Brainpool_P320t1: return(ECNamedCurveTable.GetByName("brainpoolP320t1")); case CurveType.Brainpool_P384r1: return(ECNamedCurveTable.GetByName("brainpoolP384r1")); case CurveType.Brainpool_P384t1: return(ECNamedCurveTable.GetByName("brainpoolP384t1")); case CurveType.Brainpool_P512r1: return(ECNamedCurveTable.GetByName("brainpoolP512r1")); case CurveType.Brainpool_P512t1: return(ECNamedCurveTable.GetByName("brainpoolP512t1")); } throw new ArgumentException($"Unknown curve {type}"); }
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); X9ECParameters x9 = ECNamedCurveTable.GetByName("c2tnb239v1"); ECCurve curve = x9.Curve; ECDomainParameters parameters = new ECDomainParameters(curve, x9.G, x9.N, x9.H); ECPrivateKeyParameters sKey = new ECPrivateKeyParameters( "ECDSA", new BigInteger("145642755521911534651321230007534120304391871461646461466464667494947990"), // d parameters); ECPublicKeyParameters vKey = new ECPublicKeyParameters( "ECDSA", curve.DecodePoint(Hex.Decode("045894609CCECF9A92533F630DE713A958E96C97CCB8F5ABB5A688A238DEED6DC2D9D0C94EBFB7D526BA6A61764175B99CB6011E2047F9F067293F57F5")), // Q parameters); ISigner sgr = SignerUtilities.GetSigner("ECDSA"); byte[] message = Encoding.ASCII.GetBytes("abc"); sgr.Init(true, new ParametersWithRandom(sKey, k)); sgr.BlockUpdate(message, 0, message.Length); byte[] sigBytes = sgr.GenerateSignature(); sgr.Init(false, vKey); sgr.BlockUpdate(message, 0, message.Length); if (!sgr.VerifySignature(sigBytes)) { Fail("239 Bit EC verification failed"); } BigInteger[] sig = DerDecode(sigBytes); 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]); } }
private static AsymmetricCipherKeyPair GenerateEcKeyPair() { var curveNames = ECNamedCurveTable.Names; var ecCurveSpec = ECNamedCurveTable.GetByName("secp256r1"); var keyGen = new ECKeyPairGenerator(); keyGen.Init(new ECKeyGenerationParameters(new ECDomainParameters(ecCurveSpec.Curve, ecCurveSpec.G, ecCurveSpec.N, ecCurveSpec.H, ecCurveSpec.GetSeed()), new SecureRandom())); return(keyGen.GenerateKeyPair()); }
/// <summary> /// create a private key from private key bytes /// </summary> /// <param name="privateKeyBytes">private key bytes</param> public PrivateKey(byte[] privateKeyBytes) { BigInteger d = new BigInteger(1, privateKeyBytes); var curve = ECNamedCurveTable.GetByName("secp256k1"); var domainParams = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H, curve.GetSeed()); this.privateKey = new ECPrivateKeyParameters("ECDSA", d, domainParams); //new ECPrivateKeyParameters(privateKey.get privateKey.getRaw(), SecP256K1Curve.secp256k1().getParams()) }
/// <summary> /// create public key from key bytes /// </summary> /// <param name="publicKeyBytes">the public key bytes</param> public PublicKey(byte[] publicKeyBytes) { X9ECParameters curveParams = ECNamedCurveTable.GetByName("secp256k1"); ECCurve curve = curveParams.Curve; ECPoint decodePoint = curve.DecodePoint(publicKeyBytes); ECDomainParameters domainParams = new ECDomainParameters(curve, curveParams.G, curveParams.N, curveParams.H); this.publicKey = new ECPublicKeyParameters(decodePoint, domainParams); }
public static Bytes GetPublicKey(Bytes privateKey) { var pkBytes = privateKey.ToByteArray(); var spec = ECNamedCurveTable.GetByName("secp256k1"); var pointQ = spec.G.Multiply(new BigInteger(1, pkBytes)); var publicKeyBytes = pointQ.GetEncoded(false); return(new Bytes(Arrays.CopyOfRange(publicKeyBytes, 1, publicKeyBytes.Length))); }
public virtual ECPoint GetECPoint(ECPublicKey publicKey) { var pubKey = publicKey.Base64Array; int domainSize = pubKey[0] == 4 ? ((pubKey.Length / 2) - 1) * 8 : (pubKey.Length - 1) * 8; var curve = ECNamedCurveTable.GetByName(CURVEALGO); var domainParams = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H, curve.GetSeed()); return(domainParams.Curve.DecodePoint(pubKey)); }
internal static X9ECParameters FindECCurveByOid(DerObjectIdentifier oid) { X9ECParameters byOid = CustomNamedCurves.GetByOid(oid); if (byOid == null) { byOid = ECNamedCurveTable.GetByOid(oid); } return(byOid); }
public static byte GetRecoveryId(byte[] sigR, byte[] sigS, byte[] message, byte[] publicKey) { //ECNamedCurveParameterSpec spec = ECNamedCurveTable.getParameterSpec("secp256k1"); X9ECParameters spec = ECNamedCurveTable.GetByName("secp256k1"); BigInteger pointN = spec.N; for (int recoveryId = 0; recoveryId < 2; recoveryId++) { try { BigInteger pointX = new BigInteger(1, sigR); byte[] compEnc = X9IntegerConverter.IntegerToBytes(pointX, 1 + X9IntegerConverter.GetByteLength(spec.Curve)); compEnc[0] = (byte)((recoveryId & 1) == 1 ? 0x03 : 0x02); ECPoint pointR = spec.Curve.DecodePoint(compEnc); if (!pointR.Multiply(pointN).IsInfinity) { continue; } BigInteger pointE = new BigInteger(1, message); BigInteger pointEInv = BigInteger.Zero.Subtract(pointE).Mod(pointN); BigInteger pointRInv = new BigInteger(1, sigR).ModInverse(pointN); BigInteger srInv = pointRInv.Multiply(new BigInteger(1, sigS)).Mod(pointN); BigInteger pointEInvRInv = pointRInv.Multiply(pointEInv).Mod(pointN); ECPoint pointQ = ECAlgorithms.SumOfTwoMultiplies(spec.G, pointEInvRInv, pointR, srInv); byte[] pointQBytes = pointQ.GetEncoded(false); bool matchedKeys = true; for (int j = 0; j < publicKey.Length; j++) { if (pointQBytes[j] != publicKey[j]) { matchedKeys = false; break; } } if (!matchedKeys) { continue; } return((byte)(0xFF & recoveryId)); } catch (Exception e) { continue; Console.WriteLine(" Failed: GET recoveryID"); } } return((byte)0xFF); }
public static AsymmetricCipherKeyPair GenerateECKeyPair() { var curve = ECNamedCurveTable.GetByName("secp256k1"); var domainParams = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H, curve.GetSeed()); var sr = new SecureRandom(); var keyParams = new ECKeyGenerationParameters(domainParams, sr); var generator = new ECKeyPairGenerator("ECDSA"); generator.Init(keyParams); return(generator.GenerateKeyPair()); }
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 static AsymmetricCipherKeyPair CreateECKeyPair(byte[] privKey) { var curve = ECNamedCurveTable.GetByName("secp256k1"); var domainParams = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H, curve.GetSeed()); var d = new BigInteger(1, privKey); var ecPrivKey = new ECPrivateKeyParameters(d, domainParams); var q = domainParams.G.Multiply(d); var ecPubKey = new ECPublicKeyParameters(q, domainParams); return(new AsymmetricCipherKeyPair(ecPubKey, ecPrivKey)); }
// private static readonly Hashtable CurveNames = new Hashtable(); // private static readonly Hashtable CurveAliases = new Hashtable(); // // static NamedCurveTest() // { // CurveNames.Add("prime192v1", "prime192v1"); // X9.62 // CurveNames.Add("sect571r1", "sect571r1"); // sec // CurveNames.Add("secp224r1", "secp224r1"); // CurveNames.Add("B-409", SecNamedCurves.GetName(NistNamedCurves.GetOid("B-409"))); // nist // CurveNames.Add("P-521", SecNamedCurves.GetName(NistNamedCurves.GetOid("P-521"))); // CurveNames.Add("brainpoolp160r1", "brainpoolp160r1"); // TeleTrusT // // CurveAliases.Add("secp192r1", "prime192v1"); // CurveAliases.Add("secp256r1", "prime256v1"); // } private static ECDomainParameters GetCurveParameters( string name) { X9ECParameters ecP = ECNamedCurveTable.GetByName(name); if (ecP == null) { throw new Exception("unknown curve name: " + name); } return(new ECDomainParameters(ecP.Curve, ecP.G, ecP.N, ecP.H, ecP.GetSeed())); }
protected override AsymmetricCipherKeyPair GenerateNewECDHKey() { X9ECParameters x9EC = ECNamedCurveTable.GetByOid(TeleTrusTObjectIdentifiers.BrainpoolP256R1); ECDomainParameters ecDomain = new ECDomainParameters(x9EC.Curve, x9EC.G, x9EC.N, x9EC.H, x9EC.GetSeed()); return(new AsymmetricCipherKeyPair( new ECPublicKeyParameters(x9EC.Curve.CreatePoint( new BigInteger(1, HexStringToByteArray(EphemeralPublicKeyX)), new BigInteger(1, HexStringToByteArray(EphemeralPublicKeyY)) ), ecDomain), new ECPrivateKeyParameters(new BigInteger(1, HexStringToByteArray(EccPrivateKey)), ecDomain))); }
internal static X9ECParameters FindECCurveByOid(DerObjectIdentifier oid) { // TODO ECGost3410NamedCurves support (returns ECDomainParameters though) X9ECParameters ecP = CustomNamedCurves.GetByOid(oid); if (ecP == null) { ecP = ECNamedCurveTable.GetByOid(oid); } return(ecP); }
/// Canonicalizes [signature]. /// This is necessary because if a message can be signed by (r, s), it can also be signed by (r, -s (mod N)). /// More details at /// https://github.com/web3j/web3j/blob/master/crypto/src/main/java/org/web3j/crypto/ECDSASignature.java#L27 static ECSignature _toCanonicalised(ECSignature signature) { X9ECParameters _params = ECNamedCurveTable.GetByName("secp256k1"); BigInteger _halfCurveOrder = _params.N.ShiftRight(1); if (signature.s.CompareTo(_halfCurveOrder) > 0) { BigInteger canonicalisedS = _params.N.Subtract(signature.s); signature = new ECSignature(signature.r, canonicalisedS); } return(signature); }
public override void PerformTest() { IAsymmetricCipherKeyPairGenerator g = GeneratorUtilities.GetKeyPairGenerator("ECIES"); X9ECParameters x9 = ECNamedCurveTable.GetByName("prime239v1"); ECDomainParameters ecSpec = new ECDomainParameters(x9.Curve, x9.G, x9.N, x9.H); g.Init( new ECKeyGenerationParameters( ecSpec, new SecureRandom())); IBufferedCipher c1 = CipherUtilities.GetCipher("ECIES"); IBufferedCipher c2 = CipherUtilities.GetCipher("ECIES"); doTest(g, c1, c2); g = GeneratorUtilities.GetKeyPairGenerator("ECIES"); g.Init(new KeyGenerationParameters(new SecureRandom(), 192)); doTest(g, c1, c2); g = GeneratorUtilities.GetKeyPairGenerator("ECIES"); g.Init(new KeyGenerationParameters(new SecureRandom(), 239)); doTest(g, c1, c2); g = GeneratorUtilities.GetKeyPairGenerator("ECIES"); g.Init(new KeyGenerationParameters(new SecureRandom(), 256)); doTest(g, c1, c2); doDefTest(g, c1, c2); c1 = CipherUtilities.GetCipher("IES"); c2 = CipherUtilities.GetCipher("IES"); g = GeneratorUtilities.GetKeyPairGenerator("DH"); // DHParameterSpec dhParams = new DHParameterSpec(p512, g512); // g.initialize(dhParams); g.Init( new DHKeyGenerationParameters( new SecureRandom(), new DHParameters(p512, g512))); doTest(g, c1, c2); doDefTest(g, c1, c2); }
public EMHCrypt01(GetMeterDelegate GetMeter, CheckMeterPublicKeySignatureDelegate CheckMeterPublicKeySignature) : base("ECC secp192r1", GetMeter, CheckMeterPublicKeySignature) { this.CurveName = "P-192"; this.ECP = ECNamedCurveTable.GetByName(CurveName); this.ECSpec = new ECDomainParameters(ECP.Curve, ECP.G, ECP.N, ECP.H, ECP.GetSeed()); this.C = (FpCurve)ECSpec.Curve; }
public virtual ECKeyPair GetKeyPair(ECPrivateKey privatekey, bool compressed = true) { var curve = ECNamedCurveTable.GetByName(CURVEALGO); var domainParams = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H, curve.GetSeed()); BigInteger d = new BigInteger(1, privatekey.Base64Array); ECPoint q = domainParams.G.Multiply(d); var publicParams = new ECPublicKeyParameters(q, domainParams); var pubkey = new ECPublicKey(publicParams.Q.GetEncoded(compressed)); return(new ECKeyPair(privatekey, pubkey)); }
public void PointIsValid_PointIsNotOnCurve_ReturnsFalse() { // Arrange var x9 = ECNamedCurveTable.GetByName("prime239v1"); var curve = x9.Curve; var point = Fp.p[0]; // Act var actual = ECPointVerifier.PointIsValid(point, curve); // Assert Assert.False(actual); }