cookiefarm 1.0.2__tar.gz

cookiefarm-1.0.2/.gitignore

@@ -0,0 +1,140 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+build/
+temp/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# PEP 582; used by python-next
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# VS Code settings
+.vscode/
+
+test.py

cookiefarm-1.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ByteTheCookies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cookiefarm-1.0.2/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: cookiefarm
+Version: 1.0.2
+Summary: Python decorator for parallel exploit dispatch in Attack & Defense CTFs using the CookieFarm framework.
+Project-URL: Homepage, https://github.com/ByteTheCookies/CookieFarmExploiter
+Author-email: ByteTheCookies <bytethecookies@proton.me>
+License: MIT License
+        
+        Copyright (c) 2025 ByteTheCookies
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# 🍪 CookieFarm - Exploiter Manager
+
+![Language](https://img.shields.io/badge/languages-Python-yellowgreen)
+![Keywords](https://img.shields.io/badge/keywords-CTF%2C%20Exploiting%2C%20Attack%20Defense-red)
+![License](https://img.shields.io/badge/license-MIT-blue)
+
+> Python decorator for automating exploit execution in CTF Attack & Defense competitions
+
+---
+
+## 📦 What is it?
+
+This package provides a **`@exploit_manager` decorator** designed to automate the parallel execution of exploits in CTF (*Attack & Defense*) settings, specifically for use with the [CookieFarm](https://github.com/BytesTheCookies/CookieFarm) project.
+
+It handles:
+
+* Authentication with the central server
+* Retrieving team configuration
+* Asynchronous dispatch of exploits to multiple targets
+* Automatic flag parsing from `stdout`
+
+> ⚠️ **Note:** This package is **not standalone**. It must be used together with the [CookieFarm client](https://github.com/BytesTheCookies/CookieFarm). The client provides the required APIs and team configurations.
+
+---
+
+## 📦 Installation
+
+To install the package:
+```bash
+pip install cookiefarm-exploiter
+```
+
+
+## ⚙️ How it works
+
+The `@exploit_manager` decorator takes care of:
+
+* Calling your `exploit(ip, port, name_service)` function
+* Capturing your exploit's `stdout`
+* Parsing flags via regex
+* Logging the result in JSON format, including: team ID, port, service name, and the flag found
+
+All of this is done in parallel using `asyncio` and `ThreadPoolExecutor`, making the process **extremely efficient**, even with dozens of teams.
+
+---
+
+## 🚀 Example usage
+
+```python
+from cookiefarm_exploiter import exploit_manager
+import requests
+
+@exploit_manager
+def exploit(ip, port, name_service):
+    # Run your exploit here
+    response = requests.get(f"http://{ip}:{port}/")
+
+    # Just print the flag to stdout
+    print(response.text)
+
+# Run from the command line with arguments from CookieFarm
+# python3 myexploit.py <ip_server> <password> <tick_time> <thread_number> <port> <name_service>
+```
+
+For execution, you have to pass the required arguments from the command line, which are provided by the CookieFarm client. The decorator will handle the rest.
+
+```bash
+
+python3 myexploit.py <server_address> <tick_time> <thread_number> <port> <name_service>
+```
+
+Where:
+
+* `<server_address>`: The address of the CookieFarm server
+* `<tick_time>`: The time interval for the exploit to run
+* `<thread_number>`: The number of threads to use for parallel execution
+* `<port>`: The port of the service to exploit
+* `<name_service>`: The name of the service being exploited
+
+---
+
+## 🛠️ Requirements
+
+* Python ≥ 3.12
+* Working CookieFarm client installed
+
+
+---
+
+## 📝 License
+
+Distributed under the [MIT License](LICENSE). Feel free to use, modify, and contribute.
+
+---
+
+For any questions, suggestions, or issues, feel free to open a [GitHub issue](https://www.github.com/BytesTheCookies/CookieFarmExploiter)!
+
+**Created with ❤️ by ByteTheCookies (feat. @0xMatte)**

cookiefarm-1.0.2/README.md

@@ -0,0 +1,98 @@
+# 🍪 CookieFarm - Exploiter Manager
+
+![Language](https://img.shields.io/badge/languages-Python-yellowgreen)
+![Keywords](https://img.shields.io/badge/keywords-CTF%2C%20Exploiting%2C%20Attack%20Defense-red)
+![License](https://img.shields.io/badge/license-MIT-blue)
+
+> Python decorator for automating exploit execution in CTF Attack & Defense competitions
+
+---
+
+## 📦 What is it?
+
+This package provides a **`@exploit_manager` decorator** designed to automate the parallel execution of exploits in CTF (*Attack & Defense*) settings, specifically for use with the [CookieFarm](https://github.com/BytesTheCookies/CookieFarm) project.
+
+It handles:
+
+* Authentication with the central server
+* Retrieving team configuration
+* Asynchronous dispatch of exploits to multiple targets
+* Automatic flag parsing from `stdout`
+
+> ⚠️ **Note:** This package is **not standalone**. It must be used together with the [CookieFarm client](https://github.com/BytesTheCookies/CookieFarm). The client provides the required APIs and team configurations.
+
+---
+
+## 📦 Installation
+
+To install the package:
+```bash
+pip install cookiefarm-exploiter
+```
+
+
+## ⚙️ How it works
+
+The `@exploit_manager` decorator takes care of:
+
+* Calling your `exploit(ip, port, name_service)` function
+* Capturing your exploit's `stdout`
+* Parsing flags via regex
+* Logging the result in JSON format, including: team ID, port, service name, and the flag found
+
+All of this is done in parallel using `asyncio` and `ThreadPoolExecutor`, making the process **extremely efficient**, even with dozens of teams.
+
+---
+
+## 🚀 Example usage
+
+```python
+from cookiefarm_exploiter import exploit_manager
+import requests
+
+@exploit_manager
+def exploit(ip, port, name_service):
+    # Run your exploit here
+    response = requests.get(f"http://{ip}:{port}/")
+
+    # Just print the flag to stdout
+    print(response.text)
+
+# Run from the command line with arguments from CookieFarm
+# python3 myexploit.py <ip_server> <password> <tick_time> <thread_number> <port> <name_service>
+```
+
+For execution, you have to pass the required arguments from the command line, which are provided by the CookieFarm client. The decorator will handle the rest.
+
+```bash
+
+python3 myexploit.py <server_address> <tick_time> <thread_number> <port> <name_service>
+```
+
+Where:
+
+* `<server_address>`: The address of the CookieFarm server
+* `<tick_time>`: The time interval for the exploit to run
+* `<thread_number>`: The number of threads to use for parallel execution
+* `<port>`: The port of the service to exploit
+* `<name_service>`: The name of the service being exploited
+
+---
+
+## 🛠️ Requirements
+
+* Python ≥ 3.12
+* Working CookieFarm client installed
+
+
+---
+
+## 📝 License
+
+Distributed under the [MIT License](LICENSE). Feel free to use, modify, and contribute.
+
+---
+
+For any questions, suggestions, or issues, feel free to open a [GitHub issue](https://www.github.com/BytesTheCookies/CookieFarmExploiter)!
+
+**Created with ❤️ by ByteTheCookies (feat. @0xMatte)**

cookiefarm-1.0.2/cookiefarm/__init__.py

@@ -0,0 +1,3 @@
+from .exploiter_manager import exploit_manager
+
+__all__ = ["exploit_manager"]

cookiefarm-1.0.2/cookiefarm/cli.py

@@ -0,0 +1,13 @@
+import os
+import sys
+import subprocess
+
+def main():
+    base_dir = os.path.dirname(__file__)
+    binary_path = os.path.join(base_dir, "bin", "ckc")
+
+    if not os.path.exists(binary_path):
+        print(f"Binary not found at {binary_path}")
+        exit(1)
+
+    subprocess.run([binary_path] + sys.argv[1:])

cookiefarm-1.0.2/cookiefarm/exploit_config.py

@@ -0,0 +1,78 @@
+import argparse
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ExploitConfigInfo:
+    server_address: str
+    tick_time: int
+    thread_number: int
+    port_service: int
+    name_service: str
+    test_mode: bool
+
+
+def parse_exploit_config() -> ExploitConfigInfo:
+    """
+    Parse the exploit configuration from command line arguments.
+
+    Returns:
+        ExploitConfigInfo: The parsed configuration.
+    """
+    parser = argparse.ArgumentParser(
+        description="Advanced Exploit Manager per CTF Attack/Defense"
+    )
+
+    parser.add_argument(
+        "-s",
+        "--server_address",
+        type=str,
+        help="Server address in the format <ip>:<port>",
+        required=True,
+    )
+    parser.add_argument(
+        "-t",
+        "--tick_time",
+        type=int,
+        help="Time in seconds between each exploiting phase attempt",
+        default=120,
+    )
+    parser.add_argument(
+        "-T",
+        "--thread_number",
+        type=int,
+        help="Number of threads to use for exploits",
+        default=30,
+    )
+    parser.add_argument(
+        "-p",
+        "--port_service",
+        type=int,
+        help="Port number of the service to exploit",
+        required=True,
+    )
+    parser.add_argument(
+        "-n",
+        "--name_service",
+        type=str,
+        help="Name of the service to exploit",
+        default="UnknownService",
+    )
+    parser.add_argument(
+        "-x",
+        "--test",
+        action="store_true",
+        help="Run in test mode, exploit ONLY the NOP team",
+    )
+
+    args = parser.parse_args()
+
+    return ExploitConfigInfo(
+        server_address=args.server_address,
+        tick_time=args.tick_time,
+        thread_number=args.thread_number,
+        port_service=args.port_service,
+        name_service=args.name_service,
+        test_mode=args.test if args.test else False,
+    )

cookiefarm-1.0.2/cookiefarm/exploit_executor.py

@@ -0,0 +1,147 @@
+import re
+import time
+
+from itertools import count
+from typing import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from .logger import StatusCode, log_stats, log_status
+from threading import Lock
+
+class ExploitExecutor:
+    def __init__(
+        self,
+        exploit_function: Callable,
+        teams: dict[int, str],
+        port_service: int,
+        name_service: str,
+        flag_regex: re.Pattern,
+        tick_time: int = 120,
+        thread_number: int = 30,
+    ):
+        self.exploit_function = exploit_function
+        self.teams = teams
+        self.port_service = port_service
+        self.name_service = name_service
+        self.flag_regex = flag_regex
+        self.tick_time = tick_time
+        self.thread_number = thread_number
+        self.locker = Lock()
+        self.stat = {
+            "success_team": 0,
+            "failed_team": 0,
+            "total_flag": 0,
+        }
+
+    def __extract_flag(self, source: str | list[str]) -> set[str]:
+        if isinstance(source, list):
+            if len(source) == 0 or any(isinstance(item, str) for item in source):
+                return set()
+
+            return set(self.flag_regex.findall("\n".join(source)))
+
+        elif isinstance(source, str):
+            return set(self.flag_regex.findall(source))
+
+        return set()
+
+    def __single_exploit_execution(self, team_id: int, ip: str):
+        try:
+            result = self.exploit_function(ip, self.port_service, self.name_service)
+            flags = self.__extract_flag(result)
+
+            with self.locker:
+                if flags:
+                    self.stat["success_team"] += 1
+                    self.stat["total_flag"] += len(flags)
+                else:
+                    self.stat["failed_team"] += 1
+
+            return flags
+
+        except Exception as e:
+            log_status(
+                StatusCode.ERROR,
+                f"Error while exploiting team {team_id} ({ip}:{self.port_service}): {str(e)}",
+                team_id=team_id,
+                port_service=self.port_service,
+                name_service=self.name_service,
+            )
+            return None
+
+    def get_stat(self) -> dict[str, int]:
+        """
+        Returns the current statistics of the exploit execution.
+
+        Returns:
+            dict[str, int]: A dictionary containing the statistics.
+        """
+        with self.locker:
+
+            current_stat = self.stat.copy()
+            self.stat = {
+                "success_team": 0,
+                "failed_team": 0,
+                "total_flag": 0,
+            }
+
+            return current_stat
+
+    def __process_exploits(self):
+
+        with ThreadPoolExecutor(
+            max_workers=min(self.thread_number, len(self.teams)),
+            thread_name_prefix="exploit",
+        ) as executor:
+
+            futures_to_team = {
+                executor.submit(
+                    self.__single_exploit_execution,
+                    team_id,
+                    ip,
+                ): team_id
+                for team_id, ip in self.teams.items()
+            }
+
+            for future in as_completed(futures_to_team):
+                team_id = futures_to_team[future]
+                try:
+                    flags = future.result()
+
+                    if flags:
+                        for flag in flags:
+                            log_status(
+                                StatusCode.SUCCESS,
+                                f"Flag found for team {team_id}",
+                                team_id=team_id,
+                                port_service=self.port_service,
+                                flag_code=flag,
+                                name_service=self.name_service,
+                            )
+
+                except Exception as e:
+                    log_status(
+                        StatusCode.ERROR,
+                        f"Error while processing team {team_id}: {str(e)}",
+                        team_id=team_id,
+                        port_service=self.port_service,
+                        name_service=self.name_service,
+                    )
+
+    def execute(self):
+
+        round = count(1)
+
+        while True:
+            start_time = time.time()
+
+            self.__process_exploits()
+
+            log_stats(
+                f"Round {next(round)} - statistics",
+                port_service=self.port_service,
+                name_service=self.name_service,
+                stats=self.get_stat(),
+            )
+
+            elapsed_time = time.time() - start_time
+            time.sleep(max(0, self.tick_time - elapsed_time))

cookiefarm-1.0.2/cookiefarm/exploiter_manager.py

@@ -0,0 +1,82 @@
+"""
+Exploit Manager
+This module manages the exploit process by handling authentication,
+configuration retrieval, and dispatching exploits to the target IP teams.
+
+"""
+
+import io
+import sys
+
+from threading import local
+from .server_config import ServerConfig
+from .test_executor import TestExploitExecutor
+from .exploit_executor import ExploitExecutor
+from .exploit_config import parse_exploit_config
+
+thread_local = local()
+
+
+class ThreadSafeStdout:
+    """
+    A thread-safe wrapper for standard output to ensure that
+    """
+
+    def write(self, text):
+        return self._get_buffer().write(text)
+
+    def _get_buffer(self):
+        return getattr(thread_local, "buf", sys.__stdout__)
+
+    def __getattr__(self, attr):
+        return getattr(self._get_buffer(), attr)
+
+
+# Redirect standard output to the thread-local buffer
+sys.stdout = ThreadSafeStdout()
+
+def exploit_manager(func):
+
+    def wrapper(*_args, **kwargs):
+
+        def exploit_function_wrapper(*args, **kwargs):
+            buf = io.StringIO()
+            thread_local.buf = buf
+
+            try:
+                func(*args, **kwargs)
+            finally:
+                del thread_local.buf
+                out = buf.getvalue()
+                buf.close()
+                return out
+
+
+        exploit_config = parse_exploit_config()
+        server_config = ServerConfig(
+            server_address=exploit_config.server_address
+        ).config()
+
+        try:
+            if exploit_config.test_mode:
+                TestExploitExecutor(
+                    exploit_function=exploit_function_wrapper,
+                    port_service=exploit_config.port_service,
+                    name_service=exploit_config.name_service,
+                    flag_regex=server_config.regex_flag,
+                    nop_team=server_config.nop_team,
+                ).execute()
+            else:
+                ExploitExecutor(
+                    exploit_function=exploit_function_wrapper,
+                    flag_regex=server_config.regex_flag,
+                    teams=server_config.teams,
+                    port_service=exploit_config.port_service,
+                    name_service=exploit_config.name_service,
+                    tick_time=exploit_config.tick_time,
+                    thread_number=exploit_config.thread_number,
+                ).execute()
+        except KeyboardInterrupt:
+            sys.exit(0)
+
+    return wrapper()

cookiefarm-1.0.2/cookiefarm/logger.py

@@ -0,0 +1,96 @@
+"""
+Logger module for logging status messages.
+
+"""
+
+import json
+from enum import Enum
+
+
+class StatusCode(Enum):
+    """Enumeration of possible status codes for logging."""
+
+    SUCCESS = "success"  # Case: get flag successfully
+    ERROR = "error"  # Case: get flag unsuccessfully [error in exploit returns an error]
+    FAILED = "failed"  # Case: not get the flag [exploit returns no flag]
+    FATAL = "fatal"  # Case: fatal error that requires immediate attention. Stop script's execution
+    INFO = "info"  # Case: informative message
+    STATS = "stats"  # Case: statistics message
+
+
+def log_status(
+    status: StatusCode,
+    message: str,
+    team_id: int = 0,
+    port_service: int = 0,
+    flag_code: str = "",
+    name_service: str = "",
+) -> bool:
+    """
+    Logs a status message with additional information.
+
+    Args:
+        status (StatusCode): The status code to log.
+        message (str): The message to log.
+        team_id (int, optional): The ID of the team. Defaults to 0.
+        port_service (int, optional): The port number of the service. Defaults to 0.
+        flag_code (str, optional): The flag code. Defaults to "".
+        name_service (str, optional): The name of the service. Defaults to "".
+
+    Returns:
+        bool: True if the status was logged successfully, False otherwise.
+    """
+
+    if not isinstance(status, StatusCode):
+        return False
+
+    print(
+        json.dumps(
+            {
+                "status": status.value,
+                "message": message,
+                "team_id": team_id,
+                "port_service": port_service,
+                "flag_code": flag_code,
+                "name_service": name_service,
+            }
+        ),
+        flush=True,
+    )
+    return True
+
+
+def log_stats(
+    message: str,
+    port_service: int,
+    name_service: str,
+    stats: dict[str, int]
+):
+
+    """
+    Logs statistics message.
+
+    Args:
+        message (str): The message to log.
+        port_service (int): The port number of the service.
+        name_service (str): The name of the service.
+        stats (dict[str, int]): A dictionary containing statistics.
+
+    Returns:
+        bool: True if the statistics were logged successfully, False otherwise.
+    """
+    print(
+        json.dumps(
+            {
+                "status": StatusCode.STATS.value,
+                "message": message,
+                "port_service": port_service,
+                "name_service": name_service,
+                "total_flag": stats.get("total_flag", 0),
+                "success_team": stats.get("success_team", 0),
+                "failed_team": stats.get("failed_team", 0),
+            }
+        ),
+        flush=True,
+    )
+    return True

cookiefarm-1.0.2/cookiefarm/server_config.py

@@ -0,0 +1,112 @@
+import re
+import sys
+import requests
+
+from typing import Any
+from array import array
+from pathlib import Path
+from dataclasses import dataclass
+from .logger import StatusCode, log_status
+
+
+@dataclass
+class ServerConfigInfo:
+    regex_flag: re.Pattern
+    teams: dict[int, str]
+    nop_team: tuple[int, str]
+
+
+class ServerConfig:
+    def __init__(self, server_address: str, config_api_path: str = "/api/v1/config"):
+        self.server_address = server_address
+        self.config_api_path = config_api_path
+        self.raw_config = self.__get_raw_config()
+
+    def __get_auth_token(self) -> str:
+        """
+        Get the authentication token from the session file.
+
+        Returns:
+            str: The authentication token.
+        """
+        session_path = Path.home().joinpath(".config", "cookiefarm", "session")
+
+        if not session_path.exists():
+            log_status(StatusCode.FATAL, "Session file not found. Please login first.")
+            sys.exit(1)
+
+        with open(session_path) as session_file:
+            token = session_file.read().strip()
+
+        return token
+
+    def __get_raw_config(self) -> dict[str, Any]:
+        """
+        Get the configuration from the server.
+
+        Returns:
+            dict[str, Any]: The configuration dictionary.
+        Raises:
+            ValueError: If the response from the server is not ok.
+        """
+        response = requests.get(
+            f"http://{self.server_address}{self.config_api_path}",
+            headers={
+                "Content-Type": "application/json",
+                "Cookie": f"token={self.__get_auth_token()}",
+            },
+        )
+        if not response.ok:
+            log_status(
+                StatusCode.FATAL, "Failed to retrieve configuration from the server."
+            )
+            sys.exit(1)
+
+        return response.json()
+
+    def config(self) -> ServerConfigInfo:
+        """
+        Get the configuration information from the server.
+
+        Returns:
+            ServerConfigInfo: A ServerConfigInfo object containing regex_flag and teams.
+        Raises:
+            ValueError: If the response from the server is not ok.
+        """
+        config_json = self.raw_config
+
+        regex_flag = re.compile(config_json["client"]["regex_flag"])
+        format_ip_teams: str = config_json["client"]["format_ip_teams"]
+        my_team = int(config_json["client"]["my_team_id"])
+        nop_team: int = int(config_json["client"]["nop_team"])
+
+        if my_team < nop_team:
+            x_1 = my_team
+            x_2 = nop_team
+        else:
+            x_1 = nop_team
+            x_2 = my_team
+
+        ip_teams = array("H", range(x_1))
+
+        for i in range(
+            x_1 + 1, x_2
+        ):
+            ip_teams.append(i)
+
+        for i in range(
+            x_2 + 1, int(config_json["client"]["range_ip_teams"]) + 1
+        ):
+            ip_teams.append(i)
+
+
+        for i in range(
+            my_team + 1, int(config_json["client"]["range_ip_teams"]) + 1
+        ):
+            ip_teams.append(i)
+
+        return ServerConfigInfo(
+            re.compile(regex_flag),
+            {i: format_ip_teams.format(i) for i in ip_teams},
+            (nop_team, format_ip_teams.format(nop_team))
+        )

cookiefarm-1.0.2/cookiefarm/test_executor.py

@@ -0,0 +1,82 @@
+import re
+
+from typing import Callable
+from .logger import StatusCode, log_status
+
+
+class TestExploitExecutor:
+    def __init__(
+        self,
+        exploit_function: Callable,
+        port_service: int,
+        name_service: str,
+        flag_regex: re.Pattern,
+        nop_team: tuple[int, str],
+    ):
+        self.exploit_function = exploit_function
+        self.port_service = port_service
+        self.name_service = name_service
+        self.flag_regex = flag_regex
+        self.nop_team = nop_team
+
+
+    def __extract_flag(self, source: str | list[str]) -> set[str]:
+        if isinstance(source, list):
+            if len(source) == 0 or any(isinstance(item, str) for item in source):
+                return set()
+
+            return set(self.flag_regex.findall("\n".join(source)))
+
+        elif isinstance(source, str):
+            return set(self.flag_regex.findall(source))
+
+        return set()
+
+    def __single_exploit_execution(
+        self,
+        team_id: int,
+        ip: str,
+    ):
+        try:
+            result = self.exploit_function(ip, self.port_service, self.name_service)
+            return self.__extract_flag(result)
+
+        except Exception as e:
+            log_status(
+                StatusCode.ERROR,
+                f"Error while exploiting team {team_id} ({ip}:{self.port_service}): {str(e)}",
+                team_id=team_id,
+                port_service=self.port_service,
+                name_service=self.name_service,
+            )
+            return None
+
+    def execute(self):
+        flags = self.__single_exploit_execution(self.nop_team[0], self.nop_team[1])
+
+        if flags:
+            for flag in flags:
+                log_status(
+                    StatusCode.SUCCESS,
+                    f"Flag found for team {self.nop_team[0]}: {flag}",
+                    team_id=self.nop_team[0],
+                    port_service=self.port_service,
+                    name_service=self.name_service,
+                    flag_code=flag,
+                )
+
+            log_status(
+                StatusCode.INFO,
+                message="Exploit test completed successfully",
+                team_id=self.nop_team[0],
+                port_service=self.port_service,
+                name_service=self.name_service,
+            )
+        else:
+            log_status(
+                StatusCode.FAILED,
+                f"No flags found for team {self.nop_team[0]}",
+                team_id=self.nop_team[0],
+                port_service=self.port_service,
+                name_service=self.name_service,
+            )

cookiefarm-1.0.2/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cookiefarm"
+version = "1.0.2"
+description = "Python decorator for parallel exploit dispatch in Attack & Defense CTFs using the CookieFarm framework."
+authors = [{ name = "ByteTheCookies", email = "bytethecookies@proton.me" }]
+readme = "README.md"
+requires-python = ">=3.12"
+license = { file = "LICENSE" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+]
+
+[project.urls]
+Homepage = "https://github.com/ByteTheCookies/CookieFarmExploiter"
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "cookiefarm",
+  "README.md",
+  "LICENSE",
+  "cookiefarm/bin/*"
+]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+
+[tool.hatch.build]
+include = [
+  "cookiefarm/bin/*"
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["cookiefarm"]
+
+[project.scripts]
+ckc = "cookiefarm.cli:main"

cookiefarm-1.0.2/venv_1/bin/cookiefarm

@@ -0,0 +1,8 @@
+#!/home/suga/Workspace/Projects/CookieFarmExploiter/venv_1/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from cookiefarm.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())