public void CanValidateSignature()
{
Ed25519KeyPairGenerator kpg = new Ed25519KeyPairGenerator();
kpg.Init(new Ed25519KeyGenerationParameters(Random));
AsymmetricCipherKeyPair kp = kpg.GenerateKeyPair();
Ed25519PrivateKeyParameters privateKey = (Ed25519PrivateKeyParameters)kp.Private;
Ed25519PublicKeyParameters publicKey = (Ed25519PublicKeyParameters)kp.Public;
var pubKeyBase64 = Convert.ToBase64String(publicKey.GetEncoded());
// create signature for item
byte[] msg = new byte[Random.NextInt() & 255];
Random.NextBytes(msg);
var signer = new Ed25519Signer();
signer.Init(true, privateKey);
signer.BlockUpdate(msg, 0, msg.Length);
byte[] signature = signer.GenerateSignature();
var signatureForAppCast = Convert.ToBase64String(signature);
// verify signature
var checker = new Ed25519Checker(NetSparkleUpdater.Enums.SecurityMode.Strict, pubKeyBase64);
Assert.True(checker.VerifySignature(signatureForAppCast, msg) == NetSparkleUpdater.Enums.ValidationResult.Valid);
}
public bool VerifySignature(byte[] signature)
{
if (privateKey != null)
{
throw new InvalidOperationException("Ed25519DigestSigner not initialised for verification");
}
if (Ed25519.SignatureSize != signature.Length)
{
return(false);
}
var hashLength = digest.GetDigestSize();
var hash = ArrayPool <byte> .Shared.Rent(hashLength);
try {
digest.DoFinal(hash, 0);
var pk = publicKey.GetEncoded();
var result = Ed25519.Verify(signature, 0, pk, 0, hash, 0, hashLength);
Reset();
return(result);
} finally {
ArrayPool <byte> .Shared.Return(hash);
}
}
/// <summary>
/// Generates the specified force.
/// </summary>
/// <param name="force">if set to <c>true</c> [force].</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
public bool Generate(bool force = false)
{
if (KeysExist() && !force)
{
Console.WriteLine("Keys already exist, use --force to force regeneration");
return(false);
}
// start key generation
Console.WriteLine("Generating key pair...");
var Random = new SecureRandom();
Ed25519KeyPairGenerator kpg = new Ed25519KeyPairGenerator();
kpg.Init(new Ed25519KeyGenerationParameters(Random));
AsymmetricCipherKeyPair kp = kpg.GenerateKeyPair();
Ed25519PrivateKeyParameters privateKey = (Ed25519PrivateKeyParameters)kp.Private;
Ed25519PublicKeyParameters publicKey = (Ed25519PublicKeyParameters)kp.Public;
var privKeyBase64 = Convert.ToBase64String(privateKey.GetEncoded());
var pubKeyBase64 = Convert.ToBase64String(publicKey.GetEncoded());
File.WriteAllText(_privateKeyFilePath, privKeyBase64);
File.WriteAllText(_publicKeyFilePath, pubKeyBase64);
Console.WriteLine("Storing public/private keys to " + _storagePath);
return(true);
}
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);
}
}
public RawKeyPair(string privateKey)
{
string privateKey32 = privateKey.Length == 128 ? privateKey.Substring(0, 64) : privateKey;
Ed25519PrivateKeyParameters privateKeyParams = new Ed25519PrivateKeyParameters(Hex.Decode(privateKey32), 0);
Ed25519PublicKeyParameters publicKeyParams = privateKeyParams.GeneratePublicKey();
PublicKey = publicKeyParams.GetEncoded();
PrivateKey = privateKeyParams.GetEncoded();
}
public AsymmetricKeyPair Generate()
{
Ed25519PrivateKeyParameters secretKeyParams = new Ed25519PrivateKeyParameters(_secureRandom);
Ed25519PublicKeyParameters publicKeyParams = secretKeyParams.GeneratePublicKey();
byte[] asn1SecretKey = SecretKeyAsn1Header.Concat(secretKeyParams.GetEncoded()).ToArray();
byte[] asn1PublicKey = PublicKeyAsn1Header.Concat(publicKeyParams.GetEncoded()).ToArray();
return(new AsymmetricKeyPair(new SecretKey(asn1SecretKey, KeyAlgorithm.Ed25519), new PublicKey(asn1PublicKey, KeyAlgorithm.Ed25519)));
}
public virtual bool VerifySignature(byte[] signature)
{
if (forSigning || null == publicKey)
{
throw new InvalidOperationException("Ed25519phSigner not initialised for verification");
}
byte[] pk = publicKey.GetEncoded();
return(Ed25519.VerifyPrehash(signature, 0, pk, 0, context, prehash));
}
public BaseKeyPair(string privateKey)
{
string privateKey32 = privateKey.Length == 128 ? privateKey.Substring(0, 64) : privateKey;
Ed25519PrivateKeyParameters privateKeyParams = new Ed25519PrivateKeyParameters(Hex.Decode(privateKey32), 0);
Ed25519PublicKeyParameters publicKeyParams = privateKeyParams.GeneratePublicKey();
byte[] publicBinary = publicKeyParams.GetEncoded();
byte[] privateBinary = privateKeyParams.GetEncoded();
PublicKey = Encoding.EncodeCheck(publicBinary, Constants.ApiIdentifiers.ACCOUNT_PUBKEY);
PrivateKey = Hex.ToHexString(privateBinary) + Hex.ToHexString(publicBinary);
}
public static RawKeyPair Generate()
{
Ed25519KeyPairGenerator keyPairGenerator = new Ed25519KeyPairGenerator();
keyPairGenerator.Init(new Ed25519KeyGenerationParameters(new SecureRandom()));
AsymmetricCipherKeyPair asymmetricCipherKeyPair = keyPairGenerator.GenerateKeyPair();
Ed25519PublicKeyParameters publicKeyParams = (Ed25519PublicKeyParameters)asymmetricCipherKeyPair.Public;
Ed25519PrivateKeyParameters privateKeyParams = (Ed25519PrivateKeyParameters)asymmetricCipherKeyPair.Private;
byte[] publicKey = publicKeyParams.GetEncoded();
byte[] privateKey = privateKeyParams.GetEncoded();
return(new RawKeyPair(publicKey, privateKey));
}
// **** Code to be reviewed - it compiles, but he has little if any relationship with the Dart code...
// ****
public String getEncoded()
{
byte[] seedBytes = HexEncDec.StringToByteArray(Seed);
Ed25519KeyPairGenerator wkGen = new Ed25519KeyPairGenerator();
SecureRandom rnd = new SecureRandom(seedBytes);
Ed25519KeyGenerationParameters genPar = new Ed25519KeyGenerationParameters(rnd);
wkGen.Init(genPar);
AsymmetricCipherKeyPair keys = wkGen.GenerateKeyPair();
Ed25519PublicKeyParameters key = (Ed25519PublicKeyParameters)keys.Public;
byte[] output = key.GetEncoded();
return(Convert.ToBase64String(output));
}
internal bool VerifySignature(Ed25519PublicKeyParameters publicKey, byte[] signature)
{
#if PORTABLE
byte[] buf = ToArray();
int count = buf.Length;
#else
byte[] buf = GetBuffer();
int count = (int)Position;
#endif
byte[] pk = publicKey.GetEncoded();
bool result = Ed25519.Verify(signature, 0, pk, 0, buf, 0, count);
Reset();
return(result);
}
public static KeyPair generateEd25519KeyPair()
{
Org.BouncyCastle.Crypto.Generators.Ed25519KeyPairGenerator kpg = new Org.BouncyCastle.Crypto.Generators.Ed25519KeyPairGenerator();
kpg.Init(new Ed25519KeyGenerationParameters(secureRandom));
Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair kp = kpg.GenerateKeyPair();
KeyPair nkp = new KeyPair();
Ed25519PrivateKeyParameters privateKey = (Ed25519PrivateKeyParameters)kp.Private;
Ed25519PublicKeyParameters publicKey = (Ed25519PublicKeyParameters)kp.Public;
nkp.publicKey = new PublicKey(publicKey.GetEncoded());
nkp.privateKey = new PrivateKey(privateKey.GetEncoded());
if (nkp.privateKey.isValid())
{
return(nkp);
}
return(generateEd25519KeyPair());
}
internal bool VerifySignature(Ed25519PublicKeyParameters publicKey, byte[] ctx, byte[] signature)
{
if (Ed25519.SignatureSize != signature.Length)
{
return(false);
}
lock (this)
{
#if PORTABLE || NETFX_CORE
byte[] buf = ToArray();
int count = buf.Length;
#else
byte[] buf = GetBuffer();
int count = (int)Position;
#endif
byte[] pk = publicKey.GetEncoded();
bool result = Ed25519.Verify(signature, 0, pk, 0, ctx, buf, 0, count);
Reset();
return(result);
}
}
public bool VerifySignature(byte[] signature)
{
if (privateKey != null)
{
throw new InvalidOperationException("Ed25519DigestSigner not initialised for verification");
}
if (Ed25519.SignatureSize != signature.Length)
{
return(false);
}
byte[] hash = new byte[digest.GetDigestSize()];
digest.DoFinal(hash, 0);
var pk = publicKey.GetEncoded();
var result = Ed25519.Verify(signature, 0, pk, 0, hash, 0, hash.Length);
Reset();
return(result);
}
public void CanGetAndVerifySignatureFromEnvironment()
{
// create tmp file
var tempData = RandomString(1024);
var path = Path.GetTempFileName();
File.WriteAllText(path, tempData);
Assert.True(File.Exists(path));
Assert.Equal(tempData, File.ReadAllText(path));
// create keys
var Random = new SecureRandom();
Ed25519KeyPairGenerator kpg = new Ed25519KeyPairGenerator();
kpg.Init(new Ed25519KeyGenerationParameters(Random));
AsymmetricCipherKeyPair kp = kpg.GenerateKeyPair();
Ed25519PrivateKeyParameters privateKey = (Ed25519PrivateKeyParameters)kp.Private;
Ed25519PublicKeyParameters publicKey = (Ed25519PublicKeyParameters)kp.Public;
var privKeyBase64 = Convert.ToBase64String(privateKey.GetEncoded());
var pubKeyBase64 = Convert.ToBase64String(publicKey.GetEncoded());
var manager = GetSignatureManager();
Environment.SetEnvironmentVariable(SignatureManager.PrivateKeyEnvironmentVariable, privKeyBase64);
Environment.SetEnvironmentVariable(SignatureManager.PublicKeyEnvironmentVariable, pubKeyBase64);
// get signature of file
var signature = manager.GetSignatureForFile(path);
manager.Generate(true); // force regeneration of keys to "prove" that we are using environment
// verify signature
Assert.True(manager.VerifySignature(path, signature));
// get rid of temp file
File.Delete(path);
}
/// <summary>
/// Create a Subject Public Key Info object for a given public key.
/// </summary>
/// <param name="publicKey">One of ElGammalPublicKeyParameters, DSAPublicKeyParameter, DHPublicKeyParameters, RsaKeyParameters or ECPublicKeyParameters</param>
/// <returns>A subject public key info object.</returns>
/// <exception cref="Exception">Throw exception if object provided is not one of the above.</exception>
public static SubjectPublicKeyInfo CreateSubjectPublicKeyInfo(
AsymmetricKeyParameter publicKey)
{
if (publicKey == null)
throw new ArgumentNullException("publicKey");
if (publicKey.IsPrivate)
throw new ArgumentException("Private key passed - public key expected.", "publicKey");
if (publicKey is ElGamalPublicKeyParameters)
{
ElGamalPublicKeyParameters _key = (ElGamalPublicKeyParameters)publicKey;
ElGamalParameters kp = _key.Parameters;
SubjectPublicKeyInfo info = new SubjectPublicKeyInfo(
new AlgorithmIdentifier(
OiwObjectIdentifiers.ElGamalAlgorithm,
new ElGamalParameter(kp.P, kp.G).ToAsn1Object()),
new DerInteger(_key.Y));
return info;
}
if (publicKey is DsaPublicKeyParameters)
{
DsaPublicKeyParameters _key = (DsaPublicKeyParameters) publicKey;
DsaParameters kp = _key.Parameters;
Asn1Encodable ae = kp == null
? null
: new DsaParameter(kp.P, kp.Q, kp.G).ToAsn1Object();
return new SubjectPublicKeyInfo(
new AlgorithmIdentifier(X9ObjectIdentifiers.IdDsa, ae),
new DerInteger(_key.Y));
}
if (publicKey is DHPublicKeyParameters)
{
DHPublicKeyParameters _key = (DHPublicKeyParameters) publicKey;
DHParameters kp = _key.Parameters;
SubjectPublicKeyInfo info = new SubjectPublicKeyInfo(
new AlgorithmIdentifier(
_key.AlgorithmOid,
new DHParameter(kp.P, kp.G, kp.L).ToAsn1Object()),
new DerInteger(_key.Y));
return info;
} // End of DH
if (publicKey is RsaKeyParameters)
{
RsaKeyParameters _key = (RsaKeyParameters) publicKey;
SubjectPublicKeyInfo info = new SubjectPublicKeyInfo(
new AlgorithmIdentifier(PkcsObjectIdentifiers.RsaEncryption, DerNull.Instance),
new RsaPublicKeyStructure(_key.Modulus, _key.Exponent).ToAsn1Object());
return info;
} // End of RSA.
if (publicKey is ECPublicKeyParameters)
{
ECPublicKeyParameters _key = (ECPublicKeyParameters) publicKey;
if (_key.Parameters is ECGost3410Parameters)
{
ECGost3410Parameters gostParams = (ECGost3410Parameters)_key.Parameters;
BigInteger bX = _key.Q.AffineXCoord.ToBigInteger();
BigInteger bY = _key.Q.AffineYCoord.ToBigInteger();
bool is512 = (bX.BitLength > 256);
Gost3410PublicKeyAlgParameters parameters = new Gost3410PublicKeyAlgParameters(
gostParams.PublicKeyParamSet,
gostParams.DigestParamSet,
gostParams.EncryptionParamSet);
int encKeySize;
int offset;
DerObjectIdentifier algIdentifier;
if (is512)
{
encKeySize = 128;
offset = 64;
algIdentifier = RosstandartObjectIdentifiers.id_tc26_gost_3410_12_512;
}
else
{
encKeySize = 64;
offset = 32;
algIdentifier = RosstandartObjectIdentifiers.id_tc26_gost_3410_12_256;
}
byte[] encKey = new byte[encKeySize];
ExtractBytes(encKey, encKeySize / 2, 0, bX);
ExtractBytes(encKey, encKeySize / 2, offset, bY);
return new SubjectPublicKeyInfo(new AlgorithmIdentifier(algIdentifier, parameters), new DerOctetString(encKey));
} // End of ECGOST3410_2012
if (_key.AlgorithmName == "ECGOST3410")
{
if (_key.PublicKeyParamSet == null)
throw Platform.CreateNotImplementedException("Not a CryptoPro parameter set");
ECPoint q = _key.Q.Normalize();
BigInteger bX = q.AffineXCoord.ToBigInteger();
BigInteger bY = q.AffineYCoord.ToBigInteger();
byte[] encKey = new byte[64];
ExtractBytes(encKey, 0, bX);
ExtractBytes(encKey, 32, bY);
Gost3410PublicKeyAlgParameters gostParams = new Gost3410PublicKeyAlgParameters(
_key.PublicKeyParamSet, CryptoProObjectIdentifiers.GostR3411x94CryptoProParamSet);
AlgorithmIdentifier algID = new AlgorithmIdentifier(
CryptoProObjectIdentifiers.GostR3410x2001,
gostParams.ToAsn1Object());
return new SubjectPublicKeyInfo(algID, new DerOctetString(encKey));
}
else
{
X962Parameters x962;
if (_key.PublicKeyParamSet == null)
{
ECDomainParameters kp = _key.Parameters;
X9ECParameters ecP = new X9ECParameters(kp.Curve, kp.G, kp.N, kp.H, kp.GetSeed());
x962 = new X962Parameters(ecP);
}
else
{
x962 = new X962Parameters(_key.PublicKeyParamSet);
}
byte[] pubKey = _key.Q.GetEncoded(false);
AlgorithmIdentifier algID = new AlgorithmIdentifier(
X9ObjectIdentifiers.IdECPublicKey, x962.ToAsn1Object());
return new SubjectPublicKeyInfo(algID, pubKey);
}
} // End of EC
if (publicKey is Gost3410PublicKeyParameters)
{
Gost3410PublicKeyParameters _key = (Gost3410PublicKeyParameters) publicKey;
if (_key.PublicKeyParamSet == null)
throw Platform.CreateNotImplementedException("Not a CryptoPro parameter set");
byte[] keyEnc = _key.Y.ToByteArrayUnsigned();
byte[] keyBytes = new byte[keyEnc.Length];
for (int i = 0; i != keyBytes.Length; i++)
{
keyBytes[i] = keyEnc[keyEnc.Length - 1 - i]; // must be little endian
}
Gost3410PublicKeyAlgParameters algParams = new Gost3410PublicKeyAlgParameters(
_key.PublicKeyParamSet, CryptoProObjectIdentifiers.GostR3411x94CryptoProParamSet);
AlgorithmIdentifier algID = new AlgorithmIdentifier(
CryptoProObjectIdentifiers.GostR3410x94,
algParams.ToAsn1Object());
return new SubjectPublicKeyInfo(algID, new DerOctetString(keyBytes));
}
if (publicKey is X448PublicKeyParameters)
{
X448PublicKeyParameters key = (X448PublicKeyParameters)publicKey;
return new SubjectPublicKeyInfo(new AlgorithmIdentifier(EdECObjectIdentifiers.id_X448), key.GetEncoded());
}
if (publicKey is X25519PublicKeyParameters)
{
X25519PublicKeyParameters key = (X25519PublicKeyParameters)publicKey;
return new SubjectPublicKeyInfo(new AlgorithmIdentifier(EdECObjectIdentifiers.id_X25519), key.GetEncoded());
}
if (publicKey is Ed448PublicKeyParameters)
{
Ed448PublicKeyParameters key = (Ed448PublicKeyParameters)publicKey;
return new SubjectPublicKeyInfo(new AlgorithmIdentifier(EdECObjectIdentifiers.id_Ed448), key.GetEncoded());
}
if (publicKey is Ed25519PublicKeyParameters)
{
Ed25519PublicKeyParameters key = (Ed25519PublicKeyParameters)publicKey;
return new SubjectPublicKeyInfo(new AlgorithmIdentifier(EdECObjectIdentifiers.id_Ed25519), key.GetEncoded());
}
throw new ArgumentException("Class provided no convertible: " + Platform.GetTypeName(publicKey));
}
internal static ReadOnlyMemory <byte> ToBytes(Ed25519PublicKeyParameters publicKeyParameters)
{
return(publicKeyPrefix.Concat(publicKeyParameters.GetEncoded()).ToArray());
}