tmp

python_net/packer/main.py

@@ -0,0 +1,15 @@
+# from utils.net_params import LocalNetwork
+# from utils import net_params
+
+# print(net_params)
+
+
+
+
+bstr = bytes()
+new_bytes = bytes()
+
+con = bstr + new_bytes
+
+print(type(bstr))
+print(type(con))

python_net/packer/misc/icmp.py

@@ -26,7 +26,7 @@ def checksum(source_string):
     return answer
 
 def create_packet(id, data):
-    ICMP_ECHO_REQUEST = 8 #Код типа ICMP - в нашем случае ECHO
+    ICMP_ECHO_REQUEST = 8 # Код типа ICMP - в нашем случае ECHO
     header = struct.pack('bbHHh', ICMP_ECHO_REQUEST, 0, 0, id, 1)
     data = data
     my_checksum = checksum(header + data)
@@ -45,11 +45,11 @@ def send(dest_addr,data):
         sent = my_socket.sendto(packet, (dest_addr, 1))
         packet = packet[sent:]
 
-    return my_socket,packet_id
+    return my_socket, packet_id
 
 
 def recv(my_socket, packet_id):
-    ready = select.select([my_socket], [], [], 2) #таймаут 2с
+    ready = select.select([my_socket], [], [], 2) # таймаут 2с
     rec_packet, addr = my_socket.recvfrom(1024)
     icmp_header = rec_packet[20:28]    # Байты с 20 по 28 - заголовок ICMP
     type, code, checksum, p_id, sequence = struct.unpack(

python_net/packer/tcp/ip_layer.py

@@ -0,0 +1,47 @@
+import socket
+import struct
+from ip_packet import IPPacket
+
+
+class IPLayer:
+    rc = None
+    ss = None
+    src = None
+    
+    def __init__(self):
+        self.rc = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
+        self.ss = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW)
+        self.ss.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, True)
+        self.src = IPLayer.get_ip_address()
+
+
+    def send(self, dst, data):
+        packet = IPPacket()
+        print("IP packet: ", data)
+        packet.src = socket.inet_aton(self.src)
+        packet.dst = socket.inet_aton(dst)
+        packet.data = data
+        foo = packet.to_hex_string()
+        print(len(foo), foo)
+        self.ss.sendto(foo, (dst, 0))
+        return
+        # self.ss.sendto(packet.to_hex_string(), (dst, 0))
+
+    
+
+
+
+    @staticmethod
+    def get_ip_address():
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        return s.getsockname()[0]
+    
+
+def main():
+    ip_layer = IPLayer()
+    print(ip_layer.get_ip_address())
+
+
+if __name__ == "__main__":
+    main()

python_net/packer/tcp/ip_packet.py

@@ -0,0 +1,33 @@
+import socket
+import struct
+
+
+class IPPacket:
+
+    # data = bytes()
+
+
+    def __init__(self):
+        self.version = 4
+        self.hlen = 5
+        self.service = 0
+        self.len = 0
+        self.id = 54321
+        self.flags = 0
+        self.fragment_ofset = 0
+        self.ttl = 255
+        self.ulp = 6
+        self.crc = 0
+        self.src = socket.inet_aton("1.1.1.1")
+        self.dst = socket.inet_aton("1.1.1.1")
+        self.opt = None
+        self.data = b''
+        print(type(self.data))
+
+
+    def to_hex_string(self):
+        ip_vet_hlen = (self.version << 4) + self.hlen
+
+        return struct.pack('!BBHHHBBH4s4s', ip_vet_hlen, self.service, self.len,
+                           self.id, self.fragment_ofset, self.ttl,
+                           self.ulp, self.crc, self.src, self.dst) + self.data

python_net/packer/tcp/tcp_packet.py

