Ejemplo n.º 1
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void processMessageUDP(pspsharp.network.protocols.NetPacket packet, pspsharp.network.protocols.EtherFrame frame, pspsharp.network.protocols.IPv4 ipv4) throws java.io.EOFException
        private void processMessageUDP(NetPacket packet, EtherFrame frame, IPv4 ipv4)
        {
            UDP udp = new UDP();

            udp.read(packet);

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("processMessageUDP {0}", udp));
            }

            switch (udp.destinationPort)
            {
            case UDP_PORT_DNS:
                processMessageDNS(packet, frame, ipv4, udp);
                break;

            case UDP.UDP_PORT_DHCP_SERVER:
                processMessageDHCP(packet, frame, ipv4, udp);
                break;

            default:
                Console.WriteLine(string.Format("processMessageUDP unknown destination port 0x{0:X}", udp.destinationPort));
                break;
            }
        }
Ejemplo n.º 2
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void processMessageDatagram(pspsharp.network.protocols.NetPacket packet, pspsharp.network.protocols.EtherFrame frame) throws java.io.EOFException
        private void processMessageDatagram(NetPacket packet, EtherFrame frame)
        {
            IPv4 ipv4 = new IPv4();

            ipv4.read(packet);

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("processMessageDatagram IPv4 {0}", ipv4));
            }

            switch (ipv4.protocol)
            {
            case IPv4_PROTOCOL_ICMP:
                processMessageDatagramICMP(packet, frame, ipv4);
                break;

            case IPv4_PROTOCOL_TCP:
                processMessageTCP(packet, frame, ipv4);
                break;

            case IPv4_PROTOCOL_UDP:
                processMessageUDP(packet, frame, ipv4);
                break;

            default:
                Console.WriteLine(string.Format("processMessageDatagram unknown protocol {0:D}", ipv4.protocol));
                break;
            }
        }
Ejemplo n.º 3
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void sendGratuitousARP() throws java.io.EOFException
        private void sendGratuitousARP()
        {
            EtherFrame frame = new EtherFrame();

            frame.dstMac = new pspNetMacAddress(ANY_MAC_ADDRESS);
            frame.srcMac = MacAddress;
            frame.type   = ETHER_TYPE_ARP;

            ARP arp = new ARP();

            arp.hardwareType          = HARDWARE_TYPE_ETHERNET;
            arp.protocolType          = ETHER_TYPE_IPv4;
            arp.hardwareAddressLength = MAC_ADDRESS_LENGTH;
            arp.protocolAddressLength = IP_ADDRESS_LENGTH;
            arp.operation             = ARP_OPERATION_REQUEST;
            arp.senderHardwareAddress = MacAddress;
            arp.senderProtocolAddress = IpAddress;
            // Set the target hardware address to 00:00:00:00:00:00
            arp.targetHardwareAddress = new pspNetMacAddress();
            arp.targetProtocolAddress = IpAddress;

            NetPacket packet = new NetPacket(EtherFrame.sizeOf() + arp.sizeOf());

            frame.write(packet);
            arp.write(packet);

            sendPacket(packet);
        }
Ejemplo n.º 4
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void processMessageDHCP(pspsharp.network.protocols.NetPacket packet, pspsharp.network.protocols.EtherFrame frame, pspsharp.network.protocols.IPv4 ipv4, pspsharp.network.protocols.UDP udp) throws java.io.EOFException
        private void processMessageDHCP(NetPacket packet, EtherFrame frame, IPv4 ipv4, UDP udp)
        {
            DHCP dhcp = new DHCP();

            dhcp.read(packet);

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("processMessageDHCP {0}", dhcp));
            }

            if (dhcp.isDiscovery(udp, ipv4))
            {
                // Send back a DHCP offset message
                sendDHCPReply(frame, ipv4, udp, dhcp, DHCP.DHCP_OPTION_MESSAGE_TYPE_DHCPOFFER);
            }
            else if (dhcp.isRequest(udp, ipv4, LocalIpAddress))
            {
                // Send back a DHCP acknowledgment message
                sendDHCPReply(frame, ipv4, udp, dhcp, DHCP.DHCP_OPTION_MESSAGE_TYPE_DHCPACK);
            }
            else
            {
                Console.WriteLine(string.Format("Unknown DHCP request {0}", dhcp));
            }
        }
