xGhost: Ephemeral Algorithm Protection

The Problem

When you ship code to customers, you lose control of it. Obfuscation is reversible. DRM is crackable. License keys are shareable. JavaScript is readable. Your algorithm — your core IP — becomes their property the moment it leaves your server.

Software vendors face an impossible choice: keep your algorithm on your server (adding latency, requiring connectivity, creating a single point of failure) or ship it to customers (and accept that it will be reverse-engineered, copied, and redistributed).

Current protection approaches all fail at the architectural level. Obfuscation makes code harder to read but doesn't prevent execution analysis. Hardware dongles add friction. License servers can be spoofed. Code signing proves origin but doesn't prevent copying. None of these provide cryptographic guarantees.

The Old Way

The PRIVATE.ME Solution

xGhost splits your compiled algorithm into XorIDA shares at build time. The customer installs Share 1 — which is cryptographic noise. Share 2 stays on your server. At runtime, per-call reconstruction assembles the code in memory for ~50 microseconds, executes it, and purges it. The algorithm ghosts in and out of existence.

Share 1 alone reveals zero information about your algorithm. Not obfuscated code — actual noise. Information-theoretically. A customer who copies their node_modules/ directory copies noise.

The 30-second xLink heartbeat ensures continuous authorization. Every 30 seconds, the SDK confirms the customer's DID is valid and their subscription is active. No payment → no Share 2 → no code → nothing runs.

The New Way

Three Tiers

xGhost offers three protection levels. Each uses our own cryptographic infrastructure — XorIDA, xLink, xPass, and xCompute — composed to match the threat model.

Tier 1: xGhost Basic

Your algorithm is XorIDA-split at build time into 2-of-2 shares. Share 1 ships in the npm package — it's cryptographic noise. At each function call, the SDK fetches Share 2 from your server via xLink (encrypted, DID-authenticated, 30s timestamp-bound). XorIDA reconstructs the code in memory, executes the function, and immediately purges the reconstructed code. The entire cycle takes ~50 microseconds.

Tier 2: xGhost Secure

Adds xPass MPC session binding. The server participates in a 3-party MPC session establishment — even if an attacker intercepts Share 2, it's bound to a session key that requires the server's cooperation. Session keys expire with each 30-second heartbeat cycle.

Tier 3: xGhost Zero

The algorithm never exists on the customer's machine in any form. Instead, the customer provides their data as shares, and xCompute performs the computation via MPC. The customer gets results; the server keeps the algorithm. For XorIDA-based operations (all XOR gates), MPC communication overhead is zero — Class 1 gates are free by GF(2) linearity.

How It Works

The xGhost protection stack combines four PRIVATE.ME ACIs. Each layer adds defense. Together, they create cryptographic enforcement that cannot be bypassed by code theft.

Per-Call Execution Flow (xGhost Basic)

// Customer calls the protected function:
const result = await ghostedAlgorithm(inputData);

// Under the hood (SDK handles automatically):
// t=0.000ms  Check 30s heartbeat cache (is DID still authorized?)
// t=0.001ms  Pull Share 2 from local cache (pre-fetched via xLink)
// t=0.035ms  XorIDA reconstruct (Share 1 + Share 2 → code)
// t=0.050ms  Execute function with input data
// t=0.086ms  Purge reconstructed code from memory
// t=0.087ms  Return result to customer
//
// Total: ~87µs. Code existed for ~50µs.

Use Cases

Integration

import { ghostBuild } from '@private.me/xghost';

// Your algorithm source code
const source = new TextEncoder().encode(algorithmSource);

// Split into XorIDA shares
const result = await ghostBuild({
  source,
  exports: ['matchClaims', 'scoreRisk'],
  heartbeatIntervalMs: 30_000,
});
// result.customerShare → ship to npm (cryptographic noise)
// result.vendorShare   → keep on your server
// result.manifest      → ship alongside customerShare

import { createGhost } from '@private.me/xghost';

// Initialize with customer share + heartbeat server
const ghostResult = await createGhost({
  customerShare,           // from npm install
  manifest,                // from npm install
  server: heartbeatClient, // HeartbeatServer implementation
  did: 'did:key:z6Mk...',  // customer's DID identity
});
if (!ghostResult.ok) throw ghostResult.error;
const ghost = ghostResult.value;

