public static ECKeyPair Generate()
{
ECKeyGenerationParameters keygenParams
= new ECKeyGenerationParameters(Parameters.DomainParams, Parameters.SecureRandom);
ECKeyPairGenerator generator = new ECKeyPairGenerator();
generator.Init(keygenParams);
AsymmetricCipherKeyPair keypair = generator.GenerateKeyPair();
ECPrivateKeyParameters privParams = (ECPrivateKeyParameters)keypair.Private;
ECPublicKeyParameters pubParams = (ECPublicKeyParameters)keypair.Public;
ECKeyPair k = new ECKeyPair(privParams, pubParams);
return(k);
}
public static byte[] GenerateAESKey(ECPublicKeyParameters bobPublicKey,
AsymmetricKeyParameter alicePrivateKey)
{
IBasicAgreement aKeyAgree = AgreementUtilities.GetBasicAgreement("ECDH");
aKeyAgree.Init(alicePrivateKey);
BigInteger sharedSecret = aKeyAgree.CalculateAgreement(bobPublicKey);
byte[] sharedSecretBytes = sharedSecret.ToByteArray();
IDigest digest = new Sha256Digest();
byte[] symmetricKey = new byte[digest.GetDigestSize()];
digest.BlockUpdate(sharedSecretBytes, 0, sharedSecretBytes.Length);
digest.DoFinal(symmetricKey, 0);
return(symmetricKey);
}
/// <summary>
/// Creates a random key pair from given curve name
/// </summary>
/// <param name="curveName"></param>
/// <returns></returns>
public List <byte[]> CreateRandomKeyPair(string curveName)
{
var keyPair = new List <byte[]>();
var ecp = TeleTrusTNamedCurves.GetByName(curveName);
if (ecp == null)
{
ecp = NistNamedCurves.GetByName(curveName);
}
AsymmetricCipherKeyPair kp = null;
ECPublicKeyParameters publicKey = null;
bool success = false;
while (!success)
{
IAsymmetricCipherKeyPairGenerator kpg = GeneratorUtilities.GetKeyPairGenerator("ECDSA");
var parameters = new ECDomainParameters(ecp.Curve, ecp.G, ecp.N, ecp.H, ecp.GetSeed());
var ecP = new ECKeyGenerationParameters(parameters, new SecureRandom());
kpg.Init(ecP);
kp = kpg.GenerateKeyPair();
publicKey = (ECPublicKeyParameters)kp.Public;
publicKey = SetPublicUncompressed(publicKey);
byte[] x = publicKey.Q.AffineXCoord.ToBigInteger().ToByteArrayUnsigned();
byte[] y = publicKey.Q.AffineYCoord.ToBigInteger().ToByteArrayUnsigned();
if (x.Length == y.Length)
{
success = true;
}
}
ECPrivateKeyParameters privateKey = (ECPrivateKeyParameters)kp.Private;
if (KeysVerified(privateKey, publicKey, curveName))
{
var privateBytes = privateKey.D.ToByteArrayUnsigned();
var pubKeyBytes = publicKey.Q.GetEncoded();
keyPair.Add(privateBytes);
keyPair.Add(pubKeyBytes);
}
return(keyPair);
}
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
});
}
/// <summary>
/// Load the KeyPair from the file, or generate a new one.
/// </summary>
public async Task Load()
{
var res = await _folder.CheckExistsAsync(_location);
switch (res)
{
case ExistenceCheckResult.FileExists:
var file = await _folder.GetFileAsync(_location);
var reader = new StreamReader(await file.OpenAsync(FileAccess.Read));
var data = reader.ReadLine();
if (data != null)
{
var split = data.Split(' ');
if (split.Length != 2)
{
throw new FormatException("Keys file doesn't contain proper data.");
}
var ecp = GetParams();
var q = Convert.FromBase64String(split[1]);
var point = ecp.Curve.DecodePoint(q);
var pubParams = new ECPublicKeyParameters(point, ecp);
var d = new BigInteger(Convert.FromBase64String(split[0]));
var privParams = new ECPrivateKeyParameters(d, ecp);
BcKeyPair = new AsymmetricCipherKeyPair(pubParams, privParams);
}
break;
case ExistenceCheckResult.NotFound:
var key = Generate();
await Save(key);
BcKeyPair = key;
break;
default:
throw new IOException("Unknown error occurred while trying to load/save crypto keypair.");
}
}
private static (KeyAlgorithm, AsymmetricCipherKeyPair) ParseKey(AsymmetricKeyParameter keyParam)
{
if (keyParam is RsaPrivateCrtKeyParameters)
{
var privateKey = (RsaPrivateCrtKeyParameters)keyParam;
var publicKey = new RsaKeyParameters(false, privateKey.Modulus, privateKey.PublicExponent);
return(KeyAlgorithm.RS256, new AsymmetricCipherKeyPair(publicKey, keyParam));
}
else if (keyParam is ECPrivateKeyParameters privateKey)
{
var domain = privateKey.Parameters;
var q = domain.G.Multiply(privateKey.D);
DerObjectIdentifier curveId;
KeyAlgorithm algo;
switch (domain.Curve.FieldSize)
{
case 256:
curveId = SecObjectIdentifiers.SecP256r1;
algo = KeyAlgorithm.ES256;
break;
case 384:
curveId = SecObjectIdentifiers.SecP384r1;
algo = KeyAlgorithm.ES384;
break;
case 521:
curveId = SecObjectIdentifiers.SecP521r1;
algo = KeyAlgorithm.ES512;
break;
default:
throw new NotSupportedException();
}
var publicKey = new ECPublicKeyParameters("EC", q, curveId);
return(algo, new AsymmetricCipherKeyPair(publicKey, keyParam));
}
else
{
throw new NotSupportedException();
}
}
public static bool WriteKeyPair(string filePath, string privateKey, string publicKey, string password)
{
var skParams = new ECPrivateKeyParameters(new BigInteger(privateKey, 16), ECParameters.DomainParams);
var pkPoint = ECParameters.Curve.Curve.DecodePoint(FromHexString(publicKey));
var pkParams = new ECPublicKeyParameters(pkPoint, ECParameters.DomainParams);
var akp = new AsymmetricCipherKeyPair(pkParams, skParams);
using (var writer = File.CreateText(filePath))
{
var pw = new PemWriter(writer);
pw.WriteObject(akp, Algo, password.ToCharArray(), Random);
pw.Writer.Close();
}
Console.WriteLine($@"Account info has been saved to ""{filePath}""");
return(true);
}
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 bool IsSignatureValid(PendingTransaction transaction)
{
ECPoint publicKeyPoint = GetECPublicKeyPoint(transaction.SenderPublicKey);
ECDomainParameters ecSpec = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H);
ECPublicKeyParameters publicKeyParameters = new ECPublicKeyParameters(publicKeyPoint, ecSpec);
IDsaKCalculator kCalculator = new HMacDsaKCalculator(new Sha256Digest());
ECDsaSigner signer = new ECDsaSigner(kCalculator);
signer.Init(false, publicKeyParameters);
byte[] tranHashWithoutSignature = CalculateSHA256(transaction.AsJsonWithoutSignatureAndHash());
BigInteger signatureR = new BigInteger(transaction.SenderSignature[0], 16);
BigInteger signatureS = new BigInteger(transaction.SenderSignature[1], 16);
bool isValid = signer.VerifySignature(tranHashWithoutSignature, signatureR, signatureS);
return(isValid);
}
public static bool VerifySignature(string message, string publicKey, string signature)
{
var curve = SecNamedCurves.GetByName("secp256k1");
var domain = new ECDomainParameters(curve.Curve, curve.G, curve.N, curve.H);
var publicKeyBytes = Base58Encoding.Decode(publicKey);
var q = curve.Curve.DecodePoint(publicKeyBytes);
var keyParameters = new ECPublicKeyParameters(q,
domain);
var signer = SignerUtilities.GetSigner("SHA-256withECDSA");
signer.Init(false, keyParameters);
signer.BlockUpdate(Encoding.ASCII.GetBytes(message), 0, message.Length);
var signatureBytes = Base58Encoding.Decode(signature);
return(signer.VerifySignature(signatureBytes));
}
/// <summary>
/// load public key
/// </summary>
/// <param name="pkInfo">public key or public key file path</param>
/// <returns>public key</returns>
public static ECPublicKeyParameters LoadPubkey(string pkInfo)
{
string pub;
if (!pkInfo.Contains("CERTIFICATE") && !pkInfo.Contains("PUBLIC KEY"))
{
pub = ReadPK(pkInfo);
}
else
{
pub = pkInfo;
}
TextReader ptr = new StringReader(pub);
Org.BouncyCastle.OpenSsl.PemReader pem = new Org.BouncyCastle.OpenSsl.PemReader(ptr);
ECPublicKeyParameters sm2PublicKey = (ECPublicKeyParameters)pem.ReadObject();
return(sm2PublicKey);
}
/// <summary>
/// Called by client to get his ephemaral ECC keys
/// TODO: get information about which ECC curve should be used
/// </summary>
/// <param name="version"></param>
/// <param name="data"></param>
/// <returns></returns>
public override byte[] ProcessServerKeys(ProtocolVersion version, byte[] data, X509Certificate serverCertificate)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (data.Length < 4)
{
throw new ArgumentException(nameof(data));
}
//if (data[0] != 3 || data[1] != 0 || data[2] != 23)
if (data[0] != 3 || data[1] != 0)
{
throw new ArgumentException(nameof(data));
}
//if (data[3] != 65 || data[4] > data.Length - 4)
if (data[4] > data.Length - 4)
{
throw new ArgumentException(nameof(data));
}
// Extract the public key from the data
byte[] ecPointData = new byte[data[3]];
Buffer.BlockCopy(data, 4, ecPointData, 0, ecPointData.Length);
ushort curveNameId = (ushort)(data[1] << 8 | data[2]);
var ecPoint = this.ObtainCurveNameAndPoint(curveNameId, ecPointData);
var theirPublicKey = new ECPublicKeyParameters(ecPoint, this.domainParameters);
// Calculate the actual agreement
var agreement = new ECDHBasicAgreement();
agreement.Init(this.privateKey);
this.preMasterSecret = BigIntegerToByteArray(agreement.CalculateAgreement(theirPublicKey), ecPoint.Curve.FieldSize / 8);
var signature = new byte[data.Length - 4 - data[3]];
Buffer.BlockCopy(data, 4 + data[3], signature, 0, signature.Length);
return(signature);
}
static byte[] GenerateAESKey(ECPublicKeyParameters bobPublicKey,
AsymmetricKeyParameter alicePrivateKey)
{
ECDHBasicAgreement aKeyAgree = new ECDHBasicAgreement();
aKeyAgree.Init(alicePrivateKey);
byte[] sharedSecret = aKeyAgree.CalculateAgreement(bobPublicKey).ToByteArray();
// make sure each part has the correct and same size
ResizeRight(ref sharedSecret, 66); // 66 is the desired key size
Sha256Digest digest = new Sha256Digest();
byte[] symmetricKey = new byte[digest.GetDigestSize()];
digest.BlockUpdate(sharedSecret, 0, sharedSecret.Length);
digest.DoFinal(symmetricKey, 0);
return(symmetricKey);
}
// generate private, public key pair
public static Tuple <string, string> GenerateKeyPair()
{
ECKeyPairGenerator gen = new ECKeyPairGenerator(algorithm);
ECKeyGenerationParameters keyGenParam = new ECKeyGenerationParameters(domainParameters, new SecureRandom());
gen.Init(keyGenParam);
AsymmetricCipherKeyPair keys = gen.GenerateKeyPair();
ECPrivateKeyParameters privateKey = (ECPrivateKeyParameters)(keys.Private);
ECPublicKeyParameters publicKey = (ECPublicKeyParameters)(keys.Public);
//Console.WriteLine(ToHexString(publicKey.Q.GetEncoded()));
//Console.WriteLine(GetPublicKeyFromPrivateKey(ToHexString(privateKey.D.ToByteArray())));
//Console.WriteLine(ToHexString(privateKey.D.ToByteArray()));
//Console.WriteLine(privateKey.D.ToString(16));
return(new Tuple <string, string>(ToHexString(privateKey.D.ToByteArray()), ToHexString(publicKey.Q.GetEncoded())));
}
public override void ProcessServerCertificate(Certificate serverCertificate)
{
if (base.mKeyExchange == 20)
{
throw new TlsFatalAlert(10);
}
if (serverCertificate.IsEmpty)
{
throw new TlsFatalAlert(0x2a);
}
X509CertificateStructure certificateAt = serverCertificate.GetCertificateAt(0);
SubjectPublicKeyInfo subjectPublicKeyInfo = certificateAt.SubjectPublicKeyInfo;
try
{
this.mServerPublicKey = PublicKeyFactory.CreateKey(subjectPublicKeyInfo);
}
catch (Exception exception)
{
throw new TlsFatalAlert(0x2b, exception);
}
if (this.mTlsSigner == null)
{
try
{
this.mECAgreePublicKey = TlsEccUtilities.ValidateECPublicKey((ECPublicKeyParameters)this.mServerPublicKey);
}
catch (InvalidCastException exception2)
{
throw new TlsFatalAlert(0x2e, exception2);
}
TlsUtilities.ValidateKeyUsage(certificateAt, 8);
}
else
{
if (!this.mTlsSigner.IsValidPublicKey(this.mServerPublicKey))
{
throw new TlsFatalAlert(0x2e);
}
TlsUtilities.ValidateKeyUsage(certificateAt, 0x80);
}
base.ProcessServerCertificate(serverCertificate);
}
public override void ProcessServerKeyExchange(Stream input)
{
this.mPskIdentityHint = TlsUtilities.ReadOpaque16(input);
if (this.mKeyExchange == KeyExchangeAlgorithm.DHE_PSK)
{
this.mDHParameters = TlsDHUtilities.ReceiveDHParameters(mDHVerifier, input);
this.mDHAgreePublicKey = new DHPublicKeyParameters(TlsDHUtilities.ReadDHParameter(input), mDHParameters);
}
else if (this.mKeyExchange == KeyExchangeAlgorithm.ECDHE_PSK)
{
ECDomainParameters ecParams = TlsEccUtilities.ReadECParameters(mNamedCurves, mClientECPointFormats, input);
byte[] point = TlsUtilities.ReadOpaque8(input);
this.mECAgreePublicKey = TlsEccUtilities.ValidateECPublicKey(TlsEccUtilities.DeserializeECPublicKey(
mClientECPointFormats, ecParams, point));
}
}
public override void ProcessClientKeyExchange(Stream input)
{
byte[] psk_identity = TlsUtilities.ReadOpaque16(input);
this.mPsk = mPskIdentityManager.GetPsk(psk_identity);
if (mPsk == null)
{
throw new TlsFatalAlert(AlertDescription.unknown_psk_identity);
}
mContext.SecurityParameters.pskIdentity = psk_identity;
if (this.mKeyExchange == KeyExchangeAlgorithm.DHE_PSK)
{
BigInteger Yc = TlsDHUtilities.ReadDHParameter(input);
this.mDHAgreePublicKey = TlsDHUtilities.ValidateDHPublicKey(new DHPublicKeyParameters(Yc, mDHParameters));
}
else if (this.mKeyExchange == KeyExchangeAlgorithm.ECDHE_PSK)
{
byte[] point = TlsUtilities.ReadOpaque8(input);
ECDomainParameters curve_params = this.mECAgreePrivateKey.Parameters;
this.mECAgreePublicKey = TlsEccUtilities.ValidateECPublicKey(TlsEccUtilities.DeserializeECPublicKey(
mServerECPointFormats, curve_params, point));
}
else if (this.mKeyExchange == KeyExchangeAlgorithm.RSA_PSK)
{
byte[] encryptedPreMasterSecret;
if (TlsUtilities.IsSsl(mContext))
{
// TODO Do any SSLv3 clients actually include the length?
encryptedPreMasterSecret = Streams.ReadAll(input);
}
else
{
encryptedPreMasterSecret = TlsUtilities.ReadOpaque16(input);
}
this.mPremasterSecret = mServerCredentials.DecryptPreMasterSecret(encryptedPreMasterSecret);
}
}
private void checkSignature(
int size,
ECPrivateKeyParameters sKey,
ECPublicKeyParameters vKey,
ISigner sgr,
SecureRandom k,
byte[] message,
BigInteger r,
BigInteger s)
{
sgr.Init(true, new ParametersWithRandom(sKey, k));
sgr.BlockUpdate(message, 0, message.Length);
byte[] sigBytes = sgr.GenerateSignature();
sgr.Init(false, vKey);
sgr.BlockUpdate(message, 0, message.Length);
if (!sgr.VerifySignature(sigBytes))
{
Fail(size + " bit EC verification failed");
}
BigInteger[] sig = derDecode(sigBytes);
if (!r.Equals(sig[0]))
{
Fail(size + "bit"
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r + SimpleTest.NewLine
+ " got : " + sig[0]);
}
if (!s.Equals(sig[1]))
{
Fail(size + "bit"
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s + SimpleTest.NewLine
+ " got : " + sig[1]);
}
}
public bool VerifySignature(byte[] data, byte[] publicKey, byte[] signature)
{
try
{
var q = ecParams.Curve.DecodePoint(publicKey);
var keyParameters = new ECPublicKeyParameters(q, domain);
var signer = SignerUtilities.GetSigner("SHA-256withECDSA");
signer.Init(false, keyParameters);
signer.BlockUpdate(data, 0, data.Length);
return(signer.VerifySignature(signature));
}
catch
{
return(false);
}
}
public virtual BigInteger CalculateAgreement(
ICipherParameters pubKey)
{
ECPublicKeyParameters pub = (ECPublicKeyParameters)pubKey;
if (!pub.Parameters.Equals(privKey.Parameters))
{
throw new InvalidOperationException("ECDH public key has wrong domain parameters");
}
ECPoint P = pub.Q.Multiply(privKey.D).Normalize();
if (P.IsInfinity)
{
throw new InvalidOperationException("Infinity is not a valid agreement value for ECDH");
}
return(P.AffineXCoord.ToBigInteger());
}
public static byte[] GenerateSharedSecret(ECPublicKeyParameters publicKey, ECPrivateKeyParameters privateKey)
{
var agreement = new ECDHBasicAgreement();
agreement.Init(privateKey);
var z = agreement.CalculateAgreement(publicKey);
var sharedSecret = new byte[32];
var zArr = z.ToByteArrayUnsigned();
// zero the output array
for (var i = 0; i < sharedSecret.Length; i++)
{
sharedSecret[i] = 0;
}
Array.Copy(zArr, 0, sharedSecret, 32 - zArr.Length, zArr.Length);
return(sharedSecret);
}
public override (byte[], byte[]) GetChildPublicKey(Curve curve, byte[] pubKey, byte[] chainCode, uint index)
{
if (curve.Kind == ECKind.Ed25519)
{
throw new NotSupportedException("Ed25519 public key derivation not supported by slip-10");
}
if (pubKey.Length != 33)
{
throw new NotSupportedException("Invalid public key size (expected 33 bytes)");
}
if ((index & 0x80000000) != 0)
{
throw new InvalidOperationException("Can't derive a hardened child key from a public key");
}
var c = curve.Kind switch
{
ECKind.Secp256k1 => SecNamedCurves.GetByName("secp256k1"),
ECKind.NistP256 => SecNamedCurves.GetByName("secp256r1"),
_ => throw new InvalidEnumArgumentException()
};
var dp = new ECDomainParameters(c.Curve, c.G, c.N, c.H, c.GetSeed());
var kp = new ECPublicKeyParameters("EC", c.Curve.DecodePoint(pubKey), dp);
var l = Bip32Hash(chainCode, index, pubKey);
while (true)
{
var ll = l.GetBytes(0, 32);
var lr = l.GetBytes(32, 32);
var parse256LL = new BigInteger(1, ll);
var q = kp.Parameters.G.Multiply(parse256LL).Add(kp.Q);
if (parse256LL.CompareTo(c.N) >= 0 || q.IsInfinity)
{
l = Bip32Hash(chainCode, index, 1, lr);
continue;
}
return(q.Normalize().GetEncoded(true), lr);
}
}
/// <summary>
/// Initializes the algorithm from public key.
/// </summary>
/// <remarks>
/// byte[] X
/// byte[] Y
/// </remarks>
public void FromPublicKey(byte[] publicKey)
{
if (publicKey == null)
{
throw new ArgumentNullException("publicKey");
}
if (publicKey.Length == 0)
{
throw new InvalidOperationException("Invalid EC key.");
}
if (publicKey[0] != 4)
{
throw new InvalidOperationException("EC point compression not supported.");
}
if ((publicKey.Length & 1) != 1)
{
throw new InvalidOperationException("Unsupported EC key.");
}
int keySize = publicKey.Length / 2;
if ((BitLength + 7) / 8 != keySize)
{
throw new InvalidOperationException("Unexpected EC key bit length.");
}
byte[] X = new byte[keySize];
byte[] Y = new byte[keySize];
Array.Copy(publicKey, 1, X, 0, keySize);
Array.Copy(publicKey, 1 + keySize, Y, 0, keySize);
var curve = _info.Parameters.Curve;
ECFieldElement x = curve.FromBigInteger(new BigInteger(1, X));
ECFieldElement y = curve.FromBigInteger(new BigInteger(1, Y));
ECPoint q2 = new FpPoint(curve, x, y);
PublicKey = new ECPublicKeyParameters(_info.AlgorithmName, q2, _info.Parameters);
PrivateKey = null;
}
public void TestMethod1()
{
string b64InputKey = "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEVQxN/wFsMiYihwv1psUgKRIhgX02OPBQl0aKYNtKXoCk67hE/lsR8UC77Fqm1HPuMALWG8RcihSHoZwx2HfOz11QkwvlKEf8UuMrbp0yt/mQNJx6QQm6CiZ7e63sYqdV";
ECPublicKeyParameters asyKey = (ECPublicKeyParameters)
PublicKeyFactory.CreateKey(b64InputKey.DecodeBase64Url());
ECParameters param = new ECParameters();
param.Curve = ECCurve.NamedCurves.nistP384;
param.Q.X = asyKey.Q.AffineXCoord.GetEncoded();
param.Q.Y = asyKey.Q.AffineYCoord.GetEncoded();
var ecPublicKey = ECDiffieHellman.Create(param).PublicKey;
var effi = ECDiffieHellman.Create(ECCurve.NamedCurves.nistP384);
ECParameters privateKey = effi.ExportParameters(true);
var secretPrepend = Encoding.UTF8.GetBytes("RANDOM SECRET");
byte[] secret = effi.DeriveKeyFromHash(ecPublicKey, HashAlgorithmName.SHA256, secretPrepend, new byte[0]);
IBufferedCipher decryptor = CipherUtilities.GetCipher("AES/CFB8/NoPadding");
IBufferedCipher encryptor = CipherUtilities.GetCipher("AES/CFB8/NoPadding");
decryptor.Init(false, new ParametersWithIV(new KeyParameter(secret), secret.Take(16).ToArray()));
encryptor.Init(true, new ParametersWithIV(new KeyParameter(secret), secret.Take(16).ToArray()));
string b64PublicKey = effi.PublicKey.ToDerEncoded().EncodeBase64();
var handshakeJson = new HandshakeData()
{
salt = secretPrepend.EncodeBase64()
};
var signKey = ECDsa.Create(privateKey);
string val = JWT.Encode(handshakeJson, signKey, JwsAlgorithm.ES384, new Dictionary <string, object> {
{ "x5u", b64PublicKey }
});
//Log.Warn($"Headers: {string.Join(";", JWT.Headers(val))}");
//Log.Warn($"Return salt:\n{JWT.Payload(val)}");
}
private static ECDsa ConvertToSingKeyFormat(AsymmetricCipherKeyPair key)
{
ECPublicKeyParameters pubAsyKey = (ECPublicKeyParameters)key.Public;
ECPrivateKeyParameters privAsyKey = (ECPrivateKeyParameters)key.Private;
var signParam = new ECParameters
{
Curve = ECCurve.NamedCurves.nistP384,
Q =
{
X = pubAsyKey.Q.AffineXCoord.GetEncoded(),
Y = pubAsyKey.Q.AffineYCoord.GetEncoded()
}
};
signParam.D = CryptoUtils.FixDSize(privAsyKey.D.ToByteArrayUnsigned(), signParam.Q.X.Length);
signParam.Validate();
return(ECDsa.Create(signParam));
}
public virtual ECPoint Init_enc(SM2 sm2, ECPoint userKey)
{
BigInteger k = null;
ECPoint c1 = null;
AsymmetricCipherKeyPair key = sm2.ecc_key_pair_generator.GenerateKeyPair();
ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters)key.Private;
ECPublicKeyParameters ecpub = (ECPublicKeyParameters)key.Public;
k = ecpriv.D;
c1 = ecpub.Q;
p2 = userKey.Multiply(k);
Reset();
return(c1);
}
/// <summary>
/// Used to load keypair from string provided from Save function.
/// </summary>
/// <param name="keyContents">Data from Save function</param>
public void LoadFrom(string keyContents)
{
var split = keyContents.Split(' ');
if (split.Length != 2)
{
throw new FormatException("Keys file doesn't contain proper data.");
}
var ecp = GetParams();
var q = Convert.FromBase64String(split[1]);
var point = ecp.Curve.DecodePoint(q);
var pubParams = new ECPublicKeyParameters(point, ecp);
var d = new BigInteger(Convert.FromBase64String(split[0]));
var privateKeyParameters = new ECPrivateKeyParameters(d, ecp);
_bcKeyPair = new AsymmetricCipherKeyPair(pubParams, privateKeyParameters);
}
/// <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));
}
public virtual byte[] Unwrap(byte[] encryptedCek, object privateKey, int cekSizeBits, IDictionary <string, object> header)
{
Ensure.Contains(header, new[] { "epk" }, "EcdhKeyManagement algorithm expects 'epk' key param in JWT header, but was not found");
Ensure.Contains(header, new[] { BCRYPT_ALG_ID_HEADER },
"EcdhKeyManagement algorithm expects 'enc' header to be present in JWT header, but was not found");
var epk = (IDictionary <string, object>)header["epk"];
Ensure.Contains(epk, new[] { "x", "y", "crv" },
"EcdhKeyManagement algorithm expects 'epk' key to contain 'x','y' and 'crv' fields.");
var x = new BigInteger(Base64Url.Decode(epk["x"].ToString()));
var y = new BigInteger(Base64Url.Decode(epk["y"].ToString()));
var externalPubKeyPoint = _brainpoolP256R1.Curve.CreatePoint(x, y);
var domainParams = new ECDomainParameters(_brainpoolP256R1.Curve, _brainpoolP256R1.G, _brainpoolP256R1.N, _brainpoolP256R1.H);
var externalPubKey = new ECPublicKeyParameters(externalPubKeyPoint, domainParams);
return(DeriveKey(header, cekSizeBits, externalPubKey, privateKey as ECPrivateKeyParameters));
}
private bool VerifyGost(byte[] buffer, int length, byte[] signature)
{
ECDomainParameters dParams = ECGost3410NamedCurves.GetByOid(CryptoProObjectIdentifiers.GostR3410x2001CryptoProA);
byte[] reversedPublicKey = PublicKey.Reverse().ToArray();
ECPoint q = dParams.Curve.CreatePoint(new BigInteger(1, reversedPublicKey, 32, 32), new BigInteger(1, reversedPublicKey, 0, 32), false);
ECPublicKeyParameters parameters = new ECPublicKeyParameters(q, dParams);
var signer = new ECGost3410Signer();
signer.Init(false, parameters);
var digest = new Gost3411Digest();
digest.BlockUpdate(buffer, 0, length);
byte[] hash = new byte[digest.GetDigestSize()];
digest.DoFinal(hash, 0);
return(signer.VerifySignature(hash, new BigInteger(1, signature, 32, 32), new BigInteger(1, signature, 0, 32)));
}
