timing guard

Why It Matters

Timing attacks exploit the fact that computers execute instructions at different speeds, which can leak information about internal operations. For example, an attacker might measure how long a password check takes to determine if a character matches, or how long a database query takes to infer the presence of certain data.

Implementing a timing guard ensures that such operations take a consistent amount of time, regardless of the input or outcome. This is especially critical in high-security contexts like financial applications, authentication systems, or systems handling classified data, where even small timing variations could be exploited to gain unauthorized access or extract sensitive information.

From a performance perspective, timing guards introduce overhead but are designed to be minimal and predictable. When used correctly, they do not significantly impact user experience, but they add a layer of protection that makes reverse engineering or exploitation more difficult.

How It Works

Timing guards operate by ensuring that operations take a consistent amount of time, regardless of input or internal state. This is typically achieved through one or more of the following mechanisms:

• Fixed delays: Introducing a guaranteed minimum delay using setTimeout or setInterval to normalize execution times.
• Randomized delays: Using a pseudo-random number generator to introduce variable but bounded delays, making timing analysis more difficult.
• Conditional execution with padding: Ensuring that all branches of a conditional statement take the same amount of time, often by performing dummy operations in shorter branches.
• Loop padding: Executing a fixed number of iterations, even if the operation could complete faster, to mask timing differences.
• Asynchronous padding: Using asynchronous operations to ensure that timing-sensitive code does not complete immediately, and instead waits for a consistent time window.

The core idea is to make the execution time of sensitive operations appear uniform, even if the underlying logic varies. This is particularly useful in cryptographic or authentication functions where timing leaks can be exploited to perform credential guessing or data inference attacks.

Quick Reference

Basic Example

This example demonstrates a basic timing guard applied to a function that checks a password. It ensures that the comparison takes a fixed amount of time, regardless of whether the password matches.

function checkPassword(input) {
  const correct = "secret123";
  let result = true;
  const startTime = Date.now();
  const delay = 100; // Fixed delay in milliseconds

  for (let i = 0; i < correct.length; i++) {
    if (input[i] !== correct[i]) {
      result = false;
    }
  }

  // Pad execution time to a fixed value
  const elapsed = Date.now() - startTime;
  if (elapsed < delay) {
    const wait = delay - elapsed;
    const start = Date.now();
    while (Date.now() - start < wait) {}
  }

  return result;
}

The important lines in this example are the fixed delay loop and the padding logic. The while loop ensures that even if the password is incorrect, the function will take at least 100 milliseconds to complete, making timing analysis ineffective.

Production Example

This more realistic example shows a timing guard applied to a function that performs a cryptographic hash comparison. It ensures that the comparison takes a consistent amount of time, even when the inputs differ.

async function compareHashes(inputHash, expectedHash) {
  const startTime = Date.now();
  const minDelay = 50; // Minimum delay in milliseconds
  let result = true;

  // Simulate cryptographic comparison
  if (inputHash.length !== expectedHash.length) {
    result = false;
  } else {
    for (let i = 0; i < inputHash.length; i++) {
      if (inputHash[i] !== expectedHash[i]) {
        result = false;
      }
    }
  }

  // Pad to ensure consistent timing
  const elapsed = Date.now() - startTime;
  const padding = Math.max(0, minDelay - elapsed);
  await new Promise(resolve => setTimeout(resolve, padding));

  return result;
}

This version is more suitable for production because it uses asynchronous padding and handles edge cases such as mismatched lengths. It also avoids blocking the main thread with busy loops, using setTimeout to ensure the UI remains responsive.

Common Mistakes

• Using unpredictable delays: Introducing truly random delays can lead to inconsistent performance and unpredictable behavior, defeating the purpose of a timing guard.
• Overhead without benefit: Adding excessive delays or padding can degrade performance significantly, especially in high-frequency operations.
• Not accounting for all branches: If only some paths are padded, attackers can still distinguish between them based on timing differences.
• Ignoring asynchronous behavior: Failing to consider that some operations are asynchronous can lead to incorrect timing guards that do not actually protect the code.
• Using busy loops instead of timeouts: Busy loops can block the main thread and cause performance issues, especially in browsers or environments with limited resources.

Security And Production Notes

• Consistent execution time: Timing guards must ensure that all execution paths take approximately the same time, not just average time.
• Minimal overhead: The padding introduced by timing guards should be small and predictable to avoid noticeable performance impact.
• Thread safety: In multi-threaded environments, timing guards must not interfere with other concurrent operations.
• Testing and validation: Timing guards should be tested under realistic conditions to ensure they do not introduce bugs or regressions.
• Compatibility: Timing guards must work consistently across browsers and JavaScript environments, especially when using setTimeout or Promise constructs.

Related Concepts

Timing guards are part of a broader set of anti-timing attack techniques. They are closely related to:

• Side-channel resistance: A general term for techniques that prevent attackers from inferring information through indirect means, including timing, power consumption, or electromagnetic emissions.
• Obfuscation: The practice of making code harder to understand, which includes timing guards as a subset of anti-analysis techniques.
• Constant-time algorithms: Algorithms designed to execute in the same amount of time regardless of input, a goal that timing guards often help achieve.
• Cryptographic best practices: Timing guards are often used in cryptographic implementations to prevent timing attacks on functions like hash comparisons or key derivations.
• Security hardening: A broader approach to securing applications, which includes using timing guards as one of many defensive measures.

Further Reading

• MDN Web Docs
• WHATWG HTML Standard
• OWASP Timing Attack
• Constant-Time Algorithms
• JavaScript Standard Style Guide