nopasaran 0.2.96__tar.gz → 0.2.97__tar.gz

{nopasaran-0.2.96 → nopasaran-0.2.97}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nopasaran
-Version: 0.2.96
+Version: 0.2.97
 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.96 → nopasaran-0.2.97}/nopasaran/tools/http_1_socket_server.py

@@ -124,79 +124,6 @@ class HTTP1SocketServer:
         
         return EventNames.SERVER_STARTED.name, f"Server successfully started at {host}:{port}."
 
-    def receive_test_frames(self):
-        """
-        Listen for HTTP/1.1 requests until a timeout occurs, then process all received requests.
-        
-        Returns:
-            Tuple[str, str, str]: (event_name, message, received_data)
-                - event_name: The type of event that occurred (from EventNames)
-                    - TIMEOUT: Timeout occurred before all requests were received
-                    - REJECTED: Received a 4xx or 5xx status code
-                    - RECEIVED_REQUESTS: All requests have been received
-                    - ERROR: Error occurred while receiving requests
-                - message: A descriptive message about what happened
-                - received_data: String representation of the received requests or None
-        """
-        if not self.sock:
-            return EventNames.ERROR.name, "Server not started", None
-        
-        requests_received = []
-        start_time = time.time()
-        
-        # Make the server socket non-blocking for accepting connections
-        self.sock.setblocking(False)
-        
-        # Keep accepting connections until we hit a timeout
-        while True:
-            # Check for overall timeout
-            elapsed_time = time.time() - start_time
-            if elapsed_time > self.TIMEOUT:
-                if len(requests_received) == 0:
-                    return EventNames.TIMEOUT.name, f"Timeout after {self.TIMEOUT}s and received no requests.", None
-                else:
-                    break  # We've received some requests, so consider it done
-            
-            try:
-                # Try to accept a new connection
-                ready_to_read, _, _ = select.select([self.sock], [], [], 0.5)
-                
-                if ready_to_read:
-                    client_socket, _ = self.sock.accept()
-                    client_socket.settimeout(0.5)
-                    
-                    try:
-                        data = client_socket.recv(4096)
-                        
-                        if data:
-                            # Parse the HTTP/1.1 request
-                            request_str = data.decode('utf-8', errors='ignore')
-                            requests_received.append(request_str)
-                            
-                            # Check for error status codes
-                            if "HTTP/1.1 5" in request_str or "HTTP/1.1 4" in request_str:
-                                try:
-                                    status_line = request_str.split("\r\n")[0]
-                                    status_code = status_line.split(" ")[1]
-                                    client_socket.close()
-                                    return EventNames.REJECTED.name, f"Received {status_code} status code.", request_str
-                                except (IndexError, ValueError):
-                                    client_socket.close()
-                                    return EventNames.REJECTED.name, "Received 4xx or 5xx status code.", request_str
-                    finally:
-                        client_socket.close()
-            except socket.timeout:
-                continue
-            except Exception as e:
-                return EventNames.ERROR.name, f"Error while receiving requests: {str(e)}", \
-                       str(requests_received) if requests_received else None
-        
-        # If we get here, we've either collected all requests or hit the timeout
-        if len(requests_received) == 0:
-            return EventNames.TIMEOUT.name, "No requests received before timeout.", None
-        
-        return EventNames.RECEIVED_REQUESTS.name, f"Received {len(requests_received)} HTTP/1.1 requests.", str(requests_received)
-
     def close(self):
         """Close the HTTP/1.1 connection and clean up resources"""
         try:
@@ -209,6 +136,6 @@ class HTTP1SocketServer:
             self.client_socket = None
             self.sock = None
             
-            return EventNames.CONNECTION_CLOSED.name
+            return EventNames.CONNECTION_ENDING.name
         except Exception as e:
-            return EventNames.CONNECTION_CLOSED.name
+            return EventNames.CONNECTION_ENDING.name

{nopasaran-0.2.96 → nopasaran-0.2.97}/nopasaran/tools/https_1_socket_server.py

@@ -30,13 +30,10 @@ class HTTPS1SocketServer:
     def generate_and_load_cert(self, identifier):
         cert_path, key_path = self.generate_self_signed_cert(identifier)
 
-        # Check if paths are valid
         if not cert_path or not os.path.exists(cert_path):
             raise FileNotFoundError(f"[HTTPS1SocketServer] Certificate file not found at {cert_path}")
         if not key_path or not os.path.exists(key_path):
             raise FileNotFoundError(f"[HTTPS1SocketServer] Key file not found at {key_path}")
-
-        # Optional: Ensure they're not empty (some systems fail silently on write)
         if os.path.getsize(cert_path) == 0:
             raise ValueError(f"[HTTPS1SocketServer] Certificate file is empty at {cert_path}")
         if os.path.getsize(key_path) == 0:
@@ -50,7 +47,6 @@ class HTTPS1SocketServer:
         self._cert_path = cert_path
         self._key_path = key_path
 
-
     def generate_self_signed_cert(self, identifier):
         key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
 
@@ -60,11 +56,10 @@ class HTTPS1SocketServer:
 
         alt_names = [x509.DNSName(identifier)]
         try:
-            # Try to interpret as IP address
             import ipaddress
             alt_names.append(x509.IPAddress(ipaddress.ip_address(identifier)))
         except ValueError:
