nopasaran 0.2.99__tar.gz → 0.2.101__tar.gz

{nopasaran-0.2.99 → nopasaran-0.2.101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nopasaran
-Version: 0.2.99
+Version: 0.2.101
 Summary: NoPASARAN is an advanced network tool designed to detect, fingerprint, and locate network middleboxes in a unified framework.
 Home-page: https://github.com/BenIlies/NoPASARAN
 Author: Ilies Benhabbour

{nopasaran-0.2.99 → nopasaran-0.2.101}/nopasaran/definitions/events.py

@@ -35,4 +35,5 @@ class EventNames(Enum):
     REJECTED = 24
     RESET_RECEIVED = 25
     RECEIVED_FRAMES = 26
-    RECEIVED_REQUESTS = 27
+    RECEIVED_REQUESTS = 27
+    RESPONSE_SENT = 27

{nopasaran-0.2.99 → nopasaran-0.2.101}/nopasaran/primitives/action_primitives/action_primitives.py

@@ -27,6 +27,8 @@ from nopasaran.primitives.action_primitives.replay_primitives import ReplayPrimi
 from nopasaran.primitives.action_primitives.http_simple_client_primitives import HTTPSimpleClientPrimitives
 from nopasaran.primitives.action_primitives.tcp_dns_request_primitives import TCPDNSRequestPrimitives
 from nopasaran.primitives.action_primitives.tcp_dns_response_primitives import TCPDNSResponsePrimitives
+from nopasaran.primitives.action_primitives.udp_dns_request_primitives import UDPDNSRequestPrimitives
+from nopasaran.primitives.action_primitives.udp_dns_response_primitives import UDPDNSResponsePrimitives
 
 
 class ActionPrimitives(Primitives):
@@ -60,6 +62,8 @@ class ActionPrimitives(Primitives):
         PortProbingPrimitives,
         ReplayPrimitives,
         HTTPSimpleClientPrimitives,
+        TCPDNSRequestPrimitives,
         TCPDNSResponsePrimitives,
-        TCPDNSRequestPrimitives
+        UDPDNSRequestPrimitives,
+        UDPDNSResponsePrimitives
         ]

nopasaran-0.2.101/nopasaran/primitives/action_primitives/udp_dns_request_primitives.py

@@ -0,0 +1,29 @@
+from nopasaran.decorators import parsing_decorator
+from nopasaran.definitions.events import EventNames
+import nopasaran.utils as utils
+
+class UDPDNSRequestPrimitives:
+    @staticmethod
+    @parsing_decorator(input_args=4, output_args=1)
+    def make_udp_dns_query(inputs, outputs, state_machine):
+        """
+        Make a DNS query over UDP with user-defined domain and query type.
+        inputs: [domain, query_type, server_ip, server_port]
+        outputs: [dns_response_dict]
+        """
+        domain = state_machine.get_variable_value(inputs[0])
+        query_type = state_machine.get_variable_value(inputs[1])
+        server_ip = state_machine.get_variable_value(inputs[2])
+        server_port = int(state_machine.get_variable_value(inputs[3]))
+
+        # Call utility function with provided parameters
+        result = utils.send_udp_dns_query(server_ip, server_port, domain, query_type)
+
+        # Store result and trigger events accordingly
+        if not result or result.get("response") is None:
+            state_machine.set_variable_value(outputs[0], {"received": None})
+            state_machine.trigger_event(EventNames.REQUEST_ERROR.name)
+        else:
+            state_machine.set_variable_value(outputs[0], {"received": result})
+            state_machine.trigger_event(EventNames.RESPONSE_RECEIVED.name)
+

nopasaran-0.2.101/nopasaran/primitives/action_primitives/udp_dns_response_primitives.py

