firegex 3.5.2__tar.gz → 3.5.3__tar.gz

{firegex-3.5.2/firegex.egg-info → firegex-3.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firegex
-Version: 3.5.2
+Version: 3.5.3
 Summary: Firegex client
 Home-page: https://github.com/pwnzer0tt1/firegex
 Author: Pwnzer0tt1

firegex-3.5.3/firegex/__init__.py

@@ -0,0 +1,69 @@
+
+def _get_version():
+    v = "3.5.3" if "{" not in "3.5.3" else "0.0.0"
+    if v == "0.0.0":
+        import os
+        env_v = os.getenv("FIREGEX_VERSION")
+        if env_v:
+            return env_v
+        try:
+            import re
+
+            def parse_version(ver):
+                ver = ver.lstrip("v")
+                parts = re.split(r'[^0-9]+', ver)
+                return tuple(int(p) if p.isdigit() else 0 for p in parts if p)
+
+            def find_git_dir(start_path):
+                current = start_path
+                while current and current != "/" and current != "":
+                    gd = os.path.join(current, ".git")
+                    if os.path.isdir(gd):
+                        return gd
+                    parent = os.path.dirname(current)
+                    if parent == current:
+                        break
+                    current = parent
+                return None
+
+            git_dir = find_git_dir(os.path.abspath(os.path.dirname(__file__)))
+            if not git_dir:
+                return v
+                
+            branch = None
+            with open(os.path.join(git_dir, "HEAD"), "r") as f:
+                head = f.read().strip()
+                if head.startswith("ref: refs/heads/"):
+                    branch = head.split("ref: refs/heads/")[1]
+                    
+            if branch != "main":
+                return v
+                
+            tags = []
+            try:
+                with open(os.path.join(git_dir, "packed-refs"), "r") as f:
+                    for line in f:
+                        if " refs/tags/" in line:
+                            tags.append(line.strip().split(" refs/tags/")[1])
+            except Exception:
+                pass
+                
+            tags_dir = os.path.join(git_dir, "refs", "tags")
+            try:
+                for root, _, files in os.walk(tags_dir):
+                    for file in files:
+                        tags.append(os.path.relpath(os.path.join(root, file), tags_dir).replace(os.path.sep, "/"))
+            except Exception:
+                pass
+                
+            version_tags = [t for t in set(tags) if any(c.isdigit() for c in t)]
+            if version_tags:
+                return max(version_tags, key=parse_version)
+        except Exception:
+            pass
+    return v
+
+__version__ = _get_version()
+
+#Exported functions
+__all__ = []

{firegex-3.5.2 → firegex-3.5.3}/firegex/nfproxy/__init__.py

@@ -1,5 +1,13 @@
 import functools
-from firegex.nfproxy.models import RawPacket, TCPInputStream, TCPOutputStream, TCPClientStream, TCPServerStream
+from firegex.nfproxy.models import (
+    RawPacket,
+    TCPInputStream,
+    TCPOutputStream,
+    TCPClientStream,
+    TCPServerStream,
+    HttpHistory,
+    HttpStreamHistory,
+)
 from firegex.nfproxy.internals.models import Action, FullStreamAction
 
 ACCEPT = Action.ACCEPT
@@ -35,7 +43,8 @@ def clear_pyfilter_registry():
         pyfilter.registry.clear()
 
 __all__ = [
-    "ACCEPT", "DROP", "REJECT", "UNSTABLE_MANGLE"
+    "ACCEPT", "DROP", "REJECT", "UNSTABLE_MANGLE",
     "Action", "FullStreamAction", "pyfilter",
-    "RawPacket", "TCPInputStream", "TCPOutputStream", "TCPClientStream", "TCPServerStream"
+    "RawPacket", "TCPInputStream", "TCPOutputStream", "TCPClientStream", "TCPServerStream",
+    "HttpHistory", "HttpStreamHistory"
 ]

{firegex-3.5.2 → firegex-3.5.3}/firegex/nfproxy/models/__init__.py

@@ -11,6 +11,8 @@ from firegex.nfproxy.models.http import (
     HttpResponseHeader,
     HttpFullRequest,
     HttpFullResponse,
+    HttpHistory,
+    HttpStreamHistory,
 )
 from firegex.nfproxy.internals.data import RawPacket
 from enum import Enum
@@ -31,6 +33,8 @@ type_annotations_associations = {
         HttpResponseHeader: HttpResponseHeader._fetch_packet,
         HttpFullRequest: HttpFullRequest._fetch_packet,
         HttpFullResponse: HttpFullResponse._fetch_packet,
+        HttpHistory: HttpHistory._fetch_packet,
+        HttpStreamHistory: HttpStreamHistory._fetch_packet,
     },
 }
 
