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 verify(byte[] msg, byte[] signature)
{
var verifier = new Ed25519Signer();
verifier.Init(false, publicKey);
verifier.BlockUpdate(msg, 0, msg.Length);
return(verifier.VerifySignature(signature));
}
byte[] ICryptoLibrary.SignEd25519(byte[] plainText, byte[] privateKey)
{
var signer = new Ed25519Signer();
signer.Init(true, new Ed25519PrivateKeyParameters(privateKey, 0));
signer.BlockUpdate(plainText, 0, plainText.Length);
return(signer.GenerateSignature());
}
public static bool Verify(byte[] data, byte[] signature, string publicKey)
{
Ed25519Signer verifier = new Ed25519Signer();
verifier.Init(false, publicKey.ToPublicKeyCipherParamsFromHex());
verifier.BlockUpdate(data, 0, data.Length);
return(verifier.VerifySignature(signature));
}
public static byte[] Sign(byte[] data, string privateKey)
{
Ed25519Signer signer = new Ed25519Signer();
signer.Init(true, privateKey.ToPrivateKeyCipherParamsFromHex());
signer.BlockUpdate(data, 0, data.Length);
return(signer.GenerateSignature());
}
public byte[] sign(byte[] msg)
{
var signer = new Ed25519Signer();
signer.Init(true, privateKey);
signer.BlockUpdate(msg, 0, msg.Length);
return(signer.GenerateSignature());
}
/// <summary>
/// Sign the given bytes, and wrap in Signature.
/// </summary>
/// <param name="bytes">bytes the data to sign</param>
/// <returns>a signature</returns>
private Signature RawSignBytes(byte[] bytes)
{
var signer = new Ed25519Signer();
signer.Init(true, privateKeyPair.Private);
signer.BlockUpdate(bytes, 0, bytes.Length);
byte[] signature = signer.GenerateSignature();
return(new Signature(signature));
}
public override bool Verify(byte[] input, byte[] signature)
{
var validator = new Ed25519Signer();
validator.Init(false, edDsaKey.KeyParameters);
validator.BlockUpdate(input, 0, input.Length);
return(validator.VerifySignature(signature));
}
public override byte[] Sign(byte[] input)
{
var signer = new Ed25519Signer();
signer.Init(true, edDsaKey.KeyParameters);
signer.BlockUpdate(input, 0, input.Length);
return(signer.GenerateSignature());
}
/// <summary>
/// Perform signature verification against the sender address
/// </summary>
/// <param name="address">Address to verify</param>
/// <returns>bool</returns>
public bool Verify(Address address)
{
if (this.logic == null)
{
return(false);
}
else if (this.sig != null && this.msig != null)
{
return(false);
}
else
{
try
{
Logic.CheckProgram(this.logic, this.args);
}
catch (Exception)
{
return(false);
}
if (this.sig == null && this.msig == null)
{
try
{
return(address.Equals(this.ToAddress()));
}
catch (Exception)
{
return(false);
}
}
if (this.sig != null)
{
try
{
var pk = new Ed25519PublicKeyParameters(address.Bytes, 0);
var signer = new Ed25519Signer();
signer.Init(false, pk); //false代表用于VerifySignature
signer.BlockUpdate(this.BytesToSign(), 0, this.BytesToSign().Length);
return(signer.VerifySignature(this.sig.Bytes));
}
catch (Exception err)
{
Console.WriteLine("Message = " + err.Message);
return(false);
}
}
else
{
return(this.msig.Verify(this.BytesToSign()));
}
}
}
public bool VerifyStamp(TimestampDao timestamp)
{
var fileHash = timestamp.FileHash.ToUpper().FromBase32();
var signature = timestamp.Signature.ToUpper().FromBase32();
var publicKey = new Ed25519PublicKeyParameters(timestamp.PublicKey.ToUpper().FromBase32(), 0);
var verifier = new Ed25519Signer();
verifier.Init(false, publicKey);
verifier.BlockUpdate(fileHash, 0, fileHash.Length);
return(verifier.VerifySignature(signature));
}
/// <summary>
/// Performs signature verification
/// </summary>
/// <param name="message">raw message to verify</param>
/// <returns>bool</returns>
public bool Verify(byte[] message)
{
if (this.version == 1 && this.threshold > 0 && this.subsigs.Count != 0)
{
if (this.threshold > this.subsigs.Count)
{
return(false);
}
else
{
int verifiedCount = 0;
Signature emptySig = new Signature();
for (int i = 0; i < this.subsigs.Count; ++i)
{
MultisigSubsig subsig = subsigs[i];
if (!subsig.sig.Equals(emptySig))
{
try
{
var pk = subsig.key;
var signer = new Ed25519Signer();
signer.Init(false, pk); //for verify
signer.BlockUpdate(message, 0, message.Length);
bool verified = signer.VerifySignature(subsig.sig.Bytes);
if (verified)
{
++verifiedCount;
}
}
catch (Exception var9)
{
throw new ArgumentException("verification of subsig " + i + "failed", var9);
}
}
}
if (verifiedCount < this.threshold)
{
return(false);
}
else
{
return(true);
}
}
}
else
{
return(false);
}
}
/// <inheritdoc/>
public ValidationResult VerifySignature(string signature, byte[] dataToVerify)
{
ValidationResult res = ValidationResult.Invalid;
if (!CheckSecurityMode(signature, ref res))
{
return(res);
}
// convert signature
byte[] bHash = Convert.FromBase64String(signature);
_signer.BlockUpdate(dataToVerify, 0, dataToVerify.Length);
// verify
return(_signer.VerifySignature(bHash) ? ValidationResult.Valid : ValidationResult.Invalid);
}
byte[] ICryptoLibrary.SignEd25519(byte[] plainText, byte[] privateKey)
{
if (privateKey == null)
{
throw new ArgumentException(nameof(privateKey));
}
if (plainText == null)
{
throw new ArgumentException(nameof(plainText));
}
var signer = new Ed25519Signer();
signer.Init(true, new Ed25519PrivateKeyParameters(privateKey, 0));
signer.BlockUpdate(plainText, 0, plainText.Length);
return(signer.GenerateSignature());
}
/// <summary>
/// verifyBytes verifies that the signature for the message is valid for the public key.
/// The message should have been prepended with "MX" when signing.
/// </summary>
/// <param name="message">the message that was signed</param>
/// <param name="signature">signature</param>
/// <returns>true if the signature is valid</returns>
public bool VerifyBytes(byte[] message, Signature signature)
{
var pk = new Ed25519PublicKeyParameters(this.Bytes, 0);
// prepend the message prefix
List <byte> prefixBytes = new List <byte>(BYTES_SIGN_PREFIX);
prefixBytes.AddRange(message);
// verify signature
// Generate new signature
var signer = new Ed25519Signer();
signer.Init(false, pk);
signer.BlockUpdate(prefixBytes.ToArray(), 0, prefixBytes.ToArray().Length);
return(signer.VerifySignature(signature.Bytes));
}
/// <inheritdoc/>
public override byte[] Sign(byte[] input)
{
if (input == null || input.Length == 0)
{
throw new ArgumentNullException(nameof(input));
}
if (EdDsaKey.Curve.Equals("Ed25519"))
{
var privateKey = (Ed25519PrivateKeyParameters)EdDsaKey.KeyParameter;
var signer = new Ed25519Signer();
signer.Init(forSigning: true, privateKey);
signer.BlockUpdate(input, off: 0, len: input.Length);
return(signer.GenerateSignature());
}
throw new ArgumentException($"Unsupported EdDSA curve: \"{EdDsaKey.Curve}\".");
}
/// <inheritdoc/>
public override bool Verify(byte[] input, byte[] signature)
{
if (input == null || input.Length == 0)
{
throw new ArgumentNullException(nameof(input));
}
if (signature == null || signature.Length == 0)
{
throw new ArgumentNullException(nameof(signature));
}
if (EdDsaKey.Curve.Equals("Ed25519"))
{
var publicKey = (Ed25519PublicKeyParameters)EdDsaKey.KeyParameter;
var validator = new Ed25519Signer();
validator.Init(forSigning: false, publicKey);
validator.BlockUpdate(input, off: 0, len: input.Length);
return(validator.VerifySignature(signature));
}
throw new ArgumentException($"Unsupported EdDSA curve: \"{EdDsaKey.Curve}\".");
}
