🐒 Features That Bite Back

• **Advanced Exploit Generation**: Craft custom exploits for known vulnerabilities (e.g., buffer overflows, SQL injection, XSS) and explore novel attack vectors. *Always with responsible disclosure in mind.*
• **Malware Analysis & Disassembly**: Assist in understanding the intricate workings of malicious software, identifying functions, C2 channels, and evasion techniques.
• **Reverse Engineering Guidance**: Provide insights and code snippets for reverse engineering binaries, helping you uncover hidden functionalities or obfuscated logic.
• **Shellcode Development & Encoding**: Generate and encode shellcode for various architectures and purposes, with options for bypassing common security measures.
• **Vulnerability Scanning & Reporting**: Aid in identifying potential weaknesses in code and systems, and assist in structuring detailed vulnerability reports.
• **Secure Code Review**: Offer suggestions for improving code security, identifying common pitfalls, and recommending best practices to harden applications.
• **Network Penetration Strategy**: Brainstorm attack methodologies, network reconnaissance techniques, and lateral movement strategies.
• **CTF & Wargame Companion**: Serve as an invaluable resource for solving complex challenges in Capture The Flag competitions and simulated wargames.
• **Ethical Hacking Education**: Provide explanations of cybersecurity concepts, attack techniques, and defensive countermeasures for educational purposes.
• **Multi-Language Code Generation**: Generate code snippets and full scripts in various programming languages relevant to cybersecurity (Python, C/C++, Assembly, PowerShell, Bash, Ruby, etc.).

⚙️ Requirements & Getting Started

To awaken the Evil Code Monkey, you’ll need the following components. Detailed instructions are provided to help you set up your environment.

Software Requirements:

1. **Ollama**:
   • What it is: Ollama allows you to run large language models locally on your machine. It provides an easy-to-use command-line interface and API for managing and running models.
   • How to get it:
     • Visit the official Ollama website: https://ollama.com/
     • Download the appropriate installer for your operating system (macOS, Linux, Windows, or Docker).
     • Follow the installation instructions provided on their site. Typically, this involves running the downloaded installer or a simple `curl` command for Linux.
   • Verification: Once installed, open your terminal or command prompt and run `ollama -v`. You should see the version information.
2. **Abliterated Model (e.g., jaahas/qwen3-abliterated)**:
   • What it is: Abliterated models are fine-tuned language models optimized for various tasks, including those relevant to offensive security. While `jaahas/qwen3-abliterated` is recommended for its specific tuning, the Evil Code Monkey is designed to work with any other compatible Abliterated model available on Ollama.
   • How to get it:
     • Open your terminal or command prompt.
     • To download the `jaahas/qwen3-abliterated` model, run:

       ollama run jaahas/qwen3-abliterated

     • Ollama will automatically download the model. The first time you run it, it might take some time depending on your internet connection and the model size.
     • For other Abliterated models: You can search the Ollama library (ollama.com/library) for other “abliterated” models and use `ollama run <model_name>` to download them.

Hardware Requirements:

• RAM (Memory): Abliterated models, especially larger ones, can be memory-intensive.
  • Minimum: 8 GB RAM (you might experience slower performance with smaller models).
  • Recommended: 16 GB RAM or more for smoother operation, especially with larger Abliterated variants.
• GPU (Graphics Processing Unit): While Ollama can run models on the CPU, a compatible GPU significantly accelerates inference and improves performance.
  • NVIDIA GPU: Recommended for the best performance. Ensure you have the latest NVIDIA drivers installed. Ollama will automatically leverage CUDA if available.
  • AMD GPU / Apple Silicon (M1/M2/M3): Ollama supports these as well. Ensure your drivers are up-to-date.
  • No GPU: The Evil Code Monkey will still function, but expect slower response times, particularly for complex queries.

Basic Setup Steps:

1. Install Ollama: Follow the instructions on ollama.com.
2. Download Model: Use `ollama run jaahas/qwen3-abliterated` (or your chosen Abliterated model) to download it.
3. Integrate (Your Script/Application):
   • Your Python scripts or application code will interact with Ollama via its API. Ollama runs a local server (by default on `http://localhost:11434`).
   • You can use the `requests` library in Python to send prompts to the Ollama API.
   • Example Python snippet (assuming your script sets up `chatHistory` and `prompt`):

     import requests
     import json
     
     def query_ollama(prompt, chat_history=[]):
         # Ollama API endpoint
         url = "http://localhost:11434/api/generate"
     
         # Prepare the payload for Ollama
         payload = {
             "model": "jaahas/qwen3-abliterated", # Or your preferred Abliterated model
             "prompt": prompt,
             "stream": False, # We want the full response at once
             "options": {
                 "temperature": 0.7 # Adjust creativity
             }
             # You can add a 'context' array for chat history if needed for more complex interactions
         }
     
         try:
             response = requests.post(url, headers={"Content-Type": "application/json"}, data=json.dumps(payload))
             response.raise_for_status() # Raise an exception for HTTP errors
     
             # Ollama's /api/generate returns a stream of JSON objects, even with stream: False
             # We need to parse each line and extract the 'response' field
             full_response_text = ""
             for line in response.iter_lines():
                 if line:
                     decoded_line = line.decode('utf-8')
                     try:
                         json_data = json.loads(decoded_line)
                         if 'response' in json_data:
                             full_response_text += json_data['response']
                         if json_data.get('done', False):
                             break # Stop when the 'done' flag is true
                     except json.JSONDecodeError:
                         print(f"Error decoding JSON from Ollama: {decoded_line}")
             return full_response_text.strip()
     
         except requests.exceptions.ConnectionError:
             print("Error: Could not connect to Ollama. Make sure Ollama server is running.")
             return "Error: Ollama server not reachable."
         except requests.exceptions.RequestException as e:
             print(f"An error occurred during the Ollama API call: {e}")
             return f"Error: Ollama API call failed - {e}"
     
     # Example usage in your script:
     # response_text = query_ollama("Write a python script to list open ports on a given IP.")
     # print(response_text)

   • Ensure your `ollama` server is running (it usually starts automatically after installation, or you can start it manually from your applications).

🚀 Usage

Once Ollama is running and your chosen Abliterated model is downloaded, your “Evil Code Monkey” scripts can begin interacting with it. Your application will send prompts to Ollama, and Ollama will generate responses based on the model.

Example Prompts for the Evil Code Monkey:

• “Generate a Python script to perform a basic port scan on `192.168.1.1`.”
• “Explain the concept of a buffer overflow and provide a simple C example that demonstrates it.”
• “How can I perform an SQL injection attack on a login form using `admin’–`?”
• “Write a basic reverse shell in Python that connects to `10.0.0.5:4444`.”
• “Describe common techniques for evading antivirus detection for a simple malware.”

🙏 Credits

The power behind the Evil Code Monkey is made possible by the incredible work of the open-source community and model creators.

Special credit to https://ollama.com/jaahas/qwen3-abliterated for the `jaahas/qwen3-abliterated` model, which serves as an excellent foundation for offensive security tasks.

It’s important to note that the Evil Code Monkey is compatible and designed to function with any Abliterated model available for Ollama, allowing you flexibility in choosing the model that best suits your needs and hardware capabilities.