@@ -52,5 +56,8 @@ __all__ = [
     "HttpResponseHeader",
     "HttpFullRequest",
     "HttpFullResponse",
+    "HttpHistory",
+    "HttpStreamHistory",
     "Protocols",
 ]
+

{firegex-3.5.2 → firegex-3.5.3}/firegex/nfproxy/models/http.py

@@ -48,6 +48,7 @@ class InternalHTTPMessage:
     ws_stream: list[Frame] = field(default_factory=list)  # Decoded websocket stream
     upgrading_to_h2: bool = field(default=False)
     upgrading_to_ws: bool = field(default=False)
+    added_to_history: bool = field(default=False)
 
 
 @dataclass
@@ -393,6 +394,61 @@ class InternalHttpResponse(InternalCallbackHandler, pyllhttp.Response):
         return False
 
 
+class HttpHistory:
+    """
+    HTTP History handler for pyfilters.
+    Provides access to completed previous requests and responses in the current TCP stream.
+    """
+
+    def __init__(
+        self,
+        requests: list["HttpFullRequest"] | None = None,
+        responses: list["HttpFullResponse"] | None = None,
+    ):
+        self._requests = list(requests) if requests is not None else []
+        self._responses = list(responses) if responses is not None else []
+
+    @property
+    def requests(self) -> list["HttpFullRequest"]:
+        """List of previous completed HTTP requests"""
+        return self._requests.copy()
+
+    @property
+    def responses(self) -> list["HttpFullResponse"]:
+        """List of previous completed HTTP responses"""
+        return self._responses.copy()
+
+    @classmethod
+    def _fetch_packet(cls, internal_data: DataStreamCtx):
+        if (
+            internal_data.current_pkt is None
+            or internal_data.current_pkt.is_tcp is False
+        ):
+            raise NotReadyToRun()
+
+        for key in ("http_module", "http_full", "http_header"):
+            obj = internal_data.call_mem.get(f"_fetched_obj_{key}")
+            if obj is not None:
+                if isinstance(obj, list) and obj:
+                    return [item.history for item in obj]
+                elif hasattr(obj, "history"):
+                    return obj.history
+
+        req_history_deque = internal_data.data_handler_context.get(
+            "http_history_requests", deque()
+        )
+        resp_history_deque = internal_data.data_handler_context.get(
+            "http_history_responses", deque()
+        )
+        return HttpHistory(list(req_history_deque), list(resp_history_deque))
+
+    def __repr__(self):
+        return f"<HttpHistory requests={len(self._requests)} responses={len(self._responses)}>"
+
+
+HttpStreamHistory = HttpHistory
+
+
 class InternalBasicHttpMetaClass:
     """Internal class to handle HTTP requests and responses"""
 
@@ -404,15 +460,23 @@ class InternalBasicHttpMetaClass:
         self._parser = parser
         self.raised_error = False
         self._message: InternalHTTPMessage | None = msg
+        self._history: HttpHistory | None = None
         self._contructor_hook()
 
     def _contructor_hook(self):
         pass
 
+    @property
+    def history(self) -> HttpHistory:
+        """HTTP History for the current stream connection"""
+        if self._history is None:
+            return HttpHistory([], [])
+        return self._history
+
     @property
     def total_size(self) -> int:
-        """Total size of the stream"""
-        return self._parser.total_size
+        """Total size of the message"""
+        return self._message.total_size
 
     @property
     def url(self) -> str | None:
@@ -462,7 +526,7 @@ class InternalBasicHttpMetaClass:
     @property
     def should_upgrade(self) -> bool:
         """If the message should upgrade"""
-        return self._parser.should_upgrade
+        return self._message.should_upgrade
 
     @property
     def content_length(self) -> int | None:
@@ -493,6 +557,10 @@ class InternalBasicHttpMetaClass:
         """Get a header from the message without caring about the case"""
         return self._message.lheaders.get(header.lower(), default)
 
+    @classmethod
+    def _should_release_message_headers(cls) -> bool:
+        return True
+
     @staticmethod
     def _before_fetch_callable_checks(internal_data: DataStreamCtx) -> bool:
         raise NotImplementedError()
@@ -521,6 +589,9 @@ class InternalBasicHttpMetaClass:
             parser: InternalHttpRequest | InternalHttpResponse = ParserType()
             internal_data.data_handler_context[parser_key] = parser
 
+        parser.release_message_headers = cls._should_release_message_headers()
+
+
         if not internal_data.call_mem.get(
             cls._parser_class(), False
         ):  # Need to parse HTTP
@@ -620,10 +691,55 @@ class InternalBasicHttpMetaClass:
 
         if messages_to_call == 0:
             raise NotReadyToRun()
