Modules

from havoc import Demon, RegisterCommand, RegisterModule

class Packer:
    def __init__(self):
        self.buffer = b''

    def addstr(self, string):
        self.buffer += string.encode() + b'\x00'

    def addint(self, integer):
        self.buffer += integer.to_bytes(4, 'little')

    def getbuffer(self):
        return self.buffer

def mycommand(demon_id, *args):
    """
    Custom command implementation.
    
    Args:
        demon_id: Agent ID
        *args: Command arguments
    """
    task_id = Demon.Command.task_id
    
    if len(args) < 1:
        Demon.Console.error(task_id, "Usage: mycommand <argument>")
        return False
    
    # Pack command data
    packer = Packer()
    packer.addint(0x1000)  # Command ID
    packer.addstr(args[0])  # Argument
    
    # Send to agent
    Demon.Console.info(task_id, f"Executing mycommand with: {args[0]}")
    Demon.Command.execute(demon_id, packer.getbuffer())
    
    return True

# Register the module
RegisterModule(
    "MyModule",
    "1.0",
    "Custom functionality module",
    "@YourHandle",
    [
        # List of COFF/BOF files to load
        "MyModule.x64.o",
        "MyModule.x86.o"
    ]
)

# Register commands
RegisterCommand(
    demon_id=None,
    command_name="mycommand",
    description="Execute custom functionality",
    help="mycommand <argument>",
    callback=mycommand,
    mitre="T1059"  # MITRE ATT&CK technique
)

#include <windows.h>
#include <stdio.h>
#include "Beacon.h"  // Beacon API compatibility

// Command ID (must match Module.py)
#define COMMAND_MYCOMMAND 0x1000

// Entry point
void go(char* args, int length) {
    // Parse arguments from packed buffer
    datap parser;
    BeaconDataParse(&parser, args, length);
    
    int command_id = BeaconDataInt(&parser);
    char* argument = BeaconDataExtract(&parser, NULL);
    
    if (command_id == COMMAND_MYCOMMAND) {
        // Execute functionality
        char output[256];
        sprintf(output, "[+] Executed with argument: %s", argument);
        BeaconPrintf(CALLBACK_OUTPUT, output);
        
        // Your custom logic here
        // ...
    }
}

RegisterModule(
    "AdvancedModule",
    "1.0",
    "Multiple related commands",
    "@YourHandle",
    ["Module.x64.o", "Module.x86.o"]
)

# Register multiple commands
RegisterCommand(
    demon_id=None,
    command_name="cmd1",
    description="First command",
    help="cmd1 <arg>",
    callback=command1_callback,
    mitre="T1059"
)

RegisterCommand(
    demon_id=None,
    command_name="cmd2",
    description="Second command",
    help="cmd2 <arg>",
    callback=command2_callback,
    mitre="T1059"
)

#include "Beacon.h"

// Dynamically load and use libraries
void load_custom_library() {
    HMODULE hLib = KERNEL32$LoadLibraryA("custom.dll");
    if (!hLib) {
        BeaconPrintf(CALLBACK_ERROR, "[-] Failed to load library");
        return;
    }
    
    // Get function pointer
    typedef void (*CustomFunc)(void);
    CustomFunc func = (CustomFunc)KERNEL32$GetProcAddress(hLib, "CustomFunction");
    
    if (func) {
        func();
    }
    
    KERNEL32$FreeLibrary(hLib);
}