Ejemplo n.º 5
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void processMessage(pspsharp.network.protocols.NetPacket packet) throws java.io.EOFException
        private void processMessage(NetPacket packet)
        {
            sbyte cmd = packet.readByte();

            if (cmd != WLAN_CMD_DATA)
            {
                Console.WriteLine(string.Format("processMessage unknown command 0x{0:X}", cmd));
                return;
            }

            string ssid = packet.readStringNZ(32);

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("processMessage ssid='{0}'", ssid));
            }

            if (string.ReferenceEquals(apSsid, null))
            {
                apSsid = ssid;
                //if (log.DebugEnabled)
                {
                    Console.WriteLine(string.Format("Using ssid='{0}' for the Access Point", apSsid));
                }
            }

            EtherFrame frame = new EtherFrame();

            frame.read(packet);

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("processMessage {0}", frame));
            }

            switch (frame.type)
            {
            case ETHER_TYPE_ARP:
                processMessageARP(packet);
                break;

            case ETHER_TYPE_IPv4:                     // See https://www.ietf.org/rfc/rfc894.txt
                processMessageDatagram(packet, frame);
                break;

            default:
                Console.WriteLine(string.Format("Unknow message of type 0x{0:X4}", frame.type));
                break;
            }
        }
Ejemplo n.º 6
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void sendTcpData(TcpConnectionState tcpConnectionState, byte[] data) throws java.io.EOFException
        private void sendTcpData(TcpConnectionState tcpConnectionState, sbyte[] data)
        {
            EtherFrame answerFrame = new EtherFrame();

            answerFrame.srcMac = tcpConnectionState.destinationMacAddress;
            answerFrame.dstMac = tcpConnectionState.sourceMacAddress;
            answerFrame.type   = ETHER_TYPE_IPv4;

            IPv4 answerIPv4 = new IPv4();

            answerIPv4.protocol             = IPv4_PROTOCOL_TCP;
            answerIPv4.sourceIPAddress      = tcpConnectionState.destinationIPAddress;
            answerIPv4.destinationIPAddress = tcpConnectionState.sourceIPAddress;

            TCP answerTcp = new TCP();

            answerTcp.sourcePort           = tcpConnectionState.destinationPort;
            answerTcp.destinationPort      = tcpConnectionState.sourcePort;
            answerTcp.sequenceNumber       = tcpConnectionState.destinationSequenceNumber;
            answerTcp.acknowledgmentNumber = tcpConnectionState.sourceSequenceNumber;
            answerTcp.flagACK = true;
            answerTcp.flagPSH = true;
            tcpConnectionState.destinationSequenceNumber += data.Length;
            answerTcp.data = data;

            // Update lengths and checksums
            answerTcp.computeChecksum(answerIPv4);
            answerIPv4.totalLength = answerIPv4.sizeOf() + answerTcp.sizeOf();
            answerIPv4.computeChecksum();

            // Write the different headers in sequence
            NetPacket answerPacket = new NetPacket(BUFFER_SIZE);

            answerFrame.write(answerPacket);
            answerIPv4.write(answerPacket);
            answerTcp.write(answerPacket);

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("sendTcpData frame={0}", answerFrame));
                Console.WriteLine(string.Format("sendTcpData IPv4={0}", answerIPv4));
                Console.WriteLine(string.Format("sendTcpData TCP={0}", answerTcp));
            }

            sendPacket(answerPacket);
        }
