public void ChatMessage(string sender, string receiver, string message)
{
if (receiver == sender)
{
foreach (User u in server.users)
{
try
{
Physician p = (Physician)u;
if ((p != null) && (receiver == sender))
{
if (p.hashClient(sender) && (receiver == sender))
{
receiver = p.username;
}
}
}
catch { }
}
}
ServerClient client = server.getUser(receiver);
if (client != null)
{
Console.WriteLine("sending packet to: " + client.user.username);
NetworkFlow.SendPacket(new PacketChatMessage(message, sender, receiver), client.stream);
}
}
public ServerClient(TcpClient client, Serverapplication server, SslStream stream)
{
this.server = server;
this.client = client;
this.stream = stream;
if (client != null)
{
new Thread(() =>
{
BinaryFormatter formatter = new BinaryFormatter();
while (client.Connected)
{
Packet packet = NetworkFlow.ReadPacket(stream);
if (packet != null)
{
Console.WriteLine("recieved packet");
packet.handleServerSide(this);
}
}
server.getConnectedClients().Remove(this);
if (user != null)
{
user.isOnline = false;
}
Console.WriteLine("Client disconnected");
}).Start();
}
}
public void Broadcast(string sender, string message)
{
foreach (User user in server.users)
{
ServerClient client = server.getUser(user.username);
NetworkFlow.SendPacket(new PacketBroadcastResponse(sender, message), stream);
}
}
public void BikeValues(string power, string time, string distance, string username)
{
ServerClient client = server.getUser(username);
if (client != null)
{
Console.WriteLine("Send bike values to: " + client.user.username);
NetworkFlow.SendPacket(new PacketBikeValuesResponse(power, time, distance), client.stream);
}
}
private void ReceiveThread()
{
while (true)
{
Packet packet = NetworkFlow.ReadPacket(ssl);
if (packet != null)
{
packet.handleClientSide(parent);
}
}
}
public SessionEventArgs(NetworkFlow flow, PacketParser.ApplicationLayerProtocol protocol, long startFrameNumber)
{
this.Protocol = protocol;
this.Client = flow.FiveTuple.ClientHost;
this.Server = flow.FiveTuple.ServerHost;
this.ClientPort = flow.FiveTuple.ClientPort;
this.ServerPort = flow.FiveTuple.ServerPort;
this.Tcp = flow.FiveTuple.Transport == FiveTuple.TransportProtocol.TCP;
this.StartFrameNumber = startFrameNumber;
this.StartTimestamp = flow.StartTime;
this.flow = flow;
}
public void GiveUser(string username, bool allUsers, string physicianName)
{
Console.WriteLine("Someone is requesting the user: "******"*"))
{
NetworkFlow.SendPacket(new PacketGiveUserResponse(server.GetConnectedUsers(physicianName)), stream);
Console.WriteLine("Sending all users " + allUsers);
}
else
{
Console.WriteLine("Sending user: " + server.getUserClient(username));
NetworkFlow.SendPacket(new PacketGiveUserResponse(server.GetUserFromPhysician(username)), stream);
}
}
public void Login(string username, string password)
{
Console.WriteLine("Iemand probeert in te loggen als " + username + ", wachtwoord: " + password);
//Actual login checking:
foreach (User user in server.users)
{
if (user.username.ToLower().Equals(username.ToLower()))
{
if (PasswordHash.ValidatePassword(password, user.password)) //succesfull login
{
NetworkFlow.SendPacket(new PacketLoginResponse(true, user is Physician), stream);
Console.WriteLine("{0} succesfully logged in.", username);
if (user is Physician)
{
this.user = user;
}
else
{
this.user = server.GetUserFromPhysician(username);
}
this.user.isOnline = true;
Console.WriteLine("This is the user: "******"wrong password");
NetworkFlow.SendPacket(new PacketLoginResponse(false, user is Physician), stream);
break;
}
}
}
}
public static async void Run(string nsgFlowBlob, ICollector <string> outputQueueItem, TraceWriter log,
IQueryable <NetworkFlowProcessStatus> updateStatusIn, CloudTable updateStatusOut)
{
HashSet <NetworkFlow> outboundMsgList = new HashSet <NetworkFlow>();
NsgFlowEvents nsgEvents = JsonConvert.DeserializeObject <NsgFlowEvents>(nsgFlowBlob);
string nsg = null;
DateTime lastProcessed = new DateTime();
NetworkFlowProcessStatus flowStatusRecord = new NetworkFlowProcessStatus();
foreach (NsgFlowEvents.Record flowEvent in nsgEvents.records)
{
DateTime flowCaptureTime = DateTime.Parse(flowEvent.time);
// Idenfity the NSG flow log being processed so we can get the last process time from the table
// This function is triggered on new or *updated* NSG flow log files. Multiple functions could be processing different files
// in parallel. Uniquely identify each file by the first event timestamp and record the "last processed" records in table storage
// using the first event timestamp as the primary key. This way, network flows are not processed more than once.
if (string.IsNullOrEmpty(nsg))
{
nsg = flowEvent.resourceId;
flowStatusRecord = updateStatusIn.Where(l => l.RowKey == flowCaptureTime.Ticks.ToString()).FirstOrDefault();
if (flowStatusRecord == null)
{
flowStatusRecord = new NetworkFlowProcessStatus
{
LastProcessedTime = flowCaptureTime.ToLongTimeString(),
PartitionKey = "trniel",
RowKey = flowCaptureTime.Ticks.ToString()
};
log.Info($"No processing history found");
}
else
{
lastProcessed = DateTime.Parse(flowStatusRecord.LastProcessedTime);
log.Info($"NSG flow last processed event: {lastProcessed.ToLongTimeString()}");
}
}
// Skip records we already processed
if (flowCaptureTime > lastProcessed)
{
foreach (NsgFlowEvents.Flows flowCollection in flowEvent.properties.flows)
{
if (flowCollection.rule == "DefaultRule_AllowInternetOutBound")
{
foreach (NsgFlowEvents.Flow flowItem in flowCollection.flows)
{
string[] tupleItems = flowItem.flowTuples;
foreach (string tuple in tupleItems)
{
string[] tupleData = tuple.Split(',');
NetworkFlow msg = new NetworkFlow
{
NsgID = flowEvent.resourceId,
DestIP = tupleData[2],
DestPort = tupleData[4],
Protocol = tupleData[5]
};
outboundMsgList.Add(msg);
}
}
}
}
lastProcessed = flowCaptureTime;
}
}
string messageText = JsonConvert.SerializeObject(outboundMsgList);
outputQueueItem.Add(messageText);
// Update the processing status table to we don't process these flows again once the flow log is updated
flowStatusRecord.LastProcessedTime = lastProcessed.ToLongTimeString();
TableOperation operation = TableOperation.InsertOrReplace(flowStatusRecord);
updateStatusOut.Execute(operation);
}
public void sendPacket(Packet packet)
{
NetworkFlow.SendPacket(packet, ssl);
}
public void Start()
{
const bool debug_netflow = true;
TemplatesV10 _templates_v10 = new TemplatesV10();
TemplatesV9 _templates_v9 = new TemplatesV9();
try
{
Console.WriteLine("Listening for IPFix Packets\n");
Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
IPEndPoint iep = new IPEndPoint(IPAddress.Any, 9996);
sock.Bind(iep);
EndPoint ep = iep;
byte[] data = new byte[2048];
while (true)
{
int recv = sock.ReceiveFrom(data, ref ep);
byte[] _bytes = new byte[recv];
for (int i = 0; i < recv; i++)
{
_bytes[i] = data[i];
}
NetflowCommon common = new NetflowCommon(_bytes);
if (common._version == 5)
{
PacketV5 packet = new PacketV5(_bytes);
if (debug_netflow)
{
Console.WriteLine(String.Format("Received {0}v netflow packet: {1}", common._version, JsonConvert.SerializeObject(packet)));
}
}
else if ((common._version == 9))
{
if (_bytes.Count() > 16)
{
V9Packet packet = new V9Packet(_bytes, _templates_v9);
Modules.Netflow.v9.FlowSet _flowset = packet.FlowSet.FirstOrDefault(x => x.Template.Count() != 0);
if (_flowset != null)
{
foreach (Modules.Netflow.v9.Template _template in _flowset.Template.Where(x => x.Field.Any(y => y.Value.Count != 0)))
{
NetworkFlow networkFlow = new NetworkFlow();
NetworkFlow _netflow = networkFlow;
if (_template.Field.Exists(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.IPV4_SRC_ADDR))
{
_netflow.Source_address = new IPAddress(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.IPV4_SRC_ADDR).Value.ToArray()).ToString();
_netflow.Target_address = new IPAddress(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.IPV4_DST_ADDR).Value.ToArray()).ToString();
}
else if (_template.Field.Exists(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.IPV6_SRC_ADDR))
{
_netflow.Source_address = new IPAddress(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.IPV6_SRC_ADDR).Value.ToArray()).ToString();
_netflow.Target_address = new IPAddress(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.IPV6_DST_ADDR).Value.ToArray()).ToString();
}
if (_template.Field.Exists(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.L4_SRC_PORT))
{
_netflow.Source_port = BitConverter.ToUInt16(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.L4_SRC_PORT).Value.ToArray().Reverse().ToArray(), 0);
}
if (_template.Field.Exists(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.L4_DST_PORT))
{
_netflow.Target_port = BitConverter.ToUInt16(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.L4_DST_PORT).Value.ToArray().Reverse().ToArray(), 0);
}
if (_template.Field.Exists(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.PROTOCOL))
{
_netflow.Protocol = _template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.PROTOCOL).Value[0];
}
if (_template.Field.Exists(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.FIRST_SWITCHED))
{
_netflow.Start_timestamp = BitConverter.ToUInt16(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.FIRST_SWITCHED).Value.ToArray().Reverse().ToArray(), 0);
}
if (_template.Field.Exists(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.LAST_SWITCHED))
{
_netflow.Stop_timestamp = BitConverter.ToUInt16(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.LAST_SWITCHED).Value.ToArray().Reverse().ToArray(), 0);
}
_netflow.Timestamp = DateTime.UtcNow;
if (_template.Field.Exists(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.IN_PKTS))
{
_netflow.Packets = BitConverter.ToUInt16(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.IN_PKTS).Value.ToArray().Reverse().ToArray(), 0);
}
if (_template.Field.Exists(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.IN_BYTES))
{
_netflow.Kbyte = BitConverter.ToUInt16(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v9.FieldType.IN_BYTES).Value.ToArray().Reverse().ToArray(), 0);
}
_netflow.Id = Guid.NewGuid().ToString().Replace("-", "");
if (debug_netflow)
{
Console.WriteLine(String.Format("Received {0}v netflow packet: {1}", common._version, JsonConvert.SerializeObject(_netflow)));
}
}
}
}
}
else if (common._version == 10)
{
if (_bytes.Count() > 16)
{
V10Packet packet = new V10Packet(_bytes, _templates_v10);
Modules.Netflow.v10.FlowSet _flowset = packet.FlowSet.FirstOrDefault(x => x.Template.Count() != 0);
if (_flowset != null)
{
foreach (Modules.Netflow.v10.Template _template in _flowset.Template.Where(x => x.Field.Any(y => y.Type == "sourceTransportPort" && y.Value.Count > 0)))
{
NetworkFlow _netflow = new NetworkFlow
{
Id = Guid.NewGuid().ToString().Replace("-", ""),
Source_port = BitConverter.ToUInt16(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.sourceTransportPort).Value.ToArray().Reverse().ToArray(), 0),
Target_port = BitConverter.ToUInt16(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.destinationTransportPort).Value.ToArray().Reverse().ToArray(), 0),
Protocol = _template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.protocolIdentifier).Value[0],
Start_timestamp = (long)BitConverter.ToUInt64(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.flowStartMilliseconds).Value.ToArray().Reverse().ToArray(), 0),
Stop_timestamp = (long)BitConverter.ToUInt64(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.flowEndMilliseconds).Value.ToArray().Reverse().ToArray(), 0),
Timestamp = DateTime.UtcNow,
Packets = BitConverter.ToUInt16(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.packetDeltaCount).Value.ToArray().Reverse().ToArray(), 0),
Kbyte = BitConverter.ToUInt16(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.octetDeltaCount).Value.ToArray().Reverse().ToArray(), 0)
};
if (_template.Field.Exists(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.sourceIPv4Address))
{
_netflow.Source_address = new IPAddress(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.sourceIPv4Address).Value.ToArray()).ToString();
_netflow.Target_address = new IPAddress(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.destinationIPv4Address).Value.ToArray()).ToString();
}
else if (_template.Field.Exists(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.sourceIPv6Address))
{
_netflow.Source_address = new IPAddress(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.sourceIPv6Address).Value.ToArray()).ToString();
_netflow.Target_address = new IPAddress(_template.Field.FirstOrDefault(x => x.GetTypes() == (ushort)Modules.Netflow.v10.FieldType.destinationIPv6Address).Value.ToArray()).ToString();
}
if (debug_netflow)
{
Console.WriteLine(String.Format("Received {0}v netflow packet: {1}", common._version, JsonConvert.SerializeObject(_netflow), Formatting.Indented));
}
}
}
else
{
Console.WriteLine(String.Format("Template not known for this flow yet: {0}", packet.FlowSet.First().ID));
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(String.Format("Fatal Error {0}", ex.Message));
}
}