-            pass  # it's not an IP, skip adding IPAddress
+            pass
 
         cert = (
             x509.CertificateBuilder()
@@ -102,16 +97,18 @@ class HTTPS1SocketServer:
         self.sock.bind((host, port))
         self.sock.listen(5)
         return EventNames.SERVER_STARTED.name, f"HTTPS server started at {host}:{port}"
-    
-
-
 
     def handle_client_connection(self, tls_socket):
-        request = tls_socket.recv(4096)
+        try:
+            request = tls_socket.recv(4096)
+            if not request:
+                return  # Client closed connection or sent nothing
+        except socket.timeout:
+            return  # Timed out waiting for client data
+
         request_str = request.decode("utf-8", errors="ignore")
         self.received_request_data = request
 
-        # Parse request line
         headers_end_index = request_str.find("\r\n\r\n")
         headers_part = request_str[:headers_end_index] if headers_end_index != -1 else request_str
         request_line = headers_part.split("\r\n")[0]
@@ -147,51 +144,12 @@ class HTTPS1SocketServer:
             with self.request_received:
                 self.request_received.notify_all()
 
-    def receive_test_frames(self):
-        if not self.sock:
-            return EventNames.ERROR.name, "Server not started", None
-
-        requests_received = []
-        start_time = time.time()
-        self.sock.setblocking(False)
-
-        while True:
-            if time.time() - start_time > self.TIMEOUT:
-                if not requests_received:
-                    return EventNames.TIMEOUT.name, "Timeout with no request", None
-                break
-
-            try:
-                ready_to_read, _, _ = select.select([self.sock], [], [], 0.5)
-                if ready_to_read:
-                    client_sock, _ = self.sock.accept()
-                    tls_sock = self.context.wrap_socket(client_sock, server_side=True)
-                    tls_sock.settimeout(1.0)
-                    try:
-                        self.handle_client_connection(tls_sock)
-                        req_str = self.received_request_data.decode("utf-8", errors="ignore")
-                        requests_received.append(req_str)
-                    except Exception as e:
-                        return EventNames.ERROR.name, f"TLS error: {e}", None
-            except Exception as e:
-                return EventNames.ERROR.name, str(e), None
-
-        return EventNames.RECEIVED_REQUESTS.name, f"Received {len(requests_received)} HTTPS requests.", str(requests_received)
-        
     def wait_for_request(self, port, timeout):
         """
         Wait for a single HTTPS request with TLS handshake and user-defined timeout.
-
-        Args:
-            port (int): The port to bind and listen on.
-            timeout (int): Timeout duration in seconds.
-
-        Returns:
-            Tuple[bytes or None, str]: The raw request data (or None if timed out) and an event name.
         """
         self.received_request_data = None
-        self.request_received = None  
-
+        self.request_received = None
         context = self.context
         start_time = time.time()
 
@@ -207,36 +165,44 @@ class HTTPS1SocketServer:
                     return None, EventNames.TIMEOUT.name
 
                 try:
-                    ready, _, _ = select.select([server_socket], [], [], timeout - elapsed)
+                    remaining = timeout - elapsed
+                    ready, _, _ = select.select([server_socket], [], [], remaining)
                     if ready:
                         client_sock, _ = server_socket.accept()
-                        with context.wrap_socket(client_sock, server_side=True) as tls_sock:
-                            tls_sock.settimeout(1.0)
-                            try:
+                        client_sock.settimeout(2.0)  # Important: Timeout for TLS handshake and recv
+                        try:
+                            with context.wrap_socket(client_sock, server_side=True) as tls_sock:
+                                tls_sock.settimeout(2.0)  # Also set after TLS handshake
                                 self.handle_client_connection(tls_sock)
-                                return self.received_request_data, EventNames.REQUEST_RECEIVED.name
-                            except Exception as e:
-                                return None, EventNames.ERROR.name
-                except Exception as e:
-                    return None, EventNames.ERROR.name    
+                                if self.received_request_data:
+                                    return self.received_request_data, EventNames.REQUEST_RECEIVED.name
+                                else:
+                                    return None, EventNames.TIMEOUT.name
+                        except (ssl.SSLError, socket.timeout):
+                            return None, EventNames.TIMEOUT.name
+                        except Exception:
+                            return None, EventNames.ERROR.name
+                except Exception:
+                    return None, EventNames.ERROR.name
 
     def close(self):
-        if self.client_socket:
-            self.client_socket.close()
-        if self.sock:
-            self.sock.close()
-        self.client_socket = None
-        self.sock = None
-
         try:
-            if self._cert_path and os.path.exists(self._cert_path):
-                os.remove(self._cert_path)
-            if self._key_path and os.path.exists(self._key_path):
-                os.remove(self._key_path)
-        except Exception as e:
-            return EventNames.ERROR.name, f"Certificate cleanup error: {str(e)}"
+            if self.client_socket:
+                self.client_socket.close()
+            if self.sock:
+                self.sock.close()
 
-        return EventNames.CONNECTION_CLOSED.name
+            self.client_socket = None
+            self.sock = None
 
-    
+            try:
+                if self._cert_path and os.path.exists(self._cert_path):
+                    os.remove(self._cert_path)
+                if self._key_path and os.path.exists(self._key_path):
+                    os.remove(self._key_path)
+            except Exception as e:
+                return EventNames.ERROR.name, f"Certificate cleanup error: {str(e)}"
 
+            return EventNames.CONNECTION_ENDING.name
+        except Exception:
+            return EventNames.CONNECTION_ENDING.name

{nopasaran-0.2.96 → nopasaran-0.2.97}/nopasaran.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nopasaran
-Version: 0.2.96
+Version: 0.2.97
 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.96 → nopasaran-0.2.97}/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.96',
+    version='0.2.97',
     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.",