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 }