nopasaran 0.2.96__py3-none-any.whl → 0.2.98__py3-none-any.whl

nopasaran/tools/http_1_socket_server.py

@@ -17,21 +17,45 @@ class HTTP1SocketServer:
         self.client_socket = None
         self.TIMEOUT = 5.0
 
-    def handle_client_connection(self, client_socket):
+    def handle_client_connection(self, client_socket, timeout):
         """
         Handle a client connection by processing the incoming request and sending the appropriate response.
         """
-        request = client_socket.recv(4096)
-        request_str = request.decode('utf-8')
+        client_socket.setblocking(False)
+        ready_to_read, _, _ = select.select([client_socket], [], [], timeout)
+        
+        if not ready_to_read:
+            client_socket.close()
+            return None, EventNames.TIMEOUT.name
+
+        try:
+            request = client_socket.recv(4096)
+        except socket.timeout:
+            client_socket.close()
+            return None, EventNames.TIMEOUT.name
+        except ConnectionResetError as e:
+            client_socket.close()
+            return str(e), EventNames.ERROR.name
+
+        if not request:
+            client_socket.close()
+            return None, EventNames.TIMEOUT.name
+
+        request_str = request.decode('utf-8', errors='ignore')
+
         # Extract request line and headers
         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]
-        method, path, _ = request_line.split(" ", 2)
+
+        try:
+            method, path, _ = request_line.split(" ", 2)
+        except ValueError:
+            method, path = "GET", "/"
 
         route_key = (path, method)
         route_info_list = self.routes.get(route_key)
-        
+
         if route_info_list:
             response = ""
             for route_info in route_info_list:
@@ -39,42 +63,30 @@ class HTTP1SocketServer:
                 status_code = route_info.get('status', 200)
                 headers = route_info.get('headers', [])
 
-                # Construct each part of the response
                 response_part = f"HTTP/1.1 {status_code} OK\r\n"
                 for header_name, header_value in headers:
                     response_part += f"{header_name}: {header_value}\r\n"
-                response_part += f"\r\n{response_body}\r\n\r\n"  # Double CRLF to separate responses
+                response_part += f"\r\n{response_body}\r\n\r\n"
 
-                # Append the response part to the full response
                 response += response_part
 
-            # Send the full combined response to the client
             client_socket.sendall(response.encode())
-
         else:
             response_body = 'NoPASARAN HTTP/1.1 Server'
             status_code = 404
-            headers = []
-
-            # Construct the HTTP response
-            response = f"HTTP/1.1 {status_code} OK\r\n"
-            for header_name, header_value in headers:
-                response += f"{header_name}: {header_value}\r\n"
-            response += f"\r\n{response_body}"
-
-            # Send response to client
+            response = f"HTTP/1.1 {status_code} Not Found\r\nContent-Length: {len(response_body)}\r\n\r\n{response_body}"
             client_socket.sendall(response.encode())
 
         client_socket.close()
 
-        # Store the raw received request data
         self.received_request_data = request
 
-        # Notify that a request has been received
         if self.request_received:
             with self.request_received:
                 self.request_received.notify_all()
 
+        return request, EventNames.REQUEST_RECEIVED.name
+
     def wait_for_request(self, port, timeout):
         """
         Wait for an HTTP request or timeout.
@@ -84,7 +96,7 @@ class HTTP1SocketServer:
             timeout (int): The timeout duration in seconds.
 
         Returns:
-            Tuple[bytes, str]: The raw received request data or None if a timeout occurs, and the event name.
+            Tuple[bytes or None, str]: The raw received request data or None if a timeout occurs, and the event name.
         """
         server_address = ('', port)
         self.request_received = threading.Condition()
@@ -96,22 +108,18 @@ class HTTP1SocketServer:
             server_socket.listen(1)
             server_socket.setblocking(False)
 
-            # Initialize the timeout timer
             start_time = time.time()
 
             while True:
-                # Check if the timeout has elapsed
                 elapsed_time = time.time() - start_time
-                if elapsed_time > timeout:
+                if elapsed_time >= timeout:
                     return None, EventNames.TIMEOUT.name
-                
-                # Use select to wait for a connection with a timeout
+
                 ready_to_read, _, _ = select.select([server_socket], [], [], timeout - elapsed_time)
-                
+
                 if ready_to_read:
                     client_socket, _ = server_socket.accept()