// Call the ghosted function — per-call reconstruct + purge
const result = await ghost.call('matchClaims', claimsData);
// Algorithm existed in memory for ~50µs, then purged
// Audit log: ghost.getAuditLog() → tamper-evident HMAC chain

Deployment Models

xGhost ships three deployment models. Same technology, different trust boundaries. Choose based on where the algorithm executes and who controls the infrastructure.

How Each Model Maps to Tiers

Enhanced Identity with Xid

xGhost can optionally integrate with Xid to enable unlinkable algorithm execution — verifiable within each runtime context, but uncorrelatable across invocations, tenants, or time.

Three Identity Modes

How Ephemeral Execution Identity Works

// Initialize xGhost with Xid integration
import { createGhostRuntime } from '@private.me/xghost-cli';
import { XidClient } from '@private.me/xid';

const xid = new XidClient({ mode: 'ephemeral' });
const runtime = createGhostRuntime({ identityProvider: xid });

// Each invocation derives unlinkable DID automatically
const result = await runtime.execute('tradingAlgo', { symbol: 'AAPL' });
  → [xGhost] Deriving ephemeral DID from master seed...
  → [xGhost] DID: did:key:z6MkD... (unique to this execution + tenant + epoch)
  → [xGhost] Reconstructed code with ephemeral identity (~50µs)
  → [xGhost] Executed algorithm, purged code (<1ms exposure)

// Execution is audited with unlinkable DID
// Verification works within tenant, but cross-tenant correlation fails

Market Positioning

Key Benefits

• Cross-tenant unlinkability — Can't track executors across customers
• Per-invocation derivation — Same executor has different DIDs per call
• Epoch rotation — DIDs automatically rotate daily/weekly/monthly
• Split-protected derivation — Master seed is XorIDA-split, never reconstructed
• IP protection — Execution identity bound to algorithm without exposing plaintext
• Audit without surveillance — Verifiable logs without cross-context correlation

Enterprise Toolkit

xGhost Enterprise ships as a complete self-hosted package. @private.me/xghost-cli provides the CLI, reference heartbeat server, RBAC, Docker deployment, and end-to-end tooling — everything needed to protect your first algorithm in minutes.

CLI Commands

# Split your algorithm into XorIDA shares
xghost build --source algo.js --exports "score,classify" --output ./artifacts/
  → customer-share.json, vendor-share.json, manifest.json

# Start the reference heartbeat server
xghost serve
  → HTTP server on :3100 with RBAC + JSONL stores

# Verify an exported purge audit log
xghost verify --audit-log ./audit.json
  → Replays HMAC chain, reports integrity

# Inspect a manifest
xghost inspect --manifest ./manifest.json
  → Magic, version, threshold, exports, heartbeat interval

Reference Heartbeat Server

Built on Node.js built-in http module — zero external dependencies. Seven endpoints: heartbeat, algorithm upload, license CRUD, audit log, health check. Vendor shares encrypted at rest with AES-256-GCM (key from env var or KMS).

3-Role RBAC

Docker Deployment

Multi-stage Alpine build. Non-root user. Read-only filesystem. Health checks. docker compose up and your heartbeat server is running. Air-gapped deployment supported via docker save/load.

Security Properties

Competitive Comparison

Benchmarks

Performance characteristics measured on Node.js 22, Apple M2. The complete ghost lifecycle — build, create, call, purge — completes in under 2 milliseconds.

Algorithm Protection Comparison

Ship Proofs, Not Source

xGhost generates cryptographic proofs of correct execution without exposing proprietary algorithms. Verify integrity using zero-knowledge proofs — no source code required.

Use Cases

Honest Limitations

Five known limitations documented transparently. xGhost provides practical algorithm protection with explicit constraints.

Verifiable Algorithm Protection

Every ghosted execution produces a verifiable audit trail via xProve. HMAC-chained integrity proofs confirm that the algorithm was reconstructed correctly, executed faithfully, and purged completely.

Ready to deploy xGhost?

Talk to Sol, our AI platform engineer, or book a live demo with our team.