public void TestVerifyingForMessagesMethodEquivalence()
{
var privateKey = _wrapper.GeneratePrivateKey();
var message1 = new PublicEntry {Nonce = 123};
var context = new SigningContext {NetworkType = NetworkType.Mainnet};
var signature = _wrapper.Sign(privateKey, message1.ToByteArray(), context.ToByteArray());
var expected = _wrapper.Verify(signature, message1.ToByteArray(), context.ToByteArray());
var actual = _wrapper.Verify(signature, message1, context);
actual.Should().Be(expected);
}
private IActionResult LikeOrUnlikeTweet(string tweetId, bool value)
{
var tweetLike = new TweetLikeData
{
TweetId = tweetId,
PublicKey = Base58.Bitcoin.Encode(_publicKey.Bytes),
PostedDate = DateTime.UtcNow
};
var signatureBytes = _cryptoWrapper.StdSign(_privateKey,
Encoding.UTF8.GetBytes($"{tweetLike.TweetId}{tweetLike.PublicKey}{value}{tweetLike.PostedDate}"),
_signingContext.ToByteArray()).SignatureBytes;
tweetLike.Signature = Base58.Bitcoin.Encode(signatureBytes);
var client = new RestClient(_twitterModuleConfig.TwitterLikesApiUrl);
var endpoint = value ? "Like" : "Unlike";
var request = new RestRequest($"/api/TweetLike/{endpoint}");
request.AddJsonBody(tweetLike);
var response = client.Post(request);
if (!response.IsSuccessful)
{
return(BadRequest(response.ErrorMessage));
}
return(Ok());
}
public static TransactionBroadcast Sign(this TransactionBroadcast transaction,
ICryptoContext cryptoContext,
IPrivateKey privateKey,
SigningContext context)
{
var clone = transaction.Clone();
if (transaction.Signature?.RawBytes.Length == cryptoContext.SignatureLength)
{
Logger.Debug("The transaction was already signed, returning a clone.");
return(clone);
}
clone.Signature = null;
var signatureBytes = cryptoContext.Sign(privateKey, clone.ToByteArray(),
context.ToByteArray()).SignatureBytes;
clone.Signature = new Signature
{
RawBytes = signatureBytes.ToByteString(),
SigningContext = context
};
return(clone);
}
private static Signature GeneratePublicEntrySignature(PublicEntry publicEntry,
ICryptoContext cryptoContext,
IPrivateKey privateKey,
SigningContext context)
{
publicEntry.Signature = null;
var signatureBytes = cryptoContext.Sign(privateKey, publicEntry.ToByteArray(),
context.ToByteArray()).SignatureBytes;
return(new Signature
{
RawBytes = signatureBytes.ToByteString(),
SigningContext = context
});
}
public static Signature GenerateSignature(IWrapper cryptoWrapper, IPrivateKey privateKey,
TransactionBroadcast transactionBroadcast, SigningContext signingContext)
{
var transactionWithoutSig = transactionBroadcast.Clone();
transactionWithoutSig.Signature = null;
var signature = cryptoWrapper.StdSign(privateKey, transactionWithoutSig.ToByteArray(),
signingContext.ToByteArray());
var sig = new Signature
{
RawBytes = ByteString.CopyFrom(signature.SignatureBytes), SigningContext = signingContext
};
return(sig);
}
private ISignature Sign(byte[] data, SigningContext signingContext, IPrivateKey privateKey)
{
return(_cryptoContext.Sign(privateKey, data, signingContext.ToByteArray()));
}
/// <inheritdoc/>
public bool Verify(ISignature signature, byte[] message, SigningContext signingContext)
{
return(_cryptoContext.Verify(signature, message, signingContext.ToByteArray()));
}
public void Valid_Message_Signature_Can_Return_True_Response()
{
var privateKey = _keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey);
var signingContext = new SigningContext
{
NetworkType = NetworkType.Devnet,
SignatureType = SignatureType.TransactionPublic
};
var requestMessage = new VerifyMessageRequest
{
Message = _testMessageToSign,
PublicKey = privateKey.GetPublicKey().Bytes.ToByteString(),
Signature = _keySigner.CryptoContext.Sign(privateKey, _testMessageToSign.ToByteArray(), signingContext.ToByteArray()).SignatureBytes.ToByteString(),
SigningContext = signingContext
};
_verifyMessageRequestObserver
.OnNext(new ObserverDto(_fakeContext,
requestMessage.ToProtocolMessage(_peerId)));
AssertVerifyResponse(true);
}
public void ValidateTransactionSignature_will_pass_with_valid_transaction_signature()
{
var subbedLogger = Substitute.For <ILogger>();
var cryptoContext = new FfiWrapper();
var transactionValidator = new TransactionValidator(subbedLogger, cryptoContext);
// build a valid transaction
var privateKey = cryptoContext.GeneratePrivateKey();
var validTransaction = new PublicEntry
{
SenderAddress = privateKey.GetPublicKey().Bytes.ToByteString()
};
var signingContext = new SigningContext
{
NetworkType = NetworkType.Devnet,
SignatureType = SignatureType.TransactionPublic
};
var signature = new Signature
{
// sign an actual TransactionBroadcast object
RawBytes = cryptoContext.Sign(privateKey, validTransaction.ToByteArray(), signingContext.ToByteArray())
.SignatureBytes.ToByteString(),
SigningContext = signingContext
};
validTransaction.Signature = signature;
var result = transactionValidator.ValidateTransaction(validTransaction);
result.Should().BeTrue();
}
