/*
* // https://csharp.hotexamples.com/examples/Org.BouncyCastle.Crypto.Parameters/ECPrivateKeyParameters/-/php-ecprivatekeyparameters-class-examples.html
* public ECDiffieHellmanBc(Int32 keySize)
* {
* Org.BouncyCastle.Asn1.X9.X9ECParameters ecParams;
* switch (keySize) {
* case 256:
* ecParams = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256r1");
* break;
* case 384:
* ecParams = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp384r1");
* break;
* case 521:
* ecParams = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp521r1");
* break;
* default:
*/
// https://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml
// https://tools.ietf.org/html/rfc5933
private static PublicKey toECGOSTPublicKey(byte[] keyBytes, ECKeyInfo keyinfo) // throws IOException, GeneralSecurityException
{
DNSInput @in = new DNSInput(keyBytes);
Org.BouncyCastle.Math.BigInteger x = Helpers.readBigIntegerLittleEndian(@in, keyinfo.length);
Org.BouncyCastle.Math.BigInteger y = Helpers.readBigIntegerLittleEndian(@in, keyinfo.length);
// OID to be found in Org.BouncyCastle.Security.GeneratorUtilities.GetKeyPairGenerator("ECGOST3410");
// Org.BouncyCastle.Crypto.Parameters.ECDomainParameters domain = Org.BouncyCastle.Asn1.CryptoPro.ECGost3410NamedCurves.GetByOid(Org.BouncyCastle.Asn1.CryptoPro.CryptoProObjectIdentifiers.GostR3410x94CryptoProA);
// Org.BouncyCastle.Math.EC.ECCurve c = domain.Curve;
// Org.BouncyCastle.Math.EC.ECPoint q = new Org.BouncyCastle.Math.EC.FpPoint(c, c.FromBigInteger(x), c.FromBigInteger(y));
// Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters publicParams = new Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters(q, domain);
Org.BouncyCastle.Math.EC.ECPoint q = keyinfo.curve.CreatePoint(x, y);
Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters publicParams = new Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters(q, keyinfo.spec);
// Org.BouncyCastle.Crypto.Signers.ECGost3410Signer
// Org.BouncyCastle.Security.PublicKeyFactory.CreateKey(new Org.BouncyCastle.Asn1.X509.SubjectPublicKeyInfo())
/*
* ECPoint q = new ECPoint(x, y);
*
* KeyFactory factory = KeyFactory.getInstance("ECGOST3410");
* return factory.generatePublic(new ECPublicKeySpec(q, keyinfo.spec));
*/
return(PublicKey.CreateInstance(publicParams));
}
public static byte[] GeneratePublicKey(byte[] privateKey)
{
Org.BouncyCastle.Math.BigInteger privateKeyInt = new Org.BouncyCastle.Math.BigInteger(+1, privateKey);
var parameters = SecNamedCurves.GetByName("secp256k1");
Org.BouncyCastle.Math.EC.ECPoint point = parameters.G.Multiply(privateKeyInt);
byte[] pubKeyX = point.X.ToBigInteger().ToByteArrayUnsigned();
byte[] pubKeyY = point.Y.ToBigInteger().ToByteArrayUnsigned();
Console.WriteLine("Your X point on the Elliptic Curve is: " + Encoding.Unicode.GetString(pubKeyX));
Console.WriteLine("Your Y point on the Elliptic Curve is: " + Encoding.Unicode.GetString(pubKeyY));
byte[] pubKey = new byte[pubKeyX.Length + 1];
// Copy pub key X over to pubKey
pubKeyX.CopyTo(pubKey, 1);
// Setup the parity byte
if (point.Y.ToBigInteger().Mod(new Org.BouncyCastle.Math.BigInteger("2")) == new Org.BouncyCastle.Math.BigInteger("1"))
{
pubKey[0] = 0x03;
}
else
{
pubKey[0] = 0x02;
}
// Return the public key
//return Tuple.Create(pubKeyX, pubKeyY);
return(pubKey);
}
private async Task <ECDsa> GetECDsaAsync(CancellationToken cancel)
{
string key;
if (_Config.ApnSecret != null)
{
key = _Config.ApnSecret;
}
else
{
key = await File.ReadAllTextAsync(_Config.ApnSecretPath, cancel);
}
using (TextReader reader = new StringReader(key))
{
var ecPrivateKeyParameters = (ECPrivateKeyParameters)
new Org.BouncyCastle.OpenSsl.PemReader(reader).ReadObject();
Org.BouncyCastle.Math.EC.ECPoint q =
ecPrivateKeyParameters.Parameters.G
.Multiply(ecPrivateKeyParameters.D).Normalize();
var d = ecPrivateKeyParameters.D.ToByteArrayUnsigned();
var msEcp = new ECParameters();
msEcp.Curve = ECCurve.NamedCurves.nistP256;
msEcp.Q.X = q.AffineXCoord.GetEncoded();
msEcp.Q.Y = q.AffineYCoord.GetEncoded();
msEcp.D = d;
return(ECDsa.Create(msEcp));
}
}
protected string EncodeECPointHexCompressed(Org.BouncyCastle.Math.EC.ECPoint point)
{
var compressedPoint = point.GetEncoded(true);
BigInteger biInt = new BigInteger(compressedPoint);
return(biInt.ToString(16));
}
internal static ECPublicKeyParameters GetECPublicKeyParametersFromString(string publicKeyString)
{
var publicKeyBytes = GetPublicKeyBytesWithoutCheckSum(publicKeyString);
Org.BouncyCastle.Math.EC.ECPoint q = curve.DecodePoint(publicKeyBytes);
return(new ECPublicKeyParameters(q, domainParams));
}
private ECPublicKeyParameters GetPublicKeyParameters(ECDiffieHellmanPublicKey publicKey)
{
byte[] ecdhBlob = publicKey.ToByteArray();
int keySize;
string magic = Encoding.ASCII.GetString(ecdhBlob, 0, 4);
if (magic.Equals("ECK1"))
{
keySize = 256;
}
else if (magic.Equals("ECK3"))
{
keySize = 384;
}
else if (magic.Equals("ECK5"))
{
keySize = 521;
}
else
{
throw new Exception("Unknown public key type");
}
if (keySize != _keySize)
{
throw new Exception("Public key size doesn't match our key size");
}
byte[] encoded = new byte[1 + ecdhBlob.Length - 8];
encoded[0] = 0x04;
Buffer.BlockCopy(ecdhBlob, 8, encoded, 1, ecdhBlob.Length - 8);
Org.BouncyCastle.Math.EC.ECPoint ecPoint = _domainParameters.Curve.DecodePoint(encoded);
return(new ECPublicKeyParameters(ecPoint, _domainParameters));
}
private static string EncodeECPointHexCompressed(Org.BouncyCastle.Math.EC.ECPoint point)
{
BigInteger x = point.XCoord.ToBigInteger();
BigInteger y = point.YCoord.ToBigInteger();
return(x.ToString(16) + Convert.ToInt32(y.TestBit(0)));
}
/// <summary>
/// Creates the challenge for the Chaum-Pedersen protocol, using the strong Fiat-Shamir transformation.
/// Hashes all input and a fixed domain to create an unpredictable number. Used by the initiator and token service.
/// </summary>
/// <param name="G">Curve generator</param>
/// <param name="P">Randomised point on curve</param>
/// <param name="K">Public key K = k*G</param>
/// <param name="Q">Signature Q = k*P</param>
/// <param name="X">Commitment X = r*G</param>
/// <param name="Y">Commitment Y = r*P</param>
/// <returns>A random number uniquely based on all inputs</returns>
public static BigInteger CreateChallenge(ECPoint G, ECPoint P, ECPoint K, ECPoint Q, ECPoint X, ECPoint Y)
{
// Encode the ECPoint inputs
byte[]? GEncoded = G.GetEncoded();
byte[]? PEncoded = P.GetEncoded();
byte[]? KEncoded = K.GetEncoded();
byte[]? QEncoded = Q.GetEncoded();
byte[]? XEncoded = X.GetEncoded();
byte[]? YEncoded = Y.GetEncoded();
// Domain separation: make sure hash is independent of other systems
string?domain = "AnonymousTokens";
byte[]? domainEncoded = Encoding.ASCII.GetBytes(domain);
// Using concat() is best for performance: https://stackoverflow.com/a/415396
IEnumerable <byte> points = domainEncoded
.Concat(GEncoded)
.Concat(PEncoded)
.Concat(KEncoded)
.Concat(QEncoded)
.Concat(XEncoded)
.Concat(YEncoded);
SHA256? sha256 = SHA256.Create();
BigInteger?hashAsInt = new BigInteger(sha256.ComputeHash(points.ToArray()));
return(hashAsInt.Mod(G.Curve.Order));
}
public static string GetPublicKeyFromPrivateKey(string privateKey)
{
byte[] privateKeyBytes = HexStringToByteArray(privateKey);
Org.BouncyCastle.Math.EC.ECPoint q = domainParameters.G.Multiply(new BigInteger(privateKeyBytes));
return(ToHexString(q.GetEncoded()));
}
private static void ExistingPrivateKeyToAddress(string privKeyHex) ///Gets Private Key and Makes it into an Address
{
BigInteger privateKey = new BigInteger(privKeyHex, 16);
Org.BouncyCastle.Math.EC.ECPoint pubKey = GetPublicKeyFromPrivateKey(privateKey);
string pubKeyCompressed = EncodeECPointHexCompressed(pubKey);
string addr = RipeMDHash(pubKeyCompressed);
}
public string EncodeECPointHexCompressed(ECPoint point)
{
BigInteger x = point.XCoord.ToBigInteger();
BigInteger y = point.YCoord.ToBigInteger();
return(x.ToString(16) + Convert.ToInt32(y.TestBit(0)));
}
public static byte[] getPublicKeyByteArray(byte[] privateKey)
{
Org.BouncyCastle.Math.BigInteger d = new Org.BouncyCastle.Math.BigInteger(1, privateKey);
Org.BouncyCastle.Math.EC.ECPoint q = domain.G.Multiply(d);
var publicParams = new ECPublicKeyParameters(q, domain);
return(publicParams.Q.GetEncoded(true));
}
public string GetPublicKeyCompressed(string privateKeyString)
{
BigInteger privateKey = new BigInteger(privateKeyString, 16);
ECPoint pubKey = GetPublicKeyFromPrivateKey(privateKey);
string pubKeyCompressed = EncodeECPointHexCompressed(pubKey);
return(pubKeyCompressed);
}
//0x334B4345
public static byte[] ConvertToNCryptEccPublicBlob(Org.BouncyCastle.Math.EC.ECPoint q)
{
var magic = new byte[] { 0x45, 0x43, 0x4B, 0x33 };
var len = new byte[] { 0x30, 0, 0, 0 }; // key length - 384 bit / 8
var qx = q.AffineXCoord.GetEncoded();
var qy = q.AffineYCoord.GetEncoded();
return((new[] { magic, len, qx, qy }).SelectMany(_ => _).ToArray());
}
public string GetAddressFromPrivateKey(string privateKeyHex)
{
BigInteger privateKey = new BigInteger(privateKeyHex, 16);
ECPoint publicKey = GetPublicKeyFromPrivateKey(privateKey);
string pubKeyCompressed = EncodeECPointHexCompressed(publicKey);
string address = this.CalcRipeMD160(pubKeyCompressed);
return(address);
}
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);
}
private static AsymmetricCipherKeyPair KeyFromPrivate(string privateKey)
{
BigInteger privateKeyInt = new BigInteger(privateKey, 16);
X9ECParameters curve = SecNamedCurves.GetByName("secp256k1");
ECDomainParameters domain = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H);
ECPoint q = domain.G.Multiply(privateKeyInt);
ECPrivateKeyParameters privateKeyParam = new ECPrivateKeyParameters(privateKeyInt, domain);
ECPublicKeyParameters publicKeyParam = new ECPublicKeyParameters(q, domain);
return(new AsymmetricCipherKeyPair(publicKeyParam, privateKeyParam));
}
/// <summary>
/// Gets the public key from the private key.
/// </summary>
/// <param name="privateKey"></param>
/// <returns></returns>
public static string GetPublicKey(string privateKey)
{
BigInteger privateKeyInt = new BigInteger(privateKey, 16);
X9ECParameters curve = SecNamedCurves.GetByName("secp256k1");
ECDomainParameters domain = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H);
ECPoint q = domain.G.Multiply(privateKeyInt);
byte[] bytes = q.GetEncoded();
return(Hex.ToHexString(bytes));
}
public bool VerifySignatureUsingSecp256k1(byte[] publicKey, BigInteger[] signature, byte[] message)
{
X9ECParameters parameters = SecNamedCurves.GetByName("secp256k1");
var ecParameters = new ECDomainParameters(parameters.Curve, parameters.G, parameters.N, parameters.H);
ECPoint q = ecParameters.Curve.DecodePoint(publicKey);
var publicKeyParameters = new ECPublicKeyParameters(q, ecParameters);
var signer = new ECDsaSigner();
signer.Init(false, publicKeyParameters);
return(signer.VerifySignature(message, signature[0].Abs(), signature[1].Abs()));
}
public Secp256k1PublicKey(ReadOnlySpan <byte> key)
{
var k1Params = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
this.publicKey = k1Params.Curve.DecodePoint(key.ToArray());
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);
}
public void SetUpSimpleCurve()
{
OpenECCSimpleCurve = new OpenECC.WeierstrassCurve(new System.Numerics.BigInteger(4), new System.Numerics.BigInteger(20), new System.Numerics.BigInteger(29));
OpenECCSimplePoint1 = new OpenECC.WeierstrassCurvePoint(new System.Numerics.BigInteger(5), new System.Numerics.BigInteger(22), OpenECCSimpleCurve);
OpenECCSimplePoint2 = new OpenECC.WeierstrassCurvePoint(new System.Numerics.BigInteger(16), new System.Numerics.BigInteger(27), OpenECCSimpleCurve);
OpenECCSimplePoint3 = new OpenECC.WeierstrassCurvePoint(new System.Numerics.BigInteger(13), new System.Numerics.BigInteger(6), OpenECCSimpleCurve);
OpenECCSimplePoint4 = new OpenECC.WeierstrassCurvePoint(new System.Numerics.BigInteger(14), new System.Numerics.BigInteger(6), OpenECCSimpleCurve);
BCSimpleCurve = new Org.BouncyCastle.Math.EC.FpCurve(new Org.BouncyCastle.Math.BigInteger("29"), new Org.BouncyCastle.Math.BigInteger("4"), new Org.BouncyCastle.Math.BigInteger("20"));
BCSimplePoint1 = BCSimpleCurve.CreatePoint(new Org.BouncyCastle.Math.BigInteger("5"), new Org.BouncyCastle.Math.BigInteger("22"), false);
BCSimplePoint2 = BCSimpleCurve.CreatePoint(new Org.BouncyCastle.Math.BigInteger("16"), new Org.BouncyCastle.Math.BigInteger("27"), false);
BCSimplePoint3 = BCSimpleCurve.CreatePoint(new Org.BouncyCastle.Math.BigInteger("13"), new Org.BouncyCastle.Math.BigInteger("6"), false);
BCSimplePoint4 = BCSimpleCurve.CreatePoint(new Org.BouncyCastle.Math.BigInteger("14"), new Org.BouncyCastle.Math.BigInteger("6"), false);
}
public void SetUpSecp256k1()
{
//Set up OpenECC Curve
OpenECCSecp256k1 = OpenECC.CurveFactory.secp256k1;
OpenECCGenerator = OpenECCSecp256k1.Generator;
OpenECCPoint1 = OpenECCGenerator * 3;
OpenECCPoint2 = OpenECCGenerator * 5;
//Set up BouncyCastle curve
var bc_stuff = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1");
BCSecp256k1 = bc_stuff.Curve;
BCGenerator = bc_stuff.G;
BCPoint1 = BCGenerator.Multiply(new Org.BouncyCastle.Math.BigInteger("3"));
BCPoint2 = BCGenerator.Multiply(new Org.BouncyCastle.Math.BigInteger("5"));
}
public static Key Deserialize(IEnumerable <byte> payload)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
var c = SecNamedCurves.GetByName("secp256k1");
var domain = new ECDomainParameters(c.Curve, c.G, c.N, c.H);
Org.BouncyCastle.Math.EC.ECCurve curve = domain.Curve;
Org.BouncyCastle.Math.EC.ECPoint q = curve.DecodePoint(payload.ToArray());
var publicKey = new ECPublicKeyParameters(q, domain);
return(new Key(null, publicKey));
}
private static string CreateAndSignTransaction(string recipientAddress, long value,
int fee, string data, string iso8601datetime, string senderPrivKeyHex) ///Creates and Signs Transaction
{
BigInteger privateKey = new BigInteger(senderPrivKeyHex, 16);
Org.BouncyCastle.Math.EC.ECPoint pubKey = GetPublicKeyFromPrivateKey(privateKey);
string senderPubKeyCompressed = EncodeECPointHexCompressed(pubKey);
string senderAddress = RipeMDHash(senderPubKeyCompressed);
var tran = new //Creates unsigned Transaction
{
from = senderAddress,
to = recipientAddress,
value,
fee,
dateCreated = iso8601datetime,
data,
senderPubKey = senderPubKeyCompressed,
};
string tranJson = JsonConvert.SerializeObject(tran);
byte[] tranHash = CalcSHA256(tranJson);
BigInteger[] tranSignature = SignData(privateKey, tranHash);
var tranSigned = new //Signed Transaction
{
from = senderAddress,
to = recipientAddress,
senderPubKey = senderPubKeyCompressed,
value,
fee,
data,
dateCreated = iso8601datetime,
senderSignature = new string[]
{
tranSignature[0].ToString(16),
tranSignature[1].ToString(16)
}
};
string signedTranJson = JsonConvert.SerializeObject(tranSigned, Formatting.Indented);
Print("Transaction Hash: " + BytesToHex(tranHash));
return(signedTranJson);
}
private static PublicKey toECDSAPublicKey(byte[] keyBytes, ECKeyInfo keyinfo) // throws IOException, GeneralSecurityException
{
DNSInput @in = new DNSInput(keyBytes);
// RFC 6605 Section 4
Org.BouncyCastle.Math.BigInteger x = Helpers.readBigInteger(@in, keyinfo.length);
Org.BouncyCastle.Math.BigInteger y = Helpers.readBigInteger(@in, keyinfo.length);
// Org.BouncyCastle.Asn1.X9.X9ECParameters ecParams = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp521r1");
// Org.BouncyCastle.Asn1.X9.X9ECParameters ecParams = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256r1");
// Org.BouncyCastle.Asn1.X9.X9ECParameters p = Org.BouncyCastle.Asn1.X9.X962NamedCurves.GetByOid(Org.BouncyCastle.Asn1.X9.X9ObjectIdentifiers.Prime239v1);
// Org.BouncyCastle.Asn1.X9.X9ECParameters p = Org.BouncyCastle.Asn1.X9.X962NamedCurves.GetByOid(Org.BouncyCastle.Asn1.X9.X9ObjectIdentifiers.ECDsaWithSha512);
// 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.Asn1.X9.X9ECParameters p = Org.BouncyCastle.Asn1.X9.X962NamedCurves.GetByOid(Org.BouncyCastle.Asn1.X9.X9ObjectIdentifiers.ECDsaWithSha512);
// Org.BouncyCastle.Math.EC.ECCurve c = p.Curve;
// Org.BouncyCastle.Crypto.Parameters.ECDomainParameters domain = new Org.BouncyCastle.Crypto.Parameters.ECDomainParameters(c, p.G, p.N, p.H);
// Org.BouncyCastle.Math.EC.ECPoint q = new Org.BouncyCastle.Math.EC.FpPoint(c, c.FromBigInteger(x), c.FromBigInteger(y));
// Org.BouncyCastle.Math.EC.ECPoint q = c.CreatePoint(x, y);
// Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters publicParams = new Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters(q, domain);
Org.BouncyCastle.Math.EC.ECPoint q = keyinfo.curve.CreatePoint(x, y);
Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters publicParams = new Org.BouncyCastle.Crypto.Parameters.ECPublicKeyParameters(q, keyinfo.spec);
// Org.BouncyCastle.Security.PublicKeyFactory.CreateKey(Org.BouncyCastle.X509.SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicParams));
// Org.BouncyCastle.Security.PrivateKeyFactory.CreateKey(publicParams);
// Org.BouncyCastle.Security.PrivateKeyFactory
// Org.BouncyCastle.Security.PublicKeyFactory
// Org.BouncyCastle.Security.PublicKeyFactory.CreateKey(new Org.BouncyCastle.Asn1.X509.SubjectPublicKeyInfo())
/*
* ECPoint q = new ECPoint(x, y);
*
* KeyFactory factory = KeyFactory.getInstance("EC");
* return factory.generatePublic(new ECPublicKeySpec(q, keyinfo.spec));
*/
return(PublicKey.CreateInstance(publicParams));
}
public static string GeneratePkcs10
(PrivateKey privKey, PublicKey pubKey, string commonName, string organization, string organizationUnit, string city, string state,
string countryIso2Characters, string email)
{
try
{
Org.BouncyCastle.Math.BigInteger d = new Org.BouncyCastle.Math.BigInteger(privKey.ByteArray.Reverse().ToArray());
SecureRandom secureRandom = new SecureRandom();
X9ECParameters curve = SecNamedCurves.GetByName("secp256k1");
ECDomainParameters domain = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H);
Org.BouncyCastle.Math.EC.ECPoint q = domain.G.Multiply(d);
var priv = new ECPrivateKeyParameters("EC", d, SecObjectIdentifiers.SecP256k1);
var pub = new ECPublicKeyParameters("EC", q, SecObjectIdentifiers.SecP256k1);
Dictionary <DerObjectIdentifier, string> attrs = new Dictionary <DerObjectIdentifier, string>();
attrs.Add(X509Name.O, organization);
attrs.Add(X509Name.OU, organizationUnit);
attrs.Add(X509Name.EmailAddress, email);
attrs.Add(X509Name.L, city);
attrs.Add(X509Name.ST, state);
attrs.Add(X509Name.C, countryIso2Characters);
attrs.Add(X509Name.CN, commonName);
var subject = new X509Name(attrs.Keys.ToList(), attrs.Values.ToList());
var pkcs10CertificationRequest = new Pkcs10CertificationRequest("SHA1withECDSA", subject, pub, null, priv);
var base64csr = Convert.ToBase64String(pkcs10CertificationRequest.GetEncoded());
var width = 64;
for (int i = width; i < base64csr.Length; i += width + 1)
{
base64csr = base64csr.Insert(i, "\n");
}
return(base64csr);
}
catch (Exception ex)
{
throw;
}
}
public ICipherParameters DecodePublicKey(byte[] encodedPublicKey)
{
try
{
X9ECParameters curve = SecNamedCurves.GetByOid(_curve);
ECPoint point = curve.Curve.DecodePoint(encodedPublicKey);
ECDomainParameters ecP = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H);
return(new ECPublicKeyParameters(point, ecP));
}
catch (InvalidKeySpecException exception)
{
throw new U2fException(Resources.SignatureError, exception);
}
catch (Exception exception)
{
throw new U2fException(ErrorDecodingPublicKey, exception);
}
}
private static ECDsa LoadPrivateKey(byte[] key)
{
BigInteger privKeyInt = new BigInteger(+1, key);
X9ECParameters parameters = SecNamedCurves.GetByName("secp256k1");
ECPoint ecPoint = parameters.G.Multiply(privKeyInt);
byte[] privKeyX = ecPoint.Normalize().XCoord.ToBigInteger().ToByteArrayUnsigned();
byte[] privKeyY = ecPoint.Normalize().YCoord.ToBigInteger().ToByteArrayUnsigned();
return(ECDsa.Create(new ECParameters
{
Curve = ECCurve.CreateFromFriendlyName("secp256k1"),
D = privKeyInt.ToByteArrayUnsigned(),
Q = new System.Security.Cryptography.ECPoint
{
X = privKeyX,
Y = privKeyY
}
}));
}
private string PrivateKeyHexToPublicKeyHex(string privateKeyHex)
{
byte[] privateKeyBytes = this.ValidateAndGetPrivateKeyBytes(privateKeyHex, 0x00);
if (privateKeyBytes == null)
{
return(null);
}
X9ECParameters curves = SecNamedCurves.GetByName("secp256k1");
BigInteger privateKeyInteger = new BigInteger(privateKeyBytes);
ECPoint p = curves.G.Multiply(privateKeyInteger);
byte[] publicAddress = new byte[65];
byte[] y = p.Normalize().YCoord.ToBigInteger().ToByteArray();
Array.Copy(y, 0, publicAddress, 64 - y.Length + 1, y.Length);
byte[] x = p.Normalize().XCoord.ToBigInteger().ToByteArray();
Array.Copy(x, 0, publicAddress, 32 - x.Length + 1, x.Length);
publicAddress[0] = 4;
return(this.ByteArrayToString(publicAddress));
}
public static Key Deserialize(BigInteger publicKey, BigInteger privateKey)
{
if (publicKey == null)
{
throw new ArgumentNullException(nameof(publicKey));
}
if (privateKey == null)
{
throw new ArgumentNullException(nameof(privateKey));
}
var c = SecNamedCurves.GetByName("secp256k1");
var domain = new ECDomainParameters(c.Curve, c.G, c.N, c.H);
Org.BouncyCastle.Math.EC.ECCurve curve = domain.Curve;
Org.BouncyCastle.Math.EC.ECPoint q = curve.DecodePoint(publicKey.ToByteArray());
var pubK = new ECPublicKeyParameters(q, domain);
var prK = new ECPrivateKeyParameters(privateKey, domain);
return(new Key(prK, pubK));
}
/// <summary>
/// Check ECDSA Signature (secp256r1)
/// </summary>
/// <param name="message">Message</param>
/// <param name="signature">Signature</param>
/// <param name="pubkey">Public Key</param>
/// <returns>Bool</returns>
public override bool VerifySignature(byte[] message, byte[] signature, byte[] pubkey)
{
byte[] fullpubkey = DecodePublicKey(pubkey, false, out System.Numerics.BigInteger x, out System.Numerics.BigInteger y);
Org.BouncyCastle.Math.EC.ECPoint point = _curve.Curve.DecodePoint(fullpubkey);
var keyParameters = new ECPublicKeyParameters(point, _domain);
var signer = SignerUtilities.GetSigner("SHA256withECDSA");
signer.Init(false, keyParameters);
signer.BlockUpdate(message, 0, message.Length);
if (signature.Length == 64)
{
signature = new DerSequence(
new DerInteger(new BigInteger(1, signature.Take(32).ToArray())),
new DerInteger(new BigInteger(1, signature.Skip(32).ToArray())))
.GetDerEncoded();
}
return(signer.VerifySignature(signature));
}
static byte[] GetSharedKey(ECPrivateKeyParameters sigPrivKey, byte[] serverPubKey)
{
Console.WriteLine("Generating shared key!");
var ecP = ECNamedCurveTable.GetByName("secp256k1");
var domainParams = new ECDomainParameters(ecP.Curve, ecP.G, ecP.N, ecP.H, ecP.GetSeed());
Org.BouncyCastle.Math.EC.ECPoint point = domainParams.Curve.DecodePoint(serverPubKey);
ECPublicKeyParameters oEcPublicKeyParameters = new ECPublicKeyParameters(point, domainParams);
IBasicAgreement aKeyAgree = AgreementUtilities.GetBasicAgreement("ECDH");
aKeyAgree.Init(sigPrivKey);
var sharedKey = aKeyAgree.CalculateAgreement(oEcPublicKeyParameters).ToByteArray();
Console.WriteLine($"{sharedKey.Length} bytes Created shared key ({ToHex(sharedKey)})");
return(sharedKey);
}
