public void Send(PierceMessage message)
{
message.SenderId = _id;
var makeParcel = message.MakeParcel();
_sender.Send(makeParcel);
Stats.AddPacket(PacketType.Sent);
Stats.AddBytes(makeParcel.Length, ByteType.Sent);
}
/// <summary>
/// Sends a message to all connected nodes
/// </summary>
/// <param name="message">The message to send</param>
public void SendMessage(string message)
{
var pierceMessage = new PierceMessage(PierceHeader.Message);
pierceMessage.Message = message;
byte[] parcel = pierceMessage.MakeParcel();
_tcpServer.Send(parcel);
}
public Piercer()
{
_tcpServer = new PierceServer {
InitialBufferSize = 12, Port = 443, UseSSL = true
};
X509Certificate2 cert =
new X509Certificate2(AppDomain.CurrentDomain.BaseDirectory + "pluralsight.pfx", "1234");
_tcpServer.Certificate = cert;
_tcpServer.Clients.ClientAdded += (sender, guid) => { Logger.Log("Client Added: " + guid, Severity.Info); };
_tcpServer.Clients.ClientRemoved += (sender, guid) =>
{
Logger.Log("Client Removed: " + guid, Severity.Info);
};
_strumpEndpoints = new Dictionary <uint, StrumpEndpoint>();
_tcpServer.MessageReceived += _tcpServer_MessageReceived;
_tcpServer.RemoteDeskRequestReceived += OnRemoteDeskRequest;
_tcpServer.SockParcelReceived += delegate(object o, SockeEventArgs e)
{
if (!_strumpEndpoints.ContainsKey(e.Client.ID))
{
var ep = new StrumpEndpoint();
_strumpEndpoints.Add(e.Client.ID, ep);
Logger.Log("New StrumpEndPoint for client " + e.Client.ID, Severity.Info);
ep.SockReturn += parcel =>
{
var pierceMessage = new PierceMessage(parcel);
Send(pierceMessage, e.Client);
//_strumpServer.SockIncoming(parcel);
};
ep.Points.ListChanged += delegate(object sender, ListChangedEventArgs args) { };
}
_strumpEndpoints[e.Client.ID].SockOutgoing(e.SockParcel);
};
_tcpServer.RoundTripReceived += (o, e) =>
{
Logger.Log("Roundtrip! Length " + e.Payload.Length, Severity.Debug);
var pierceMessage = new PierceMessage(PierceHeader.RoundTrip);
pierceMessage.Payload = e.Payload;
Send(pierceMessage, e.Client);
};
}
public override byte[] ParseIncomingSSL(int read, byte[] initialBuffer, SslStream stream, ClientContext context)
{
Stats.AddBytes(read, ByteType.Received);
Stats.AddPacket(PacketType.Received);
if (read != InitialBufferSize)
{
Logger.Log("Initial buffer incorrect size", Severity.Warning);
return(null);
}
if (initialBuffer[0] == 0x02 && initialBuffer[1] == 0x07)
{
short int16 = BitConverter.ToInt16(initialBuffer, 2);
if (Enum.TryParse(int16.ToString(), out PierceHeader header))
{
int len = BitConverter.ToInt32(initialBuffer, 8);
//Logger.Log(header.ToString(), Severity.Info);
//Logger.Log("Length: " + len, Severity.Info);
var list = new List <byte>();
list.AddRange(initialBuffer);
var payload = new byte[len];
//int readback = stream.Read(payload, 0, len);
int bytesread = 0;
do
{
int readback = stream.Read(payload, bytesread, len - bytesread);
Stats.AddBytes(readback, ByteType.Received);
bytesread += readback;
} while (bytesread < len);
list.AddRange(payload);
if (bytesread != len)
{
Logger.Log("Full message not read or too much read!", Severity.Warning);
return(null);
}
var endbit = new byte[4];
var endread = stream.Read(endbit, 0, 4);
Stats.AddBytes(endread, ByteType.Received);
if (endread != 4)
{
Logger.Log("End bit is wrong length!", Severity.Warning);
return(null);
}
list.AddRange(endbit);
PierceMessage message = PierceMessage.Parse(list.ToArray());
//Logger.Log("Message: " + message, Severity.Info);
//Logger.Log(BitConverter.ToString(payload), Severity.Info);
switch (message.Header)
{
case PierceHeader.Invalid:
Logger.Log("Invalid header received (0x00)", Severity.Warning);
return(null);
case PierceHeader.Handshake:
Logger.Log("Handshake received, version " + BitConverter.ToString(payload), Severity.Info);
uint id = (uint)new Random().Next();
while (RemoteClientList.ContainsKey(id))
{
id = (uint)new Random().Next();
}
if (!RemoteClientList.TryAdd(id, new RemoteClientInfo(id, context)))
{
throw new Exception("Conflicting key on creation, this is impossible");
}
var pierceMessage = new PierceMessage(PierceHeader.HandshakeOK);
pierceMessage.Payload = BitConverter.GetBytes(id);
byte[] bytes = pierceMessage.MakeParcel();
stream.Write(bytes);
// return back to server for stat collection
return(list.ToArray());
case PierceHeader.HandshakeOK:
break;
case PierceHeader.Message:
break;
case PierceHeader.ScreenShot:
break;
case PierceHeader.RemoteDeskRequest:
OnRemoteDeskRequestReceived(null);
break;
case PierceHeader.Socks5:
var sockParcel = SockParcel.DeSerialize(message.Payload);
if (RemoteClientList.ContainsKey(message.SenderId))
{
OnSockParcelReceived(RemoteClientList[message.SenderId], sockParcel);
}
else
{
Logger.Log(message.SenderId + " is an unrecognized Client ID", Severity.Warning);
}
break;
case PierceHeader.RoundTrip:
if (RemoteClientList.ContainsKey(message.SenderId))
{
OnRoundTripReceived(RemoteClientList[message.SenderId], message.Payload);
}
else
{
Logger.Log(message.SenderId + " is an unrecognized Client ID", Severity.Warning);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
Logger.Log("Invalid header received", Severity.Warning);
return(null);
}
}
else
{
Logger.Log("Invalid magic bytes received", Severity.Warning);
return(null);
}
return(initialBuffer);
}
public Form1()
{
InitializeComponent();
_listview = new FastObjectListView();
olvColumnId = new OLVColumn();
olvColumnSent = new OLVColumn();
olvColumnRec = new OLVColumn();
olvColumnState = new OLVColumn();
olvColumnIp = new OLVColumn();
olvColumnAddress = new OLVColumn();
_listview.AllColumns.Add(olvColumnId);
_listview.AllColumns.Add(olvColumnSent);
_listview.AllColumns.Add(olvColumnRec);
_listview.AllColumns.Add(olvColumnState);
_listview.AllColumns.Add(olvColumnIp);
_listview.AllColumns.Add(olvColumnAddress);
_listview.CellEditUseWholeCell = false;
_listview.Columns.AddRange(new ColumnHeader[] {
olvColumnId,
olvColumnSent,
olvColumnRec,
olvColumnState,
olvColumnIp,
olvColumnAddress
});
_listview.Cursor = Cursors.Default;
_listview.Dock = DockStyle.Fill;
_listview.HideSelection = false;
_listview.Location = new Point(0, 0);
_listview.Name = "fastObjectListView1";
_listview.ShowGroups = false;
_listview.Size = new Size(925, 551);
_listview.TabIndex = 21;
_listview.UseCompatibleStateImageBehavior = false;
_listview.View = View.Details;
_listview.VirtualMode = true;
//
// olvColumnId
//
olvColumnId.AspectName = "UniqueId";
olvColumnId.Text = "UniqueId";
//
// olvColumnSent
//
olvColumnSent.AspectName = "ParcelsSent";
olvColumnSent.Text = "Parcels Sent";
//
// olvColumnRec
//
olvColumnRec.AspectName = "ParcelsReceived";
olvColumnRec.Text = "Parcels Received";
//
// olvColumnState
//
olvColumnState.AspectName = "State";
olvColumnState.Text = "State";
olvColumnState.Width = 150;
//
// olvColumnIp
//
olvColumnIp.AspectName = "IP";
olvColumnIp.Text = "IP";
olvColumnIp.Width = 90;
//
// olvColumnAddress
//
olvColumnAddress.AspectName = "Address";
olvColumnAddress.Text = "Hostname";
olvColumnAddress.Width = 125;
_listview.Dock = DockStyle.Fill;
splitContainer1.Panel1.Controls.Add(_listview);
_pierceClient = new PierceClient();
_strumpServer = new StrumpServer();
_strumpServer.Certificate = null;
_strumpServer.InitialBufferSize = 2;
_strumpServer.Port = 1080;
_strumpServer.Stats = new Stats();
_strumpServer.UseSSL = false;
_listview.SetObjects(new List <SOCKSRequest>());
Logger.Instance.LogAdded += (sender, log) =>
{
if ((checkBoxLogging.Checked && log.Severity == Severity.Debug) || log.Severity != Severity.Debug)
{
Print(log.ToString());
}
};
_strumpServer.SockOutgoing = parcel =>
{
//if (parcel.Parcel != null && (checkBoxLogging.Checked && parcel.Parcel.Length > 5000))
// Logger.Log("STRUMP REC: " + parcel, Severity.Debug);
var pierceMessage = new PierceMessage(parcel);
while (!_pierceClient.Connected)
{
Thread.Sleep(1000);
}
_pierceClient.Send(pierceMessage);
};
_strumpServer.ConnectionAdded += (sender, request) => { _listview.AddObject(request); };
_strumpServer.ConnectionRemoved += (sender, request) => { _listview.RemoveObject(request); };
}
private void ConnectCallback(IAsyncResult ar)
{
try
{
_client.EndConnect(ar);
}
catch (SocketException e)
{
Logger.Log(e);
Reconnect();
return;
}
SslStream ssl = new SslStream(_client.GetStream(), false, ValidateServerCertificate, null);
if (_sender == null)
{
_sender = new ConcurrentSender(ssl);
_sender.StatusUpdate += (sender, s) => OnSenderStatusUpdate(s);
}
else
{
_sender.SetStream(ssl);
if (_sender.Paused)
{
_sender.UnPause();
}
}
//ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
var x509Certificate2Collection = new X509Certificate2Collection(Cert);
try
{
ssl.AuthenticateAsClient(Ip, x509Certificate2Collection, SslProtocols.Tls12, false);
}
catch (Exception e)
{
Logger.Log(e);
Reconnect();
return;
}
Logger.Log("Connected to " + Ip + ":" + Port, Severity.Info);
var pierceMessage = new PierceMessage(PierceHeader.Handshake);
byte[] parcel = pierceMessage.MakeParcel();
var tuple = new Tuple <byte[], SslStream>(parcel, ssl);
try
{
ssl.BeginWrite(parcel, 0, parcel.Length, WriteCallBack, tuple);
}
catch (Exception e)
{
Logger.Log(e);
Reconnect();
return;
}
}
private void OnObjectReceived(PierceMessage message)
{
var o = message.DeserializePayload();
throw new Exception("Unknown object received");
}
private void ReadCallBack(IAsyncResult ar)
{
Stats.AddPacket(PacketType.Received);
var state = (StateObject)ar.AsyncState;
int bytesRead;
try
{
bytesRead = state.ssl.EndRead(ar);
}
catch (IOException e)
{
// terminated connection
Logger.Log("Connection terminated by server", Severity.Warning);
Reconnect();
return;
}
if (bytesRead == 0)
{
Logger.Log("0 bytes read, terminating", Severity.Warning);
Reconnect();
return;
}
Stats.AddBytes(bytesRead, ByteType.Received);
state.ms.Write(state.buffer, 0, bytesRead);
while (!PierceMessage.CheckMessageComplete(state.ms.ToArray()))
{
var readbuffer = new byte[1024];
try
{
bytesRead = state.ssl.Read(readbuffer, 0, readbuffer.Length);
Stats.AddBytes(bytesRead, ByteType.Received);
state.ms.Write(readbuffer, 0, bytesRead);
}
catch (IOException e)
{
Logger.Log("Error while receiving PierceMessage: " + e.Message, Severity.Warning);
Reconnect();
return;
}
catch (SocketException e)
{
Logger.Log("Error while receiving PierceMessage: " + e.Message, Severity.Warning);
Reconnect();
return;
}
catch (ObjectDisposedException e)
{
Logger.Log("Error while receiving PierceMessage: " + e.Message, Severity.Warning);
Reconnect();
return;
}
}
PierceMessage message = PierceMessage.Parse(state.ms.ToArray());
//Logger.Log("Client rec: " + message, Severity.Info);
if (string.IsNullOrEmpty(message.ParseError))
{
switch (message.Header)
{
case PierceHeader.HandshakeOK:
_id = BitConverter.ToUInt32(message.Payload, 0);
Connected = true;
Logger.Log("Handshake OK, client id " + _id, Severity.Info);
break;
case PierceHeader.RemoteDeskRequest:
// nein
break;
case PierceHeader.ScreenShot:
break;
case PierceHeader.Invalid:
break;
case PierceHeader.Handshake:
break;
case PierceHeader.Message:
break;
case PierceHeader.Socks5:
var sockParcel = SockParcel.DeSerialize(message.Payload);
OnSockParcelReceived(sockParcel);
break;
case PierceHeader.RoundTrip:
OnRoundTripReturn(message.Payload);
break;
case PierceHeader.Object:
OnObjectReceived(message);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
// start listening again with new object
StateObject newstate = new StateObject(state.ssl);
state.ssl.BeginRead(newstate.buffer, 0, StateObject.BufferSize, ReadCallBack, newstate);
}
public void Send(PierceMessage message, RemoteClientInfo client)
{
_tcpServer.Send(message.MakeParcel(), client.Context);
}
