public void KeySigner_Can_Verify_A_Signature()
{
var toSign = Encoding.UTF8.GetBytes("sign this plz");
var signature = _keySigner.Sign(toSign, new SigningContext());
_keySigner.Verify(signature, toSign, new SigningContext()).Should().BeTrue();
}
private void CanFireNextPipelineOnValidSignature()
{
_keySigner.Verify(Arg.Any <ISignature>(), Arg.Any <byte[]>(), default)
.ReturnsForAnyArgs(true);
var signatureHandler = new ProtocolMessageVerifyHandler(_keySigner);
signatureHandler.ChannelRead(_fakeContext, _protocolMessageSigned);
_fakeContext.ReceivedWithAnyArgs().FireChannelRead(_protocolMessageSigned).Received(1);
}
// [Fact(Skip = "true")]
public async Task PeerClientChannelFactory_should_put_the_correct_handlers_on_the_inbound_pipeline()
{
var testingChannel = new EmbeddedChannel("test".ToChannelId(),
true, _factory.InheritedHandlers.ToArray());
var senderId = PeerIdHelper.GetPeerId("sender");
var correlationId = CorrelationId.GenerateCorrelationId();
var protocolMessage = new PingRequest().ToProtocolMessage(senderId, correlationId);
var signature = ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength);
var signedMessage = protocolMessage.Sign(signature);
_keySigner.Verify(Arg.Is <ISignature>(s => s.SignatureBytes.SequenceEqual(signature)), Arg.Any <byte[]>(),
default)
.ReturnsForAnyArgs(true);
var observer = new ProtocolMessageObserver(0, Substitute.For <ILogger>());
var messageStream = ((ObservableServiceHandler)_factory.InheritedHandlers.Last()).MessageStream;
using (messageStream.Subscribe(observer))
{
testingChannel.WriteInbound(signedMessage);
_correlationManager.DidNotReceiveWithAnyArgs().TryMatchResponse(protocolMessage);
await _gossipManager.DidNotReceiveWithAnyArgs().BroadcastAsync(null);
_keySigner.ReceivedWithAnyArgs(1).Verify(null, null, null);
_testScheduler.Start();
observer.Received.Count.Should().Be(1);
observer.Received.Single().Payload.CorrelationId.ToCorrelationId().Id.Should().Be(correlationId.Id);
}
}
public void RpcServerChannelFactory_should_put_the_correct_inbound_handlers_on_the_pipeline()
{
var testingChannel = new EmbeddedChannel("test".ToChannelId(),
true, _factory.InheritedHandlers.ToArray());
var senderId = PeerIdHelper.GetPeerId("sender");
var correlationId = CorrelationId.GenerateCorrelationId();
var signatureBytes = ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength);
_keySigner.Verify(Arg.Any <ISignature>(), Arg.Any <byte[]>(), Arg.Any <SigningContext>())
.Returns(true);
var protocolMessage = new PingRequest().ToSignedProtocolMessage(senderId, signatureBytes, correlationId: correlationId);
var observer = new ProtocolMessageObserver(0, Substitute.For <ILogger>());
var messageStream = _factory.InheritedHandlers.OfType <ObservableServiceHandler>()
.Single().MessageStream;
using (messageStream.Subscribe(observer))
{
testingChannel.WriteInbound(protocolMessage);
_correlationManager.DidNotReceiveWithAnyArgs().TryMatchResponse(protocolMessage);
_keySigner.ReceivedWithAnyArgs(1).Verify(null, null, null);
_testScheduler.Start();
observer.Received.Count.Should().Be(1);
observer.Received.Single().Payload.CorrelationId.ToCorrelationId().Id.Should().Be(correlationId.Id);
}
}
public PeerServerChannelFactoryTests()
{
_testScheduler = new TestScheduler();
_correlationManager = Substitute.For <IPeerMessageCorrelationManager>();
_gossipManager = Substitute.For <IBroadcastManager>();
_keySigner = Substitute.For <IKeySigner>();
var peerSettings = Substitute.For <IPeerSettings>();
peerSettings.NetworkType.Returns(NetworkType.Devnet);
var peerValidator = Substitute.For <IPeerIdValidator>();
peerValidator.ValidatePeerIdFormat(Arg.Any <PeerId>()).Returns(true);
_factory = new TestPeerServerChannelFactory(
_correlationManager,
_gossipManager,
_keySigner,
peerValidator,
peerSettings,
_testScheduler);
_senderId = PeerIdHelper.GetPeerId("sender");
_correlationId = CorrelationId.GenerateCorrelationId();
_signature = ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength);
_keySigner.Verify(Arg.Any <ISignature>(), Arg.Any <byte[]>(), default)
.ReturnsForAnyArgs(true);
}
RpcServerChannelFactory_Pipeline_Should_Produce_Response_Object_RpcClientChannelFactory_Can_Process()
{
var recipient = PeerIdHelper.GetPeerId("recipient");
var sender = PeerIdHelper.GetPeerId("sender");
var signature = Substitute.For <ISignature>();
_peerIdValidator.ValidatePeerIdFormat(Arg.Any <PeerId>()).Returns(true);
_serverKeySigner.Sign(Arg.Any <byte[]>(), default).ReturnsForAnyArgs(signature);
var correlationId = CorrelationId.GenerateCorrelationId();
var protocolMessage = new GetPeerCountResponse().ToProtocolMessage(sender, correlationId);
var dto = new MessageDto(
protocolMessage,
recipient
);
_clientCorrelationManager.TryMatchResponse(Arg.Any <ProtocolMessage>()).Returns(true);
_serverChannel.WriteOutbound(dto);
var sentBytes = _serverChannel.ReadOutbound <IByteBuffer>();
_serverCorrelationManager.DidNotReceiveWithAnyArgs().AddPendingRequest(Arg.Any <CorrelatableMessage <ProtocolMessage> >());
_serverKeySigner.ReceivedWithAnyArgs(1)
.Sign(Arg.Any <byte[]>(), default);
_clientKeySigner.Verify(
Arg.Any <ISignature>(),
Arg.Any <byte[]>(),
default)
.ReturnsForAnyArgs(true);
_authenticationStrategy.Authenticate(Arg.Any <PeerId>()).Returns(true);
var observer = new ProtocolMessageObserver(0, Substitute.For <ILogger>());
var messageStream = _clientFactory.InheritedHandlers.OfType <ObservableServiceHandler>().Single().MessageStream;
using (messageStream.Subscribe(observer))
{
_clientChannel.WriteInbound(sentBytes);
_clientChannel.ReadInbound <ProtocolMessage>();
_clientCorrelationManager.ReceivedWithAnyArgs(1).TryMatchResponse(Arg.Any <ProtocolMessage>());
_clientKeySigner.ReceivedWithAnyArgs(1).Verify(null, null, null);
_testScheduler.Start();
observer.Received.Count.Should().Be(1);
observer.Received.Single().Payload.CorrelationId.ToCorrelationId().Id.Should().Be(correlationId.Id);
}
await _serverChannel.DisconnectAsync();
await _clientChannel.DisconnectAsync();
}
private bool Verify(ProtocolMessage signedMessage)
{
if (signedMessage.Signature == null)
{
return(false);
}
var sig = signedMessage.Signature.RawBytes.ToByteArray();
var pub = signedMessage.PeerId.PublicKey.ToByteArray();
var signature = _keySigner.CryptoContext.GetSignatureFromBytes(sig, pub);
var messageWithoutSig = signedMessage.Clone();
messageWithoutSig.Signature = null;
return(_keySigner.Verify(signature, messageWithoutSig, signedMessage.Signature.SigningContext));
}
/// <param name="verifyMessageRequest"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerId"></param>
/// <param name="correlationId"></param>
/// <returns></returns>
protected override VerifyMessageResponse HandleRequest(VerifyMessageRequest verifyMessageRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
Guard.Argument(verifyMessageRequest, nameof(verifyMessageRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerId, nameof(senderPeerId)).NotNull();
Logger.Debug("received message of type VerifyMessageRequest");
var decodedMessage = verifyMessageRequest.Message.ToByteArray();
var decodedPublicKey = verifyMessageRequest.PublicKey.ToByteArray();
var decodedSignature = verifyMessageRequest.Signature.ToByteArray();
var signatureContext = verifyMessageRequest.SigningContext;
if (decodedPublicKey.Length != _keySigner.CryptoContext.PublicKeyLength)
{
Logger.Error("{0} {1}", PublicKeyInvalid, verifyMessageRequest);
return(ReturnResponse(false));
}
if (decodedSignature.Length != _keySigner.CryptoContext.SignatureLength)
{
Logger.Error("{0} {1}", SignatureInvalid, verifyMessageRequest);
return(ReturnResponse(false));
}
ISignature signature = null;
try
{
signature = _keySigner.CryptoContext.GetSignatureFromBytes(decodedSignature, decodedPublicKey);
}
catch (Exception e)
{
Logger.Error(e, "{0} {1}", SignatureInvalid, verifyMessageRequest);
return(ReturnResponse(false));
}
var result = _keySigner.Verify(signature, decodedMessage, signatureContext);
Logger.Debug("message content is {0}", verifyMessageRequest.Message);
return(ReturnResponse(result));
}
public BroadcastHandlerTests()
{
_keySigner = Substitute.For <IKeySigner>();
_keySigner.Verify(Arg.Any <ISignature>(), Arg.Any <byte[]>(), default).ReturnsForAnyArgs(true);
_fakeBroadcastManager = Substitute.For <IBroadcastManager>();
_broadcastHandler = new BroadcastHandler(_fakeBroadcastManager);
var fakeSignature = Substitute.For <ISignature>();
fakeSignature.SignatureBytes.Returns(ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength));
_signingContext = DevNetPeerSigningContext.Instance;
var peerId = PeerIdHelper.GetPeerId("Test");
var innerMessage = new TransactionBroadcast();
_broadcastMessageSigned = innerMessage
.ToSignedProtocolMessage(peerId, fakeSignature, _signingContext)
.ToSignedProtocolMessage(peerId, fakeSignature, _signingContext);
}
public static bool Verify(this IKeySigner crypto, ISignature signature, IMessage message, SigningContext context)
{
using var pooled = message.SerializeToPooledBytes();
return(crypto.Verify(signature, pooled.Span, context));
}