@@ -0,0 +1,40 @@
+from nopasaran.decorators import parsing_decorator
+from nopasaran.tools.udp_dns_socket_server import UDPDNSSocketServer
+
+class UDPDNSResponsePrimitives:
+
+    @staticmethod
+    @parsing_decorator(input_args=0, output_args=1)
+    def create_udp_dns_server(inputs, outputs, state_machine):
+        server = UDPDNSSocketServer()
+        state_machine.set_variable_value(outputs[0], server)
+
+    @staticmethod
+    @parsing_decorator(input_args=2, output_args=0)
+    def start_udp_dns_server(inputs, outputs, state_machine):
+        server = state_machine.get_variable_value(inputs[0])
+        port = int(state_machine.get_variable_value(inputs[1]))
+        server.start(port)
+
+    @staticmethod
+    @parsing_decorator(input_args=4, output_args=1)
+    def wait_and_respond_udp_dns_query(inputs, outputs, state_machine):
+        """
+        Wait for a DNS query and respond based on provided spec.
+        Inputs: [server_instance, port, timeout, response_spec]
+        Outputs: [result_dict]
+        Example response_spec:
+        {"type": "CNAME", "value": "safe.com", "qname": "blocked.com."}
+        """
+        server = state_machine.get_variable_value(inputs[0])
+        timeout = int(state_machine.get_variable_value(inputs[2]))
+        response_spec = state_machine.get_variable_value(inputs[3])  # can be None
+
+        result, _ = server.wait_for_query(timeout, response_spec)
+        state_machine.set_variable_value(outputs[0], result)
+
+    @staticmethod
+    @parsing_decorator(input_args=1, output_args=0)
+    def close_udp_dns_server(inputs, outputs, state_machine):
+        server = state_machine.get_variable_value(inputs[0])
+        server.close()

{nopasaran-0.2.99 → nopasaran-0.2.101}/nopasaran/tools/tcp_dns_socket_server.py

@@ -4,6 +4,7 @@ import select
 import time
 from dnslib import DNSRecord, RR, QTYPE, A, CNAME, MX, TXT, NS, SOA, PTR, AAAA, SRV, DS, RRSIG, NSEC, DNSKEY
 from nopasaran.definitions.events import EventNames
+import logging
 
 class TCPDNSSocketServer:
     def __init__(self):
@@ -14,6 +15,7 @@ class TCPDNSSocketServer:
         self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         self.sock.bind(('', port))
         self.sock.listen(5)
+        logging.info(f"TCP DNS server started on port {port}")
         return EventNames.SERVER_STARTED.name, f"TCP DNS server started on port {port}"
 
     def wait_for_query(self, timeout, response_spec=None):
@@ -21,69 +23,66 @@ class TCPDNSSocketServer:
         start_time = time.time()
         self.sock.setblocking(False)
 
-        print(f"[Server] Waiting for connections on port {self.sock.getsockname()[1]} with timeout {timeout} seconds")
+        logging.info(f"Waiting for connections on port {self.sock.getsockname()[1]} with timeout {timeout} seconds")
 
         while True:
             remaining_time = timeout - (time.time() - start_time)
-            print(f"[Server] Remaining time: {remaining_time:.2f} seconds")
+            logging.debug(f"Remaining time: {remaining_time:.2f} seconds")
             if remaining_time <= 0:
-                print("[Server] Timeout reached with no connection.")
+                logging.warning("Timeout reached with no connection.")
                 return {"received": None}, EventNames.TIMEOUT.name
 
             ready, _, _ = select.select([self.sock], [], [], remaining_time)
             if ready:
-                print("[Server] Socket is ready, accepting...")
                 client_sock, client_addr = self.sock.accept()
-                print(f"[Server] Accepted connection from {client_addr}")
+                logging.info(f"Accepted connection from {client_addr}")
 
                 try:
-                    # Set client socket read timeout
                     client_sock.settimeout(5)
                     length_data = client_sock.recv(2)
-                    print(f"[Server] Received length_data: {length_data}")
+                    logging.debug(f"Received length_data: {length_data}")
 
                     if len(length_data) < 2:
-                        print("[Server] Incomplete length_data")
+                        logging.error("Incomplete length_data")
                         return {"received": None}, EventNames.ERROR.name
 
                     expected_length = struct.unpack("!H", length_data)[0]
-                    print(f"[Server] Expecting {expected_length} bytes of query data")
+                    logging.debug(f"Expecting {expected_length} bytes of query data")
 
                     request_data = b""
                     receive_start_time = time.time()
                     receive_timeout = 5  # seconds
 
                     while len(request_data) < expected_length:
-                        # Check elapsed time to prevent infinite waiting
                         if time.time() - receive_start_time > receive_timeout:
-                            print("[Server] Timeout while receiving DNS query data")
+                            logging.warning("Timeout while receiving DNS query data")
                             return {"received": None}, EventNames.TIMEOUT.name
 
                         try:
                             chunk = client_sock.recv(expected_length - len(request_data))
                             if not chunk:
-                                print("[Server] Connection closed before full query received")
+                                logging.error("Connection closed before full query received")
                                 return {"received": None}, EventNames.ERROR.name
                             request_data += chunk
