firegex 3.5.3__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-3.5.3 → firegex-4.0.0}/firegex/__init__.py

@@ -1,6 +1,6 @@
 
 def _get_version():
-    v = "3.5.3" if "{" not in "3.5.3" else "0.0.0"
+    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")

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

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

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.3 → 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.3"
+VERSION = "4.0.0"
 
 setuptools.setup(
     name="firegex",

firegex-3.5.3/PKG-INFO

@@ -1,182 +0,0 @@
-Metadata-Version: 2.4
-Name: firegex
-Version: 3.5.3
-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.3/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.3/firegex.egg-info/PKG-INFO

@@ -1,182 +0,0 @@
-Metadata-Version: 2.4
-Name: firegex
-Version: 3.5.3
-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.