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}\"."); }