@@ -0,0 +1,150 @@
+"""
+Структура TCP сегмента:
+
+Слово 1
+
+    SRC (16 бит) номер порта источника
+    DST (16 бит) номер порта назначения
+
+Слово 2    
+    SEQ (32 бита) позиционный номер, место первого байта данных сегмента в 
+        потоке данных от источника до получателя.
+
+Слово 3
+    ACK (32 бита) квитанция
+
+Слово 4
+    LEN (4 бита) длина заголовка
+    reserv (6 бит)
+    FLAGS (6 бит) флаги
+    WND (16 бит) размер окна приема
+
+"""
+
+import socket
+import struct
+import array
+
+
+class TCPPacket:
+    _srcip = None
+    _dstip = None
+
+    SRC = 0 # номер порта источника
+    DST = 0
+    SEQ = 0 # позиционный номер
+    ACK = 0 # квитанция
+    LEN = 0 # длина заголовка
+
+    # flags
+    f_URG = 0 
+    f_ACK = 0
+    f_PSH = 0
+    f_RST = 0
+    f_SYN = 0
+    f_FIN = 0
+
+    WND = 0 # размер окна приема
+    CHK = 0 # контрольная сумма
+    URG = 0 # указатель границы срочный данных
+    OPT = ''    # опции
+    DATA = ""   # данные
+
+    
+    def __init__(self) -> None:
+        print("Create TCP packet instance")
+
+
+    def set_data(self, data):
+        self.DATA = data
+
+
+    def set_ip(self, src, dst):
+        self._srcip = src
+        self._dstip = dst
+
+    
+    def to_hex_string(self):
+
+        tcp_flags = self.f_FIN + (self.f_SYN << 1) + (self.f_RST << 2) + \
+                    (self.f_PSH << 3) + (self.f_ACK << 4) + (self.f_URG << 5)
+        
+        header = struct.pack('!HHLLBBHHH', self.SRC, self.DST, self.SEQ, self.ACK,
+                             (self.LEN << 4) + 0, tcp_flags, self.WND, self.CHK, self.URG)
+
+        # calculate data length
+        data_len = 0
+        if(self.DATA != None):
+            data_len = len(self.DATA)
+
+        # create pseudo TCP packet
+        psh = struct.pack('!4s4sBBH',
+                          socket.inet_aton(self._srcip), # type: ignore
+                          socket.inet_aton(self._dstip),                          0, # type: ignore
+                          socket.IPPROTO_TCP,
+                          len(header) + data_len)
+
+        psh = psh + header + bytes(self.DATA, 'utf-8')
+
+        crc = self.crc(psh)
+
+        return struct.pack('!HHLLBBH', self.SRC, self.DST, self.SEQ, self.ACK, \
+                            (self.LEN << 4) + 0, tcp_flags, self.WND) + \
+                            struct.pack('H', crc) + struct.pack('!H', self.URG) + \
+                            bytes(self.DATA, 'utf-8')
+
+
+
+    def crc(self, data: bytes):
+        if len(data)%2 != 0:
+            data += b'\0'
+
+        res = sum(array.array("H", data))
+        res = (res >> 16) + (res & 0xffff)
+        res += res >> 16
+
+        return (~res) & 0xffff
+
+
+    @staticmethod
+    def get_falgs_from_byte(data):
+        flags = [0,0,0,0,0,0]
+
+        flags[0] = (data >> 5) & 1
+        flags[1] = data >> 4 & 1
+        flags[2] = data >> 3 & 1
+        flags[3] = data >> 2 & 1
+        flags[4] = data >> 1 & 1
+        flags[5] = data & 1
+
+        return (flags[0], flags[1], flags[2], flags[3], flags[4], flags[5])
+
+
+    def __str__(self):
+        s = ""
+        s += "TCP Segment"
+        s += "\tSource Port: {}, Destination Port: {}\n".format(self.SRC, self.DST)
+        s += "\tSequence: {}, Acknowledgement: {}\n".format(self.SEQ, self.ACK)
+        s += "\tFlags\n"
+        s += "\t\tURG: {}, ACK: {}, PSH: {}\n".format(self.f_URG, self.f_ACK, self.f_PSH)
+        s += "\t\tRST: {}, SYN: {}, FIN: {}\n".format(self.f_RST, self.f_SYN, self.f_FIN)
+        s += "\tHeader Length: {}, Window Size: {}\n".format(self.LEN, self.WND)
+        # Other parameters
+        s += "Over parameters\n"
+        s += "\t\tSRC ip: {}, DST ip: {}\n".format(self._srcip, self._dstip)
+        return s
+
+
+
+
+
+def main():
+    pack = TCPPacket()
+    print(pack)
+    
+
+
+if __name__ == "__main__":
+    main()
+
+

python_net/packer/tcp/tcp_socket.py

@@ -0,0 +1,94 @@
+import socket
+import threading
+import time
+from tcp_packet import TCPPacket
+from ip_layer import IPLayer
+
+# from utils import net_params
+
+class TCPSocket:
+
+    _localport = 1234
+    _ip_layer = None
+
+    ip = None       # ip назначения
+    port = None     # port назначения
+
+    next_seq_num = 0
+    next_ack_num = 0
+
+    send_data = ""
+    recv_data = ""
+
+    def __init__(self, ip_layer):
+        self._ip_layer = ip_layer
+        recv_thread = threading.Thread(target=self._recv_thread, daemon=True)
+        send_thread = threading.Thread(target=self._send_thread, daemon=True)
+        recv_thread.start()
+        send_thread.start()
+
+
+    def send(self, data):
+        self.send_data += data
+
+
+    def _send(self, packet):
+        packet.SEQ = self.next_seq_num
+
+        if packet.ACK == 1: 
+            packet.ACK = self.next_ack_num
+        if (packet.f_SYN == 1 or packet.f_FIN == 1):
+            self.next_seq_num = self.next_seq_num + 1
+        elif (packet.f_ACK == 1 and len(packet.DATA) == 0):
+            self.next_seq_num = self.next_seq_num
+        elif (len(packet.DATA) != 0):
+            self.next_seq_num = self.next_seq_num + len(packet.DATA)
+        
+
+        self._ip_layer.send(self.ip, packet.to_hex_string())
+
+
+    def _recv_thread(self):
+        while True:
+            # print("This is recv thread")
+            time.sleep(2)
+
+
+    def _send_thread(self):
+        while True:
+            # print("This is send thread")
+            time.sleep(1)
+
+
+    def connect(self, ip, port):
+        self.ip = ip
+        self.port = port
+        # print("Opening connection")
+
+        # send SYN
+        syn = self.make_tcp_packet()
+        syn.f_SYN = 1
+        print(syn)
+        self._send(syn)
+
+
+    def make_tcp_packet(self):
+        packet = TCPPacket()
+        packet.set_ip(IPLayer.get_ip_address(), self.ip)
+        packet.SRC = self._localport # type: ignore
+        packet.DST = self.port # type: ignore
+        return packet
+
+
+
+def main():
+    ip_layer = IPLayer()
+    sock = TCPSocket(ip_layer)
+    sock.connect("8.8.8.8", 80)   
+    # lock_net = LocalNetwork()
+    # print(lock_net.get_ip()) # type: ignore
+
+
+if __name__ == "__main__":
+    main()
+