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