-                            print(f"[Server] Received {len(request_data)}/{expected_length} bytes")
+                            logging.debug(f"Received {len(request_data)}/{expected_length} bytes")
                         except socket.timeout:
-                            print("[Server] Socket recv() timed out")
+                            logging.warning("Socket recv() timed out")
                             return {"received": None}, EventNames.TIMEOUT.name
 
                     if not request_data:
-                        print("[Server] No request data received")
+                        logging.error("No request data received")
                         return {"received": None}, EventNames.ERROR.name
 
-                    print("[Server] Parsing DNS query...")
+                    logging.debug("Parsing DNS query...")
                     parsed_query = DNSRecord.parse(request_data)
-                    print(f"[Server] Parsed query: {parsed_query.toZone()}")
+                    logging.info(f"Parsed query:\n{parsed_query.toZone()}")
 
-                    print("[Server] Building DNS response...")
+                    logging.debug("Building DNS response...")
                     response = self.build_response(parsed_query, response_spec)
 
-                    print("[Server] Sending DNS response...")
+                    logging.debug("Sending DNS response...")
                     self.send_dns_response(client_sock, response)
-                    print("[Server] DNS response sent successfully.")
+                    logging.info("DNS response sent successfully.")
 
                     return {
                         "received": parsed_query.toZone(),
@@ -91,11 +90,9 @@ class TCPDNSSocketServer:
                     }, EventNames.REQUEST_RECEIVED.name
 
                 finally:
-                    print("[Server] Closing client socket")
+                    logging.debug("Closing client socket")
                     client_sock.close()
 
-
-
     def build_response(self, query_record, response_spec=None):
         qname = str(query_record.q.qname)
         qtype = query_record.q.qtype
@@ -124,33 +121,32 @@ class TCPDNSSocketServer:
 
         handler = handlers.get(response_type)
         if not handler:
-            print(f"[Server Error] No handler found for response_type: {response_type}")
+            logging.warning(f"No handler for response_type: {response_type}")
             return query_record.reply()
 
         reverse_qtype = {QTYPE[k]: k for k in QTYPE if isinstance(k, int)}
         rtype = reverse_qtype.get(response_type)
         if rtype is None:
-            print(f"[Server Error] Unsupported response_type: {response_type}")
+            logging.warning(f"Unsupported response_type: {response_type}")
             return query_record.reply()
 
         try:
-            print(f"[Server] Calling handler for type {response_type}")
+            logging.debug(f"Calling handler for type {response_type}")
             rdata = handler()
-            print(f"[Server] Handler produced rdata: {rdata}")
+            logging.debug(f"Handler produced rdata: {rdata}")
         except Exception as e:
-            print(f"[Server Error] Handler for {response_type} failed: {e}")
+            logging.error(f"Handler for {response_type} failed: {e}", exc_info=True)
             return query_record.reply()
 
         response.add_answer(RR(rname=response_qname, rtype=rtype, rclass=1, ttl=60, rdata=rdata))
         return response
 
-
-
     def _parse_srv(self, value):
         try:
             target, port, priority, weight = value.split(",")
             return SRV(int(priority), int(weight), int(port), target)
         except Exception:
+            logging.warning(f"Failed to parse SRV value: '{value}', using default fallback")
             return SRV(0, 0, 80, "service.example.com")
 
     def send_dns_response(self, client_sock, dns_record):
@@ -160,11 +156,12 @@ class TCPDNSSocketServer:
             client_sock.sendall(length_prefix + response_bytes)
             return EventNames.RESPONSE_SENT.name
         except Exception as e:
-            print(f"Failed to send DNS response: {e}")
+            logging.error(f"Failed to send DNS response: {e}", exc_info=True)
             return EventNames.ERROR.name
 
     def close(self):
         if self.sock:
             self.sock.close()
             self.sock = None
-        return EventNames.CONNECTION_CLOSED.name
+        logging.info("TCP socket closed")
+        return EventNames.CONNECTION_ENDING.name

nopasaran-0.2.101/nopasaran/tools/udp_dns_socket_server.py