Ejemplo n.º 7
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void sendICMPEchoResponse(pspsharp.network.protocols.NetPacket packet, pspsharp.network.protocols.EtherFrame frame, pspsharp.network.protocols.IPv4 ipv4, pspsharp.network.protocols.ICMP icmp) throws java.io.EOFException
        private void sendICMPEchoResponse(NetPacket packet, EtherFrame frame, IPv4 ipv4, ICMP icmp)
        {
            bool reachable = false;

            try
            {
                InetAddress inetAddress = InetAddress.getByAddress(ipv4.destinationIPAddress);
                // Timeout after 1 second
                reachable = inetAddress.isReachable(null, ipv4.timeToLive, 1000);
            }
            catch (UnknownHostException)
            {
            }
            catch (IOException)
            {
            }

            if (reachable)
            {
                // See https://en.wikipedia.org/wiki/Ping_(networking_utility)
                EtherFrame answerFrame = new EtherFrame(frame);
                answerFrame.swapSourceAndDestination();

                IPv4 answerIPv4 = new IPv4(ipv4);
                answerIPv4.swapSourceAndDestination();
                answerIPv4.timeToLive--;                 // When a packet arrives at a router, the router decreases the TTL FieldInfo.

                ICMP answerIcmp = new ICMP(icmp);
                answerIcmp.type = ICMP.ICMP_CONTROL_ECHO_REPLY;
                answerIcmp.computeChecksum();

                answerIPv4.totalLength = answerIPv4.sizeOf() + answerIcmp.sizeOf();
                answerIPv4.computeChecksum();

                // Write the different headers in sequence
                NetPacket answerPacket = new NetPacket(BUFFER_SIZE);
                answerFrame.write(answerPacket);
                answerIPv4.write(answerPacket);
                answerIcmp.write(answerPacket);

                sendPacket(answerPacket);
            }
        }
Ejemplo n.º 8
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void processMessageDatagramICMP(pspsharp.network.protocols.NetPacket packet, pspsharp.network.protocols.EtherFrame frame, pspsharp.network.protocols.IPv4 ipv4) throws java.io.EOFException
        private void processMessageDatagramICMP(NetPacket packet, EtherFrame frame, IPv4 ipv4)
        {
            ICMP icmp = new ICMP();

            icmp.read(packet);

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("processMessageDatagramICMP {0}", icmp));
            }

            switch (icmp.type)
            {
            case ICMP_CONTROL_ECHO_REQUEST:
                sendICMPEchoResponse(packet, frame, ipv4, icmp);
                break;

            default:
                Console.WriteLine(string.Format("processMessageDatagramICMP unknown type=0x{0:X}, code=0x{1:X}", icmp.type, icmp.code));
                break;
            }
        }
Ejemplo n.º 9
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void processMessageTCP(pspsharp.network.protocols.NetPacket packet, pspsharp.network.protocols.EtherFrame frame, pspsharp.network.protocols.IPv4 ipv4) throws java.io.EOFException
        private void processMessageTCP(NetPacket packet, EtherFrame frame, IPv4 ipv4)
        {
            TCP tcp = new TCP();

            tcp.read(packet);

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("processMessageTCP {0}", tcp));
            }

            TcpConnectionState tcpConnectionState = getTcpConnectionState(ipv4, tcp);

            if (tcp.flagSYN)
            {
                if (tcpConnectionState != null)
                {
                    if (!tcpConnectionState.pendingConnection)
                    {
                        Console.WriteLine(string.Format("processMessageTCP SYN received but connection already exists: {0}", tcpConnectionState));
                        return;
                    }

                    //if (log.DebugEnabled)
                    {
                        Console.WriteLine(string.Format("processMessageTCP SYN received for a connection still pending ({0}), retrying the connection", tcpConnectionState));
                    }

                    try
                    {
                        tcpConnectionState.close();
                    }
                    catch (IOException e)
                    {
                        //if (log.DebugEnabled)
                        {
                            Console.WriteLine("error while closing connection", e);
                        }
                    }
                    tcpConnectionStates.Remove(tcpConnectionState);
                }

                tcpConnectionState = new TcpConnectionState();
                tcpConnectionState.sourceMacAddress          = frame.srcMac;
                tcpConnectionState.destinationMacAddress     = frame.dstMac;
                tcpConnectionState.sourceIPAddress           = ipv4.sourceIPAddress;
                tcpConnectionState.destinationIPAddress      = ipv4.destinationIPAddress;
                tcpConnectionState.sourcePort                = tcp.sourcePort;
                tcpConnectionState.destinationPort           = tcp.destinationPort;
                tcpConnectionState.sourceSequenceNumber      = tcp.sequenceNumber + tcp.data.Length;
                tcpConnectionState.destinationSequenceNumber = random.Next();
                tcpConnectionState.pendingConnection         = true;
                tcpConnectionStates.Add(tcpConnectionState);
            }
            else if (tcp.flagACK)
            {
                if (tcpConnectionState == null)
                {
                    // Acknowledge to an unknown connection, ignore
                    //if (log.DebugEnabled)
                    {
                        Console.WriteLine(string.Format("processMessageTCP ACK received for unknown connection: {0}", tcp));
                    }
                    return;
                }

                try
                {
                    if (tcp.flagFIN)
                    {
                        tcpConnectionState.sourceSequenceNumber += tcp.data.Length;
                        tcpConnectionState.sourceSequenceNumber++;
                        sendAcknowledgeTCP(tcpConnectionState, false);
                    }
                    else if (tcp.flagPSH)
                    {
                        // Acknowledge the reception of the data
                        tcpConnectionState.sourceSequenceNumber += tcp.data.Length;
                        sendAcknowledgeTCP(tcpConnectionState, false);

                        // Queue the received data for the destination
                        tcpConnectionState.addPendingWriteData(tcp.data);
                    }
                }
                catch (IOException e)
                {
                    Console.WriteLine("processMessageTCP", e);
                }
            }
        }
