Why the Mutation Algorithm is Documented (And Why It Makes Us Stronger)

Security Through Obscurity Is Not Security

When we documented the Pretense mutation algorithm in full, the first reaction from some advisors was: "Won't attackers just reverse your mutations if they can read the spec?"

The answer is no. And understanding why reveals something important about how Pretense actually works.

How Mutation Actually Works

The mutation algorithm takes an identifier name and produces a deterministic synthetic using a keyed hash:

function mutate(identifier: string, kind: 'fn' | 'v' | 'cls', key: string): string {
  // PretenseMut: key-seeded hash
  const hash = hmac(key, identifier).slice(0, 4);
  return `_${kind}${hash}`;

// With key "project-alpha-2025": mutate('getUserToken', 'fn', key) // -> _fn4a2b mutate('processPayment', 'fn', key) // -> _fn9k2m

// With key "different-key": mutate('getUserToken', 'fn', key) // -> _fn7x1q (completely different) ```

The algorithm is documented. The key is private. This is exactly how SSL/TLS works. The protocol specification is public. Your private key is private. Publishing the protocol does not help attackers break your encrypted traffic.

Why a Documented Algorithm Makes Us Stronger

**1. Security teams can audit it**

Security tools that are black boxes ask you to trust them. Tools with documented algorithms let you verify them. For an enterprise security product, auditability is a feature, not a liability.

**2. Trust through transparency**

A CISO evaluating Pretense can review the mutation engine documentation and understand exactly what it does. There are no hidden behaviors, no secret modes, no unexplained data collection.

**3. Accelerated enterprise procurement**

Large enterprises require code review before approving vendor tools. Enterprise customers can request a full technical security review session with our engineering team. A documented algorithm makes that review straightforward and accelerates procurement.

**4. The algorithm is not the secret**

The security guarantee does not come from hiding how mutation works. It comes from the mutation keys being generated locally and never transmitted. Knowing the algorithm without a key produces nothing useful.

What Stays Private

A documented algorithm does not mean everything is exposed:

- **Your mutation keys** — generated locally, never transmitted to Pretense servers - **Your mutation maps** — stored in .pretense/ on your machine - **Your audit logs** — local unless you enable SIEM export - **Your code** — never sent to Pretense infrastructure

The cloud service (dashboard, billing, compliance reporting) is commercial. The local-first protection layer is fully documented for enterprise security review.

The GitHub Copilot Comparison

GitHub Copilot is trained on code including potentially your code. The training process is opaque. You cannot audit what data was used or how the model uses your patterns.

Pretense's mutation engine is the opposite: fully documented, deterministic, with no training component that could absorb your code. The synthetic identifiers Pretense sends to LLMs are mathematically provably disconnected from your real identifiers without the key.

How to Verify the Mutation Engine

Enterprise customers receive a full technical documentation package. To verify the core claim — that mutations without the key are non-reversible — request a security review session and our team will walk through the full algorithm, key derivation, and audit logging with your security team.

[Request a security review](/early-access) | [Read the Technical Docs](/docs)