@@ -0,0 +1,120 @@
+import socket
+import struct
+import select
+import time
+from dnslib import DNSRecord, RR, QTYPE, A, CNAME, MX, TXT, NS, SOA, PTR, AAAA, SRV, DS, RRSIG, NSEC, DNSKEY
+from nopasaran.definitions.events import EventNames
+import logging
+
+class UDPDNSSocketServer:
+    def __init__(self):
+        self.sock = None
+
+    def start(self, port):
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.sock.bind(('', port))
+        logging.info(f"UDP DNS server started on port {port}")
+        return EventNames.SERVER_STARTED.name, f"UDP DNS server started on port {port}"
+
+    def wait_for_query(self, timeout, response_spec=None):
+        self.sock.settimeout(timeout)
+        logging.info(f"Waiting for UDP packets on port {self.sock.getsockname()[1]} with timeout {timeout} seconds")
+
+        try:
+            data, client_addr = self.sock.recvfrom(512)  # max size of a DNS UDP packet
+            logging.debug(f"Received {len(data)} bytes from {client_addr}")
+
+            logging.debug("Parsing DNS query...")
+            parsed_query = DNSRecord.parse(data)
+            logging.info(f"Parsed query:\n{parsed_query.toZone()}")
+
+            logging.debug("Building DNS response...")
+            response = self.build_response(parsed_query, response_spec)
+
+            logging.debug("Sending DNS response...")
+            self.send_dns_response(client_addr, response)
+            logging.info("DNS response sent successfully.")
+
+            return {
+                "received": parsed_query.toZone(),
+                "client_address": client_addr
+            }, EventNames.REQUEST_RECEIVED.name
+
+        except socket.timeout:
+            logging.warning("Timeout reached with no packet received.")
+            return {"received": None}, EventNames.TIMEOUT.name
+        except Exception as e:
+            logging.error(f"Error while handling DNS query: {e}", exc_info=True)
+            return {"received": None}, EventNames.ERROR.name
+
+    def build_response(self, query_record, response_spec=None):
+        qname = str(query_record.q.qname)
+        qtype = query_record.q.qtype
+        response_qname = response_spec.get("qname") if response_spec and response_spec.get("qname") else qname
+        response_type = response_spec.get("type").upper() if response_spec and response_spec.get("type") else QTYPE[qtype].name
+        response_value = response_spec.get("value") if response_spec else None
+
+        response = query_record.reply()
+
+        handlers = {
+            "A": lambda: A(response_value or "127.0.0.1"),
+            "CNAME": lambda: CNAME(response_value or response_qname),
+            "MX": lambda: MX(response_value or f"mail.{response_qname}", preference=10),
+            "TXT": lambda: TXT(response_value or f"dummy record for {response_qname}"),
+            "NS": lambda: NS(response_value or f"ns1.{response_qname}"),
+            "SOA": lambda: SOA(response_value or f"ns1.{response_qname}", f"admin.{response_qname}", (2024051801, 3600, 3600, 3600, 3600)),
+            "PTR": lambda: PTR(response_value or f"ptr.{response_qname}"),
+            "AAAA": lambda: AAAA(response_value or "::1"),
+            "SRV": lambda: self._parse_srv(response_value or f"service.{response_qname},80,0,0"),
+            "DS": lambda: DS(12345, 1, 1, bytes(response_value or f"abcdef{response_qname}", 'utf-8')),
+            "RRSIG": lambda: RRSIG(1, 1, 0, 3600, 0, 0, 0, response_value or f"signer.{response_qname}", b"signature"),
+            "NSEC": lambda: NSEC(response_value or f"next.{response_qname}", []),
+            "DNSKEY": lambda: DNSKEY(256, 3, 8, bytes(response_value or f"publickey{response_qname}", 'utf-8')),
+            "ANY": lambda: A(response_value or "127.0.0.1")
+        }
+
+        handler = handlers.get(response_type)
+        if not handler:
+            logging.warning(f"No handler for response_type: {response_type}")
+            return query_record.reply()
+
+        reverse_qtype = {QTYPE[k]: k for k in QTYPE if isinstance(k, int)}
+        rtype = reverse_qtype.get(response_type)
+        if rtype is None:
+            logging.warning(f"Unsupported response_type: {response_type}")
+            return query_record.reply()
+
+        try:
+            logging.debug(f"Calling handler for type {response_type}")
+            rdata = handler()
+            logging.debug(f"Handler produced rdata: {rdata}")
+        except Exception as e:
+            logging.error(f"Handler for {response_type} failed: {e}", exc_info=True)
+            return query_record.reply()
+
+        response.add_answer(RR(rname=response_qname, rtype=rtype, rclass=1, ttl=60, rdata=rdata))
+        return response
+
+    def _parse_srv(self, value):
+        try:
+            target, port, priority, weight = value.split(",")
+            return SRV(int(priority), int(weight), int(port), target)
+        except Exception:
+            logging.warning(f"Failed to parse SRV value: '{value}', using default fallback")
+            return SRV(0, 0, 80, "service.example.com")
+
+    def send_dns_response(self, client_addr, dns_record):
+        try:
+            self.sock.sendto(dns_record.pack(), client_addr)
+            return EventNames.RESPONSE_SENT.name
+        except Exception as e:
+            logging.error(f"Failed to send DNS response to {client_addr}: {e}", exc_info=True)
+            return EventNames.ERROR.name
+
+    def close(self):
+        if self.sock:
+            self.sock.close()
+            self.sock = None
+        logging.info("UDP socket closed")
+        return EventNames.CONNECTION_ENDING.name