Ejemplo n.º 10
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void processMessageDNS(pspsharp.network.protocols.NetPacket packet, pspsharp.network.protocols.EtherFrame frame, pspsharp.network.protocols.IPv4 ipv4, pspsharp.network.protocols.UDP udp) throws java.io.EOFException
        private void processMessageDNS(NetPacket packet, EtherFrame frame, IPv4 ipv4, UDP udp)
        {
            DNS dns = new DNS();

            dns.read(packet);

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("processMessageDNS {0}", dns));
            }

            if (!dns.isResponseFlag && dns.questionCount == 1)
            {
                DNS.DNSRecord question = dns.questions[0];
                string        hostName = question.recordName;

                DNS answerDns = new DNS(dns);
                try
                {
                    InetAddress inetAddress = InetAddress.getByName(hostName);
                    //if (log.DebugEnabled)
                    {
                        Console.WriteLine(string.Format("DNS response '{0}'={1}", hostName, inetAddress));
                    }

                    DNS.DNSAnswerRecord answer = new DNS.DNSAnswerRecord();
                    answer.recordName           = hostName;
                    answer.recordClass          = question.recordClass;
                    answer.recordType           = question.recordType;
                    answer.data                 = inetAddress.Address;
                    answer.dataLength           = answer.data.Length;
                    answerDns.responseCode      = DNS_RESPONSE_CODE_NO_ERROR;
                    answerDns.answerRecordCount = 1;
                    answerDns.answerRecords     = new DNS.DNSAnswerRecord[] { answer };
                }
                catch (UnknownHostException e)
                {
                    answerDns.responseCode = DNS_RESPONSE_CODE_NAME_ERROR;
                    //if (log.DebugEnabled)
                    {
                        Console.WriteLine(string.Format("processMessageDNS unknown host '{0}'({1})", hostName, e.ToString()));
                    }
                }

                answerDns.isResponseFlag = true;

                EtherFrame answerFrame = new EtherFrame(frame);
                answerFrame.swapSourceAndDestination();

                IPv4 answerIPv4 = new IPv4(ipv4);
                answerIPv4.swapSourceAndDestination();
                answerIPv4.timeToLive--;                 // When a packet arrives at a router, the router decreases the TTL FieldInfo.

                UDP answerUdp = new UDP(udp);
                answerUdp.swapSourceAndDestination();

                // Update lengths and checksums
                answerUdp.Length = answerUdp.sizeOf() + answerDns.sizeOf();
                answerUdp.computeChecksum();
                answerIPv4.totalLength = answerIPv4.sizeOf() + answerUdp.Length;
                answerIPv4.computeChecksum();

                // Write the different headers in sequence
                NetPacket answerPacket = new NetPacket(BUFFER_SIZE);
                answerFrame.write(answerPacket);
                answerIPv4.write(answerPacket);
                answerUdp.write(answerPacket);
                answerDns.write(answerPacket);

                sendPacket(answerPacket);
            }
        }
