public void TestStdSignVerify()
{
IPrivateKey privateKey = _wrapper.GeneratePrivateKey();
byte[] message = Encoding.UTF8.GetBytes("fa la la la");
byte[] context = Encoding.UTF8.GetBytes("context");
ISignature signature = _wrapper.Sign(privateKey, message, context);
bool isVerified = _wrapper.Verify(signature, message, context);
isVerified.Should().BeTrue();
}
private bool ValidateTransactionSignature(PublicEntry transaction)
{
if (transaction.Signature.RawBytes == ByteString.Empty)
{
_logger.Error("Transaction signature is null");
return(false);
}
var transactionSignature = _cryptoContext.GetSignatureFromBytes(transaction.Signature.RawBytes.ToByteArray(),
transaction.SenderAddress.ToByteArray());
var signingContext = transaction.Signature.SigningContext.ToByteArray();
// we need to verify the signature matches the message, but transactionBroadcast contains the signature and original data,
// passing message+sig will mean your verifying an incorrect message and always return false, so just null the sig.
var transactionClone = transaction.Clone();
transactionClone.Signature = null;
if (_cryptoContext.Verify(transactionSignature, transactionClone.ToByteArray(), signingContext))
{
return(true);
}
_logger.Information(
"Transaction Signature {signature} invalid.",
transactionSignature);
return(false);
}
public (byte[], bool) Run(byte[] inputData)
{
if (inputData.Length != 160)
{
return(Bytes.Empty, false);
}
byte[] message = inputData.AsSpan().Slice(0, 32).ToArray();
byte[] signatureBytes = inputData.AsSpan().Slice(32, 64).ToArray();
byte[] signingContext = inputData.AsSpan().Slice(96, 32).ToArray();
byte[] publicKey = inputData.AsSpan().Slice(128, 32).ToArray();
ISignature signature = _cryptoContext.GetSignatureFromBytes(signatureBytes, publicKey);
return(_cryptoContext.Verify(signature, message, signingContext)
? (new byte[] { 1 }, true)
: (new byte[] { 0 }, true));
}
public static bool Verify(this ICryptoContext crypto, ISignature signature, IMessage message, IMessage context)
{
ProtoPreconditions.CheckNotNull(message, nameof(message));
ProtoPreconditions.CheckNotNull(context, nameof(context));
var messageSize = message.CalculateSize();
var contextSize = context.CalculateSize();
var array = ArrayPool <byte> .Shared.Rent(messageSize + contextSize);
using (var output = new CodedOutputStream(array))
{
message.WriteTo(output);
context.WriteTo(output);
}
var result = crypto.Verify(signature, array.AsSpan(0, messageSize), array.AsSpan(messageSize, contextSize));
ArrayPool <byte> .Shared.Return(array);
return(result);
}
public void TestFailureSigningVerification()
{
var key1 = _context.GeneratePrivateKey();
var data = Encoding.UTF8.GetBytes("Testing testing 1 2 3");
var signingContext = Encoding.UTF8.GetBytes("Testing testing 1 2 3 context");
var signature = _context.Sign(key1, data, signingContext);
var key2 = _context.GeneratePrivateKey();
var publicKey2 = _context.GetPublicKeyFromPrivateKey(key2);
var invalidSignature = _context.GetSignatureFromBytes(signature.SignatureBytes, publicKey2.Bytes);
_context.Verify(invalidSignature, data, signingContext)
.Should().BeFalse("signature should not verify with incorrect key");
}
private bool ValidateTransactionSignature(TransactionBroadcast transactionBroadcast, NetworkType networkType)
{
if (transactionBroadcast.Signature.RawBytes == ByteString.Empty)
{
_logger.Error("Transaction signature is null");
return(false);
}
var transactionSignature = _cryptoContext.GetSignatureFromBytes(transactionBroadcast.Signature.RawBytes.ToByteArray(),
transactionBroadcast.PublicEntries.First().Base.SenderPublicKey.ToByteArray());
var transactionWithoutSig = transactionBroadcast.Clone();
transactionWithoutSig.Signature = null;
if (!_cryptoContext.Verify(transactionSignature, transactionWithoutSig.ToByteArray(), transactionBroadcast.Signature.SigningContext.ToByteArray()))
{
return(true);
}
_logger.Information(
"Transaction Signature {signature} invalid.",
transactionSignature);
return(false);
}
/// <inheritdoc/>
public bool Verify(ISignature signature, byte[] message, SigningContext signingContext)
{
return(_cryptoContext.Verify(signature, message, signingContext.ToByteArray()));
}
/// <inheritdoc/>
public bool Verify(ISignature signature, ReadOnlySpan <byte> data, SigningContext signingContext)
{
using var pooled = signingContext.SerializeToPooledBytes();
return(_cryptoContext.Verify(signature, data, pooled.Span));
}