{nopasaran-0.2.99 → nopasaran-0.2.101}/nopasaran/utils.py

@@ -5,6 +5,7 @@ import socket
 import select
 import ssl
 import struct
+import logging
 from dnslib import DNSRecord, QTYPE
 
 
@@ -399,7 +400,7 @@ def group_ports(ports):
 def send_tcp_dns_query(server_ip, server_port, domain, query_type="A"):
     dnsatypes = {
         1: "A", 2: "NS", 5: "CNAME", 6: "SOA", 12: "PTR", 15: "MX",
-        16: "TXT", 28: "AAAA", 33: "SRV",  43: "DS",
+        16: "TXT", 28: "AAAA", 33: "SRV", 43: "DS",
         46: "RRSIG", 47: "NSEC", 48: "DNSKEY", 255: "ANY"
     }
 
@@ -408,46 +409,43 @@ def send_tcp_dns_query(server_ip, server_port, domain, query_type="A"):
     lookup_by_name = {v.upper(): k for k, v in dnsatypes.items()}
     query_type_str = str(query_type).strip().upper()
 
-    print(f"[Debug] Received query_type: {query_type_str}")
+    logging.debug(f"Received query_type: {query_type_str}")
 
-    # Validate query type
     if query_type_str.isdigit():
         qtype = int(query_type_str)
         if qtype not in dnsatypes:
             result["error"] = f"Unsupported numeric query type: {query_type}.\nSupported types are: {supported_types}"
-            print("[Error]", result["error"])
+            logging.error(result["error"])
             return result
     else:
         qtype = lookup_by_name.get(query_type_str)
         if qtype is None:
             result["error"] = f"Unsupported string query type: {query_type}.\nSupported types are: {supported_types}"
-            print("[Error]", result["error"])
+            logging.error(result["error"])
             return result
 
     try:
-        print(f"[Debug] Building DNS query for domain {domain} with type {query_type_str} ({qtype})")
-        dns_query = DNSRecord.question(domain, qtype=query_type_str)
+        logging.debug(f"Building DNS query for domain {domain} with type {query_type_str} ({qtype})")
+        dns_query = DNSRecord.question(domain, qtype=dnsatypes[qtype])
         dns_query.header.id = random.randint(0, 65535)
         query_packet = dns_query.pack()
         result["query"] = dns_query.toZone()
 
-        print("[Debug] Opening socket")
+        logging.debug("Opening TCP socket")
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-            sock.bind(('', 0))
             sock.settimeout(2)
-
-            print(f"[Debug] Connecting to {server_ip}:{server_port}")
+            logging.debug(f"Connecting to {server_ip}:{server_port}")
             sock.connect((server_ip, server_port))
 
             length_prefix = struct.pack("!H", len(query_packet))
-            print("[Debug] Sending DNS query")
+            logging.debug("Sending DNS query")
             sock.sendall(length_prefix + query_packet)
 
-            print("[Debug] Waiting for response")
+            logging.debug("Waiting for response")
             length_data = sock.recv(2)
             if len(length_data) < 2:
                 result["error"] = "Incomplete length prefix"
-                print("[Error]", result["error"])
+                logging.error(result["error"])
                 return result
 
             expected_length = struct.unpack("!H", length_data)[0]
@@ -458,12 +456,65 @@ def send_tcp_dns_query(server_ip, server_port, domain, query_type="A"):
                     break
                 response_data += chunk
 