Ejemplo n.º 11
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void sendDHCPReply(pspsharp.network.protocols.EtherFrame frame, pspsharp.network.protocols.IPv4 ipv4, pspsharp.network.protocols.UDP udp, pspsharp.network.protocols.DHCP dhcp, int messageType) throws java.io.EOFException
        private void sendDHCPReply(EtherFrame frame, IPv4 ipv4, UDP udp, DHCP dhcp, int messageType)
        {
            // Send back a DHCP offer message
            EtherFrame answerFrame = new EtherFrame(frame);

            answerFrame.swapSourceAndDestination();
            answerFrame.srcMac = MacAddress;

            IPv4 answerIPv4 = new IPv4(ipv4);

            answerIPv4.sourceIPAddress = IpAddress;
            answerIPv4.timeToLive--;             // When a packet arrives at a router, the router decreases the TTL FieldInfo.

            UDP answerUdp = new UDP(udp);

            answerUdp.swapSourceAndDestination();

            DHCP answerDhcp = new DHCP(dhcp);

            answerDhcp.opcode              = DHCP_BOOT_REPLY;
            answerDhcp.yourIPAddress       = LocalIpAddress;
            answerDhcp.nextServerIPAddress = IpAddress;

            answerDhcp.clearOptions();
            // The DHCP message type
            answerDhcp.addOption(new DHCP.DHCPOption(DHCP.DHCP_OPTION_MESSAGE_TYPE, (sbyte)messageType));
            // The subnet mask
            answerDhcp.addOption(new DHCP.DHCPOption(DHCP.DHCP_OPTION_SUBNET_MASK, getIpAddress(sceNetApctl.SubnetMaskInt)));
            // The only router is myself
            answerDhcp.addOption(new DHCP.DHCPOption(DHCP.DHCP_OPTION_ROUTER, IpAddress));
            // The IP address lease time is forever
            answerDhcp.addOption(new DHCP.DHCPOption(DHCP.DHCP_OPTION_IP_ADDRESS_LEASE_TIME, int.MaxValue));
            // The DHCP server identification is myself
            answerDhcp.addOption(new DHCP.DHCPOption(DHCP.DHCP_OPTION_SERVER_IDENTIFIER, IpAddress));
            // The only DNS server is myself
            answerDhcp.addOption(new DHCP.DHCPOption(DHCP.DHCP_OPTION_DNS, IpAddress));
            // The broadcast address
            answerDhcp.addOption(new DHCP.DHCPOption(DHCP.DHCP_OPTION_BROADCAST_ADDRESS, DHCP.broadcastIPAddress));

            // Update lengths and checksums
            answerUdp.Length = answerUdp.sizeOf() + answerDhcp.sizeOf();
            answerUdp.computeChecksum();
            answerIPv4.totalLength = answerIPv4.sizeOf() + answerUdp.Length;
            answerIPv4.computeChecksum();

            // Write the different headers in sequence
            NetPacket answerPacket = new NetPacket(BUFFER_SIZE);

            answerFrame.write(answerPacket);
            answerIPv4.write(answerPacket);
            answerUdp.write(answerPacket);
            answerDhcp.write(answerPacket);

            //if (log.DebugEnabled)
            {
                Console.WriteLine(string.Format("sendDHCPReply frame={0}", answerFrame));
                Console.WriteLine(string.Format("sendDHCPReply IPv4={0}", answerIPv4));
                Console.WriteLine(string.Format("sendDHCPReply UDP={0}", answerUdp));
                Console.WriteLine(string.Format("sendDHCPReply messageType={0:D}, DHCP={1}", messageType, answerDhcp));
            }

            sendPacket(answerPacket);
        }