-                    self.handle_client_connection(client_socket)
-                    return self.received_request_data, EventNames.REQUEST_RECEIVED.name
+                    return self.handle_client_connection(client_socket, timeout - elapsed_time)
 
     def start(self, host, port):
         """
@@ -121,81 +129,8 @@ class HTTP1SocketServer:
         self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         self.sock.bind((host, port))
         self.sock.listen(5)
-        
-        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)
+        return EventNames.SERVER_STARTED.name, f"Server successfully started at {host}:{port}."
 
     def close(self):
         """Close the HTTP/1.1 connection and clean up resources"""
@@ -204,11 +139,10 @@ class HTTP1SocketServer:
                 self.client_socket.close()
             if self.sock:
                 self.sock.close()
-            
-            # Clear references
+
             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/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.dist-info → nopasaran-0.2.98.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nopasaran
-Version: 0.2.96
+Version: 0.2.98
 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.dist-info → nopasaran-0.2.98.dist-info}/RECORD

@@ -68,17 +68,17 @@ nopasaran/sniffers/sniffer.py,sha256=rmUlW4_IvLurz_qelpFFSdIaiyWXBljFZ2Cdec3ohSE
 nopasaran/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nopasaran/tools/checks.py,sha256=-Y5gOm0f8ZIkOdiViCCrTR9jC1MTt8IbnOrLp5tBzVo,1299
 nopasaran/tools/echo_socket_server.py,sha256=_a6bcDq4pXVjeEnNqPuulipgfH2bddf-N-ExXBTuQiE,3748
-nopasaran/tools/http_1_socket_server.py,sha256=-4VVe0kOpdGNb2IsiXmaVCp26AjC9czsLS-QiYOEFIk,8945
+nopasaran/tools/http_1_socket_server.py,sha256=jZTxZdRutDnPwxvAiC4GM2gCBgWhwv1by2bzgxCXZFc,5162
 nopasaran/tools/http_2_overwrite.py,sha256=vKJzAwbisK9qkN3GCp7FuFfSaPAiUGPwZD9ABYi6eIs,25177
 nopasaran/tools/http_2_socket_base.py,sha256=KDfkU4Nr_TXxqzp1-ZHec_UawfDZ5oIIj-JysEhi0Q0,11233
 nopasaran/tools/http_2_socket_client.py,sha256=5mmc8FuT2dNVAihbMdvyytVwME_xSc7mez_jwU3YZOA,6256
 nopasaran/tools/http_2_socket_server.py,sha256=8W-bxmdoGyK5moxpC87V1EGuZ9jJpIKhokvZrDV84kk,5551
-nopasaran/tools/https_1_socket_server.py,sha256=0mJ_0zCC-7rtvyjehTnm1QJxWx8R4YHkAWRHm2msvL4,9217
+nopasaran/tools/https_1_socket_server.py,sha256=ytLVYdH5je4L6ElCKKhhsbU_53gT6QF9l5ym7q5TMmo,8162
 nopasaran/tools/tcp_dns_socket_server.py,sha256=UKOgyhCXj-u9KJoP8qsQLbyyIkjOhyG7-_3GSP8e0DM,7908
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nopasaran-0.2.96.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-nopasaran-0.2.96.dist-info/METADATA,sha256=sRSoSMacpUl3Yva3uyxmqSaptJ65Wea-m3mrxQ0F638,5496
-nopasaran-0.2.96.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-nopasaran-0.2.96.dist-info/entry_points.txt,sha256=LaOz5GlWuMLjzg4KOEB5OVTattCXVW6a4nSW-WQajCw,55
-nopasaran-0.2.96.dist-info/top_level.txt,sha256=60R1FzpprzU8iiJ1cBMNOA0F083_lYoctFo7pzOpMwY,16
-nopasaran-0.2.96.dist-info/RECORD,,
+nopasaran-0.2.98.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+nopasaran-0.2.98.dist-info/METADATA,sha256=VwjlwGoctGVL9FLSVDuih3xWpaGIkAgLRr6LwWGKgII,5496
+nopasaran-0.2.98.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+nopasaran-0.2.98.dist-info/entry_points.txt,sha256=LaOz5GlWuMLjzg4KOEB5OVTattCXVW6a4nSW-WQajCw,55
+nopasaran-0.2.98.dist-info/top_level.txt,sha256=60R1FzpprzU8iiJ1cBMNOA0F083_lYoctFo7pzOpMwY,16
+nopasaran-0.2.98.dist-info/RECORD,,