firegex 3.5.2__tar.gz → 4.0.0__tar.gz

firegex-4.0.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: firegex
+Version: 4.0.0
+Summary: Firegex client
+Home-page: https://github.com/pwnzer0tt1/firegex
+Author: Pwnzer0tt1
+Author-email: pwnzer0tt1@poliba.it
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer
+Requires-Dist: pydantic>=2
+Requires-Dist: typing-extensions>=4.7.1
+Requires-Dist: pycryptodome
+Requires-Dist: watchfiles
+Requires-Dist: fgex
+Requires-Dist: websockets
+Requires-Dist: brotli
+Requires-Dist: pyllhttp
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Firegex Python Library and CLI
+
+This is the Python library for [Firegex](https://github.com/Pwnzer0tt1/firegex), a firewall built for CTF Attack-Defense competitions. It provides the `firegex.nfproxy` package used to write [Netfilter Proxy](../docs/nfproxy.md) Python packet filters, the `fgex` CLI, and a local proxy simulator (`proxysim`) for testing filters without a running Firegex instance.
+
+## Installation
+
+```bash
+pip install -U firegex
+```
+
+`fgex` is an alias package for `firegex`: installing either one gives you the same `firegex` module and the `fgex`/`firegex` CLI commands.
+
+## Documentation
+
+**➡️ [Netfilter Proxy: writing and testing `@pyfilter` scripts](../docs/nfproxy.md)** — the `pyfilter` decorator, every data structure (`RawPacket`, `TCPInputStream`/`TCPOutputStream`, `HttpRequest`/`HttpResponse` and their variants, `HttpHistory`), packet statements, stream limits, the `fgex nfproxy` CLI simulator, and a full worked example.
+
+That page is also what's shown in the Firegex web UI itself (the docs button on the nfproxy pages) — both are generated from that single file, so they can never drift out of sync.
+
+## Firegex's other filtering modules
+
+This library only covers Netfilter Proxy. Firegex ships several other independent modules, each with its own guide:
+
+- **[Netfilter Regex](../docs/nfregex.md)** — fast, PCRE2/hyperscan-based regex matching against raw traffic.
+- **[Hijack Port to Proxy](../docs/porthijack.md)** — redirect traffic to your own external proxy without touching the target service.
+- **[Firewall Rules](../docs/firewall.md)** — plain nftables allow/drop/reject rules.
+- **[TLS Decryption](../docs/tls.md)** — decrypt-and-reinspect bridge for services that speak TLS natively.

firegex-4.0.0/README.md

@@ -0,0 +1,26 @@
+# Firegex Python Library and CLI
+
+This is the Python library for [Firegex](https://github.com/Pwnzer0tt1/firegex), a firewall built for CTF Attack-Defense competitions. It provides the `firegex.nfproxy` package used to write [Netfilter Proxy](../docs/nfproxy.md) Python packet filters, the `fgex` CLI, and a local proxy simulator (`proxysim`) for testing filters without a running Firegex instance.
+
+## Installation
+
+```bash
+pip install -U firegex
+```
+
+`fgex` is an alias package for `firegex`: installing either one gives you the same `firegex` module and the `fgex`/`firegex` CLI commands.
+
+## Documentation
+
+**➡️ [Netfilter Proxy: writing and testing `@pyfilter` scripts](../docs/nfproxy.md)** — the `pyfilter` decorator, every data structure (`RawPacket`, `TCPInputStream`/`TCPOutputStream`, `HttpRequest`/`HttpResponse` and their variants, `HttpHistory`), packet statements, stream limits, the `fgex nfproxy` CLI simulator, and a full worked example.
+
+That page is also what's shown in the Firegex web UI itself (the docs button on the nfproxy pages) — both are generated from that single file, so they can never drift out of sync.
+
+## Firegex's other filtering modules
+
+This library only covers Netfilter Proxy. Firegex ships several other independent modules, each with its own guide:
+
+- **[Netfilter Regex](../docs/nfregex.md)** — fast, PCRE2/hyperscan-based regex matching against raw traffic.
+- **[Hijack Port to Proxy](../docs/porthijack.md)** — redirect traffic to your own external proxy without touching the target service.
+- **[Firewall Rules](../docs/firewall.md)** — plain nftables allow/drop/reject rules.
+- **[TLS Decryption](../docs/tls.md)** — decrypt-and-reinspect bridge for services that speak TLS natively.

firegex-4.0.0/firegex/__init__.py

@@ -0,0 +1,69 @@
+
+def _get_version():
+    v = "4.0.0" if "{" not in "4.0.0" 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-4.0.0}/firegex/nfproxy/__init__.py

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

{firegex-3.5.2 → firegex-4.0.0}/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-4.0.0}/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-4.0.0/firegex.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: firegex
+Version: 4.0.0
+Summary: Firegex client
+Home-page: https://github.com/pwnzer0tt1/firegex
+Author: Pwnzer0tt1
+Author-email: pwnzer0tt1@poliba.it
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer
+Requires-Dist: pydantic>=2
+Requires-Dist: typing-extensions>=4.7.1
+Requires-Dist: pycryptodome
+Requires-Dist: watchfiles
+Requires-Dist: fgex
+Requires-Dist: websockets
+Requires-Dist: brotli
+Requires-Dist: pyllhttp
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Firegex Python Library and CLI
+
+This is the Python library for [Firegex](https://github.com/Pwnzer0tt1/firegex), a firewall built for CTF Attack-Defense competitions. It provides the `firegex.nfproxy` package used to write [Netfilter Proxy](../docs/nfproxy.md) Python packet filters, the `fgex` CLI, and a local proxy simulator (`proxysim`) for testing filters without a running Firegex instance.
+
+## Installation
+
+```bash
+pip install -U firegex
+```
+
+`fgex` is an alias package for `firegex`: installing either one gives you the same `firegex` module and the `fgex`/`firegex` CLI commands.
+
+## Documentation
+
+**➡️ [Netfilter Proxy: writing and testing `@pyfilter` scripts](../docs/nfproxy.md)** — the `pyfilter` decorator, every data structure (`RawPacket`, `TCPInputStream`/`TCPOutputStream`, `HttpRequest`/`HttpResponse` and their variants, `HttpHistory`), packet statements, stream limits, the `fgex nfproxy` CLI simulator, and a full worked example.
+
+That page is also what's shown in the Firegex web UI itself (the docs button on the nfproxy pages) — both are generated from that single file, so they can never drift out of sync.
+
+## Firegex's other filtering modules
+
+This library only covers Netfilter Proxy. Firegex ships several other independent modules, each with its own guide:
+
+- **[Netfilter Regex](../docs/nfregex.md)** — fast, PCRE2/hyperscan-based regex matching against raw traffic.
+- **[Hijack Port to Proxy](../docs/porthijack.md)** — redirect traffic to your own external proxy without touching the target service.
+- **[Firewall Rules](../docs/firewall.md)** — plain nftables allow/drop/reject rules.
+- **[TLS Decryption](../docs/tls.md)** — decrypt-and-reinspect bridge for services that speak TLS natively.

{firegex-3.5.2 → firegex-4.0.0}/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 = "4.0.0"
 
 setuptools.setup(
     name="firegex",

firegex-3.5.2/PKG-INFO

@@ -1,182 +0,0 @@
-Metadata-Version: 2.4
-Name: firegex
-Version: 3.5.2
-Summary: Firegex client
-Home-page: https://github.com/pwnzer0tt1/firegex
-Author: Pwnzer0tt1
-Author-email: pwnzer0tt1@poliba.it
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: typer
-Requires-Dist: pydantic>=2
-Requires-Dist: typing-extensions>=4.7.1
-Requires-Dist: pycryptodome
-Requires-Dist: watchfiles
-Requires-Dist: fgex
-Requires-Dist: websockets
-Requires-Dist: brotli
-Requires-Dist: pyllhttp
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Firegex Python Library and CLI
-
-This is the Python library for Firegex. It is used to get additional features of Firegex and use the feature of the command `fgex`.
-
-## Installation
-
-```bash
-pip install -U firegex
-```
-
-fgex is an alias of firegex. You can use `fgex` instead of `firegex`.
-
-## Command line usage:
-
-```text
-➤ fgex nfproxy -h
-
- Usage: fgex nfproxy [OPTIONS] FILTER_FILE ADDRESS PORT
-
- Run an nfproxy simulation
-
-╭─ Arguments ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ *    filter_file      TEXT     The path to the filter file [default: None] [required]                                                               │
-│ *    address          TEXT     The address of the target to proxy [default: None] [required]                                                        │
-│ *    port             INTEGER  The port of the target to proxy [default: None] [required]                                                           │
-╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-╭─ Options ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ --proto                 [tcp|http]  The protocol to proxy [default: tcp]                                                                            │
-│ --from-address          TEXT        The address of the local server [default: None]                                                                 │
-│ --from-port             INTEGER     The port of the local server [default: 7474]                                                                    │
-│                 -6                  Use IPv6 for the connection                                                                                     │
-│ --help          -h                  Show this message and exit.                                                                                     │
-╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-```
-
-## Library usage:
-
-## NfProxy decorator
-
-```python
-from firegex.nfproxy import pyfilter
-```
-This decorator is used to create a filter for the nfproxy.
-Example:
-```python
-@pyfilter
-def my_filter(raw_packet: RawPacket): #Logging filter
-    print(raw_packet.data)
-```
-
-## Data handlers
-
-### RawPacket
-```python
-from firegex.nfproxy import RawPacket
-```
-This handler will be called every time arrives a packet from the network. It will receive a RawPacket object with the following properties:
-- is_input: bool - It's true if the packet is an input packet, false if it's an output packet
-- is_ipv6: bool - It's true if the packet is an ipv6 packet, false if it's an ipv4 packet
-- is_tcp: bool - It's true if the packet is a tcp packet, false if it's an udp packet
-- data: bytes - The data of the packet assembled and sorted from TCP
-- l4_size: int - The size of the layer 4 data
-- raw_packet_header_len: int - The size of the original packet header
-- l4_data: bytes - The layer 4 payload of the packet
-- raw_packet: bytes - The raw packet with IP and TCP headers
-
-### TCPInputStream
-Alias: TCPClientStream
-```python
-from firegex.nfproxy import TCPInputStream
-```
-This handler will be called every time a TCP stream is assembled in input. It will receive a TCPInputStream object with the following properties:
-- data: bytes - The data of the packets assembled and sorted from TCP
-- is_ipv6: bool - It's true if the packet is an ipv6 packet, false if it's an ipv4 packet
-- total_stream_size: int - The size of the stream
-
-### TCPOutputStream
-Alias: TCPServerStream
-```python
-from firegex.nfproxy import TCPOutputStream
-```
-This handler will be called every time a TCP stream is assembled in output. It will receive a TCPOutputStream object with the following properties:
-- data: bytes - The data of the packets assembled and sorted from TCP
-- is_ipv6: bool - It's true if the packet is an ipv6 packet, false if it's an ipv4 packet
-- total_stream_size: int - The size of the stream
-
-### HttpRequest
-```python
-from firegex.nfproxy import HttpRequest
-```
-This handler will be called twice: one for the request headers and one for the request body. It will receive a HttpRequest object with the following properties:
-- method: bytes - The method of the request
-- url: str - The url of the request
-- headers: dict - The headers of the request
-- user_agent: str - The user agent of the request
-- content_encoding: str - The content encoding of the request
-- body: bytes - The body of the request
-- headers_complete: bool - It's true if the headers are complete
-- message_complete: bool - It's true if the message is complete
-- http_version: str - The http version of the request
-- keep_alive: bool - It's true if the request should keep alive
-- should_upgrade: bool - It's true if the request should upgrade
-- content_length: int - The content length of the request
-- get_header(header: str, default=None): str - Get a header from the request without caring about the case
-- total_size: int - The total size of the stream
-- stream: bytes - The stream of the request
-
-### HttpRequestHeader
-```python
-from firegex.nfproxy import HttpRequestHeader
-```
-This handler will be called only when the request headers are complete. It will receive a HttpRequestHeader object with the same properties as HttpRequest.
-
-### HttpFullRequest
-```python
-from firegex.nfproxy import HttpFullRequest
-```
-This handler will be called only when the request is complete. It will receive a HttpFullRequest object with the same properties as HttpRequest.
-
-### HttpResponse
-```python
-from firegex.nfproxy import HttpResponse
-```
-This handler will be called twice: one for the response headers and one for the response body. It will receive a HttpResponse object with the following properties:
-- status_code: int - The status code of the response
-- url: str - The url of the response
-- headers: dict - The headers of the response
-- user_agent: str - The user agent of the response
-- content_encoding: str - The content encoding of the response
-- body: bytes - The body of the response
-- headers_complete: bool - It's true if the headers are complete
-- message_complete: bool - It's true if the message is complete
-- http_version: str - The http version of the response
-- keep_alive: bool - It's true if the response should keep alive
-- should_upgrade: bool - It's true if the response should upgrade
-- content_length: int - The content length of the response
-- get_header(header: str, default=None): str - Get a header from the response without caring about the case
-- total_size: int - The total size of the stream
-- stream: bytes - The stream of the response
-
-### HttpResponseHeader
-```python
-from firegex.nfproxy import HttpResponseHeader
-```
-This handler will be called only when the response headers are complete. It will receive a HttpResponseHeader object with the same properties as HttpResponse.
-
-### HttpFullResponse
-```python
-from firegex.nfproxy import HttpFullResponse
-```
-This handler will be called only when the response is complete. It will receive a HttpFullResponse object with the same properties as HttpResponse.

firegex-3.5.2/README.md

@@ -1,151 +0,0 @@
-# Firegex Python Library and CLI
-
-This is the Python library for Firegex. It is used to get additional features of Firegex and use the feature of the command `fgex`.
-
-## Installation
-
-```bash
-pip install -U firegex
-```
-
-fgex is an alias of firegex. You can use `fgex` instead of `firegex`.
-
-## Command line usage:
-
-```text
-➤ fgex nfproxy -h
-
- Usage: fgex nfproxy [OPTIONS] FILTER_FILE ADDRESS PORT
-
- Run an nfproxy simulation
-
-╭─ Arguments ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ *    filter_file      TEXT     The path to the filter file [default: None] [required]                                                               │
-│ *    address          TEXT     The address of the target to proxy [default: None] [required]                                                        │
-│ *    port             INTEGER  The port of the target to proxy [default: None] [required]                                                           │
-╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-╭─ Options ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ --proto                 [tcp|http]  The protocol to proxy [default: tcp]                                                                            │
-│ --from-address          TEXT        The address of the local server [default: None]                                                                 │
-│ --from-port             INTEGER     The port of the local server [default: 7474]                                                                    │
-│                 -6                  Use IPv6 for the connection                                                                                     │
-│ --help          -h                  Show this message and exit.                                                                                     │
-╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-```
-
-## Library usage:
-
-## NfProxy decorator
-
-```python
-from firegex.nfproxy import pyfilter
-```
-This decorator is used to create a filter for the nfproxy.
-Example:
-```python
-@pyfilter
-def my_filter(raw_packet: RawPacket): #Logging filter
-    print(raw_packet.data)
-```
-
-## Data handlers
-
-### RawPacket
-```python
-from firegex.nfproxy import RawPacket
-```
-This handler will be called every time arrives a packet from the network. It will receive a RawPacket object with the following properties:
-- is_input: bool - It's true if the packet is an input packet, false if it's an output packet
-- is_ipv6: bool - It's true if the packet is an ipv6 packet, false if it's an ipv4 packet
-- is_tcp: bool - It's true if the packet is a tcp packet, false if it's an udp packet
-- data: bytes - The data of the packet assembled and sorted from TCP
-- l4_size: int - The size of the layer 4 data
-- raw_packet_header_len: int - The size of the original packet header
-- l4_data: bytes - The layer 4 payload of the packet
-- raw_packet: bytes - The raw packet with IP and TCP headers
-
-### TCPInputStream
-Alias: TCPClientStream
-```python
-from firegex.nfproxy import TCPInputStream
-```
-This handler will be called every time a TCP stream is assembled in input. It will receive a TCPInputStream object with the following properties:
-- data: bytes - The data of the packets assembled and sorted from TCP
-- is_ipv6: bool - It's true if the packet is an ipv6 packet, false if it's an ipv4 packet
-- total_stream_size: int - The size of the stream
-
-### TCPOutputStream
-Alias: TCPServerStream
-```python
-from firegex.nfproxy import TCPOutputStream
-```
-This handler will be called every time a TCP stream is assembled in output. It will receive a TCPOutputStream object with the following properties:
-- data: bytes - The data of the packets assembled and sorted from TCP
-- is_ipv6: bool - It's true if the packet is an ipv6 packet, false if it's an ipv4 packet
-- total_stream_size: int - The size of the stream
-
-### HttpRequest
-```python
-from firegex.nfproxy import HttpRequest
-```
-This handler will be called twice: one for the request headers and one for the request body. It will receive a HttpRequest object with the following properties:
-- method: bytes - The method of the request
-- url: str - The url of the request
-- headers: dict - The headers of the request
-- user_agent: str - The user agent of the request
-- content_encoding: str - The content encoding of the request
-- body: bytes - The body of the request
-- headers_complete: bool - It's true if the headers are complete
-- message_complete: bool - It's true if the message is complete
-- http_version: str - The http version of the request
-- keep_alive: bool - It's true if the request should keep alive
-- should_upgrade: bool - It's true if the request should upgrade
-- content_length: int - The content length of the request
-- get_header(header: str, default=None): str - Get a header from the request without caring about the case
-- total_size: int - The total size of the stream
-- stream: bytes - The stream of the request
-
-### HttpRequestHeader
-```python
-from firegex.nfproxy import HttpRequestHeader
-```
-This handler will be called only when the request headers are complete. It will receive a HttpRequestHeader object with the same properties as HttpRequest.
-
-### HttpFullRequest
-```python
-from firegex.nfproxy import HttpFullRequest
-```
-This handler will be called only when the request is complete. It will receive a HttpFullRequest object with the same properties as HttpRequest.
-
-### HttpResponse
-```python
-from firegex.nfproxy import HttpResponse
-```
-This handler will be called twice: one for the response headers and one for the response body. It will receive a HttpResponse object with the following properties:
-- status_code: int - The status code of the response
-- url: str - The url of the response
-- headers: dict - The headers of the response
-- user_agent: str - The user agent of the response
-- content_encoding: str - The content encoding of the response
-- body: bytes - The body of the response
-- headers_complete: bool - It's true if the headers are complete
-- message_complete: bool - It's true if the message is complete
-- http_version: str - The http version of the response
-- keep_alive: bool - It's true if the response should keep alive
-- should_upgrade: bool - It's true if the response should upgrade
-- content_length: int - The content length of the response
-- get_header(header: str, default=None): str - Get a header from the response without caring about the case
-- total_size: int - The total size of the stream
-- stream: bytes - The stream of the response
-
-### HttpResponseHeader
-```python
-from firegex.nfproxy import HttpResponseHeader
-```
-This handler will be called only when the response headers are complete. It will receive a HttpResponseHeader object with the same properties as HttpResponse.
-
-### HttpFullResponse
-```python
-from firegex.nfproxy import HttpFullResponse
-```
-This handler will be called only when the response is complete. It will receive a HttpFullResponse object with the same properties as HttpResponse.

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__ = []

firegex-3.5.2/firegex.egg-info/PKG-INFO

@@ -1,182 +0,0 @@
-Metadata-Version: 2.4
-Name: firegex
-Version: 3.5.2
-Summary: Firegex client
-Home-page: https://github.com/pwnzer0tt1/firegex
-Author: Pwnzer0tt1
-Author-email: pwnzer0tt1@poliba.it
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: typer
-Requires-Dist: pydantic>=2
-Requires-Dist: typing-extensions>=4.7.1
-Requires-Dist: pycryptodome
-Requires-Dist: watchfiles
-Requires-Dist: fgex
-Requires-Dist: websockets
-Requires-Dist: brotli
-Requires-Dist: pyllhttp
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Firegex Python Library and CLI
-
-This is the Python library for Firegex. It is used to get additional features of Firegex and use the feature of the command `fgex`.
-
-## Installation
-
-```bash
-pip install -U firegex
-```
-
-fgex is an alias of firegex. You can use `fgex` instead of `firegex`.
-
-## Command line usage:
-
-```text
-➤ fgex nfproxy -h
-
- Usage: fgex nfproxy [OPTIONS] FILTER_FILE ADDRESS PORT
-
- Run an nfproxy simulation
-
-╭─ Arguments ─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ *    filter_file      TEXT     The path to the filter file [default: None] [required]                                                               │
-│ *    address          TEXT     The address of the target to proxy [default: None] [required]                                                        │
-│ *    port             INTEGER  The port of the target to proxy [default: None] [required]                                                           │
-╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-╭─ Options ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
-│ --proto                 [tcp|http]  The protocol to proxy [default: tcp]                                                                            │
-│ --from-address          TEXT        The address of the local server [default: None]                                                                 │
-│ --from-port             INTEGER     The port of the local server [default: 7474]                                                                    │
-│                 -6                  Use IPv6 for the connection                                                                                     │
-│ --help          -h                  Show this message and exit.                                                                                     │
-╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
-```
-
-## Library usage:
-
-## NfProxy decorator
-
-```python
-from firegex.nfproxy import pyfilter
-```
-This decorator is used to create a filter for the nfproxy.
-Example:
-```python
-@pyfilter
-def my_filter(raw_packet: RawPacket): #Logging filter
-    print(raw_packet.data)
-```
-
-## Data handlers
-
-### RawPacket
-```python
-from firegex.nfproxy import RawPacket
-```
-This handler will be called every time arrives a packet from the network. It will receive a RawPacket object with the following properties:
-- is_input: bool - It's true if the packet is an input packet, false if it's an output packet
-- is_ipv6: bool - It's true if the packet is an ipv6 packet, false if it's an ipv4 packet
-- is_tcp: bool - It's true if the packet is a tcp packet, false if it's an udp packet
-- data: bytes - The data of the packet assembled and sorted from TCP
-- l4_size: int - The size of the layer 4 data
-- raw_packet_header_len: int - The size of the original packet header
-- l4_data: bytes - The layer 4 payload of the packet
-- raw_packet: bytes - The raw packet with IP and TCP headers
-
-### TCPInputStream
-Alias: TCPClientStream
-```python
-from firegex.nfproxy import TCPInputStream
-```
-This handler will be called every time a TCP stream is assembled in input. It will receive a TCPInputStream object with the following properties:
-- data: bytes - The data of the packets assembled and sorted from TCP
-- is_ipv6: bool - It's true if the packet is an ipv6 packet, false if it's an ipv4 packet
-- total_stream_size: int - The size of the stream
-
-### TCPOutputStream
-Alias: TCPServerStream
-```python
-from firegex.nfproxy import TCPOutputStream
-```
-This handler will be called every time a TCP stream is assembled in output. It will receive a TCPOutputStream object with the following properties:
-- data: bytes - The data of the packets assembled and sorted from TCP
-- is_ipv6: bool - It's true if the packet is an ipv6 packet, false if it's an ipv4 packet
-- total_stream_size: int - The size of the stream
-
-### HttpRequest
-```python
-from firegex.nfproxy import HttpRequest
-```
-This handler will be called twice: one for the request headers and one for the request body. It will receive a HttpRequest object with the following properties:
-- method: bytes - The method of the request
-- url: str - The url of the request
-- headers: dict - The headers of the request
-- user_agent: str - The user agent of the request
-- content_encoding: str - The content encoding of the request
-- body: bytes - The body of the request
-- headers_complete: bool - It's true if the headers are complete
-- message_complete: bool - It's true if the message is complete
-- http_version: str - The http version of the request
-- keep_alive: bool - It's true if the request should keep alive
-- should_upgrade: bool - It's true if the request should upgrade
-- content_length: int - The content length of the request
-- get_header(header: str, default=None): str - Get a header from the request without caring about the case
-- total_size: int - The total size of the stream
-- stream: bytes - The stream of the request
-
-### HttpRequestHeader
-```python
-from firegex.nfproxy import HttpRequestHeader
-```
-This handler will be called only when the request headers are complete. It will receive a HttpRequestHeader object with the same properties as HttpRequest.
-
-### HttpFullRequest
-```python
-from firegex.nfproxy import HttpFullRequest
-```
-This handler will be called only when the request is complete. It will receive a HttpFullRequest object with the same properties as HttpRequest.
-
-### HttpResponse
-```python
-from firegex.nfproxy import HttpResponse
-```
-This handler will be called twice: one for the response headers and one for the response body. It will receive a HttpResponse object with the following properties:
-- status_code: int - The status code of the response
-- url: str - The url of the response
-- headers: dict - The headers of the response
-- user_agent: str - The user agent of the response
-- content_encoding: str - The content encoding of the response
-- body: bytes - The body of the response
-- headers_complete: bool - It's true if the headers are complete
-- message_complete: bool - It's true if the message is complete
-- http_version: str - The http version of the response
-- keep_alive: bool - It's true if the response should keep alive
-- should_upgrade: bool - It's true if the response should upgrade
-- content_length: int - The content length of the response
-- get_header(header: str, default=None): str - Get a header from the response without caring about the case
-- total_size: int - The total size of the stream
-- stream: bytes - The stream of the response
-
-### HttpResponseHeader
-```python
-from firegex.nfproxy import HttpResponseHeader
-```
-This handler will be called only when the response headers are complete. It will receive a HttpResponseHeader object with the same properties as HttpResponse.
-
-### HttpFullResponse
-```python
-from firegex.nfproxy import HttpFullResponse
-```
-This handler will be called only when the response is complete. It will receive a HttpFullResponse object with the same properties as HttpResponse.