public void ChannelLifecycleHttpClient()
{
new FileInfo(".test.2.conf").Delete();
HttpClient httpClient = new HttpClient();
httpClient.BaseAddress = new Uri("http://localhost:5000/");
ConfigManager config = new ConfigManager(".test.2.conf");
SenderClient sender = new SenderClient(config, config.Config.Peers[0].ChannelID, httpClient.BaseAddress.ToString(), httpClient);
ReceiverClient receiver = new ReceiverClient(config, config.Config.Peers[0].ChannelID, httpClient.BaseAddress.ToString(), httpClient);
sender.CheckIfAvailable();
Assert.False(sender.IsAvailable);
receiver.Connect();
sender.CheckIfAvailable();
Assert.True(sender.IsAvailable);
receiver.Disconnect();
sender.CheckIfAvailable();
Assert.False(sender.IsAvailable);
new FileInfo(".test.2.conf").Delete();
}
static void Main(string[] args)
{
SenderClient senderClient = new SenderClient();
ReceiverClient receiverClient = new ReceiverClient();
try
{
_rsaWithCspKey.AssignNeyCspKey();
var publicKey = _rsaWithCspKey.CryptoServiceProvider.ExportParameters(false);
var privateKey = _rsaWithCspKey.CryptoServiceProvider.ExportParameters(true);
senderClient.PublicKey = publicKey;
receiverClient.PublicKey = publicKey;
receiverClient.PrivateData = privateKey;
SenderClientData(senderClient as SenderClient);
ReceiverClientData(receiverClient as ReceiverClient);
}
finally
{
_rsaWithCspKey.DeleteKeyFromCsp();
}
}
private async Task OnMessageReceived(Message message, CancellationToken cancellationToken)
{
_logger.LogDebug("Message received with ID {MessageId}", message.MessageId);
await TriggerWorkflowsAsync(message, CancellationToken.None);
await ReceiverClient.CompleteAsync(message.SystemProperties.LockToken);
}
public void RequestSetStartupSafeModeTest()
{
if (NonAdmin.DoesServiceExist("Bolter Admin Service", Environment.MachineName))
{
var keyPath = @"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon";
var shellKey = "Shell";
var key = Registry.LocalMachine.OpenSubKey(keyPath, false);
ReceiverClient client = new ReceiverClient();
client.ConnectToBolterService(IP_SERVER_ADDRESS, PORT);
Thread.Sleep(1000);
string initial = (string)key.GetValue(shellKey);
Console.WriteLine("Initial value :" + initial);
client.RequestSetStartupSafeMode(true, System.Reflection.Assembly.GetEntryAssembly().Location);
Thread.Sleep(1000);
string edited = (string)key.GetValue(shellKey);
Console.WriteLine("Edited value :" + edited);
client.RequestSetStartupSafeMode(false, System.Reflection.Assembly.GetEntryAssembly().Location);
Thread.Sleep(1000);
string revert = (string)key.GetValue(shellKey);
Console.WriteLine("Revert value :" + revert);
Assert.AreEqual(initial, revert);
}
else
{
Assert.Fail("The Bolter Service must be installed to run this test");
}
}
static void ReceiverInitWorkaround(string config)
{
string msg = Guid.NewGuid().ToString();
Console.WriteLine("Bug workaround - waiting for own answer.");
CLIConfig cfg = LoadConfig(config + ".local");
ConfigManager cm = new ConfigManager(config);
List <ReceiverClient> list = new List <ReceiverClient>();
Peer p = cm.Config.Peers.Single(x => x.PeerID == cm.Config.MyID);
Console.WriteLine("Init receiver channel: " + p.ChannelID.ToString());
ReceiverClient client = new ReceiverClient(cm, p.ChannelID, cfg.ServerURL);
client.MessageReceived = HandleReceivedInit;
client.Connect();
SenderClient sclient = new SenderClient(cm, p.ChannelID, cfg.ServerURL);
while (initReply.ToLower().Trim() != msg.ToLower().Trim())
{
sclient.SendMessage(msg);
Thread.Sleep(100);
}
Console.WriteLine("Got it... Good.");
foreach (ReceiverClient r in list)
{
r.Disconnect();
}
}
static void RealServiceTestTCP(bool install)
{
string IP_SERVER_ADDRESS = "127.0.0.1";
int PORT = 8976;
if (install)
{
if (Bolter.NonAdmin.IsInAdministratorMode())
{
Admin.InstallService();
}
else
{
throw new InvalidOperationException("Need the demo to be in Admin mode to install the service");
}
}
var client = new ReceiverClient();
client.ConnectToBolterService(IP_SERVER_ADDRESS, PORT);
// client.SendMessage("First_msg");
// client.SendMessage("2nd_msg");
// client.SendMessage("last msg");
// client.SendMessage("2nd_msg_2");
int LOGON32_LOGON_BATCH = 4; // DOESNT WORK
int LOGON32_LOGON_NETWORK = 3;
int LOGON32_LOGON_INTERACTIVE = 2;
int LOGON32_LOGON_NETWORK_CLEARTEXT = 8;
int LOGON32_LOGON_SERVICE = 5;
int type = LOGON32_LOGON_INTERACTIVE;
client.RequestImpersonation(type);
Thread.Sleep(5000);
client.RequestSetBatchAndCMDBlock(true);
//client.WaitAndPrintResponse();
// client.SendToService("{ \"name\":\"SetBatchAndCMDBlock\",\"block\":false}");
///client.SendToService("Last msg");
// client.RequestSetBatchAndCMDBlock(false);
// client.RequestSetBatchAndCMDBlock(true);
// Auto free
var timer = new System.Timers.Timer(20000);
timer.Elapsed += (s, e) =>
{
// Reconnect test
// client.RequestDisableAllAdminRestrictions(AppDomain.CurrentDomain.BaseDirectory);
client.SendMessage("Hello");
Thread.Sleep(3000);
client.SendMessage("Hello2");
if (install)
{
Admin.UninstallService();
}
};
timer.AutoReset = false;
timer.Start();
}
public async Task <ReceiverResponse> HandleReceiverRequestAsync(Models.ActionRequest actionRequest)
{
return(await GrpcCallerService.CallService(_urls.Receivers(actionRequest.SessionData.Language), async channel =>
{
var client = new ReceiverClient(channel);
var request = MapToGrpcActionRequest(actionRequest);
var response = await client.HandleReceiverRequestAsync(request);
return MapToReceiverResponse(response);
}));
}
public async Task <ReceiverResponse> HandleAfterActionRequestAsync(SessionData session)
{
return(await GrpcCallerService.CallService(_urls.Receiver, async channel =>
{
var client = new ReceiverClient(channel);
var request = MapToChatRequest(session);
var response = await client.HandleAfterActionAsync(request);
return MapToReceiverResponse(response);
}));
}
private static void TcpAdminBridgeTest()
{
var tcpClient = new ReceiverClient();
// TODO relative paths
var bridgePath = @"C:\Users\franc\source\repos\Bolter\BridgeProcess\bin\Debug\netcoreapp3.1\BridgeProcess.exe";
var mockServiceApp = @"C:\Users\franc\source\repos\Bolter\MockService\bin\Debug\netcoreapp3.1\MockService.exe";
tcpClient.ConnectToBolterService(IP_SERVER_ADDRESS, PORT);
// Info commands
tcpClient.SendMessage("unblocksqdsqd");
tcpClient.SendMessage("ooo");
tcpClient.RequestInstallService();
Console.ReadLine();
Bolter.NonAdmin.DisableAllNonAdminRestrictions();
tcpClient.RequestDisableAllAdminRestrictions(AppDomain.CurrentDomain.BaseDirectory);
}
private static void ReceiverClientData(ReceiverClient receiverClient)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"{Environment.NewLine} ## Receiver Client ##");
Console.ResetColor();
Console.WriteLine("Public Data");
Console.WriteLine($"{"Exponent",-25} : {BitConverter.ToString(receiverClient.PublicKey.Exponent)}");
Console.WriteLine($"{"Modulus",-25} : {BitConverter.ToString(receiverClient.PublicKey.Modulus)}");
Console.WriteLine();
Console.WriteLine(receiverClient.ToString());
Console.WriteLine($"{"Cipher Message",-25} : {_hexValue}");
Console.WriteLine($"{"Delivered Message",-25} : {Encoding.UTF8.GetString(_rsaWithCspKey.DecryptData(GetBytesFromHex(_hexValue)))}");
}
public void SendAndReceive()
{
new FileInfo(".test.3r.conf").Delete();
new FileInfo(".test.3s.conf").Delete();
ConfigManager rconfig = new ConfigManager(".test.3r.conf");
ConfigManager sconfig = new ConfigManager(".test.3s.conf");
rconfig.PeerWith(sconfig);
Guid ch = sconfig.Config.Peers.Single(x => x.PeerID == rconfig.Config.MyID).ChannelID;
SenderClient sender = new SenderClient(sconfig, ch, "http://localhost:5000/");
ReceiverClient receiver = new ReceiverClient(rconfig, ch, "http://localhost:5000/");
sender.CheckIfAvailable();
Assert.False(sender.IsAvailable);
lastMsg = "";
receiver.MessageReceived = receiverHanlder;
receiver.Connect();
sender.CheckIfAvailable();
Assert.True(sender.IsAvailable);
Assert.Equal("", lastMsg);
sender.SendMessage("TEST MESSAGE");
Thread.Sleep(10 * 1000);
Assert.Equal("TEST MESSAGE", lastMsg);
receiver.Disconnect();
sender.CheckIfAvailable();
Assert.False(sender.IsAvailable);
new FileInfo(".test.3r.conf").Delete();
new FileInfo(".test.3s.conf").Delete();
}
static void Main(string[] args)
{
Console.WriteLine("This is the demo client (console version), user : "******"[MATRIX] Requesting remote service admin commands");
// Use the service or bridge admin app
cl.ConnectToBolterService(IP_SERVER_ADDRESS, PORT);
// cl.RequestSetBatchAndCMDBlock(false);
// cl.RequestPreventDateEditingW10(true);
// cl.RequestSetBatchAndCMDBlock(false);
// AdminSandbox.RequestRemoteCommands(cl);
Console.WriteLine("[MATRIX] All commands requested");
// Thread.Sleep(20000);
Console.WriteLine("Now unblocking");
cl.RequestDisableAllAdminRestrictions(AppDomain.CurrentDomain.BaseDirectory);
Console.WriteLine("Sleeping 20s");
}
else
{
Admin.SetBatchAndCMDBlock(false, "franc");
Admin.PreventDateEditingW10(true);
Admin.SetBatchAndCMDBlock(false, "franc");
}
Console.WriteLine("Unblocked Admin");
NonAdmin.DisableAllNonAdminRestrictions();
//cl.RequestDisableAllAdminRestrictions(AppDomain.CurrentDomain.BaseDirectory);
// RealServiceTestTCP(true);
new ManualResetEvent(false).WaitOne();
}
static void Receiver(string config)
{
CLIConfig cfg = LoadConfig(config + ".local");
ConfigManager cm = new ConfigManager(config);
List <ReceiverClient> list = new List <ReceiverClient>();
foreach (Peer p in cm.Config.Peers)
{
Console.WriteLine("Receiver Channel: " + p.ChannelID.ToString());
ReceiverClient client = new ReceiverClient(cm, p.ChannelID, cfg.ServerURL);
client.MessageReceived = HandleReceivedMessage;
client.Connect();
}
Console.WriteLine("Press enter to close");
Console.ReadLine();
//client.Disconnect();
foreach (ReceiverClient r in list)
{
r.Disconnect();
}
}
/// <summary>
/// Main method of receiver
/// </summary>
/// <param name="args">args from command line</param>
static void Main(string[] args)
{
ReceiverClient client = new ReceiverClient();
client.Run(args);
}
