public static EncryptionUpdate Decode(G2ReceivedPacket packet)
{
// not decrypted
EncryptionUpdate eu = new EncryptionUpdate(false);
return(eu);
}
public static KeyRequest Decode(G2ReceivedPacket packet)
{
KeyRequest kr = new KeyRequest();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
if (child.Name == Packet_Encryption)
{
kr.Encryption = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
}
else if (child.Name == Packet_Key)
{
kr.Key = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
}
else if (child.Name == Packet_IV)
{
kr.IV = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
}
}
return(kr);
}
public void Receive_CrawlAck(CrawlAck ack, G2ReceivedPacket packet)
{
DhtContact source = new DhtContact(ack.Source, packet.Source.IP);
if (!CrawlMap.ContainsKey(source.RoutingID))
{
return;
}
CrawlNode node = CrawlMap[source.RoutingID];
node.Ack = ack;
foreach (DhtContact contact in ack.ProxyServers)
{
if (!CrawlMap.ContainsKey(contact.RoutingID))
{
CrawlMap[contact.RoutingID] = new CrawlNode(contact);
}
}
foreach (DhtContact contact in ack.ProxyClients)
{
if (!CrawlMap.ContainsKey(contact.RoutingID))
{
CrawlNode newNode = new CrawlNode(contact);
newNode.Proxy = node;
CrawlMap[contact.RoutingID] = newNode;
}
}
}
public static Ping Decode(G2ReceivedPacket packet)
{
Ping pi = new Ping();
if (G2Protocol.ReadPayload(packet.Root))
{
pi.Ident = BitConverter.ToUInt16(packet.Root.Data, packet.Root.PayloadPos);
}
G2Protocol.ResetPacket(packet.Root);
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_Source:
pi.Source = DhtSource.ReadPacket(child);
break;
case Packet_RemoteIP:
pi.RemoteIP = new IPAddress(Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize));
break;
}
}
return(pi);
}
void ReceiveAck(G2ReceivedPacket raw, LightClient client, RudpPacket packet)
{
// remove acked packet
foreach (Tuple <uint, RudpPacket> tuple in client.Packets)
{
if (tuple.Param2.PeerID == packet.PeerID)
{
client.Packets.Remove(tuple);
client.Attempts = 0;
break;
}
}
// read ack ident and move to top
foreach (RudpAddress address in client.Addresses)
{
if (address.Ident == packet.Ident)
{
client.Addresses.Remove(address);
client.Addresses.AddFirst(address);
address.LastAck = Core.TimeNow;
break;
}
}
client.NextTry = Core.TimeNow;
// receieved ack, try to send next packet immediately
client.TrySend(Network);
}
public static ProxyReq Decode(G2ReceivedPacket packet)
{
ProxyReq pr = new ProxyReq();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
switch (child.Name)
{
case Packet_Source:
if (G2Protocol.ReadPayload(child))
{
pr.SenderID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
}
break;
case Packet_Blocked:
pr.Type = ProxyType.ClientBlocked;
break;
case Packet_NAT:
pr.Type = ProxyType.ClientNAT;
break;
}
}
return(pr);
}
public static ProxyAck Decode(G2ReceivedPacket packet)
{
ProxyAck pa = new ProxyAck();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
switch (child.Name)
{
case Packet_Source:
if (G2Protocol.ReadPayload(child))
{
pa.Source = DhtSource.ReadPacket(child);
}
break;
case Packet_Accept:
pa.Accept = true;
break;
case Packet_Contacts:
if (G2Protocol.ReadPayload(child))
{
pa.ContactList.Add(DhtContact.ReadPacket(child));
}
break;
}
}
return(pa);
}
public void IncomingPacket(G2ReceivedPacket packet)
{
if (Core.Sim == null || Core.Sim.Internet.TestCoreThread)
{
lock (IncomingPackets)
// if each packet 1kb, have a megabyte buffer for backed up packets (hashing, etc..)
if (IncomingPackets.Count < 1000)
{
IncomingPackets.Enqueue(packet);
}
Core.ProcessEvent.Set();
}
else
{
try
{
ReceivePacket(packet);
}
catch (Exception ex)
{
UpdateLog("Exception", "DhtNetwork::IncomingPacket: " + ex.Message);
}
}
}
public void Send_CrawlAck(CrawlRequest req, G2ReceivedPacket packet)
{
CrawlAck ack = new CrawlAck();
ack.Source = GetLocalSource();
ack.Version = DeOpsContext.CoreVersion.ToString();
ack.Uptime = (Core.TimeNow - Core.StartTime).Seconds;
foreach (TcpConnect connection in TcpControl.ProxyServers)
{
ack.ProxyServers.Add(new DhtContact(connection, connection.RemoteIP));
}
foreach (TcpConnect connection in TcpControl.ProxyClients)
{
ack.ProxyClients.Add(new DhtContact(connection, connection.RemoteIP));
}
if (packet.ReceivedTcp)
{
ack.ToAddress = packet.Source;
packet.Tcp.SendPacket(ack);
}
else
{
SendPacket(packet.Source, ack);
}
}
public void Receive_Close(G2ReceivedPacket embeddedPacket)
{
CommClose close = CommClose.Decode(embeddedPacket);
CloseMsg = close.Reason;
Log("Received Close (" + close.Reason + ")");
UpdateStatus(SessionStatus.Closed);
}
public void Receive_StoreReq(G2ReceivedPacket packet)
{
StoreReq store = StoreReq.Decode(packet);
if (Core.ServiceBandwidth.ContainsKey(store.Service))
{
Core.ServiceBandwidth[store.Service].InPerSec += packet.Root.Data.Length;
}
if (store.Source.Firewall == FirewallType.Open)
{
// dont need to add to routing if nat/blocked because eventual routing ping by server will auto add
Network.Routing.Add(new DhtContact(store.Source, packet.Source.IP));
}
// forward to proxied nodes - only replicate data to blocked nodes on operation network
if (!Network.IsLookup)
{
// when we go offline it will be these nodes that update their next proxy with stored info
foreach (TcpConnect socket in Network.TcpControl.ProxyClients)
{
if (packet.Tcp != socket)
{
if (packet.ReceivedUdp)
{
store.FromAddress = packet.Source;
}
socket.SendPacket(store);
}
}
}
// pass to components
DataReq data = new DataReq(packet.Source, store.Key, store.Service, store.DataType, store.Data);
if (packet.ReceivedTcp && packet.Tcp.Proxy == ProxyType.Server)
{
data.LocalProxy = new DhtClient(packet.Tcp);
}
if (data.Service == 0)
{
Receive_Patch(packet.Source, store.Data);
}
else if (StoreEvent.Contains(store.Service, store.DataType))
{
StoreEvent[store.Service, store.DataType].Invoke(data);
}
}
public static SearchReq Decode(G2ReceivedPacket packet)
{
SearchReq req = new SearchReq();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_Source:
req.Source = DhtSource.ReadPacket(child);
break;
case Packet_SearchID:
req.SearchID = BitConverter.ToUInt32(child.Data, child.PayloadPos);
break;
case Packet_Target:
req.TargetID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
break;
case Packet_Service:
req.Service = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_DataType:
req.DataType = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Parameters:
req.Parameters = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Nodes:
req.Nodes = BitConverter.ToBoolean(child.Data, child.PayloadPos);
break;
case Packet_EndSearch:
req.EndProxySearch = true;
break;
}
}
return(req);
}
public void ReceiveTunnelPacket(G2ReceivedPacket raw, TunnelPacket tunnel)
{
if (Core.InvokeRequired) // called from lookup core's thread
{
Core.RunInCoreAsync(delegate() { ReceiveTunnelPacket(raw, tunnel); });
return;
}
Debug.Assert(!IsLookup);
if (IsLookup)
{
return;
}
// decrypt public packet
if (Core.Sim == null || Core.Sim.Internet.TestEncryption) // turn off encryption during simulation
{
if (tunnel.Payload.Length < 16)
{
throw new Exception("Not enough data received for IV");
}
tunnel.Payload = Utilities.DecryptBytes(tunnel.Payload, tunnel.Payload.Length, LocalAugmentedKey);
}
G2ReceivedPacket opPacket = new G2ReceivedPacket();
opPacket.Root = new G2Header(tunnel.Payload);
// set source information
if (G2Protocol.ReadPacket(opPacket.Root))
{
opPacket.Source = new DhtAddress();
// used to add direct op contact if source firewall is open
// or re-routing through same lookup proxy
opPacket.Source.IP = raw.Source.IP;
opPacket.Source.UdpPort = raw.Source.UdpPort;
// op user/client set by net/comm processing
opPacket.Source.TunnelClient = tunnel.Source;
opPacket.Source.TunnelServer = tunnel.SourceServer;
PacketLogEntry logEntry = new PacketLogEntry(Core.TimeNow, TransportProtocol.Tunnel, DirectionType.In, opPacket.Source, opPacket.Root.Data);
LogPacket(logEntry);
IncomingPacket(opPacket);
}
}
public void Receive_SessionRequest(G2ReceivedPacket embeddedPacket)
{
SessionRequest request = SessionRequest.Decode(embeddedPacket);
Log("Session Request Received");
RequestReceived = true;
byte[] sessionKey = Core.User.Settings.KeyPair.Decrypt(request.EncryptedKey, false);
// new connection
if (OutboundEnc == null)
{
OutboundEnc = new RijndaelManaged();
OutboundEnc.Key = Utilities.ExtractBytes(sessionKey, 0, 32);
OutboundEnc.IV = Utilities.ExtractBytes(sessionKey, 32, 16);
}
// if key request
else
{
if (Utilities.MemCompare(OutboundEnc.Key, Utilities.ExtractBytes(sessionKey, 0, 32)) == false ||
Utilities.MemCompare(OutboundEnc.IV, Utilities.ExtractBytes(sessionKey, 32, 16)) == false)
{
Send_Close("Verification after key request failed");
return;
}
Send_SessionAck();
ConnectAckSent = true;
return;
}
// if public key null
if (!Core.KeyMap.ContainsKey(UserID))
{
StartEncryption();
Send_KeyRequest();
return;
}
if (Comm.Listening)
{
Send_SessionRequest();
}
StartEncryption();
Send_SessionAck();
ConnectAckSent = true;
}
public void Receive_ProxyUpdate(G2ReceivedPacket embeddedPacket)
{
ProxyUpdate update = ProxyUpdate.Decode(embeddedPacket);
Comm.AddAddress(new RudpAddress(update.Proxy));
if (embeddedPacket.ReceivedTcp)
{
Comm.AddAddress(new RudpAddress(update.Proxy, embeddedPacket.Tcp));
}
Comm.CheckRoutes();
Log("Received Proxy Update (" + update.Proxy + ")");
}
public void Receive_KeyRequest(G2ReceivedPacket embeddedPacket)
{
KeyRequest request = KeyRequest.Decode(embeddedPacket);
if (request.Key != null)
{
OutboundEnc = new RijndaelManaged();
OutboundEnc.Key = request.Key;
OutboundEnc.IV = request.IV;
StartEncryption();
}
Send_KeyAck();
}
public void Receive_ProxyAck(G2ReceivedPacket packet)
{
ProxyAck ack = ProxyAck.Decode(packet);
// update routing
if (packet.ReceivedUdp && ack.Source.Firewall == FirewallType.Open)
{
Routing.Add(new DhtContact(ack.Source, packet.Source.IP));
}
foreach (DhtContact contact in ack.ContactList)
{
Routing.Add(contact);
}
// dont do proxy if we're not firewalled or remote host didnt accept
if (Core.Firewall == FirewallType.Open || !ack.Accept)
{
if (packet.ReceivedTcp)
{
packet.Tcp.CleanClose("Proxy request rejected");
}
return;
}
// received ack udp
if (packet.ReceivedUdp)
{
if (!TcpControl.ProxyMap.ContainsKey(ack.Source.RoutingID))
{
TcpControl.MakeOutbound(packet.Source, ack.Source.TcpPort, "proxy ack recv");
}
}
// received ack tcp
else
{
packet.Tcp.Proxy = ProxyType.Server;
TcpControl.AddProxy(packet.Tcp);
TcpControl.CheckProxies();
// location and rudp connections updated after 20 seconds
}
}
public void UnreliableReceive(byte[] data)
{
byte[] decrypted = Utilities.DecryptBytes(data, data.Length, InboundEnc.Key);
G2ReceivedPacket packet = new G2ReceivedPacket();
packet.Root = new G2Header(decrypted);
if (G2Protocol.ReadPacket(packet.Root))
{
PacketLogEntry logEntry = new PacketLogEntry(Core.TimeNow, TransportProtocol.Rudp, DirectionType.In, Comm.PrimaryAddress.Address, decrypted);
Core.Network.LogPacket(logEntry);
ReceivePacket(packet);
}
}
/*public void SendUnreliable(RudpAddress address, uint service, int type, G2Packet packet)
* {
* // insecure, rudp provides this same method which is more secure, if a rudp connection is already established
*
* RudpPacket wrap = CreateRudpPacket(address.Address, service, type, packet, false);
*
* int sentBytes = LightClient.SendtoAddress(Core.Network, address, wrap);
*
* Core.ServiceBandwidth[service].OutPerSec += sentBytes;
* }*/
public void ReceivePacket(G2ReceivedPacket raw, RudpPacket packet)
{
DhtClient client = new DhtClient(packet.SenderID, packet.SenderClient);
if (!Clients.ContainsKey(client.RoutingID))
{
Clients[client.RoutingID] = new LightClient(client);
}
LightClient light = Clients[client.RoutingID];
light.LastSeen = Core.TimeNow;
// either direct, or node's proxy
light.AddAddress(Core, new RudpAddress(raw.Source), true);
if (raw.ReceivedTcp) // add this second so sending ack through tcp proxy is perferred
{
light.AddAddress(Core, new RudpAddress(raw.Source, raw.Tcp), true);
}
if (packet.PacketType == RudpPacketType.LightAck)
{
ReceiveAck(raw, light, packet);
}
else if (packet.PacketType == RudpPacketType.Light)
{
RudpLight info = new RudpLight(packet.Payload);
if (Core.ServiceBandwidth.ContainsKey(info.Service))
{
Core.ServiceBandwidth[info.Service].InPerSec += raw.Root.Data.Length;
}
if (Data.Contains(info.Service, info.Type))
{
Data[info.Service, info.Type].Invoke(client, info.Data);
}
if (packet.Sequence == 1) // reliable packet
{
SendAck(light, packet, info.Service);
}
}
}
public void Receive_SearchAck(SearchAck ack, G2ReceivedPacket packet)
{
DhtContact source = new DhtContact(ack.Source, packet.Source.IP);
if (!CrawlMap.ContainsKey(source.RoutingID))
{
CrawlMap[source.RoutingID] = new CrawlNode(source);
}
foreach (DhtContact contact in ack.ContactList)
{
if (!CrawlMap.ContainsKey(contact.RoutingID))
{
CrawlMap[contact.RoutingID] = new CrawlNode(contact);
}
}
}
public void TryAdd(G2ReceivedPacket packet, DhtSource source, bool pong)
{
// packet has IP and tunnel info
// source has operational info
// if firewall flag not set add to routing
if (source.Firewall == FirewallType.Open)
{
Add(new DhtContact(source, packet.Source.IP), pong);
}
// if tunneled source doesnt have op reachable IP, must go over global
else if (packet.Tunneled)
{
Add(new DhtContact(source, packet.Source.IP, packet.Source.TunnelClient, packet.Source.TunnelServer), pong);
}
}
public void SetLocalIP(IPAddress localIP, G2ReceivedPacket packet)
{
if (localIP != null && !packet.Tunneled)
{
bool lanIP = Utilities.IsLocalIP(localIP); // re init to what they think our ip is
if (!lanIP || LanMode && lanIP)
{
Core.LocalIP = localIP;
}
if (!lanIP && LanMode)
{
SetLanMode(false);
}
}
}
public static SearchAck Decode(G2ReceivedPacket packet)
{
SearchAck ack = new SearchAck();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
if (child.Name == Packet_Proxied)
{
ack.Proxied = true;
continue;
}
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_Source:
ack.Source = DhtSource.ReadPacket(child);
break;
case Packet_SearchID:
ack.SearchID = BitConverter.ToUInt32(child.Data, child.PayloadPos);
break;
case Packet_Contacts:
ack.ContactList.Add(DhtContact.ReadPacket(child));
break;
case Packet_Service:
ack.Service = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Values:
ack.ValueList.Add(Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize));
break;
}
}
return(ack);
}
public static CommClose Decode(G2ReceivedPacket packet)
{
CommClose close = new CommClose();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
if (child.Name == Packet_Message)
{
if (G2Protocol.ReadPayload(child))
{
close.Reason = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
}
}
}
return(close);
}
public void Receive_ProxyRequest(G2ReceivedPacket packet)
{
ProxyReq request = ProxyReq.Decode(packet);
ProxyAck ack = new ProxyAck();
ack.Source = GetLocalSource();
// check if there is space for type required
if (Core.Firewall == FirewallType.Open && TcpControl.AcceptProxy(request.Type, ack.Source.UserID))
{
ack.Accept = true;
}
else if (packet.ReceivedTcp)
{
packet.Tcp.CleanClose("Couldn't accept proxy request");
return;
}
// always send some contacts along so node can find closer proxy
ack.ContactList = Routing.Find(request.SenderID, 8);
// received request tcp
if (packet.ReceivedUdp)
{
UdpControl.SendTo(packet.Source, ack);
}
// received request tcp
else
{
packet.Tcp.Proxy = request.Type;
packet.Tcp.SendPacket(ack);
TcpControl.AddProxy(packet.Tcp);
// check if a proxy needs to be disconnected now because overflow
TcpControl.CheckProxies();
}
}
public static SessionAck Decode(G2ReceivedPacket packet)
{
SessionAck sa = new SessionAck();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
if (child.Name == Packet_Name)
{
if (G2Protocol.ReadPayload(child))
{
sa.Name = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
}
}
}
return(sa);
}
public static SessionRequest Decode(G2ReceivedPacket packet)
{
SessionRequest sr = new SessionRequest();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
if (child.Name == Packet_Key)
{
if (G2Protocol.ReadPayload(child))
{
sr.EncryptedKey = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
}
}
}
return(sr);
}
void ParsePacket(byte[] buff, int length, IPEndPoint sender, bool copied)
{
G2ReceivedPacket packet = new G2ReceivedPacket();
packet.Root = new G2Header(buff);
if (G2Protocol.ReadPacket(packet.Root))
{
packet.Source = new DhtContact(0, 0, sender.Address, 0, 0);
byte[] packetData = copied ? buff : Utilities.ExtractBytes(packet.Root.Data, packet.Root.PacketPos, packet.Root.PacketSize);
PacketLogEntry logEntry = new PacketLogEntry(Core.TimeNow, TransportProtocol.LAN, DirectionType.In, packet.Source, packetData);
Network.LogPacket(logEntry);
Network.IncomingPacket(packet);
}
}
public static StoreReq Decode(G2ReceivedPacket packet)
{
StoreReq req = new StoreReq();
G2Header child = new G2Header(packet.Root.Data);
while (G2Protocol.ReadNextChild(packet.Root, child) == G2ReadResult.PACKET_GOOD)
{
if (!G2Protocol.ReadPayload(child))
{
continue;
}
switch (child.Name)
{
case Packet_Source:
req.Source = DhtSource.ReadPacket(child);
break;
case Packet_Key:
req.Key = BitConverter.ToUInt64(child.Data, child.PayloadPos);
break;
case Packet_Service:
req.Service = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_DataType:
req.DataType = CompactNum.ToUInt32(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_Data:
req.Data = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
break;
case Packet_TTL:
req.TTL = BitConverter.ToUInt16(child.Data, child.PayloadPos);
break;
}
}
return(req);
}
public void Receive_KeyAck(G2ReceivedPacket embeddedPacket)
{
KeyAck keyAck = KeyAck.Decode(embeddedPacket);
Log("Key Ack Received");
Core.IndexKey(UserID, ref keyAck.PublicKey);
// send session request with encrypted current key
Send_SessionRequest();
if (RequestReceived)
{
Send_SessionAck();
ConnectAckSent = true;
}
// receiving session gets, verifies sender can encrypt with public key and goes alriiight alriight
}
