} // End Function VerifySignature
// https://stackoverflow.com/questions/18244630/elliptic-curve-with-digital-signature-algorithm-ecdsa-implementation-on-bouncy
public static Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair GenerateEcdsaKeyPair()
{
Org.BouncyCastle.Crypto.Generators.ECKeyPairGenerator gen =
new Org.BouncyCastle.Crypto.Generators.ECKeyPairGenerator();
Org.BouncyCastle.Security.SecureRandom secureRandom =
new Org.BouncyCastle.Security.SecureRandom();
// https://github.com/bcgit/bc-csharp/blob/master/crypto/src/asn1/sec/SECNamedCurves.cs#LC1096
Org.BouncyCastle.Asn1.X9.X9ECParameters ps =
Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
Org.BouncyCastle.Crypto.Parameters.ECDomainParameters ecParams =
new Org.BouncyCastle.Crypto.Parameters.ECDomainParameters(ps.Curve, ps.G, ps.N, ps.H);
Org.BouncyCastle.Crypto.Parameters.ECKeyGenerationParameters keyGenParam =
new Org.BouncyCastle.Crypto.Parameters.ECKeyGenerationParameters(ecParams, secureRandom);
gen.Init(keyGenParam);
Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair kp = gen.GenerateKeyPair();
// Org.BouncyCastle.Crypto.Parameters.ECPrivateKeyParameters priv =
// (Org.BouncyCastle.Crypto.Parameters.ECPrivateKeyParameters)kp.Private;
return(kp);
} // End Function GenerateEcdsaKeyPair
/// <summary>
/// Calculates an ECDSA signature in DER format for the given input hash. Note that the input is expected to be
/// 32 bytes long.
/// </summary>
public byte[] Sign(byte[] input, Org.BouncyCastle.Math.BigInteger privateKey)
{
const string BITCOIN_CURVE = "secp256k1";
ECDsaSigner signer = new ECDsaSigner();
Org.BouncyCastle.Asn1.X9.X9ECParameters ecp = SecNamedCurves.GetByName(BITCOIN_CURVE);
ECDomainParameters EcParameters = new ECDomainParameters(ecp.Curve, ecp.G, ecp.N, ecp.H);
var privateKeyParameters = new ECPrivateKeyParameters(privateKey, EcParameters);
signer.Init(true, privateKeyParameters);
var signatures = signer.GenerateSignature(input);
// What we get back from the signer are the two components of a signature, r and s. To get a flat byte stream
// of the type used by BitCoin we have to encode them using DER encoding, which is just a way to pack the two
// components into a structure.
using (var byteOutputStream = new MemoryStream())
{
var derSequenceGenerator = new DerSequenceGenerator(byteOutputStream);
derSequenceGenerator.AddObject(new DerInteger(signatures[0]));
derSequenceGenerator.AddObject(new DerInteger(signatures[1]));
derSequenceGenerator.Close();
return(byteOutputStream.ToArray());
}
}
private static byte[] ExportCertificate(X509Certificate certificate, AsymmetricCipherKeyPair subjectKeyPair, TCertificateFormat certificateFormat)
{
byte[] result = null;
switch (certificateFormat)
{
case TCertificateFormat.NotSet:
break;
case TCertificateFormat.PEM:
using (MemoryStream stream = new MemoryStream())
{
using (StreamWriter writer = new StreamWriter(stream))
{
Org.BouncyCastle.Utilities.IO.Pem.PemWriter pemWriter = new Org.BouncyCastle.Utilities.IO.Pem.PemWriter(writer);
if (subjectKeyPair.Private is ECKeyParameters)
{
ECPrivateKeyParameters priv = (ECPrivateKeyParameters)subjectKeyPair.Private;
ECDomainParameters dp = priv.Parameters;
int orderBitLength = dp.N.BitLength;
Org.BouncyCastle.Asn1.Sec.ECPrivateKeyStructure ec;
Org.BouncyCastle.Asn1.X9.X962Parameters x962;
if (priv.PublicKeyParamSet == null)
{
Org.BouncyCastle.Asn1.X9.X9ECParameters ecP = new Org.BouncyCastle.Asn1.X9.X9ECParameters(dp.Curve, dp.G, dp.N, dp.H, dp.GetSeed());
x962 = new Org.BouncyCastle.Asn1.X9.X962Parameters(ecP);
}
else
{
x962 = new Org.BouncyCastle.Asn1.X9.X962Parameters(priv.PublicKeyParamSet);
}
ec = new Org.BouncyCastle.Asn1.Sec.ECPrivateKeyStructure(orderBitLength, priv.D, SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(subjectKeyPair.Public).PublicKeyData, x962);
pemWriter.WriteObject(new Org.BouncyCastle.Utilities.IO.Pem.PemObject("EC PRIVATE KEY", ec.GetEncoded()));
}
else
{
pemWriter.WriteObject(new Org.BouncyCastle.OpenSsl.MiscPemGenerator(subjectKeyPair.Private));
}
pemWriter.WriteObject(new Org.BouncyCastle.OpenSsl.MiscPemGenerator(subjectKeyPair.Public));
pemWriter.WriteObject(new Org.BouncyCastle.OpenSsl.MiscPemGenerator(certificate));
writer.Flush();
result = stream.ToArray();
}
}
break;
case TCertificateFormat.PFX:
//Asn1Sequence asn1Sequence = Asn1Sequence.GetInstance(Asn1Object.FromByteArray(certificate.GetEncoded()));
//asn1Sequence.GetObjects
//Org.BouncyCastle.Asn1.Pkcs.Pfx pfx = new Org.BouncyCastle.Asn1.Pkcs.Pfx();
//Org.BouncyCastle.Asn1.Pkcs.PrivateKeyInfo info = Org.BouncyCastle.Pkcs.PrivateKeyInfoFactory.CreatePrivateKeyInfo(subjectKeyPair.Private);
//result = pfx.GetEncoded(Asn1Encodable.Der);
break;
case TCertificateFormat.CER:
result = certificate.GetEncoded();
break;
default:
break;
}
return result;
}
public static ECDomainParameters GetDomainParams()
{
//CREATE BTC ECURVE
//http://stackoverflow.com/questions/19665491/how-do-i-get-an-ecdsa-public-key-from-just-a-bitcoin-signature-sec1-4-1-6-k
Org.BouncyCastle.Asn1.X9.X9ECParameters ecp = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName(CURVE_NAME);
ECDomainParameters ecDomainParams = new ECDomainParameters(ecp.Curve, ecp.G, ecp.N, ecp.H);
return(ecDomainParams);
}
public static ECPrivateKeyParameters ConvertPrivateToParameters(string privateKey)
{
BigInteger biPrivateKey = new BigInteger(1, ValidateAndGetHexPrivateKey(privateKey).Skip(1).ToArray());
Org.BouncyCastle.Asn1.X9.X9ECParameters ecP = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
ECDomainParameters ecSpec = new ECDomainParameters(ecP.Curve, ecP.G, ecP.N, ecP.H, ecP.GetSeed());
return(new ECPrivateKeyParameters(biPrivateKey, ecSpec));
}
/// <summary>
/// Create the bitcoin ECSDA public key from private key
/// </summary>
/// <param name="d"></param>
/// <returns></returns>
public static Byte[] ConvertPrivateKeyToPublicKeyAsBytes(Org.BouncyCastle.Math.BigInteger d)
{
//Bitcoin public private key uses this named curve
Org.BouncyCastle.Asn1.X9.X9ECParameters ecp = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName(CURVENAME);
ECDomainParameters ecDomainParams = new ECDomainParameters(ecp.Curve, ecp.G, ecp.N, ecp.H);
ECPoint point = ecp.G.Multiply(d);
return(point.GetEncoded());
}
internal Secp256k1PublicKey(Org.BouncyCastle.Asn1.X9.X9ECParameters k1Params, Org.BouncyCastle.Math.EC.ECPoint publicKey)
{
this.publicKey = publicKey;
this.signer = new Org.BouncyCastle.Crypto.Signers.ECDsaSigner(
new Org.BouncyCastle.Crypto.Signers.HMacDsaKCalculator(
new Org.BouncyCastle.Crypto.Digests.Sha256Digest()));
var parameters = new Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters(
this.publicKey,
new Org.BouncyCastle.Crypto.Parameters.ECDomainParameters(k1Params.Curve, k1Params.G, k1Params.N, k1Params.H));
signer.Init(false, parameters);
}
/// <summary>
/// Generates a key pair
/// </summary>
void GenerateKeyPair()
{
ECKeyPairGenerator keyGen = new ECKeyPairGenerator("ECDSA");
SecureRandom secureRandom = SecureRandom.GetInstance("SHA1PRNG");
Org.BouncyCastle.Asn1.X9.X9ECParameters ecp = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp192k1");//("prime192v1");//("secp224k1");
ECDomainParameters ecSpec = new ECDomainParameters(ecp.Curve, ecp.G, ecp.N, ecp.H, ecp.GetSeed());
ECKeyGenerationParameters ecKeyGenParams = new ECKeyGenerationParameters(ecSpec, secureRandom);
keyGen.Init(ecKeyGenParams);
AsymmetricCipherKeyPair keyPair = keyGen.GenerateKeyPair();
PrivateKey = keyPair.Private as ECPrivateKeyParameters;
PublicKey = keyPair.Public as ECPublicKeyParameters;
}
public static ECPublicKeyParameters ConvertPublicToParameters(string publicKey)
{
Org.BouncyCastle.Asn1.X9.X9ECParameters ecP = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
ECDomainParameters ecSpec = new ECDomainParameters(ecP.Curve, ecP.G, ecP.N, ecP.H, ecP.GetSeed());
var pubBytes = ValidateAndGetHexPublicKey(publicKey).Skip(1).ToArray();
var c = (FpCurve)ecP.Curve;
ECFieldElement x = c.FromBigInteger(new BigInteger(1, pubBytes.Take(32).ToArray()));
ECFieldElement y = c.FromBigInteger(new BigInteger(1, pubBytes.Skip(32).ToArray()));
ECPoint dd = new FpPoint(c, x, y);
return(new ECPublicKeyParameters(dd, ecSpec));
}
//Implementation of https://blog.todotnet.com/2018/02/public-private-keys-and-signing/
public static string GetSignature(string privateKey, string message)
{
Org.BouncyCastle.Asn1.X9.X9ECParameters curve = SecNamedCurves.GetByName("secp256k1");
ECDomainParameters domain = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H);
ECPrivateKeyParameters keyParameters = new ECPrivateKeyParameters(new Org.BouncyCastle.Math.BigInteger(privateKey), domain);
ISigner signer = SignerUtilities.GetSigner("SHA-256withECDSA");
signer.Init(true, keyParameters);
signer.BlockUpdate(Encoding.ASCII.GetBytes(message), 0, message.Length);
byte[] signature = signer.GenerateSignature();
return(Base58Encoding.Encode(signature));
}
} // End Function GenerateEcKeyPair
public static Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair GenerateEcKeyPair(
string curveName
, Org.BouncyCastle.Security.SecureRandom secureRandom
)
{
Org.BouncyCastle.Asn1.X9.X9ECParameters ecParam = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName(curveName);
if (ecParam == null)
{
ecParam = Org.BouncyCastle.Crypto.EC.CustomNamedCurves.GetByName(curveName);
}
return(GenerateEcKeyPair(ecParam, secureRandom));
} // End Function GenerateEcKeyPair
// https://stackoverflow.com/questions/17439732/recreating-keys-ecpublickeyparameters-in-c-sharp-with-bouncycastle
// TODO: find curve name...
private static Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters CreateEcPublicKeyParameters(
Org.BouncyCastle.Math.BigInteger xx
, Org.BouncyCastle.Math.BigInteger yy)
{
// Org.BouncyCastle.Math.EC.ECPoint q = new Org.BouncyCastle.Math.EC.ECPoint(x, y);
// Org.BouncyCastle.Crypto.Tls.NamedCurve.secp224k1
// DefineCurveAlias("P-256", SecObjectIdentifiers.SecP256r1); // Alg 13
// DefineCurveAlias("P-384", SecObjectIdentifiers.SecP384r1); // Alg 14
// DefineCurveAlias("P-521", SecObjectIdentifiers.SecP521r1);
string curveName = "P-521";
Org.BouncyCastle.Asn1.X9.X9ECParameters ecP = Org.BouncyCastle.Asn1.Nist.NistNamedCurves.GetByName(curveName);
Org.BouncyCastle.Math.EC.FpCurve c = (Org.BouncyCastle.Math.EC.FpCurve)ecP.Curve;
Org.BouncyCastle.Math.EC.ECFieldElement x = c.FromBigInteger(xx);
Org.BouncyCastle.Math.EC.ECFieldElement y = c.FromBigInteger(yy);
Org.BouncyCastle.Math.EC.ECPoint q = new Org.BouncyCastle.Math.EC.FpPoint(c, x, y);
Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters publicParams = null;
// Org.BouncyCastle.Crypto.Parameters.ECKeyParameters publicParams = new Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters(q, domain);
// Org.BouncyCastle.Crypto.AsymmetricKeyParameter publicParams = new Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters(q, domain);
// Org.BouncyCastle.Crypto.ICipherParameters publicParams = new Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters(q, domain);
// Org.BouncyCastle.Crypto.Digests.GeneralDigest.
// Org.BouncyCastle.Crypto.Signers.GenericSigner
// Org.BouncyCastle.Crypto.Generators.ECKeyPairGenerator
// Org.BouncyCastle.Security.SignerUtilities.GetSigner("SHA-384withRSA");
// Org.BouncyCastle.Security.DigestUtilities.GetDigest("");
// Org.BouncyCastle.Security.CipherUtilities.GetCipher("");
// Org.BouncyCastle.Security.GeneratorUtilities.GetKeyGenerator("");
// Org.BouncyCastle.Security.WrapperUtilities.GetAlgorithmName
// Org.BouncyCastle.Security.MacUtilities.CalculateMac("", null, System.Text.Encoding.UTF8.GetBytes("HashThis"));
// Org.BouncyCastle.Security.ParameterUtilities.CreateKeyParameter("name", new byte[] { });
// Org.BouncyCastle.Security.ParameterUtilities.GenerateParameters("name", new Org.BouncyCastle.Security.SecureRandom());
// Org.BouncyCastle.Security.PublicKeyFactory.CreateKey()
// Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters oara = new Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters("ECDH", q, Org.BouncyCastle.Asn1.Sec.SecObjectIdentifiers.SecP521r1);
return(publicParams);
}
internal Secp256k1KeyPair(Org.BouncyCastle.Math.BigInteger privateKey)
{
this.privateKey = privateKey;
this.k1Params = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
this.publicKey = new Secp256k1PublicKey(k1Params, k1Params.G.Multiply(privateKey));
signer = new Org.BouncyCastle.Crypto.Signers.ECDsaSigner(
new Org.BouncyCastle.Crypto.Signers.HMacDsaKCalculator(
new Org.BouncyCastle.Crypto.Digests.Sha256Digest()));
var parameters = new Org.BouncyCastle.Crypto.Parameters.ECPrivateKeyParameters(
this.privateKey,
new Org.BouncyCastle.Crypto.Parameters.ECDomainParameters(k1Params.Curve, k1Params.G, k1Params.N, k1Params.H));
signer.Init(true, parameters);
}
/// <summary>
/// Generate a full 256bit secure random key
/// </summary>
public static KeyPair CreateKeys()
{
SecureRandom secRnd = new SecureRandom();
byte[] max = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B, 0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x40 };
Org.BouncyCastle.Asn1.X9.X9ECParameters ps = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
KeyPair kps = new KeyPair();
kps.bytePrivateKey = new byte[32];
kps.bytePublicAddress = new byte[65];
byte[] shaResult = ComputeSha256(DateTime.UtcNow.ToString() + DateTime.UtcNow.Ticks.ToString());
for (int j = 0; j < 32; j++)
{
kps.bytePrivateKey[j] = Convert.ToByte((secRnd.Next(1, secRnd.Next(2, int.MaxValue - 256)) + Convert.ToInt32(shaResult[j])) % max[j]);
}
Org.BouncyCastle.Math.BigInteger Db = new Org.BouncyCastle.Math.BigInteger(1, kps.bytePrivateKey);
ECPoint dd = ps.G.Multiply(Db);
byte[] Y = dd.Y.ToBigInteger().ToByteArray();
Array.Copy(Y, 0, kps.bytePublicAddress, 64 - Y.Length + 1, Y.Length);
byte[] X = dd.X.ToBigInteger().ToByteArray();
Array.Copy(X, 0, kps.bytePublicAddress, 32 - X.Length + 1, X.Length);
kps.bytePublicAddress[0] = 4;
byte[] rv = new byte[33];
Array.Copy(kps.bytePrivateKey, 0, rv, 1, 32);
rv[0] = 0x80;
kps.strPrivateKey = ByteArrayToBase58Check(rv);
byte[] shaofpubkey = ComputeSha256(kps.bytePublicAddress);
RIPEMD160 rip = System.Security.Cryptography.RIPEMD160.Create();
byte[] _hash160 = rip.ComputeHash(shaofpubkey);
byte[] hex2 = new byte[21];
Array.Copy(_hash160, 0, hex2, 1, 20);
hex2[0] = 0;
kps.strPublicAddress = ByteArrayToBase58Check(hex2);
//}
return(kps);
}
/// <summary>
/// Create the bitcoin ECSDA public key from private key
/// </summary>
/// <param name="d"></param>
/// <returns></returns>
public static String ConvertPrivateKeyToPublicKeyHexString(Org.BouncyCastle.Math.BigInteger d)
{
//Bitcoin public private key uses this named curve
Org.BouncyCastle.Asn1.X9.X9ECParameters ecp = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName(CURVENAME);
ECDomainParameters ecDomainParams = new ECDomainParameters(ecp.Curve, ecp.G, ecp.N, ecp.H);
ECPoint point = ecp.G.Multiply(d);
byte[] output = point.GetEncoded();
//Console.WriteLine("Result x " + result.X.ToBigInteger());
//Console.WriteLine("Result y " + result.Y.ToBigInteger());
String publicKeyHexString = StringHelper.ByteArrayToHexString(output);
return(publicKeyHexString);
}
} // End Function GenerateDHKeyPair
public static Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair GenerateEcKeyPair(
Org.BouncyCastle.Asn1.X9.X9ECParameters ecParam
, Org.BouncyCastle.Security.SecureRandom secureRandom
)
{
Org.BouncyCastle.Crypto.Parameters.ECDomainParameters ecDomain =
new Org.BouncyCastle.Crypto.Parameters.ECDomainParameters(ecParam.Curve, ecParam.G, ecParam.N);
Org.BouncyCastle.Crypto.Parameters.ECKeyGenerationParameters keygenParam =
new Org.BouncyCastle.Crypto.Parameters.ECKeyGenerationParameters(ecDomain, secureRandom);
Org.BouncyCastle.Crypto.Generators.ECKeyPairGenerator keyGenerator =
new Org.BouncyCastle.Crypto.Generators.ECKeyPairGenerator();
keyGenerator.Init(keygenParam);
return(keyGenerator.GenerateKeyPair());
} // End Function GenerateEcKeyPair
public void generateKeyPair()
{
try
{
ECKeyPairGenerator gen = new ECKeyPairGenerator("ECDSA");
SecureRandom secureRandom = new SecureRandom();
Org.BouncyCastle.Asn1.X9.X9ECParameters ecp = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp224k1");
ECDomainParameters ecSpec = new ECDomainParameters(ecp.Curve, ecp.G, ecp.N, ecp.H, ecp.GetSeed());
ECKeyGenerationParameters ecgp = new ECKeyGenerationParameters(ecSpec, secureRandom);
gen.Init(ecgp);
AsymmetricCipherKeyPair eckp = gen.GenerateKeyPair();
this.privateKey = eckp.Private;
this.publicKey = eckp.Public;
}
catch (Exception e)
{
throw new Exception("", e);
}
}
private void btnPrivToPub_Click(object sender, System.EventArgs e)
{
byte[] hex = ValidateAndGetHexPrivateKey(0x00);
if (hex == null)
{
return;
}
Org.BouncyCastle.Asn1.X9.X9ECParameters ps = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
Org.BouncyCastle.Math.BigInteger Db = new Org.BouncyCastle.Math.BigInteger(hex);
ECPoint dd = ps.G.Multiply(Db);
byte[] pubaddr = new byte[65];
byte[] Y = dd.Y.ToBigInteger().ToByteArray();
System.Array.Copy(Y, 0, pubaddr, 64 - Y.Length + 1, Y.Length);
byte[] X = dd.X.ToBigInteger().ToByteArray();
System.Array.Copy(X, 0, pubaddr, 32 - X.Length + 1, X.Length);
pubaddr[0] = 4;
txtPubHex.Text = ByteArrayToString(pubaddr);
}
public static void GenerateKeys(out string forPubKey, out string forPrivKey, out string address, AddressFamily?family = null, string prefix = null)
{
if (prefix == null)
{
prefix = string.Empty;
}
ECKeyPairGenerator gen = new ECKeyPairGenerator("ECDSA");
Org.BouncyCastle.Asn1.X9.X9ECParameters ecp = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
ECDomainParameters ecSpec = new ECDomainParameters(ecp.Curve, ecp.G, ecp.N, ecp.H, ecp.GetSeed());
SecureRandom secureRandom = new SecureRandom();
ECKeyGenerationParameters ecgp = new ECKeyGenerationParameters(ecSpec, secureRandom);
gen.Init(ecgp);
AsymmetricCipherKeyPair keyPair = gen.GenerateKeyPair();
//Stick to Base58 Encoding As Per Family Networks
ECPrivateKeyParameters priv = (ECPrivateKeyParameters)keyPair.Private;
while (true)
{
byte[] hexpriv = priv.D.ToByteArrayUnsigned();
forPrivKey = ByteArrayToString(hexpriv);
forPubKey = forPrivKey.ConvertPrivateToPublic();
address = forPubKey.ConvertPublicHexToHash().ConvertPublicHashToAddress(family);
if (address.Substring(1, prefix.Length) == prefix)
{
return;
}
else
{
priv = new ECPrivateKeyParameters(priv.D.Add(new BigInteger(1, new byte[] { 0x01 })), ecSpec);
}
}
}
} // End Function GenerateEcKeyPair
public static Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair GenerateGostKeyPair(string curveName, Org.BouncyCastle.Security.SecureRandom random)
{
Org.BouncyCastle.Asn1.X9.X9ECParameters ecParam = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName(curveName);
if (ecParam == null)
{
ecParam = Org.BouncyCastle.Crypto.EC.CustomNamedCurves.GetByName(curveName);
}
Org.BouncyCastle.Crypto.Parameters.ECDomainParameters parameters = new Org.BouncyCastle.Crypto.Parameters.ECDomainParameters(ecParam);
Org.BouncyCastle.Crypto.Parameters.ECKeyGenerationParameters keyGenerationParameters = new Org.BouncyCastle.Crypto.Parameters.ECKeyGenerationParameters(parameters, random);
Org.BouncyCastle.Crypto.Generators.ECKeyPairGenerator keygenerator = new Org.BouncyCastle.Crypto.Generators.ECKeyPairGenerator("ECGOST3410");
keygenerator.Init(keyGenerationParameters);
Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair pair = keygenerator.GenerateKeyPair();
// Org.BouncyCastle.Crypto.Parameters.ECPrivateKeyParameters validatorPrivate = (Org.BouncyCastle.Crypto.Parameters.ECPrivateKeyParameters)pair.Private;
// Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters validatorPublic = (Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters)pair.Public;
return(pair);
} // End Function GenerateGostKeyPair
private void btnGenerate_Click(object sender, System.EventArgs e)
{
ECKeyPairGenerator gen = new ECKeyPairGenerator();
SecureRandom secureRandom = new SecureRandom();
Org.BouncyCastle.Asn1.X9.X9ECParameters ps = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
ECDomainParameters ecParams = new ECDomainParameters(ps.Curve, ps.G, ps.N, ps.H);
ECKeyGenerationParameters keyGenParam = new ECKeyGenerationParameters(ecParams, secureRandom);
gen.Init(keyGenParam);
AsymmetricCipherKeyPair kp = gen.GenerateKeyPair();
ECPrivateKeyParameters priv = (ECPrivateKeyParameters)kp.Private;
byte[] hexpriv = priv.D.ToByteArrayUnsigned();
txtPrivHex.Text = ByteArrayToString(hexpriv);
btnPrivHexToWIF_Click(null, null);
btnPrivToPub_Click(null, null);
btnPubHexToHash_Click(null, null);
btnPubHashToAddress_Click(null, null);
}
private void button4_Click(object sender, System.EventArgs e)
{
Org.BouncyCastle.Asn1.X9.X9ECParameters ps = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
}
private static byte[] ExportCertificate(X509Certificate certificate, AsymmetricCipherKeyPair subjectKeyPair, TCertificateFormat certificateFormat)
{
byte[] result = null;
switch (certificateFormat)
{
case TCertificateFormat.NotSet:
break;
case TCertificateFormat.PEM:
using (MemoryStream stream = new MemoryStream())
{
using (StreamWriter writer = new StreamWriter(stream))
{
Org.BouncyCastle.Utilities.IO.Pem.PemWriter pemWriter = new Org.BouncyCastle.Utilities.IO.Pem.PemWriter(writer);
if (subjectKeyPair.Private is ECKeyParameters)
{
ECPrivateKeyParameters priv = (ECPrivateKeyParameters)subjectKeyPair.Private;
ECDomainParameters dp = priv.Parameters;
int orderBitLength = dp.N.BitLength;
Org.BouncyCastle.Asn1.Sec.ECPrivateKeyStructure ec;
Org.BouncyCastle.Asn1.X9.X962Parameters x962;
if (priv.PublicKeyParamSet == null)
{
Org.BouncyCastle.Asn1.X9.X9ECParameters ecP = new Org.BouncyCastle.Asn1.X9.X9ECParameters(dp.Curve, dp.G, dp.N, dp.H, dp.GetSeed());
x962 = new Org.BouncyCastle.Asn1.X9.X962Parameters(ecP);
}
else
{
x962 = new Org.BouncyCastle.Asn1.X9.X962Parameters(priv.PublicKeyParamSet);
}
ec = new Org.BouncyCastle.Asn1.Sec.ECPrivateKeyStructure(orderBitLength, priv.D, SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(subjectKeyPair.Public).PublicKeyData, x962);
pemWriter.WriteObject(new Org.BouncyCastle.Utilities.IO.Pem.PemObject("EC PRIVATE KEY", ec.GetEncoded()));
}
else
{
pemWriter.WriteObject(new Org.BouncyCastle.OpenSsl.MiscPemGenerator(subjectKeyPair.Private));
}
pemWriter.WriteObject(new Org.BouncyCastle.OpenSsl.MiscPemGenerator(subjectKeyPair.Public));
pemWriter.WriteObject(new Org.BouncyCastle.OpenSsl.MiscPemGenerator(certificate));
writer.Flush();
result = stream.ToArray();
}
}
break;
case TCertificateFormat.PFX:
//Asn1Sequence asn1Sequence = Asn1Sequence.GetInstance(Asn1Object.FromByteArray(certificate.GetEncoded()));
//asn1Sequence.GetObjects
//Org.BouncyCastle.Asn1.Pkcs.Pfx pfx = new Org.BouncyCastle.Asn1.Pkcs.Pfx();
//Org.BouncyCastle.Asn1.Pkcs.PrivateKeyInfo info = Org.BouncyCastle.Pkcs.PrivateKeyInfoFactory.CreatePrivateKeyInfo(subjectKeyPair.Private);
//result = pfx.GetEncoded(Asn1Encodable.Der);
break;
case TCertificateFormat.CER:
result = certificate.GetEncoded();
break;
default:
break;
}
return(result);
}
private static void AddCurveParameters(TEllipticCurve curve, Org.BouncyCastle.Asn1.DerObjectIdentifier id)
{
Org.BouncyCastle.Asn1.X9.X9ECParameters ecP = Org.BouncyCastle.Crypto.EC.CustomNamedCurves.GetByOid(id);
_CurveParameters.Add(curve, new Org.BouncyCastle.Crypto.Parameters.ECDomainParameters(ecP.Curve, ecP.G, ecP.N, ecP.H, ecP.GetSeed()));
}
private AsymmetricKeyParameter GetPubKeyParams(Pkcs11KeyInfo privKeyInfo, Pkcs11KeyInfo pubKeyInfo)
{
if (privKeyInfo != null && (privKeyInfo.CkaKeyType != (ulong)CKK.CKK_RSA && privKeyInfo.CkaKeyType != (ulong)CKK.CKK_ECDSA))
{
throw new Exception("Unsupported key type");
}
if (pubKeyInfo != null && (pubKeyInfo.CkaKeyType != (ulong)CKK.CKK_RSA && pubKeyInfo.CkaKeyType != (ulong)CKK.CKK_ECDSA))
{
throw new Exception("Unsupported key type");
}
Pkcs11KeyInfo rsaKeyInfo = (privKeyInfo != null) ? privKeyInfo : pubKeyInfo;
using (ISession session = _slot.OpenSession(SessionType.ReadWrite))
{
if (privKeyInfo.CkaKeyType == (ulong)CKK.CKK_RSA)
{
List <IObjectAttribute> attributes = session.GetAttributeValue(rsaKeyInfo.ObjectHandle, new List <CKA> {
CKA.CKA_MODULUS, CKA.CKA_PUBLIC_EXPONENT
});
BigInteger modulus = new BigInteger(1, attributes[0].GetValueAsByteArray());
BigInteger publicExponent = new BigInteger(1, attributes[1].GetValueAsByteArray());
return(new RsaKeyParameters(false, modulus, publicExponent));
}
else
{
List <IObjectAttribute> attributes = session.GetAttributeValue(rsaKeyInfo.ObjectHandle, new List <CKA> {
CKA.CKA_EC_POINT, CKA.CKA_EC_PARAMS
});
BigInteger modulus = new BigInteger(1, attributes[0].GetValueAsByteArray());
DerObjectIdentifier oid = DerObjectIdentifier.GetInstance(DerObjectIdentifier.FromByteArray(attributes[1].GetValueAsByteArray()));
Org.BouncyCastle.Asn1.X9.X9ECParameters ecParams = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByOid(oid);
byte[] ecPointArray1 = null;
byte[] ecPointArray = attributes[0].GetValueAsByteArray();
if (ecPointArray[1] > 127)
{
ecPointArray1 = new byte[ecPointArray.Length - 3];
Array.Copy(ecPointArray, 3, ecPointArray1, 0, ecPointArray1.Length);
}
else
{
ecPointArray1 = new byte[ecPointArray.Length - 2];
Array.Copy(ecPointArray, 2, ecPointArray1, 0, ecPointArray1.Length);
}
byte[] ecPointX = new byte[(ecPointArray1.Length - 1) / 2];
byte[] ecPointY = new byte[(ecPointArray1.Length - 1) / 2];
Array.Copy(ecPointArray1, 1, ecPointX, 0, ecPointX.Length);
Array.Copy(ecPointArray1, 1 + ecPointX.Length, ecPointY, 0, ecPointY.Length);
Org.BouncyCastle.Math.EC.ECPoint point = ecParams.Curve.CreatePoint(new BigInteger(1, ecPointX), new BigInteger(1, ecPointY));
ECDomainParameters ecDomainParams = new ECDomainParameters(ecParams.Curve, ecParams.G, ecParams.N, ecParams.H);
ECPublicKeyParameters ecPubKeyParams = new ECPublicKeyParameters(point, ecDomainParams);
return(ecPubKeyParams);
}
}
}
