switch dispatcher

Why It Matters

Switch dispatchers are important for developers who must protect their application logic from reverse engineering. In environments where JavaScript is executed in the browser, attackers can easily analyze and modify code unless it is obfuscated. By using a switch dispatcher, the logic of how decisions are made becomes less obvious, making it harder to predict or manipulate the flow of execution.

For maintainers, switch dispatchers can also introduce complexity that may hinder debugging or future updates. However, in high-security contexts, this trade-off is often acceptable. The ability to obscure decision points is particularly valuable when the code path determines access to sensitive resources or triggers critical system behaviors.

How It Works

A switch dispatcher works by replacing a standard switch statement with a more complex structure that hides the original logic. The core idea is to obscure the mapping between input values and execution paths, often by generating dynamic or encoded values that are decoded at runtime.

• The original switch statement is replaced with a series of conditional checks or encoded lookups.
• Input values are transformed using encoding or hashing before being passed to the dispatcher.
• The dispatcher decodes or maps these values to execute the appropriate code path.
• The resulting structure often includes multiple layers of abstraction, such as function calls or array lookups, to further obscure logic.
• Runtime decoding is typically performed using a separate decoding function or in-line logic that is harder to follow.

Quick Reference

Basic Example

The following example demonstrates a basic switch dispatcher transformation. A simple switch statement is replaced with a structure that decodes a value before executing a matching action.

function dispatcher(input) {
  const decoded = decodeValue(input);
  switch (decoded) {
    case 'a': return 'Action A';
    case 'b': return 'Action B';
    default: return 'Default';
  }
}

function decodeValue(value) {
  return value === 1 ? 'a' : value === 2 ? 'b' : 'default';
}

In this example, the decodeValue function maps numeric inputs to string values before the switch evaluates them. This obscures the relationship between input and output, making it harder to reverse engineer.

Production Example

In a production environment, a switch dispatcher may include more complex logic, such as dynamic array lookups, cryptographic encoding, or runtime evaluation. This example shows a more robust implementation that supports multiple input types and includes error handling.

function secureDispatcher(input) {
  const key = generateKey(input);
  const actions = [
    () => 'Action 1',
    () => 'Action 2',
    () => 'Action 3'
  ];
  const index = hash(key) % actions.length;
  if (index < 0 || index >= actions.length) {
    return 'Invalid input';
  }
  return actions[index]();
}

function generateKey(input) {
  return typeof input === 'number' ? input.toString() : input;
}

function hash(str) {
  let hash = 0;
  for (let i = 0; i < str.length; i++) {
    const char = str.charCodeAt(i);
    hash = ((hash << 5) - hash) + char;
    hash = hash & hash;
  }
  return Math.abs(hash);
}

This version is more suitable for production because it handles different input types, uses a hash function to map inputs to array indices, and includes validation to prevent out-of-bounds access. The added complexity makes it harder to reverse-engineer, while maintaining performance and correctness.

Common Mistakes

• Not validating inputs before decoding, leading to potential runtime errors or unintended behavior.
• Using predictable or static keys for encoding, which can be easily reversed by attackers.
• Overcomplicating the dispatcher logic, which can reduce performance and increase debugging difficulty.
• Failing to account for edge cases in input mapping, such as null or undefined values.
• Not securing the decoding function, which can expose the original logic if it is accessible.

Security And Production Notes

• Ensure that decoding logic is not easily accessible or reversible through static analysis.
• Validate all inputs to prevent unexpected behavior or code injection.
• Use cryptographic methods for encoding when high security is required.
• Consider performance impact of complex decoding steps, especially in high-frequency operations.
• Regularly review obfuscation logic to ensure it remains effective against evolving reverse-engineering techniques.

Related Concepts

Switch dispatchers are closely related to several other obfuscation and security techniques:

• Control flow obfuscation – A broader category that includes switch dispatchers to obscure program execution paths.
• String encoding – Used to hide literal values in code, often in conjunction with switch dispatchers.
• Function renaming – Replaces meaningful function names with obfuscated identifiers to hinder analysis.
• Dead code insertion – Adds unused code to mislead attackers, often used alongside switch dispatchers.
• Dynamic code evaluation – Involves runtime code generation, which can be used to further obscure decision logic.

Further Reading

• MDN Web Docs
• WHATWG HTML Standard