public void TestECMqvRandom() { var random = new SecureRandom(); var curve = new FPCurve( new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839"), // q new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16)); // b var parameters = new ECDomainParameters( curve, curve.DecodePoint(Hex.Decode("020ffa963cdca8816ccc33b8642bedf905c3d358573d3f27fbbd3b3cb9aaaf")), // G new BigInteger("883423532389192164791648750360308884807550341691627752275345424702807307")); // n var pGen = new ECKeyPairGenerator(); pGen.Init(new ECKeyGenerationParameters(parameters, random)); // Pre-established key pairs IAsymmetricCipherKeyPair u1 = pGen.GenerateKeyPair(); IAsymmetricCipherKeyPair v1 = pGen.GenerateKeyPair(); // Ephemeral key pairs IAsymmetricCipherKeyPair u2 = pGen.GenerateKeyPair(); IAsymmetricCipherKeyPair v2 = pGen.GenerateKeyPair(); IBigInteger x = CalculateAgreement(u1, u2, v1, v2); if (x == null) { Fail("MQV Test Vector (random) agreement failed"); } }
public override void PerformTest() { StaticTest(); BigInteger n = new BigInteger("6277101735386680763835789423176059013767194773182842284081"); FpCurve curve = new FpCurve( new BigInteger("6277101735386680763835789423207666416083908700390324961279"), // q new BigInteger("fffffffffffffffffffffffffffffffefffffffffffffffc", 16), // a new BigInteger("64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1", 16), // b n, BigInteger.One); ECDomainParameters parameters = new ECDomainParameters( curve, curve.DecodePoint(Hex.Decode("03188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012")), // G n, BigInteger.One); ECKeyPairGenerator eGen = new ECKeyPairGenerator(); KeyGenerationParameters gParam = new ECKeyGenerationParameters(parameters, new SecureRandom()); eGen.Init(gParam); AsymmetricCipherKeyPair p1 = eGen.GenerateKeyPair(); AsymmetricCipherKeyPair p2 = eGen.GenerateKeyPair(); DoTest(p1, p2); }
public void TestECDHBasicAgreementCofactor() { SecureRandom random = new SecureRandom(); X9ECParameters x9 = CustomNamedCurves.GetByName("curve25519"); ECDomainParameters ec = new ECDomainParameters(x9.Curve, x9.G, x9.N, x9.H, x9.GetSeed()); ECKeyPairGenerator kpg = new ECKeyPairGenerator(); kpg.Init(new ECKeyGenerationParameters(ec, random)); AsymmetricCipherKeyPair p1 = kpg.GenerateKeyPair(); AsymmetricCipherKeyPair p2 = kpg.GenerateKeyPair(); IBasicAgreement e1 = new ECDHBasicAgreement(); IBasicAgreement e2 = new ECDHBasicAgreement(); e1.Init(p1.Private); e2.Init(p2.Private); BigInteger k1 = e1.CalculateAgreement(p2.Public); BigInteger k2 = e2.CalculateAgreement(p1.Public); if (!k1.Equals(k2)) { Fail("calculated agreement test failed"); } }
public void TestECDHBasicAgreement() { SecureRandom random = new SecureRandom(); BigInteger n = new BigInteger("883423532389192164791648750360308884807550341691627752275345424702807307"); FpCurve curve = new FpCurve( new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839"), // q new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16), // b n, BigInteger.One); ECDomainParameters parameters = new ECDomainParameters( curve, curve.DecodePoint(Hex.Decode("020ffa963cdca8816ccc33b8642bedf905c3d358573d3f27fbbd3b3cb9aaaf")), // G n, BigInteger.One); ECKeyPairGenerator pGen = new ECKeyPairGenerator(); ECKeyGenerationParameters genParam = new ECKeyGenerationParameters(parameters, random); pGen.Init(genParam); AsymmetricCipherKeyPair p1 = pGen.GenerateKeyPair(); AsymmetricCipherKeyPair p2 = pGen.GenerateKeyPair(); // // two way // IBasicAgreement e1 = new ECDHBasicAgreement(); IBasicAgreement e2 = new ECDHBasicAgreement(); e1.Init(p1.Private); e2.Init(p2.Private); BigInteger k1 = e1.CalculateAgreement(p2.Public); BigInteger k2 = e2.CalculateAgreement(p1.Public); if (!k1.Equals(k2)) { Fail("calculated agreement test failed"); } // // two way // e1 = new ECDHCBasicAgreement(); e2 = new ECDHCBasicAgreement(); e1.Init(p1.Private); e2.Init(p2.Private); k1 = e1.CalculateAgreement(p2.Public); k2 = e2.CalculateAgreement(p1.Public); if (!k1.Equals(k2)) { Fail("calculated agreement test failed"); } }
private static AsymmetricCipherKeyPair CreateEcKeyPairAndEnsure32BytePrivateKey(ECKeyPairGenerator keyPairGenerator) { AsymmetricCipherKeyPair keyPair = keyPairGenerator.GenerateKeyPair(); while (((ECPrivateKeyParameters)keyPair.Private).D.ToByteArray().Length != 32) { keyPair = keyPairGenerator.GenerateKeyPair(); } return(keyPair); }
public static string[] GenerateKeys(byte[] seed) { ECKeyPairGenerator gen = new ECKeyPairGenerator(); var secureRandom = new SecureRandom(); secureRandom.SetSeed(seed); var keyGenParam = new ECKeyGenerationParameters(domain, secureRandom); gen.Init(keyGenParam); AsymmetricCipherKeyPair keyPair = gen.GenerateKeyPair(); ECPrivateKeyParameters privateParams = (ECPrivateKeyParameters)keyPair.Private; ECPublicKeyParameters publicParams = (ECPublicKeyParameters)keyPair.Public; BigInteger privateKey = privateParams.D; BigInteger publicKey = new BigInteger(publicParams.Q.GetEncoded()); BigInteger publicKeyCompressed = new BigInteger(publicParams.Q.GetEncoded(true)); string[] walletKeyPair = new string[2]; walletKeyPair[0] = privateKey.ToString(16); walletKeyPair[1] = publicKey.ToString(16); return(walletKeyPair); }
// CLIENT TO SERVER STUFF public static AsymmetricCipherKeyPair GenerateClientKey() { var generator = new ECKeyPairGenerator("ECDH"); generator.Init(new ECKeyGenerationParameters(new DerObjectIdentifier("1.3.132.0.34"), SecureRandom.GetInstance("SHA256PRNG"))); return(generator.GenerateKeyPair()); }
public virtual BigInteger[] GenerateSignature(byte[] message) { AsymmetricCipherKeyPair pair; if (!this.forSigning) { throw new InvalidOperationException("not initialised for signing"); } BigInteger n = ((ECPrivateKeyParameters)this.key).Parameters.N; int bitLength = n.BitLength; BigInteger integer2 = new BigInteger(1, message); int num2 = integer2.BitLength; ECPrivateKeyParameters key = (ECPrivateKeyParameters)this.key; if (num2 > bitLength) { throw new DataLengthException("input too large for ECNR key."); } BigInteger integer3 = null; BigInteger integer4 = null; do { ECKeyPairGenerator generator = new ECKeyPairGenerator(); generator.Init(new ECKeyGenerationParameters(key.Parameters, this.random)); pair = generator.GenerateKeyPair(); ECPublicKeyParameters @public = (ECPublicKeyParameters)pair.Public; integer3 = @public.Q.AffineXCoord.ToBigInteger().Add(integer2).Mod(n); }while (integer3.SignValue == 0); BigInteger d = key.D; integer4 = ((ECPrivateKeyParameters)pair.Private).D.Subtract(integer3.Multiply(d)).Mod(n); return(new BigInteger[] { integer3, integer4 }); }
private static AsymmetricCipherKeyPair GenerateEllipticCurveKeyPair(SecureRandom secureRandom) { var keyPairGenerator = new ECKeyPairGenerator(); keyPairGenerator.Init(new ECKeyGenerationParameters(SecObjectIdentifiers.SecP256r1, secureRandom)); return(keyPairGenerator.GenerateKeyPair()); }
private string ECC_GY = "BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0"; //坐标yG public KeyParameter KeyGenerator() { var SM2_ECC_P = new BigInteger(ECC_P, 16); var SM2_ECC_A = new BigInteger(ECC_A, 16); var SM2_ECC_B = new BigInteger(ECC_B, 16); var SM2_ECC_N = new BigInteger(ECC_N, 16); var SM2_ECC_H = BigInteger.One; var SM2_ECC_GX = new BigInteger(ECC_GX, 16); var SM2_ECC_GY = new BigInteger(ECC_GY, 16); ECCurve curve = new FpCurve(SM2_ECC_P, SM2_ECC_A, SM2_ECC_B, SM2_ECC_N, SM2_ECC_H); var g = curve.CreatePoint(SM2_ECC_GX, SM2_ECC_GY); var domainParams = new ECDomainParameters(curve, g, SM2_ECC_N); var keyPairGenerator = new ECKeyPairGenerator(); var aKeyGenParams = new ECKeyGenerationParameters(domainParams, new SecureRandom()); keyPairGenerator.Init(aKeyGenParams); var aKp = keyPairGenerator.GenerateKeyPair(); var subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(aKp.Public); var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(aKp.Private); var pk = Hex.ToHexString(privateKeyInfo.GetEncoded()); return(new KeyParameter { PrivateKey = Base64.ToBase64String(privateKeyInfo.GetEncoded()), PublicKey = Base64.ToBase64String(subjectPublicKeyInfo.GetEncoded()) }); }
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)); }
internal static AsymmetricCipherKeyPair Create(int pkSize, string pkAlgo) { SecureRandom random = new SecureRandom(new CryptoApiRandomGenerator()); KeyGenerationParameters genParam = new KeyGenerationParameters(random, pkSize); AsymmetricCipherKeyPair keyPair; switch (pkAlgo) { case "RSA": RsaKeyPairGenerator rsaGenerator = new RsaKeyPairGenerator(); rsaGenerator.Init(genParam); keyPair = rsaGenerator.GenerateKeyPair(); break; case "DSA": DsaKeyPairGenerator dsaGenerator = new DsaKeyPairGenerator(); dsaGenerator.Init(genParam); keyPair = dsaGenerator.GenerateKeyPair(); break; case "ECDSA": ECKeyPairGenerator ecGenerator = new ECKeyPairGenerator(pkAlgo); ecGenerator.Init(genParam); keyPair = ecGenerator.GenerateKeyPair(); break; default: throw new ArgumentException("Algorithm not supported", pkAlgo); } return(keyPair); }
private void button1_Click(object sender, EventArgs e) { ECKeyGenerationParameters keyGenerationParameters = new ECKeyGenerationParameters(parameters, random); ECKeyPairGenerator keygenerator = new ECKeyPairGenerator("ECGOST3410"); keygenerator.Init(keyGenerationParameters); AsymmetricCipherKeyPair pair = keygenerator.GenerateKeyPair(); ECPrivateKeyParameters validatorPrivate = (ECPrivateKeyParameters)pair.Private; ECPublicKeyParameters validatorPublic = (ECPublicKeyParameters)pair.Public; /*validatorPrivate = new ECPrivateKeyParameters( * "ECGOST3410", * new BigInteger("55441196065363246126355624130324183196576709222340016572108097750006097525544"), // d * parameters); * * validatorPublic = new ECPublicKeyParameters( * "ECGOST3410", * new FpPoint(curve, * new FpFieldElement(mod_p, new BigInteger("57520216126176808443631405023338071176630104906313632182896741342206604859403")), // x * new FpFieldElement(mod_p, new BigInteger("17614944419213781543809391949654080031942662045363639260709847859438286763994"))), // y * parameters); */ tbValPrivate.Text = validatorPrivate.D.ToString(16); tbValPublicX.Text = validatorPublic.Q.X.ToBigInteger().ToString(16); tbValPublicY.Text = validatorPublic.Q.Y.ToBigInteger().ToString(16); }
public static Task <ECDSAKeyPair> Generate() { return(Task.Run(() => { ECKeyGenerationParameters param = new ECKeyGenerationParameters(getDomain(), new Org.BouncyCastle.Security.SecureRandom()); var gen = new ECKeyPairGenerator("EC"); gen.Init(param); var pair = gen.GenerateKeyPair(); var prv = (pair.Private as ECPrivateKeyParameters).D.ToByteArrayUnsigned(); if (prv.Length != 32) { var temp = new byte[32]; Array.Clear(temp, 0, 32 - prv.Length); prv.CopyTo(temp, 32 - prv.Length); prv = temp; Insight.Track("Generate ECDSAKeyPair: prv.Length != 32"); } return new ECDSAKeyPair() { PublicKeyData = (pair.Public as ECPublicKeyParameters).Q.GetEncoded(), PrivateKeyData = prv }; })); }
private static AsymmetricCipherKeyPair GenerateKeyPair(ECDomainParameters domainParams, string x) { ECKeyPairGenerator kpg = new ECKeyPairGenerator(); kpg.Init(new ECKeyGenerationParameters(domainParams, new TestRandomBigInteger(x, 16))); return(kpg.GenerateKeyPair()); }
/// <summary> /// get csr /// </summary> /// <param name="issuerName"></param> /// <returns></returns> public static Tuple <string, AsymmetricKeyParameter> GetCsr(string issuerName) { //generate KeyPair var keyGenerator = new ECKeyPairGenerator(); ECKeyGenerationParameters pa = new ECKeyGenerationParameters(SecObjectIdentifiers.SecP256r1, new SecureRandom()); keyGenerator.Init(pa); var keypair = keyGenerator.GenerateKeyPair(); //domain name of CSR file X509Name principal = new X509Name(string.Format("CN={0},OU=client,O=BSN", string.IsNullOrEmpty(issuerName) ? "test02@app0001202004161020152918451" : issuerName)); //load public key SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keypair.Public); CertificationRequestInfo info = new CertificationRequestInfo(principal, subjectPublicKeyInfo, new DerSet()); //signature byte[] bs = ECDSAHelper.CsrSignData(info.GetEncoded(Asn1Encodable.Der), keypair.Private, pa.DomainParameters.N); //generate csr object Pkcs10CertificationRequest p10 = new Pkcs10CertificationRequest(new CertificationRequest (info, new AlgorithmIdentifier(X9ObjectIdentifiers.ECDsaWithSha256), new DerBitString(bs)).GetEncoded()); //generate csr string Org.BouncyCastle.Utilities.IO.Pem.PemObject pemCSR = new Org.BouncyCastle.Utilities.IO.Pem.PemObject("CERTIFICATE REQUEST", p10.GetEncoded()); StringWriter str = new StringWriter(); Org.BouncyCastle.Utilities.IO.Pem.PemWriter pemCsr = new Org.BouncyCastle.Utilities.IO.Pem.PemWriter(str); pemCsr.WriteObject(pemCSR); pemCsr.Writer.Flush(); return(new Tuple <string, AsymmetricKeyParameter>(str.ToString(), keypair.Private)); }
//Method to generate RSA Key Pair #region RSA KeyPair Generation Method public static AsymmetricCipherKeyPair GetKeyPair(string type) { //bouncy Castle librray Method to generate RSA Key Pair if (type == "RSA") { SecureRandom secureRandom = new SecureRandom(); var keyGenerationParameters = new KeyGenerationParameters(secureRandom, RsaKeySize); var keyPairGenerator = new RsaKeyPairGenerator(); keyPairGenerator.Init(keyGenerationParameters); //returning keys AsymmetricCipherKeyPair keypair = keyPairGenerator.GenerateKeyPair(); return(keypair); } else { SecureRandom secureRandom = new SecureRandom(); ECKeyPairGenerator gen = new ECKeyPairGenerator("ECDSA"); //selecting the Secp256k1 curve DerObjectIdentifier oid = SecObjectIdentifiers.SecP256k1; X9ECParameters ecPs = CustomNamedCurves.GetByOid(oid); ECDomainParameters ec = new ECDomainParameters( ecPs.Curve, ecPs.G, ecPs.N, ecPs.H, ecPs.GetSeed()); ECKeyGenerationParameters ecP = new ECKeyGenerationParameters(ec, secureRandom); gen.Init(ecP); return(gen.GenerateKeyPair()); } }
public static X509Certificate2 GenerateSelfSignedCertEcdsa() { var randomGenerator = new CryptoApiRandomGenerator(); var random = new SecureRandom(randomGenerator); var certificateGenerator = new X509V3CertificateGenerator(); var serialNumber = BigIntegers.CreateRandomInRange( BigInteger.One, BigInteger.ValueOf(Int64.MaxValue), random); certificateGenerator.SetSerialNumber(serialNumber); const string signatureAlgorithm = "SHA256withECDSA"; certificateGenerator.SetSignatureAlgorithm(signatureAlgorithm); var subjectDN = new X509Name("CN=simpletorrent"); var issuerDN = subjectDN; certificateGenerator.SetIssuerDN(issuerDN); certificateGenerator.SetSubjectDN(subjectDN); var notBefore = DateTime.UtcNow.Date.AddHours(-24); var notAfter = notBefore.AddYears(1000); certificateGenerator.SetNotBefore(notBefore); certificateGenerator.SetNotAfter(notAfter); ECKeyGenerationParameters genParam = new ECKeyGenerationParameters(X962NamedCurves.GetOid("prime256v1"), random); var keyPairGenerator = new ECKeyPairGenerator(); keyPairGenerator.Init(genParam); var subjectKeyPair = keyPairGenerator.GenerateKeyPair(); certificateGenerator.SetPublicKey(subjectKeyPair.Public); var issuerKeyPair = subjectKeyPair; var certificate = certificateGenerator.Generate(issuerKeyPair.Private, random); var store = new Pkcs12Store(); string friendlyName = certificate.SubjectDN.ToString(); var certificateEntry = new X509CertificateEntry(certificate); store.SetCertificateEntry(friendlyName, certificateEntry); store.SetKeyEntry(friendlyName, new AsymmetricKeyEntry(subjectKeyPair.Private), new[] { certificateEntry }); string password = "******"; var stream = new MemoryStream(); store.Save(stream, password.ToCharArray(), random); //mono bug #1660 fix -> convert to definite-length encoding byte[] pfx = Pkcs12Utilities.ConvertToDefiniteLength(stream.ToArray(), password.ToCharArray()); var convertedCertificate = new X509Certificate2( pfx, password, X509KeyStorageFlags.PersistKeySet | X509KeyStorageFlags.Exportable); return(convertedCertificate); }
public static CertPrivateKey GenerateEcPrivateKey(int bits) { // From: // http://www.bouncycastle.org/wiki/display/JA1/Elliptic+Curve+Key+Pair+Generation+and+Key+Factories // var csr = new Pkcs10CertificationRequest() // string curveName; // switch (bits) // { // case 256: // curveName = "P-256"; // break; // case 384: // curveName = "P-384"; // break; // default: // throw new ArgumentException("bit length is unsupported or unknown", nameof(bits)); // } // var ecParamSpec = ECNamedCurveTable.GetByName(curveName); // From: // https://www.codeproject.com/Tips/1150485/Csharp-Elliptical-Curve-Cryptography-with-Bouncy-C var ecKpg = new ECKeyPairGenerator("ECDSA"); ecKpg.Init(new KeyGenerationParameters(new SecureRandom(), bits)); var ecKp = ecKpg.GenerateKeyPair(); return(new CertPrivateKey { KeyPair = ecKp }); }
public ECKey() { var generator = new ECKeyPairGenerator("EC"); generator.Init(new ECKeyGenerationParameters(CURVE, _secureRandom)); var pair = generator.GenerateKeyPair(); _Key = (ECPrivateKeyParameters)pair.Private; }
public static void StartGenerateKeypair(byte[] seed, GenCompleteEventHandler evt) { Thread genThread = new Thread(new ParameterizedThreadStart((o) => { //create a random number generator using SHA512 algorithm SecureRandom rnd = SecureRandom.GetInstance(RANDOM_ALGO); rnd.SetSeed(seed); X9ECParameters curve = TeleTrusTNamedCurves.GetByName(ECDSA_CURVE); ECDomainParameters domain = new ECDomainParameters(curve.Curve, curve.G, curve.N); //create the parameters for initializing the key pair generator using the brainpoolp384t1 curve ECKeyGenerationParameters parms = new ECKeyGenerationParameters(domain, rnd); //create and initialize the key pair generator ECKeyPairGenerator gen = new ECKeyPairGenerator("ECDSA"); gen.Init(parms); //generate the key pair AsymmetricCipherKeyPair kp = gen.GenerateKeyPair(); //trigger the event Xamarin.Forms.Device.BeginInvokeOnMainThread(() => { if (evt != null) { evt(kp); } }); })); genThread.Start(); }
/// <summary> /// Starts key exchange algorithm /// </summary> /// <param name="session">The session.</param> /// <param name="message">Key exchange init message.</param> public override void Start(Session session, KeyExchangeInitMessage message) { base.Start(session, message); Session.RegisterMessage("SSH_MSG_KEX_ECDH_REPLY"); Session.KeyExchangeEcdhReplyMessageReceived += Session_KeyExchangeEcdhReplyMessageReceived; DomainParameters = new ECDomainParameters(CurveParameter.Curve, CurveParameter.G, CurveParameter.N, CurveParameter.H, CurveParameter.GetSeed()); var g = new ECKeyPairGenerator(); g.Init(new ECKeyGenerationParameters(DomainParameters, new SecureRandom())); var aKeyPair = g.GenerateKeyPair(); KeyAgreement = new ECDHCBasicAgreement(); KeyAgreement.Init(aKeyPair.Private); _clientExchangeValue = ((ECPublicKeyParameters)aKeyPair.Public).Q.GetEncoded(); SendMessage(new KeyExchangeEcdhInitMessage(_clientExchangeValue)); }
private static void GenerateIdentity(int keySize = 256) { ECKeyPairGenerator gen = new ECKeyPairGenerator(); SecureRandom secureRandom = new SecureRandom(); KeyGenerationParameters keyGenParam = new KeyGenerationParameters(secureRandom, keySize); gen.Init(keyGenParam); var keyPair = gen.GenerateKeyPair(); BigInteger privateKey = ((ECPrivateKeyParameters)keyPair.Private).D; Console.WriteLine("Private key (hex): " + privateKey.ToString(16)); Console.WriteLine("Private key: " + privateKey.ToString(10)); Console.WriteLine("Password for private key encryption:"); var password = Console.ReadLine(); var encryptedPrivateKey = CryptographyUtilities.Encrypt(privateKey.ToByteArray(), password); StorageFileProvider <string> .SetModel(Constants.WalletEncryptedPrivateKeyFilePath, encryptedPrivateKey); ECPoint pubKey = ((ECPublicKeyParameters)keyPair.Public).Q; string pubKeyCompressed = CryptographyUtilities.EncodeECPointHexCompressed(pubKey); Console.WriteLine("Public key (compressed): " + pubKeyCompressed); string addr = CryptographyUtilities.CalcRipeMD160(pubKeyCompressed); Console.WriteLine("Blockchain address: " + addr); }
public static AsymmetricCipherKeyPair GenerateECKeyPair(SecureRandom random, ECDomainParameters ecParams) { ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator(); keyPairGenerator.Init(new ECKeyGenerationParameters(ecParams, random)); return(keyPairGenerator.GenerateKeyPair()); }
private void ECDH_GenerateEphemeral(EncryptMessage msg) { CBORObject epk = CBORObject.NewMap(); if (_mKey.AsString("kty") == "EC") { X9ECParameters p = NistNamedCurves.GetByName(_mKey.AsString("crv")); ECDomainParameters parameters = new ECDomainParameters(p.Curve, p.G, p.N, p.H); ECKeyPairGenerator pGen = new ECKeyPairGenerator(); ECKeyGenerationParameters genParam = new ECKeyGenerationParameters(parameters, Message.s_PRNG); pGen.Init(genParam); AsymmetricCipherKeyPair p1 = pGen.GenerateKeyPair(); epk.Add("kty", "EC"); epk.Add("crv", _mKey.AsString("crv")); ECPublicKeyParameters priv = (ECPublicKeyParameters)p1.Public; epk.Add("x", priv.Q.Normalize().XCoord.ToBigInteger().ToByteArrayUnsigned()); epk.Add("y", priv.Q.Normalize().YCoord.ToBigInteger().ToByteArrayUnsigned()); } else if (_mKey.AsString("kty") == "OKP") { switch (_mKey.AsString("crv")) { case "X25519": Ed25519KeyPairGenerator pGen = new Ed25519KeyPairGenerator(); Ed25519KeyGenerationParameters genParam = new Ed25519KeyGenerationParameters(Message.s_PRNG); pGen.Init(genParam); AsymmetricCipherKeyPair p1 = pGen.GenerateKeyPair(); Ed25519PublicKeyParameters pub = (Ed25519PublicKeyParameters)p1.Public; epk.Add("kty", "OKP"); epk.Add("crv", "X25519"); epk.Add("x", pub.GetEncoded()); break; default: throw new JoseException("Unknown OPK curve"); } } else { throw new JoseException("Internal Error"); } if (msg.FindAttribute(CBORObject.FromObject("epk"), PROTECTED) != null) { msg.AddAttribute(CBORObject.FromObject("epk"), epk, PROTECTED); } else if (msg.FindAttribute(CBORObject.FromObject("epk"), PROTECTED) != null) { msg.AddAttribute(CBORObject.FromObject("epk"), epk, PROTECTED); } else { AddAttribute("epk", epk, UNPROTECTED); } }
/// <summary> /// 生成一个随机密钥 /// </summary> /// <returns>一个新的椭圆曲线密钥对</returns> public static AsymmetricCipherKeyPair GenerateKeyPair() { ECKeyPairGenerator keygen = new ECKeyPairGenerator(); keygen.Init(new ECKeyGenerationParameters(DomainParameters, new SecureRandom())); return(keygen.GenerateKeyPair()); }
public void TestECDsaP256Sha256WithGeneratedKey() { var secureRandom = new SecureRandom(); X9ECParameters p = NistNamedCurves.GetByName("P-256"); var parameters = new ECDomainParameters(p.Curve, p.G, p.N, p.H); var ecParams = new ECKeyGenerationParameters(parameters, secureRandom); var ecGen = new ECKeyPairGenerator("ECDSA"); ecGen.Init(ecParams); var pairKey = ecGen.GenerateKeyPair(); var priKey = pairKey.Private as ECPrivateKeyParameters; byte[] m = Hex.Decode("1BD4ED430B0F384B4E8D458EFF1A8A553286D7AC21CB2F6806172EF5F94A06AD"); var dsa = new ECDsaSigner(); dsa.Init(true, new ParametersWithRandom(priKey, secureRandom)); IBigInteger[] sig = dsa.GenerateSignature(m); // Verify the signature var pubKey = pairKey.Public as ECPublicKeyParameters; dsa.Init(false, pubKey); if (!dsa.VerifySignature(m, sig[0], sig[1])) { Fail("signature fails"); } }
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); }
private byte[] NewKey(int keyLength, object externalPubKey, IDictionary <string, object> header) { // create ECDH-ES content encryption key // generate keypair for ECDH SecureRandom rnd = new SecureRandom(); var keyGen = new ECKeyPairGenerator(); var domainParams = new ECDomainParameters(_brainpoolP256R1.Curve, _brainpoolP256R1.G, _brainpoolP256R1.N, _brainpoolP256R1.H); var genParam = new ECKeyGenerationParameters(domainParams, rnd); keyGen.Init(genParam); var ecdhKeyPair = keyGen.GenerateKeyPair(); var ephemeralPubkey = (ECPublicKeyParameters)ecdhKeyPair.Public; var ephemeralPrvKey = (ECPrivateKeyParameters)ecdhKeyPair.Private; header["epk"] = new Dictionary <string, object> { ["kty"] = "EC", ["x"] = Base64Url.Encode(ephemeralPubkey.Q.XCoord.GetEncoded()), ["y"] = Base64Url.Encode(ephemeralPubkey.Q.YCoord.GetEncoded()), ["crv"] = CRV }; var deriveKey = DeriveKey(header, keyLength, externalPubKey as ECPublicKeyParameters, ephemeralPrvKey); //Console.Out.WriteLine($"dervied key (cek): {VAU.ByteArrayToHexString(deriveKey)}"); return(deriveKey); }
/// <summary> /// Create ECDSA and generates new key pair /// </summary> /// <param name="type">0 or 1 (1 faster)</param> /// <param name="forSign">if created for signing, otherwise for verifying</param> public ECDSAWrapper(int type, bool forSign) { try { this.initCurveandParams(type); SecureRandom random = new SecureRandom(); ECKeyGenerationParameters genParam = new ECKeyGenerationParameters(this.parameters, random); ECKeyPairGenerator pGen = new ECKeyPairGenerator(); pGen.Init(genParam); this.pair = pGen.GenerateKeyPair(); if (forSign) { this.ecdsa.Init(true, new ParametersWithRandom(this.pair.Private, random)); } else { this.ecdsa.Init(false, this.pair.Public); } } catch (Exception ex) { throw new Exception("Error while creating ECDSA with new key pair", ex); } }