public Key Uncover(Key scan, PubKey ephem) { X9ECParameters curve = ECKey.Secp256k1; byte[] priv = new BigInteger(1, PubKey.GetStealthSharedSecret(scan, ephem)) .Add(new BigInteger(1, this.ToBytes())) .Mod(curve.N) .ToByteArrayUnsigned(); if (priv.Length < 32) { priv = new byte[32 - priv.Length].Concat(priv).ToArray(); } var key = new Key(priv, fCompressedIn: this.IsCompressed); return(key); }
public static X9ECParameters GetByOid(DerObjectIdentifier oid) { X9ECParameters byOid = X962NamedCurves.GetByOid(oid); if (byOid == null) { byOid = SecNamedCurves.GetByOid(oid); } if (byOid == null) { byOid = TeleTrusTNamedCurves.GetByOid(oid); } if (byOid == null) { byOid = AnssiNamedCurves.GetByOid(oid); } return(byOid); }
public static KeyPairEC SecP256r1KeyPairGen() { string curve = "secp256r1"; X9ECParameters ecParams = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName(curve); ECDomainParameters domainParameters = new ECDomainParameters(ecParams.Curve, ecParams.G, ecParams.N, ecParams.H, ecParams.GetSeed()); ECKeyGenerationParameters keyGenParams = new ECKeyGenerationParameters(domainParameters, new SecureRandom()); AsymmetricCipherKeyPair keyPair; ECKeyPairGenerator generator = new ECKeyPairGenerator(); generator.Init(keyGenParams); keyPair = generator.GenerateKeyPair(); ECPrivateKeyParameters privateKey = (ECPrivateKeyParameters)keyPair.Private; ECPublicKeyParameters publicKey = (ECPublicKeyParameters)keyPair.Public; var privKeyBytes = privateKey.D.ToByteArrayUnsigned(); var pubKeyBytes = publicKey.Q.GetEncoded(); string privKey = ToSolidHex(privKeyBytes); string pubKey = ToSolidHex(pubKeyBytes); Console.WriteLine($"Curve: {curve}"); Console.WriteLine($"Generated private key ({privKeyBytes.Length} bytes):"); Console.WriteLine($"{ToHex(privKeyBytes)}"); Console.WriteLine($"Generated public key ({pubKeyBytes.Length} bytes):"); Console.WriteLine($"{ToHex(pubKeyBytes)}"); Console.WriteLine("====================================="); Console.WriteLine($"priv:"); Console.WriteLine($"{privKey}"); Console.WriteLine($"pub:"); Console.WriteLine($"{pubKey}"); return(new KeyPairEC() { PrivKey = privKeyBytes, PubKey = pubKeyBytes, PrivKeyByteHexStr = privKey, PubKeyByteHexStr = pubKey }); }
private void GenerateKeys(string curveName) { X9ECParameters ecParams = SecNamedCurves.GetByName(curveName); _domainParameters = new ECDomainParameters(ecParams.Curve, ecParams.G, ecParams.N, ecParams.H, ecParams.GetSeed()); ECKeyGenerationParameters keyGenParams = new ECKeyGenerationParameters(_domainParameters, new SecureRandom()); AsymmetricCipherKeyPair keyPair; ECKeyPairGenerator generator = new ECKeyPairGenerator(); generator.Init(keyGenParams); keyPair = generator.GenerateKeyPair(); _privateKey = (ECPrivateKeyParameters)keyPair.Private; _publicKey = (ECPublicKeyParameters)keyPair.Public; }
public static void Main() { X9ECParameters secp256k1 = ECNamedCurveTable.GetByName("secp256k1"); ECDomainParameters domainParams = new ECDomainParameters(secp256k1.Curve, secp256k1.G, secp256k1.N, secp256k1.H, secp256k1.GetSeed()); const string d = "e8HThqO0wR_Qw4pNIb80Cs0mYuCSqT6BSQj-o-tKTrg"; const string x = "A3hkIubgDggcoHzmVdXIm11gZ7UMaOa71JVf1eCifD8"; const string y = "ejpRwmCvNMdXMOjR2DodOt09OLPgNUrcKA9hBslaFU0"; var point = secp256k1.Curve.CreatePoint( new BigInteger(1, Base64UrlEncoder.DecodeBytes(x)), new BigInteger(1, Base64UrlEncoder.DecodeBytes(y))); var handler = new JsonWebTokenHandler(); var token = handler.CreateToken(new SecurityTokenDescriptor { Issuer = "me", Audience = "you", SigningCredentials = new SigningCredentials(new BouncyCastleEcdsaSecurityKey( new ECPrivateKeyParameters(new BigInteger(1, Base64UrlEncoder.DecodeBytes(d)), domainParams)) { KeyId = "123" }, "ES256K") }); Console.WriteLine(token); var result = handler.ValidateToken( token, new TokenValidationParameters { ValidIssuer = "me", ValidAudience = "you", IssuerSigningKey = new BouncyCastleEcdsaSecurityKey( new ECPublicKeyParameters(point, domainParams)) { KeyId = "123" } }); Console.WriteLine($"Is signature valid: {result.IsValid}"); }
private void AddTestCurves(IList x9s, X9ECParameters x9) { ECCurve curve = x9.Curve; int[] coords = ECCurve.GetAllCoordinateSystems(); for (int i = 0; i < coords.Length; ++i) { int coord = coords[i]; if (curve.CoordinateSystem == coord) { x9s.Add(x9); } else if (curve.SupportsCoordinateSystem(coord)) { ECCurve c = curve.Configure().SetCoordinateSystem(coord).Create(); x9s.Add(new X9ECParameters(c, c.ImportPoint(x9.G), x9.N, x9.H)); } } }
private ECPrivateKeyParameters ParseKey(string data) { Dictionary <string, string> values = ToDictionnary(data); string curveName = values["curve"].Replace("NIST", ""); X9ECParameters curve = SecNamedCurves.GetByOid(curves[curveName]); var domain = new ECDomainParameters(curve.Curve, curve.G, new BigInteger(values["q"], 16), curve.H); Assert.Equal(domain.N, curve.N); var key = new ECPrivateKeyParameters(new BigInteger(values["x"], 16), domain); ECPoint pub = curve.G.Multiply(key.D); Assert.Equal(pub.Normalize().XCoord.ToBigInteger(), new BigInteger(values["Ux"], 16)); Assert.Equal(pub.Normalize().YCoord.ToBigInteger(), new BigInteger(values["Uy"], 16)); return(key); }
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 e) { throw new U2fException(ErrorDecodingPublicKey, e); } catch (Exception e) { throw new U2fException("Could not parse user public key", e); } }
/// <summary> /// SM2解密 /// </summary> /// <param name="privateKey">私钥</param> /// <param name="cipherData">密文</param> /// <returns></returns> public static string Decrypt(string privateKey, string cipherData) { byte[] cipherDataByte = Hex.Decode(cipherData); //获取一条SM2曲线参数 X9ECParameters sm2EcParameters = GMNamedCurves.GetByName("sm2p256v1"); //构造domain参数 ECDomainParameters domainParameters = new ECDomainParameters(sm2EcParameters.Curve, sm2EcParameters.G, sm2EcParameters.N); BigInteger privateKeyD = new BigInteger(privateKey, 16); ECPrivateKeyParameters privateKeyParameters = new ECPrivateKeyParameters(privateKeyD, domainParameters); SM2Engine sm2Engine = new SM2Engine(); sm2Engine.Init(false, privateKeyParameters); byte[] arrayOfBytes = sm2Engine.ProcessBlock(cipherDataByte, 0, cipherDataByte.Length); return(Encoding.UTF8.GetString(arrayOfBytes)); }
// 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) { ECDomainParameters ecdp = ECGost3410NamedCurves.GetByName(name); if (ecdp != null) { return(ecdp); } 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())); }
private void RandMult(string label, X9ECParameters spec) { ECCurve C = spec.Curve; ECPoint G = (ECPoint)spec.G; BigInteger n = spec.N; SecureRandom random = new SecureRandom(); random.SetSeed(DateTimeUtilities.CurrentUnixMs()); Console.WriteLine(label); int[] coords = ECCurve.GetAllCoordinateSystems(); for (int i = 0; i < coords.Length; ++i) { int coord = coords[i]; if (C.SupportsCoordinateSystem(coord)) { ECCurve c = C; ECPoint g = G; if (c.CoordinateSystem != coord) { c = C.Configure().SetCoordinateSystem(coord).Create(); g = c.ImportPoint(G); } double avgDuration = RandMult(random, g, n); string coordName = COORD_NAMES[coord]; StringBuilder sb = new StringBuilder(); sb.Append(" "); sb.Append(coordName); for (int j = coordName.Length; j < 30; ++j) { sb.Append(' '); } sb.Append(": "); sb.Append(avgDuration); sb.Append("ms"); Console.WriteLine(sb.ToString()); } } }
internal static ECDomainParameters LookupParameters(DerObjectIdentifier publicKeyParamSet) { if (publicKeyParamSet == null) { throw new ArgumentNullException("publicKeyParamSet"); } ECDomainParameters eCDomainParameters = ECGost3410NamedCurves.GetByOid(publicKeyParamSet); if (eCDomainParameters == null) { X9ECParameters x9ECParameters = ECKeyPairGenerator.FindECCurveByOid(publicKeyParamSet); if (x9ECParameters == null) { throw new ArgumentException("OID is not a valid public key parameter set", "publicKeyParamSet"); } eCDomainParameters = new ECDomainParameters(x9ECParameters.Curve, x9ECParameters.G, x9ECParameters.N, x9ECParameters.H, x9ECParameters.GetSeed()); } return(eCDomainParameters); }
private static ECPoint Recover(BigInteger[] sig, byte[] hash, int recid, bool check) { X9ECParameters ecParams = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1"); int i = recid / 2; BigInteger order = ecParams.N; BigInteger field = (ecParams.Curve as FpCurve).Q; BigInteger x = order.Multiply(new BigInteger(i.ToString())).Add(sig[0]); if (x.CompareTo(field) >= 0) { throw new Exception("X too large"); } byte[] compressedPoint = new Byte[x.ToByteArrayUnsigned().Length + 1]; compressedPoint[0] = (byte)(0x02 + (recid % 2)); Buffer.BlockCopy(x.ToByteArrayUnsigned(), 0, compressedPoint, 1, compressedPoint.Length - 1); ECPoint R = ecParams.Curve.DecodePoint(compressedPoint); if (check) { ECPoint O = R.Multiply(order); if (!O.IsInfinity) { throw new Exception("Check failed"); } } int n = (ecParams.Curve as FpCurve).Q.ToByteArrayUnsigned().Length * 8; BigInteger e = new BigInteger(1, hash); if (8 * hash.Length > n) { e = e.ShiftRight(8 - (n & 7)); } e = BigInteger.Zero.Subtract(e).Mod(order); BigInteger rr = sig[0].ModInverse(order); BigInteger sor = sig[1].Multiply(rr).Mod(order); BigInteger eor = e.Multiply(rr).Mod(order); ECPoint Q = ecParams.G.Multiply(eor).Add(R.Multiply(sor)); return(Q); }
/// <summary> /// 生成SM2公私钥对 /// </summary> /// <returns></returns> private static AsymmetricCipherKeyPair CreateKeyPairInternal() { //获取一条SM2曲线参数 X9ECParameters sm2EcParameters = GMNamedCurves.GetByName("sm2p256v1"); //构造domain参数 ECDomainParameters domainParameters = new ECDomainParameters(sm2EcParameters.Curve, sm2EcParameters.G, sm2EcParameters.N); //1.创建密钥生成器 ECKeyPairGenerator keyPairGenerator = new ECKeyPairGenerator(); //2.初始化生成器,带上随机数 keyPairGenerator.Init(new ECKeyGenerationParameters(domainParameters, SecureRandom.GetInstance("SHA1PRNG"))); //3.生成密钥对 AsymmetricCipherKeyPair asymmetricCipherKeyPair = keyPairGenerator.GenerateKeyPair(); return(asymmetricCipherKeyPair); }
private void EncodePrivateKey() { X9ECParameters ecP = X962NamedCurves.GetByOid(X9ObjectIdentifiers.Prime239v3); // // named curve // X962Parameters _params = new X962Parameters(X9ObjectIdentifiers.Prime192v1); PrivateKeyInfo info = new PrivateKeyInfo(new AlgorithmIdentifier(X9ObjectIdentifiers.IdECPublicKey, _params), new ECPrivateKeyStructure(BigInteger.Ten).ToAsn1Object()); if (!Arrays.AreEqual(info.GetEncoded(), namedPriv)) { Fail("failed private named generation"); } Asn1Object o = Asn1Object.FromByteArray(namedPriv); if (!info.Equals(o)) { Fail("failed private named equality"); } // // explicit curve parameters // _params = new X962Parameters(ecP); info = new PrivateKeyInfo(new AlgorithmIdentifier(X9ObjectIdentifiers.IdECPublicKey, _params), new ECPrivateKeyStructure(BigInteger.ValueOf(20)).ToAsn1Object()); if (!Arrays.AreEqual(info.GetEncoded(), expPriv)) { Fail("failed private explicit generation"); } o = Asn1Object.FromByteArray(expPriv); if (!info.Equals(o)) { Fail("failed private explicit equality"); } }
public static ECDomainParameters GetParametersForNamedCurve(int namedCurve) { string nameOfNamedCurve = GetNameOfNamedCurve(namedCurve); if (nameOfNamedCurve == null) { return(null); } X9ECParameters byName = CustomNamedCurves.GetByName(nameOfNamedCurve); if (byName == null) { byName = ECNamedCurveTable.GetByName(nameOfNamedCurve); if (byName == null) { return(null); } } return(new ECDomainParameters(byName.Curve, byName.G, byName.N, byName.H, byName.GetSeed())); }
internal static ECDomainParameters GetECParameters(NamedCurve namedCurve) { if (!Enum.IsDefined(typeof(NamedCurve), namedCurve)) { return(null); } string curveName = namedCurve.ToString(); // Lazily created the first time a particular curve is accessed X9ECParameters ecP = SecNamedCurves.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())); }
public void PrepareKey() { try { byte key_idx = 0; X9ECParameters curve = SecNamedCurves.GetByName("secp256k1"); AsymmetricKeyParameter pub_key = null; pub_key = new ECPublicKeyParameters("ECDSA", curve.Curve.DecodePoint(Hex.Decode(ECPubKeyStr)), SecNamedCurves.GetOid("secp256k1")); AsymmetricKeyParameter priv_key = null; setParameters(this, pub_key, priv_key, key_idx, "ECDSA"); } catch (Exception ex) { MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
// TODO Add an equivalent class for ECNamedCurveParameterSpec? //private ECNamedCurveParameterSpec ReadECParameters( // private X9ECParameters ReadECParameters(PemObject pemObject) // { // DerObjectIdentifier oid = (DerObjectIdentifier)Asn1Object.FromByteArray(pemObject.Content); // // //return ECNamedCurveTable.getParameterSpec(oid.Id); // return GetCurveParameters(oid.Id); // } //private static ECDomainParameters GetCurveParameters( private static X9ECParameters GetCurveParameters( string name) { // TODO ECGost3410NamedCurves support (returns ECDomainParameters though) X9ECParameters ecP = CustomNamedCurves.GetByName(name); if (ecP == null) { 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()); return(ecP); }
/// <summary> /// Create a new ephermal key on the curve. /// </summary> /// <param name="curveName"> /// The name of the curve, for example "P-256". /// </param> /// <returns> /// The new created emphermal key. /// </returns> public static EphermalKey Generate(string curveName) { X9ECParameters ecP = ECNamedCurveTable.GetByName(curveName); if (ecP == null) { throw new Exception($"Unknown curve name '{curveName}'."); } var domain = new ECDomainParameters(ecP.Curve, ecP.G, ecP.N, ecP.H, ecP.GetSeed()); var g = GeneratorUtilities.GetKeyPairGenerator("EC"); g.Init(new ECKeyGenerationParameters(domain, new SecureRandom())); var keyPair = g.GenerateKeyPair(); return(new EphermalKey { privateKey = (ECPrivateKeyParameters)keyPair.Private, publicKey = (ECPublicKeyParameters)keyPair.Public }); }
internal static ECDomainParameters LookupParameters(DerObjectIdentifier publicKeyParamSet) { if (publicKeyParamSet == null) { throw new ArgumentNullException("publicKeyParamSet"); } ECDomainParameters byOid = ECGost3410NamedCurves.GetByOid(publicKeyParamSet); if (byOid != null) { return(byOid); } X9ECParameters parameters2 = ECKeyPairGenerator.FindECCurveByOid(publicKeyParamSet); if (parameters2 == null) { throw new ArgumentException("OID is not a valid public key parameter set", "publicKeyParamSet"); } return(new ECDomainParameters(parameters2.Curve, parameters2.G, parameters2.N, parameters2.H, parameters2.GetSeed())); }
public static Ecdsa Generate() { X9ECParameters ecParams = Org.BouncyCastle.Asn1.Sec.SecNamedCurves.GetByName("secp256k1"); ECDomainParameters domainParameters = new ECDomainParameters(ecParams.Curve, ecParams.G, ecParams.N, ecParams.H, ecParams.GetSeed()); ECKeyGenerationParameters keyGenParams = new ECKeyGenerationParameters(domainParameters, new SecureRandom()); AsymmetricCipherKeyPair keyPair; ECKeyPairGenerator generator = new ECKeyPairGenerator(); generator.Init(keyGenParams); keyPair = generator.GenerateKeyPair(); ECPrivateKeyParameters privateKey = (ECPrivateKeyParameters)keyPair.Private; ECPublicKeyParameters publicKey = (ECPublicKeyParameters)keyPair.Public; return(new Ecdsa(publicKey.Q.GetEncoded(), privateKey.D.ToByteArrayUnsigned())); }
public static bool VerifyHashed(byte[] signature, byte[] publicKey, byte[] data) { var(sigR, sigS, _) = GetRSV(signature); 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(data, new BigInteger(1, sigR.ToByteArray()), new BigInteger(1, sigS.ToByteArray()))); } catch { return(false); } }
/// <summary> /// SM2加密 /// </summary> /// <param name="publicKey">公钥</param> /// <param name="data">明文</param> /// <returns>密文</returns> public static string Encrypt(string publicKey, string data) { // 获取一条SM2曲线参数 X9ECParameters sm2EcParameters = GMNamedCurves.GetByName("sm2p256v1"); // 构造domain参数 ECDomainParameters domainParameters = new ECDomainParameters(sm2EcParameters.Curve, sm2EcParameters.G, sm2EcParameters.N); //提取公钥点 ECPoint pukPoint = sm2EcParameters.Curve.DecodePoint(Hex.Decode(publicKey)); // 公钥前面的02或者03表示是压缩公钥,04表示未压缩公钥, 04的时候,可以去掉前面的04 ECPublicKeyParameters publicKeyParameters = new ECPublicKeyParameters(pukPoint, domainParameters); SM2Engine sm2Engine = new SM2Engine(); sm2Engine.Init(true, new ParametersWithRandom(publicKeyParameters, new SecureRandom())); byte[] input = Encoding.UTF8.GetBytes(data); byte[] arrayOfBytes = sm2Engine.ProcessBlock(input, 0, input.Length); return(Hex.ToHexString(arrayOfBytes)); }
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 } })); }
protected override TlsSignerCredentials GetECDsaSignerCredentials() { #if SUPPORT_RPK foreach (OneKey k in _serverKeys) { if (k.HasKeyType((int)COSE.GeneralValuesInt.KeyType_EC2) && k.HasAlgorithm(COSE.AlgorithmValues.ECDSA_256)) { X9ECParameters p = k.GetCurve(); ECDomainParameters parameters = new ECDomainParameters(p.Curve, p.G, p.N, p.H); ECPrivateKeyParameters privKey = new ECPrivateKeyParameters("ECDSA", ConvertBigNum(k[CoseKeyParameterKeys.EC_D]), parameters); ECPoint point = k.GetPoint(); ECPublicKeyParameters param = new ECPublicKeyParameters(point, parameters); SubjectPublicKeyInfo spi = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(param); return(new DefaultTlsSignerCredentials(mContext, new RawPublicKey(spi), privKey, new SignatureAndHashAlgorithm(HashAlgorithm.sha256, SignatureAlgorithm.ecdsa))); } } #endif // If we did not fine appropriate signer credientials - ask for help TlsEvent e = new TlsEvent(TlsEvent.EventCode.SignCredentials) { CipherSuite = KeyExchangeAlgorithm.ECDHE_ECDSA }; EventHandler <TlsEvent> handler = TlsEventHandler; if (handler != null) { handler(this, e); } if (e.SignerCredentials != null) { return(e.SignerCredentials); } throw new TlsFatalAlert(AlertDescription.internal_error); }
public static byte[] DoSignEcDsa( IEnumerable <BufLen> bufs, I2PSigningPrivateKey key, IDigest digest, X9ECParameters ecparam, int sigsize) { foreach (var buf in bufs) { digest.BlockUpdate(buf.BaseArray, buf.BaseArrayOffset, buf.Length); } var hash = new byte[digest.GetDigestSize()]; digest.DoFinal(hash, 0); var param = new ECDomainParameters(ecparam.Curve, ecparam.G, ecparam.N, ecparam.H); var pk = new ECPrivateKeyParameters(key.ToBigInteger(), param); var s = new Org.BouncyCastle.Crypto.Signers.ECDsaSigner(); s.Init(true, new ParametersWithRandom(pk)); var sig = s.GenerateSignature(hash); var result = new byte[sigsize]; var b1 = sig[0].ToByteArrayUnsigned(); var b2 = sig[1].ToByteArrayUnsigned(); // https://geti2p.net/en/docs/spec/common-structures#type_Signature // When a signature is composed of two elements (for example values R,S), // it is serialized by padding each element to length/2 with leading zeros if necessary. // All types are Big Endian, except for EdDSA, which is stored and transmitted in a Little Endian format. // Pad msb. Big endian. Array.Copy(b1, 0, result, sigsize / 2 - b1.Length, b1.Length); Array.Copy(b2, 0, result, sigsize - b2.Length, b2.Length); DebugUtils.LogDebug("DoSignEcDsa: " + digest.ToString() + ": Used."); return(result); }
public static BigInteger CalculateSharedKey(BigInteger BIx, BigInteger BIy, ECPrivateKeyParameters privateKey) { IBasicAgreement aKeyAgree = AgreementUtilities.GetBasicAgreement("ECDH"); aKeyAgree.Init(privateKey); X9ECParameters ecP = NistNamedCurves.GetByName("P-521"); ECDomainParameters ecSpec = new ECDomainParameters(ecP.Curve, ecP.G, ecP.N, ecP.H, ecP.GetSeed()); FpCurve c = (FpCurve)ecSpec.Curve; ECFieldElement x = new FpFieldElement(c.Q, BIx); ECFieldElement y = new FpFieldElement(c.Q, BIy); ECPoint q = new FpPoint(ecP.Curve, x, y); ECPublicKeyParameters publicKey = new ECPublicKeyParameters("ECDH", q, SecObjectIdentifiers.SecP521r1); BigInteger k1 = aKeyAgree.CalculateAgreement(publicKey); return(k1); }
public ICipherParameters AsPublicKey() { if (PublicKeyX != null) { return(PublicKeyX); } switch (_json["kty"].AsString()) { case "EC": X9ECParameters p = NistNamedCurves.GetByName(this.AsString("crv")); ECDomainParameters parameters = new ECDomainParameters(p.Curve, p.G, p.N, p.H); ECPoint point = p.Curve.CreatePoint(this.AsBigInteger("x"), this.AsBigInteger("y")); ECPublicKeyParameters pubKey = new ECPublicKeyParameters(point, parameters); PublicKeyX = pubKey; break; } return(PublicKeyX); }
public static Byte[] getSharedSecret(Byte[] PrivateKeyIn, Byte[] PublicKeyIn) { ECDHCBasicAgreement agreement = new ECDHCBasicAgreement(); X9ECParameters curve = null; ECDomainParameters ecParam = null; ECPrivateKeyParameters privKey = null; ECPublicKeyParameters pubKey = null; ECPoint point = null; curve = NistNamedCurves.GetByName("P-256"); ecParam = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H, curve.GetSeed()); privKey = new ECPrivateKeyParameters(new BigInteger(PrivateKeyIn), ecParam); point = ecParam.Curve.DecodePoint(PublicKeyIn); pubKey = new ECPublicKeyParameters(point, ecParam); agreement.Init(privKey); BigInteger secret = agreement.CalculateAgreement(pubKey); return(secret.ToByteArrayUnsigned()); }