CyberChef

To create a new operation for CyberChef, you must extend the Operation class and implement the core lifecycle methods. The Operation class manages metadata (name, module, description), input/output types (using Dish enums), and the collection of Ingredient objects that represent the operation's parameters.

Core Methods to Implement

• run(input, args): The primary execution logic. It takes the input and an array of args (the values for the operation's ingredients) and returns the processed result.
• present(data, args): (Optional) Overriding this allows you to transform the raw output of run() into a human-readable format for display in the CyberChef UI without changing the actual data returned by run().
• highlight(pos, args) and highlightReverse(pos, args): (Optional) Used to provide visual highlighting of specific positions within the output.

Managing Parameters (Ingredients)

Operations use Ingredient objects to define their configuration interface. You can manage these via:

• this.args: A getter/setter for the configuration of the ingredients.
• this.ingValues: A getter/setter for the actual values assigned to the ingredients.
• validateIngredients(args): Validates the current or provided ingredient values against their constraints, throwing an OperationError if invalid.

import Operation from './src/core/Operation.mjs';

class MyCustomOperation extends Operation {
    constructor() {
        super();
        this.name = 'My Custom Op';
        this.module = 'custom-module';
        // Add ingredients here using addIngredient()
    }

    run(input, args) {
        // Perform transformation logic
        return input.toString().split('').reverse().join('');
    }

    present(data, args) {
        // Return a human-readable version for the UI
        return `Result: ${data}`;
    }
}

The Recipe class is the central controller for a sequence of Operation objects acting upon a Dish. It manages the lifecycle of a recipe, including parsing configurations, hydrating operation instances, executing the sequence, and presenting results.

Key capabilities include:

• Configuration: Create recipes from JSON configuration objects or strings.
• Execution: Run operations sequentially on a Dish, supporting breakpoints and flow control (forking).
• Flow Control: Detect and handle operations that alter the recipe execution path (e.g., loops or conditional jumps).
• Presentation: Automatically present the output of the final operation in a user-friendly format.

import Recipe from './src/core/Recipe.mjs';

// Example: Creating a recipe from a config object
const recipeConfig = [
  { op: 'To Base64', args: {} },
  { op: 'From Hex', args: { 'alphabet': '0123456789abcdef' } }
];
const recipe = new Recipe(recipeConfig);

The decode function parses a Bech32 or Bech32m encoded string back into its constituent parts.

Parameters:

• str (string): The encoded string to decode.
• encoding (string, default: 'Auto-detect'): Specifies the expected encoding: 'Bech32', 'Bech32m', or 'Auto-detect' (which attempts Bech32 first, then Bech32m).

Returns: An object containing:

• hrp (string): The decoded Human-Readable Part.
• data (number[]): The decoded data bytes.
• encoding (string): The encoding type that was successfully verified.
• witnessVersion (number | null): If the string was identified as a SegWit address, this contains the witness version; otherwise null.

Constraints:

• The input string cannot be mixed case (must be all uppercase or all lowercase).
• The input string cannot exceed 90 characters.

import { decode } from './Bech32.mjs';

const result = decode('bc1qw508d6qejxtdg4yjrsqegz6lq5tx0w362l66p');
console.log(result.hrp);            // 'bc'
console.log(result.data);           // [decoded bytes]
console.log(result.witnessVersion); // e.g., 0

The execute method runs the sequence of operations defined in the recipe against a provided Dish.

Parameters:

• dish: The Dish instance containing the data to be processed.
• startFrom (number, default: 0): The index of the operation in opList to start execution from.
• forkState (object, default: {}): State used for forked recipes (e.g., containing numRegisters, numJumps, or forkOffset).

Returns:

• Promise<number>: The index of the operation where execution finished or paused (e.g., at a breakpoint).

Behavior:

• It automatically hydrates operation modules before running.
• If an operation is disabled, it is skipped.
• If a breakpoint is encountered, execution pauses and returns the current index.
• If a flowControl operation is encountered, it manages state jumps and registers.
• Errors of type OperationError or DishError are caught, and their messages are set as the output in the Dish (as a string), stopping execution at that point.

// Assuming 'dish' is an existing Dish instance
const finalIndex = await recipe.execute(dish);
console.log(`Recipe finished at operation index: ${finalIndex}`);