-            print("[Debug] Received response data")
+            logging.debug("Received response data")
+            parsed_response = DNSRecord.parse(response_data)
+            result["response"] = parsed_response.to_dict()
+            return result
+
+    except Exception as e:
+        result["error"] = f"Exception occurred: {str(e)}"
+        logging.error("An error occurred while sending the TCP DNS query")
+        return result
+
+def send_udp_dns_query(server_ip, server_port, domain, query_type="A"):
+    dnsatypes = {
+        1: "A", 2: "NS", 5: "CNAME", 6: "SOA", 12: "PTR", 15: "MX",
+        16: "TXT", 28: "AAAA", 33: "SRV", 43: "DS",
+        46: "RRSIG", 47: "NSEC", 48: "DNSKEY", 255: "ANY"
+    }
+
+    result = {"query": None, "response": None, "error": None}
+    supported_types = ', '.join([f"{v}({k})" for k, v in dnsatypes.items()])
+    lookup_by_name = {v.upper(): k for k, v in dnsatypes.items()}
+    query_type_str = str(query_type).strip().upper()
+
+    logging.debug(f"Received query_type: {query_type_str}")
+
+    if query_type_str.isdigit():
+        qtype = int(query_type_str)
+        if qtype not in dnsatypes:
+            result["error"] = f"Unsupported numeric query type: {query_type}.\nSupported types are: {supported_types}"
+            logging.error(result["error"])
+            return result
+    else:
+        qtype = lookup_by_name.get(query_type_str)
+        if qtype is None:
+            result["error"] = f"Unsupported string query type: {query_type}.\nSupported types are: {supported_types}"
+            logging.error(result["error"])
+            return result
+
+    try:
+        logging.debug(f"Building DNS query for domain {domain} with type {query_type_str} ({qtype})")
+        dns_query = DNSRecord.question(domain, qtype=dnsatypes[qtype])
+        dns_query.header.id = random.randint(0, 65535)
+        query_packet = dns_query.pack()
+        result["query"] = dns_query.toZone()
+
+        logging.debug("Opening UDP socket")
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+            sock.settimeout(2)
+            logging.debug(f"Sending UDP DNS query to {server_ip}:{server_port}")
+            sock.sendto(query_packet, (server_ip, server_port))
+
+            logging.debug("Waiting for UDP response")
+            response_data, _ = sock.recvfrom(4096)
+
+            logging.debug("Received UDP response")
             parsed_response = DNSRecord.parse(response_data)
             result["response"] = parsed_response.to_dict()
             return result
 
     except Exception as e:
         result["error"] = f"Exception occurred: {str(e)}"
-        print("[Error]", result["error"])
+        logging.error("An error occurred while sending the UDP DNS query")
         return result

{nopasaran-0.2.99 → nopasaran-0.2.101}/nopasaran.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nopasaran
-Version: 0.2.99
+Version: 0.2.101
 Summary: NoPASARAN is an advanced network tool designed to detect, fingerprint, and locate network middleboxes in a unified framework.
 Home-page: https://github.com/BenIlies/NoPASARAN
 Author: Ilies Benhabbour

{nopasaran-0.2.99 → nopasaran-0.2.101}/nopasaran.egg-info/SOURCES.txt

@@ -65,6 +65,8 @@ nopasaran/primitives/action_primitives/tcp_dns_response_primitives.py
 nopasaran/primitives/action_primitives/tcp_primitives.py
 nopasaran/primitives/action_primitives/timing_primitives.py
 nopasaran/primitives/action_primitives/tls_primitives.py
+nopasaran/primitives/action_primitives/udp_dns_request_primitives.py
+nopasaran/primitives/action_primitives/udp_dns_response_primitives.py
 nopasaran/primitives/action_primitives/udp_primitives.py
 nopasaran/primitives/condition_primitives/__init__.py
 nopasaran/primitives/condition_primitives/condition_primitives.py
@@ -84,4 +86,5 @@ nopasaran/tools/http_2_socket_client.py
 nopasaran/tools/http_2_socket_server.py
 nopasaran/tools/https_1_socket_server.py
 nopasaran/tools/tcp_dns_socket_server.py
+nopasaran/tools/udp_dns_socket_server.py
 tests/__init__.py

{nopasaran-0.2.99 → nopasaran-0.2.101}/setup.py

@@ -13,7 +13,7 @@ with open(requirements_file, "r") as f:
 # Version will automatically be updated when pushed on the main branch
 setup(
     name="nopasaran",
-    version='0.2.99',
+    version='0.2.101',
     author="Ilies Benhabbour",
     author_email="ilies.benhabbour@kaust.edu.sa",
     description="NoPASARAN is an advanced network tool designed to detect, fingerprint, and locate network middleboxes in a unified framework.",