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);
}
public RpcServerChannelFactoryTests()
{
_testScheduler = new TestScheduler();
_correlationManager = Substitute.For <IRpcMessageCorrelationManager>();
_keySigner = Substitute.For <IKeySigner>();
_keySigner.CryptoContext.SignatureLength.Returns(64);
var authenticationStrategy = Substitute.For <IAuthenticationStrategy>();
authenticationStrategy.Authenticate(Arg.Any <PeerId>()).Returns(true);
var peerSettings = Substitute.For <IPeerSettings>();
peerSettings.NetworkType.Returns(NetworkType.Devnet);
var peerIdValidator = Substitute.For <IPeerIdValidator>();
peerIdValidator.ValidatePeerIdFormat(Arg.Any <PeerId>()).Returns(true);
_factory = new TestRpcServerChannelFactory(
_correlationManager,
_keySigner,
authenticationStrategy,
peerIdValidator,
peerSettings,
_testScheduler);
}
public VerifyMessageRequestObserver(IPeerSettings peerSettings,
ILogger logger,
IKeySigner keySigner)
: base(logger, peerSettings)
{
_keySigner = keySigner;
}
public CatalystNodePoa(IKeySigner keySigner,
IPeerService peer,
IConsensus consensus,
IDfs dfs,
ILedger ledger,
ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
IMempool <PublicEntryDao> memPool,
IContract contract = null)
{
_peer = peer;
_peerClient = peerClient;
_peerSettings = peerSettings;
Consensus = consensus;
_dfs = dfs;
_ledger = ledger;
_keySigner = keySigner;
_logger = logger;
_memPool = memPool;
_contract = contract;
var privateKey = keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey);
_publicKey = keySigner.CryptoContext.GetPublicKeyFromPrivateKey(privateKey);
}
public void Init()
{
Setup(TestContext.CurrentContext);
_testMessageToSign = ByteString.CopyFromUtf8("TestMsg");
ContainerProvider.ContainerBuilder.RegisterInstance(TestKeyRegistry.MockKeyRegistry()).As <IKeyRegistry>();
ContainerProvider.ContainerBuilder.RegisterModule(new KeystoreModule());
ContainerProvider.ContainerBuilder.RegisterModule(new KeySignerModule());
ContainerProvider.ContainerBuilder.RegisterModule(new RpcServerModule());
ContainerProvider.ContainerBuilder.RegisterModule(new DfsModule());
ContainerProvider.ContainerBuilder.RegisterModule(new MempoolModule());
ContainerProvider.ContainerBuilder.RegisterModule(new ConsensusModule());
ContainerProvider.ContainerBuilder.RegisterModule(new BulletProofsModule());
ContainerProvider.ContainerBuilder.RegisterModule(new AuthenticationModule());
ContainerProvider.ContainerBuilder.RegisterModule(new HashingModule());
ContainerProvider.ContainerBuilder.RegisterType <VerifyMessageRequestObserver>().As <IRpcRequestObserver>();
ContainerProvider.ContainerBuilder.RegisterInstance(PeerIdHelper.GetPeerId("Test"))
.As <PeerId>();
ContainerProvider.ConfigureContainerBuilder();
_scope = ContainerProvider.Container.BeginLifetimeScope(CurrentTestName);
_keySigner = ContainerProvider.Container.Resolve <IKeySigner>();
_peerId = ContainerProvider.Container.Resolve <PeerId>();
_fakeContext = Substitute.For <IChannelHandlerContext>();
var fakeChannel = Substitute.For <IChannel>();
_fakeContext.Channel.Returns(fakeChannel);
_verifyMessageRequestObserver = _scope.Resolve <IRpcRequestObserver>();
}
public VerifyMessageRequestObserverTests()
{
_signingContext = new SigningContext
{
NetworkType = NetworkType.Devnet,
SignatureType = SignatureType.ProtocolRpc
};
_testPeerId = PeerIdHelper.GetPeerId("TestPeerIdentifier");
var peerSettings = _testPeerId.ToSubstitutedPeerSettings();
_keySigner = Substitute.For <FakeKeySigner>();
_keySigner.CryptoContext.Returns(new FfiWrapper());
var logger = Substitute.For <ILogger>();
_fakeContext = Substitute.For <IChannelHandlerContext>();
var fakeChannel = Substitute.For <IChannel>();
_fakeContext.Channel.Returns(fakeChannel);
_verifyMessageRequestObserver = new VerifyMessageRequestObserver(peerSettings, logger, _keySigner);
_verifyMessageRequest = GetValidVerifyMessageRequest();
}
public CatalystNodePoa(IKeySigner keySigner,
IPeerService peer,
IConsensus consensus,
IDfsService dfsService,
ILedger ledger,
ILogger logger,
IPeerClient peerClient,
IPeerSettings peerSettings,
IMempool <PublicEntryDao> memPool,
ISynchroniser synchronizer,
IPeerRepository peerRepository,
IContract contract = null)
{
Guard.Argument(peerRepository, nameof(peerRepository)).NotNull();
_peer = peer;
_peerClient = peerClient;
_peerSettings = peerSettings;
Consensus = consensus;
_dfsService = dfsService;
_ledger = ledger;
_keySigner = keySigner;
_logger = logger;
_memPool = memPool;
_contract = contract;
_synchronizer = synchronizer;
_peerRepository = peerRepository;
var privateKey = keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey);
_publicKey = keySigner.CryptoContext.GetPublicKeyFromPrivateKey(privateKey);
}
public TestPeerClientChannelFactory(IKeySigner keySigner,
IPeerMessageCorrelationManager correlationManager,
IPeerIdValidator peerIdValidator,
IPeerSettings peerSettings,
IScheduler scheduler)
: base(keySigner, correlationManager, peerIdValidator, peerSettings, scheduler)
{
_handlers = HandlerGenerationFunction();
}
public TestRpcServerChannelFactory(IRpcMessageCorrelationManager correlationManager,
IKeySigner keySigner,
IAuthenticationStrategy authenticationStrategy,
IPeerIdValidator peerIdValidator,
IPeerSettings peerSettings,
TestScheduler testScheduler)
: base(correlationManager, keySigner, authenticationStrategy, peerIdValidator, peerSettings, testScheduler)
{
_handlers = HandlerGenerationFunction();
}
public TestPeerServerChannelFactory(IPeerMessageCorrelationManager correlationManager,
IBroadcastManager broadcastManager,
IKeySigner keySigner,
IPeerIdValidator peerIdValidator,
IPeerSettings signingContextProvider,
TestScheduler testScheduler)
: base(correlationManager, broadcastManager, keySigner, peerIdValidator, signingContextProvider,
testScheduler)
{
_handlers = HandlerGenerationFunction();
}
public BroadcastManagerTests()
{
_senderPeerId = PeerIdHelper.GetPeerId("sender");
_keySigner = Substitute.For <IKeySigner>();
var fakeSignature = Substitute.For <ISignature>();
_keySigner.Sign(Arg.Any <byte[]>(), default).ReturnsForAnyArgs(fakeSignature);
_keySigner.CryptoContext.SignatureLength.Returns(64);
_peers = Substitute.For <IPeerRepository>();
_cache = new MemoryCache(new MemoryCacheOptions());
_peerSettings = _senderPeerId.ToSubstitutedPeerSettings();
}
public ProtocolMessageSignHandlerTests()
{
_fakeContext = Substitute.For <IChannelHandlerContext>();
_keySigner = Substitute.For <IKeySigner>();
_signature = Substitute.For <ISignature>();
_signature.SignatureBytes.Returns(ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength));
_signature.PublicKeyBytes.Returns(ByteUtil.GenerateRandomByteArray(new FfiWrapper().PublicKeyLength));
_dto = new MessageDto(new PingRequest().ToProtocolMessage(PeerIdHelper.GetPeerId("sender")),
PeerIdHelper.GetPeerId("recipient")
);
}
public SignMessageRequestObserverTests()
{
_keySigner = Substitute.For <IKeySigner>();
_signature = Substitute.For <ISignature>();
_signature.SignatureBytes.Returns(ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength));
_signature.PublicKeyBytes.Returns(ByteUtil.GenerateRandomByteArray(new FfiWrapper().PublicKeyLength));
_logger = Substitute.For <ILogger>();
_fakeContext = Substitute.For <IChannelHandlerContext>();
var fakeChannel = Substitute.For <IChannel>();
_fakeContext.Channel.Returns(fakeChannel);
_keySigner.Sign(default, default).ReturnsForAnyArgs(_signature);
public PeerClientChannelFactory(IKeySigner keySigner,
IPeerMessageCorrelationManager correlationManager,
IPeerIdValidator peerIdValidator,
IPeerSettings peerSettings,
IScheduler scheduler = null)
{
_scheduler = scheduler ?? Scheduler.Default;
_keySigner = keySigner;
_correlationManager = correlationManager;
_peerIdValidator = peerIdValidator;
_signingContext = new SigningContext {
NetworkType = peerSettings.NetworkType, SignatureType = SignatureType.ProtocolPeer
};
}
public ProtocolMessageVerifyHandlerTests()
{
_fakeContext = Substitute.For <IChannelHandlerContext>();
_keySigner = Substitute.For <IKeySigner>();
_signingContext = DevNetPeerSigningContext.Instance;
var signatureBytes = ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength);
var publicKeyBytes = ByteUtil.GenerateRandomByteArray(new FfiWrapper().PublicKeyLength);
var peerId = PeerIdHelper.GetPeerId(publicKeyBytes);
_protocolMessageSigned = new PingRequest()
.ToSignedProtocolMessage(peerId, signatureBytes, _signingContext)
.ToSignedProtocolMessage(peerId, signatureBytes, _signingContext);
}
public RpcClientChannelFactoryTests()
{
_testScheduler = new TestScheduler();
_correlationManager = Substitute.For <IRpcMessageCorrelationManager>();
_keySigner = Substitute.For <IKeySigner>();
var peerIdValidator = Substitute.For <IPeerIdValidator>();
peerIdValidator.ValidatePeerIdFormat(Arg.Any <PeerId>()).Returns(true);
var peerSettings = Substitute.For <IPeerSettings>();
peerSettings.NetworkType.Returns(NetworkType.Devnet);
_factory = new TestRpcClientChannelFactory(_keySigner, _correlationManager, peerIdValidator,
peerSettings, _testScheduler);
}
/// <summary>
/// </summary>
/// <param name="keySigner"></param>
/// <param name="messageCorrelationCache"></param>
/// <param name="peerIdValidator"></param>
/// <param name="peerSettings"></param>
/// <param name="backLogValue"></param>
/// <param name="scheduler"></param>
public RpcClientChannelFactory(IKeySigner keySigner,
IRpcMessageCorrelationManager messageCorrelationCache,
IPeerIdValidator peerIdValidator,
IPeerSettings peerSettings,
int backLogValue = 100,
IScheduler scheduler = null) : base(backLogValue)
{
var observableScheduler = scheduler ?? Scheduler.Default;
_keySigner = keySigner;
_messageCorrelationCache = messageCorrelationCache;
_peerIdValidator = peerIdValidator;
_signingContext = new SigningContext {
NetworkType = peerSettings.NetworkType, SignatureType = SignatureType.ProtocolRpc
};
_observableServiceHandler = new ObservableServiceHandler(observableScheduler);
}
/// <summary>
/// </summary>
/// <param name="correlationManger"></param>
/// <param name="keySigner"></param>
/// <param name="authenticationStrategy"></param>
/// <param name="peerIdValidator"></param>
/// <param name="peerSettings"></param>
/// <param name="scheduler"></param>
public RpcServerChannelFactory(IRpcMessageCorrelationManager correlationManger,
IKeySigner keySigner,
IAuthenticationStrategy authenticationStrategy,
IPeerIdValidator peerIdValidator,
IPeerSettings peerSettings,
IScheduler scheduler = null)
{
var observableScheduler = scheduler ?? Scheduler.Default;
_correlationManger = correlationManger;
_authenticationStrategy = authenticationStrategy;
_keySigner = keySigner;
_peerIdValidator = peerIdValidator;
_signingContext = new SigningContext {
NetworkType = peerSettings.NetworkType, SignatureType = SignatureType.ProtocolRpc
};
_observableServiceHandler = new ObservableServiceHandler(observableScheduler);
}
public void Init()
{
Setup(TestContext.CurrentContext);
_testScheduler = new TestScheduler();
ContainerProvider.ContainerBuilder.RegisterInstance(TestKeyRegistry.MockKeyRegistry()).As <IKeyRegistry>();
ContainerProvider.ContainerBuilder.RegisterModule(new KeystoreModule());
ContainerProvider.ContainerBuilder.RegisterModule(new KeySignerModule());
ContainerProvider.ContainerBuilder.RegisterModule(new BulletProofsModule());
ContainerProvider.ContainerBuilder.RegisterModule(new HashingModule());
ContainerProvider.ConfigureContainerBuilder();
_scope = ContainerProvider.Container.BeginLifetimeScope(CurrentTestName);
_keySigner = ContainerProvider.Container.Resolve <IKeySigner>();
_logger = Substitute.For <ILogger>();
_fakeContext = Substitute.For <IChannelHandlerContext>();
var fakeChannel = Substitute.For <IChannel>();
_fakeContext.Channel.Returns(fakeChannel);
}
/// <summary>Initializes a new instance of the <see cref="BroadcastManager"/> class.</summary>
/// <param name="peers">The peers.</param>
/// <param name="peerSettings">Peer settings</param>
/// <param name="memoryCache">The memory cache.</param>
/// <param name="peerClient">The peer client.</param>
/// <param name="signer">The signature writer</param>
/// <param name="logger"></param>
public BroadcastManager(IPeerRepository peers,
IPeerSettings peerSettings,
IMemoryCache memoryCache,
IPeerClient peerClient,
IKeySigner signer,
ILogger logger)
{
_logger = logger;
_peerId = peerSettings.PeerId;
_pendingRequests = memoryCache;
_peers = peers;
_signingContext = new SigningContext {
NetworkType = peerSettings.NetworkType, SignatureType = SignatureType.ProtocolPeer
};
_peerClient = peerClient;
_signer = signer;
_incomingBroadcastSignatureDictionary = new ConcurrentDictionary <ICorrelationId, ProtocolMessage>();
_entryOptions = () => new MemoryCacheEntryOptions()
.AddExpirationToken(new CancellationChangeToken(new CancellationTokenSource(TimeSpan.FromMinutes(10)).Token));
}
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 TweetController(IKeySigner keySigner,
IWrapper cryptoWrapper,
IMempoolRepository <TransactionBroadcastDao> mempoolRepository,
ITransactionReceivedEvent transactionReceivedEvent,
ITwitterModuleConfig twitterModuleConfig)
{
_signingContext = new SigningContext
{
NetworkType = NetworkType.Devnet,
SignatureType = SignatureType.TransactionPublic
};
_privateKey = keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey);
_publicKey = keySigner.CryptoContext.GetPublicKey(_privateKey);
_cryptoWrapper = cryptoWrapper;
_mempoolRepository = (MempoolDocumentRepository)mempoolRepository;
_transactionReceivedEvent = transactionReceivedEvent;
_twitterModuleConfig = twitterModuleConfig;
}
public PeerClientChannelFactoryTests()
{
_testScheduler = new TestScheduler();
_serverCorrelationManager = Substitute.For <IPeerMessageCorrelationManager>();
_serverKeySigner = Substitute.For <IKeySigner>();
_serverKeySigner.CryptoContext.SignatureLength.Returns(64);
var broadcastManager = Substitute.For <IBroadcastManager>();
_peerIdValidator = Substitute.For <IPeerIdValidator>();
var peerSettings = Substitute.For <IPeerSettings>();
peerSettings.NetworkType.Returns(NetworkType.Devnet);
var serverFactory = new UnitTests.P2P.IO.Transport.Channels.PeerServerChannelFactoryTests.TestPeerServerChannelFactory(
_serverCorrelationManager,
broadcastManager,
_serverKeySigner,
_peerIdValidator,
peerSettings,
_testScheduler);
_signature = Substitute.For <ISignature>();
_clientCorrelationManager = Substitute.For <IPeerMessageCorrelationManager>();
_clientKeySigner = Substitute.For <IKeySigner>();
_clientKeySigner.CryptoContext.SignatureLength.Returns(64);
_clientFactory = new UnitTests.P2P.IO.Transport.Channels.PeerClientChannelFactoryTests.TestPeerClientChannelFactory(
_clientKeySigner,
_clientCorrelationManager,
_peerIdValidator,
peerSettings,
_testScheduler);
_serverChannel =
new EmbeddedChannel("server".ToChannelId(), true, serverFactory.InheritedHandlers.ToArray());
_clientChannel =
new EmbeddedChannel("client".ToChannelId(), true, _clientFactory.InheritedHandlers.ToArray());
}
public SignMessageRequestObserverTests(ITestOutputHelper output) : base(output, new[]
{
Path.Combine(Constants.ConfigSubFolder, TestConstants.TestShellNodesConfigFile)
})
{
_testScheduler = new TestScheduler();
ContainerProvider.ContainerBuilder.RegisterInstance(TestKeyRegistry.MockKeyRegistry()).As <IKeyRegistry>();
ContainerProvider.ContainerBuilder.RegisterModule(new KeystoreModule());
ContainerProvider.ContainerBuilder.RegisterModule(new KeySignerModule());
ContainerProvider.ContainerBuilder.RegisterModule(new BulletProofsModule());
ContainerProvider.ContainerBuilder.RegisterModule(new HashingModule());
ContainerProvider.ConfigureContainerBuilder();
_scope = ContainerProvider.Container.BeginLifetimeScope(CurrentTestName);
_keySigner = ContainerProvider.Container.Resolve <IKeySigner>();
_logger = Substitute.For <ILogger>();
_fakeContext = Substitute.For <IChannelHandlerContext>();
var fakeChannel = Substitute.For <IChannel>();
_fakeContext.Channel.Returns(fakeChannel);
}
public RpcClientChannelFactoryTests()
{
_testScheduler = new TestScheduler();
_serverCorrelationManager = Substitute.For <IRpcMessageCorrelationManager>();
_serverKeySigner = Substitute.For <IKeySigner>();
_serverKeySigner.CryptoContext.SignatureLength.Returns(64);
_authenticationStrategy = Substitute.For <IAuthenticationStrategy>();
_peerIdValidator = Substitute.For <IPeerIdValidator>();
var peerSettings = Substitute.For <IPeerSettings>();
peerSettings.NetworkType.Returns(NetworkType.Devnet);
_serverFactory = new UnitTests.Rpc.IO.Transport.Channels.RpcServerChannelFactoryTests.TestRpcServerChannelFactory(
_serverCorrelationManager,
_serverKeySigner,
_authenticationStrategy,
_peerIdValidator,
peerSettings,
_testScheduler);
_clientCorrelationManager = Substitute.For <IRpcMessageCorrelationManager>();
_clientKeySigner = Substitute.For <IKeySigner>();
_clientKeySigner.CryptoContext.SignatureLength.Returns(64);
var clientFactory =
new UnitTests.Rpc.IO.Transport.Channels.RpcClientChannelFactoryTests.TestRpcClientChannelFactory(
_clientKeySigner,
_clientCorrelationManager,
_peerIdValidator,
peerSettings,
_testScheduler);
_serverChannel =
new EmbeddedChannel("server".ToChannelId(), true, _serverFactory.InheritedHandlers.ToArray());
_clientChannel =
new EmbeddedChannel("client".ToChannelId(), true, clientFactory.InheritedHandlers.ToArray());
}
/// <summary>
/// Use this to sign a <see cref="ProtocolMessage"/> before sending it.
/// If a signature was found on the message, this will error.
/// </summary>
/// <param name="protocolMessage">The message that needs to be signed.</param>
/// <param name="keySigner">An instance of <see cref="IKeySigner"/> used to build the signature.</param>
/// <param name="signingContext">The context used to sign the message.</param>
public static ProtocolMessage Sign(this ProtocolMessage protocolMessage,
IKeySigner keySigner,
SigningContext signingContext)
{
if ((protocolMessage.Signature?.RawBytes.Length ?? 0) == keySigner.CryptoContext.SignatureLength)
{
Logger.Debug("The protocol message was already signed, returning a clone.");
return(protocolMessage.Clone());
}
protocolMessage.Signature = null;
var signatureBytes = keySigner.Sign(protocolMessage.ToByteArray(),
signingContext).SignatureBytes;
var signature = new Signature
{
SigningContext = signingContext,
RawBytes = signatureBytes.ToByteString()
};
protocolMessage.Signature = signature;
return(protocolMessage);
}
public ProtocolMessageSignHandler(IKeySigner keySigner, SigningContext signingContext)
{
_keySigner = keySigner;
_signingContext = signingContext;
}
public static ISignature Sign(this IKeySigner crypto, IMessage message, SigningContext context)
{
using var pooled = message.SerializeToPooledBytes();
return(crypto.Sign(pooled.Span, context));
}
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));
}
public ProtocolMessageVerifyHandler(IKeySigner keySigner)
: base(Log.Logger.ForContext(MethodBase.GetCurrentMethod().DeclaringType))
{
_keySigner = keySigner;
}