-        elif messages_to_call == 1:
-            return cls(parser, messages_tosend[0])
 
-        return [cls(parser, ele) for ele in messages_tosend]
+        raw_max = internal_data.filter_glob.get("FGEX_MAX_HISTORY_SIZE", 100)
+        try:
+            max_history = max(0, int(raw_max))
+        except (ValueError, TypeError):
+            max_history = 100
+
+        req_history_deque: deque = (
+            internal_data.data_handler_context.setdefault(
+                "http_history_requests", deque(maxlen=max_history)
+            )
+        )
+        if req_history_deque.maxlen != max_history:
+            req_history_deque = deque(req_history_deque, maxlen=max_history)
+            internal_data.data_handler_context["http_history_requests"] = req_history_deque
+
+        resp_history_deque: deque = (
+            internal_data.data_handler_context.setdefault(
+                "http_history_responses", deque(maxlen=max_history)
+            )
+        )
+        if resp_history_deque.maxlen != max_history:
+            resp_history_deque = deque(resp_history_deque, maxlen=max_history)
+            internal_data.data_handler_context["http_history_responses"] = resp_history_deque
+
+        built_instances = []
+        for msg in messages_tosend:
+            history_snapshot = HttpHistory(
+                list(req_history_deque), list(resp_history_deque)
+            )
+            instance = cls(parser, msg)
+            instance._history = history_snapshot
+            built_instances.append(instance)
+
+            if msg.message_complete and not msg.added_to_history:
+                msg.added_to_history = True
+                if internal_data.current_pkt.is_input:
+                    req_history_deque.append(HttpFullRequest(parser, msg))
+                else:
+                    resp_history_deque.append(HttpFullResponse(parser, msg))
+
+        if len(built_instances) == 1:
+            res = built_instances[0]
+            internal_data.call_mem[f"_fetched_obj_{cls._parser_class()}"] = res
+            return res
+
+        internal_data.call_mem[f"_fetched_obj_{cls._parser_class()}"] = built_instances
+        return built_instances
+
 
 
 class HttpRequest(InternalBasicHttpMetaClass):
@@ -639,7 +755,7 @@ class HttpRequest(InternalBasicHttpMetaClass):
     @property
     def method(self) -> bytes:
         """Method of the request"""
-        return self._parser.msg.method
+        return self._message.method
 
     @staticmethod
     def _parser_class() -> str:
@@ -662,7 +778,8 @@ class HttpResponse(InternalBasicHttpMetaClass):
     @property
     def status_code(self) -> int:
         """Status code of the response"""
-        return self._parser.msg.status
+        return self._message.status
+
 
     @staticmethod
     def _parser_class() -> str:
@@ -678,6 +795,10 @@ class HttpFullRequest(HttpRequest):
     This data handler will be called when the request data is complete
     """
 
+    @classmethod
+    def _should_release_message_headers(cls) -> bool:
+        return False
+
     def _contructor_hook(self):
         self._parser.release_message_headers = False
 
@@ -695,6 +816,10 @@ class HttpFullResponse(HttpResponse):
     This data handler will be called when the response data is complete
     """
 
+    @classmethod
+    def _should_release_message_headers(cls) -> bool:
+        return False
+
     def _contructor_hook(self):
         self._parser.release_message_headers = False
 
@@ -706,6 +831,7 @@ class HttpFullResponse(HttpResponse):
         return f"<HttpFullResponse status_code={self.status_code} url={self.url} headers={self.headers} body=[{0 if not self.body else len(self.body)} bytes] http_version={self.http_version} keep_alive={self.keep_alive} should_upgrade={self.should_upgrade} headers_complete={self.headers_complete} message_complete={self.message_complete} content_length={self.content_length} stream={self.stream} ws_stream={self.ws_stream}>"
 
 
+
 class HttpRequestHeader(HttpRequest):
     """
     HTTP Request Header handler

{firegex-3.5.2 → firegex-3.5.3/firegex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firegex
-Version: 3.5.2
+Version: 3.5.3
 Summary: Firegex client
 Home-page: https://github.com/pwnzer0tt1/firegex
 Author: Pwnzer0tt1

{firegex-3.5.2 → firegex-3.5.3}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 with open('requirements.txt', 'r', encoding='utf-8') as f:
     required = [ele.strip() for ele in f.read().splitlines() if not ele.strip().startswith("#") and ele.strip() != ""]
 
-VERSION = "3.5.2"
+VERSION = "3.5.3"
 
 setuptools.setup(
     name="firegex",

firegex-3.5.2/firegex/__init__.py

@@ -1,5 +0,0 @@
-
-__version__ = "3.5.2" if "{" not in "3.5.2" else "0.0.0"
-
-#Exported functions
-__all__ = []