Shield.
Trust center · Security overview

Security at Shield

Shield is built around a simple principle: the safest data is the data we don’t have. The source code you submit for obfuscation never lands on disk, and the rest of what we store is the minimum needed to run your account.

Source code never stored at restTLS 1.2+ on every endpointPasswordless magic-link sign-inSingle-session anti-account-sharingAudit log of every obfuscation

At a glance

This page describes Shield’s security posture in concrete detail. Each section answers a question you or your security team are likely to ask. If something is unclear, missing, or feels light, mail and we’ll respond within one business day.

What we store

Account metadata, plan + subscription status, aggregate usage counts, opaque API key hashes, tamper-event reports. Nothing else.

What we never store

The source code or HTML you submit for obfuscation. The protected output. Your card number. Any data not strictly required to run your account.

Where it runs

A DigitalOcean server in San Francisco, behind Cloudflare. Managed PostgreSQL, encrypted at rest. The app runs in an isolated container with a read-only filesystem; every deploy is health-checked and rolls back on its own.

Where payments live

Stripe. Card data is collected by Stripe Elements directly inside their hardened iframe — it never touches our server. We see only the last 4 digits and brand.

How we handle your data

Our data minimization is deliberate. Every byte we hold is a byte that could be lost, leaked, or subpoenaed. We hold as little as possible to make Shield work.

Data we store

WhatDetailWhy
Account identifierUUID, email, display name, username, optional avatar. Sign-in is passwordless — no password is used to authenticate.Authenticate you (via one-time email links) and address you correctly.
Plan & subscriptionPlan ID, subscription status, period dates, cancel-at-period-end flag — synced from Stripe via webhooksEnforce quotas and surface your billing state.
Usage metadataPer-obfuscation: timestamp, kind (JS/HTML), strictness level, byte counts, duration, anonymized 16-char IP hash. Bucketed per (user, calendar month).Quota accounting and the History view.
API key hashesSHA-256 of the secret portion only. The plaintext key is shown exactly once at creation time.Authenticate API requests without recoverable storage of secrets.
Telemetry eventsWhen you set a telemetry URL: reason code (integrity / debugger / headless / etc.), coarse geo, 16-char IP hash, user-agent substring. Hard-capped at 10,000 events per account; older events evicted automatically.Power the threat-intel dashboard.
GitHub connectionOptional. Your Personal Access Token, encrypted at rest with envelope encryption + AES-256.GitHub round-trip integration on Pro+ plans.
Stripe customer IDA pointer (cus_...) into Stripe. No card data ever stored on our side.Tie Shield account to Stripe customer.
Session recordsRandom 64-char session ID, user agent string, anonymized IP hash, last_seen timestamp. Hard expiry 30 days; idle expiry 10 minutes.Single-session policy enforcement.

Data we never store

  • Source code submitted for obfuscation. Processed in-memory in the obfuscation engine and discarded when the HTTP response completes.
  • Obfuscated output. Same path: returned to you in the response, not retained.
  • Card numbers, CVCs, expiry dates. Collected by Stripe Elements in a domain-isolated iframe; we receive only a tokenized PaymentMethod ID.
  • Plaintext API keys. Hashed at creation; the plaintext appears once on the screen and is then gone forever.
  • Passwords. Sign-in is passwordless — we don’t use or store account passwords at all.
  • Raw IP addresses. Hashed to a 16-character SHA-256 prefix at the moment of capture. The raw IP is not stored or logged.
Right of access & deletion: you can delete your account at any time from Dashboard → Profile. We retain billing records as legally required and a hashed copy of your prior email to prevent abuse re-registration. See our Privacy Policy for the complete data lifecycle.

We do not store your code

This is the question we’re asked most. The answer: source code submitted to Shield is processed in-memory and never written to disk or any database.

Concretely, the lifecycle of a single obfuscation request is:

  1. HTTPS request arrives at Cloudflare’s edge and is forwarded through an encrypted tunnel to our server and the Node.js service
  2. The service parses the JSON body into a JavaScript string in memory
  3. The obfuscation engine runs in a worker thread (off the main event loop, so one job can’t stall the service). AST parsing, transforms, defense injection — all in memory.
  4. The protected output string is JSON-encoded into the HTTP response
  5. The response is flushed to the network
  6. The strings are garbage-collected when the request handler returns

Only the metadata of the request — timestamp, kind, level, byte counts, duration, anonymized IP hash, your user ID — is persisted to the audit log table. The source and output bytes are not.

This is verifiable against our source code. The relevant endpoint handlers (e.g. app/api/obfuscate/route.ts) hold the source in a parameter, pass it through the engine (in a worker thread), return the result, and do not write it. We are happy to walk through this with your security team on request.

Account & authentication

Passwordless sign-in

Shield uses passwordless, magic-link authentication for every account — administrators included. To sign up or sign in you enter your email and receive a unique one-time link; clicking it confirms the address and starts your session. There is no password anywhere to leak, phish, guess, or reuse. Link tokens are 32 bytes of randomness, stored only as a SHA-256 hash, single-use, and expire in 20 minutes.

Sessions

Login creates a DB-backed session record with a cryptographically random 64-character session ID. AHttpOnly, SameSite=Lax, Secure cookie carries the ID; everything else (user_id, expires_at, user_agent, anonymized ip_hash, last_seen_at) lives in the database. Hard expiry: 30 days. Idle expiry: 10 minutes (rolling — any authenticated request slides the window).

Single-session anti-account-sharing: every successful login deletes all other sessions for that user. Two devices cannot be logged in simultaneously. Designed to deter password sharing across organizations.

API keys

Each key is a 32-byte random token, base-prefixed withshield_. We store the SHA-256 hash of the secret portion only. The plaintext key is rendered to your browser exactly once — at creation — and then irretrievable. Lost keys cannot be recovered; they must be re-generated. Revoke any time from Dashboard → API keys.

Signup abuse prevention

Because sign-in is passwordless, every account is provably tied to a reachable inbox. On top of that we reject disposable / temporary-mail domains at signup, and collapse the Gmail dot/“+tag” aliases that resolve to one mailbox so a single inbox can’t farm multiple free accounts. An input passing these checks still has to click a live email link before it can use the tool.

Encryption

In transit

Every endpoint serves over HTTPS. TLS is terminated and certificates are provisioned and rotated automatically by our managed edge; plain HTTP is redirected to HTTPS. The app publishes Strict-Transport-Security with a two-yearmax-age, includeSubDomains, and preload, alongside a set of hardening headers on every response: X-Frame-Options: DENY (anti- clickjacking), X-Content-Type-Options: nosniff, a strict Referrer-Policy, and a locked-down Permissions-Policy.

At rest

The PostgreSQL database is a DigitalOcean managed database, encrypted at rest, and its off-site backups are encrypted before they leave our server. Application secrets (Stripe keys, email keys, the token-encryption key) are kept on the server in files only the service can read and are handed to it at start-up — never in the code repository. Avatar images are stored in PostgreSQL, so the application keeps no local filesystem state.

Application-level protection is applied to sensitive values on top of storage encryption:

  • API keys: SHA-256 hash (one-way)
  • Magic sign-in link tokens: SHA-256 hash, single-use, 20-minute TTL
  • GitHub PATs: AES-256-GCM (fails closed if the encryption key is unset — never stored in plaintext)
  • Session IDs: not encrypted (entropy is the protection — 256 bits)

In memory

Sensitive values are not logged. The obfuscation engine receives source code strings and discards them when the request completes; we do not write them to stdout, stderr, or the database. Process memory is not deliberately zeroed (Node’s GC handles reclamation), which is a known trade-off documented here for completeness.

Application security

  • Input validation: every public API endpoint validates its request body against a Zod schema before any logic runs; mismatches return a 400 with no further processing. User-facing validators (e.g. email format) use linear, backtracking-safe patterns to avoid regular-expression denial-of-service.
  • CSRF protection: the GitHub OAuth flow rotates a single-use CSRF token via HttpOnly cookie. Stripe checkout calls use session authentication; no cross-site form posts are accepted.
  • Rate limiting: the public playground (/api/try) enforces a per-IP quota (5 / hour, 2 / minute, hashed IP). Login is throttled per-IP and per-identifier (DB-backed, checked before any expensive work); sign-up, magic-link requests, and password-reset requests are throttled to prevent email bombing and mass-account creation. Authenticated APIs are additionally gated by monthly plan quota.
  • Dependency scanning: GitHub Dependabot is enabled against our main repository. Vulnerable dependencies generate PRs we triage within one business day for high severity.
  • Secret management: secrets live in the platform’s encrypted environment variables, injected at runtime and never committed to git. Stripe keys, the webhook secret, the email API key, and the token-encryption key are never logged.
  • Security headers: HSTS (2-year, preload), X-Frame-Options: DENY,X-Content-Type-Options: nosniff, a strict referrer policy, and a restrictive permissions policy are served on every response.
  • Isolation & availability: the CPU-bound obfuscation engine runs in a pool of worker threads, so a large job can never stall the main event loop or make the service unresponsive to other users.
  • Change management: every code change is in git history with author + timestamp. Each push is built, smoke-tested and scanned for known vulnerabilities before it deploys; database migrations run first and abort the release on failure, and a release that fails its health check is rolled back automatically.
  • Backups: PostgreSQL is continuously backed up with point-in-time recovery, plus nightly encrypted off-site backups we control. A restore of the latest backup is tested automatically every week.

Infrastructure

Shield runs on a DigitalOcean server in San Francisco behind Cloudflare, with DigitalOcean Managed PostgreSQL. DigitalOcean holds SOC 2 Type II and SOC 3 reports and its data centers are ISO 27001 certified; Cloudflare holds SOC 2 Type II and ISO 27001, 27018 and 27701. These are our providers’ certifications (see the note under Compliance). The stack:

LayerTechnologyRole
Edge / TLSCloudflareHTTPS termination, DDoS and bot protection, encrypted tunnel to the server (no open web ports)
App runtimeNode 22 + Next.js 15Application server + dashboard (auto-deployed from git)
ObfuscationWorker-thread poolCPU-bound engine, isolated off the main event loop
DatabaseDigitalOcean Managed PostgreSQLUsers, sessions, subscriptions, usage logs, telemetry, API key hashes, avatars; encrypted at rest, point-in-time recovery, nightly encrypted off-site backups
ComputeDigitalOcean server, isolated containerSingle-region, read-only filesystem, no local data, health-checked deploys with automatic rollback

Single-region by design: we run in one region for predictable latency and a simpler footprint. Multi-region failover is on the Enterprise-tier roadmap.

Subprocessors

These are the third-party services Shield uses to operate. Each is a tier-1 vendor with their own current compliance attestations:

Payment processing, billing, customer portal

Data shared: Tokenized card / PaymentMethod IDs only — full card numbers never reach Shield. Customer email + name + Stripe customer ID.

PCI DSS Level 1SOC 1 Type IISOC 2 Type IIISO 27001
DigitalOcean
Trust page
The server Shield runs on and the managed PostgreSQL database (United States)

Data shared: Everything the application stores: the PostgreSQL database (accounts, sessions, subscriptions, usage, avatars) and runtime logs.

SOC 2 Type IISOC 3ISO 27001 (data centers)
Cloudflare
Trust page
Network edge: DNS, HTTPS termination, DDoS and bot protection

Data shared: All traffic to and from Shield, in transit — including code you submit, on its way to our server. Shield does not cache API traffic at the edge.

SOC 2 Type IIISO 27001ISO 27018ISO 27701
Backblaze
Trust page
Off-site storage of database backups

Data shared: Database backups encrypted before they leave our server (AES-256, key held only by us). Backblaze cannot read them.

SOC 2 Type II
Transactional email (magic sign-in links, email verification, password reset)

Data shared: Recipient email address and the message content (which contains a one-time link). No source code or billing data.

SOC 2 Type II
GitHub (Microsoft)
Trust page
Our source-code repository; optional customer repo integration (Business/Unlimited)

Data shared: Our own source code (private repo). For customers who opt in, a GitHub access token (encrypted at rest) used to read/write files in their repositories.

SOC 1 Type IISOC 2 Type IIISO 27001ISO 27017ISO 27018

We do not use an analytics provider or a CRM. If we add a new subprocessor, this list will be updated and any change communicated to existing customers with 30 days’ notice.

Compliance & certifications

We are transparent about where we are in the formal compliance lifecycle. Our security posture is mature; formal attestations are an ongoing investment.

Provider vs. Shield certifications. Shield runs on DigitalOcean (SOC 2 Type II and SOC 3; ISO 27001 data centers) behind Cloudflare (SOC 2 Type II; ISO 27001, 27018 and 27701). Those are our infrastructure providers’ certifications, and Shield inherits the underlying controls they cover. They are not a certification of Shield itself — a certification like SOC 2 or ISO 27001 attests to our own organization’s controls and is issued only after an audit of Shield. The statuses below reflect Shield’s own state accurately.
SOC 2 Type II
Not currently attested

Our hosting provider and network edge are themselves SOC 2 Type II attested — provider controls we build on, not a Shield attestation. Shield has no third-party SOC 2 report of its own yet: our data minimization (no customer source code stored, payments offloaded to Stripe) keeps the audit scope small, and we pursue Type I scoping when a specific enterprise prospect requires it.

GDPR
Aligned

EU customers are supported. We act as data processor for any personal data you provide. Data subject access requests can be made via our contact form and are answered within 30 days. See Privacy Policy.

CCPA / CPRA
Aligned

California consumers have the same rights of access, deletion, and correction. Sale of personal information: we do not sell.

PCI DSS
Out of scope

Card data is collected by Stripe Elements directly in their hardened iframe and never touches our server. Stripe is PCI DSS Level 1 certified. The applicable Stripe SAQ-A pattern means our PCI scope is effectively zero.

HIPAA
Not applicable

Shield is a code-obfuscation tool and does not handle Protected Health Information. Our Terms prohibit submitting PHI or other regulated data, and we do not sign Business Associate Agreements. Do not use Shield for data subject to HIPAA.

ISO 27001
Not currently certified

The data centers and network we run on are ISO 27001 certified — provider certifications, not Shield’s own. Shield’s own certification is on the same roadmap as SOC 2, pursued when a specific Enterprise lead requires it.

If your organization requires a specific compliance artifact to evaluate Shield, please contact with the requirement and timeline.

Incident response

We follow a documented incident response process. The abbreviated version:

  1. Detect. Through monitoring, vulnerability disclosure, or customer report.
  2. Triage. Within one business hour of detection, classify severity (P0 — service down or data exposure; P1 — degraded; P2 — non-urgent).
  3. Contain. P0 / P1 incidents trigger immediate mitigation (block, rotate, take offline). Where customer credentials may be involved, we invalidate sessions.
  4. Eradicate & recover. Apply fix, restore service, validate.
  5. Notify. Affected customers receive direct email notification within 72 hours of incident confirmation. If the incident involves unauthorized access to personal data, we notify regulators where required by GDPR / CCPA.
  6. Post-mortem. A blameless post-mortem within 14 days of closure, with action items tracked to completion.
Status page: We do not currently operate a public status page. For any sustained service degradation, watch our support channel for proactive customer email.

Report a vulnerability

We welcome coordinated vulnerability disclosure. If you believe you’ve found a security issue in Shield, please contact us before publishing or sharing details:

Security contact
  • · We acknowledge reports within one business day.
  • · Triage and severity assessment within five business days.
  • · We will not pursue legal action against good-faith researchers acting under coordinated disclosure.
  • · Public credit on this page (with your consent) for valid, in-scope reports.

Out of scope

  • Reports purely about missing security headers on marketing pages
  • Self-XSS that requires the victim to paste hostile code into their own console
  • Social engineering of Shield staff
  • DoS / volumetric attacks
  • Findings on third-party services (report those to the relevant vendor)
  • Theoretical concerns without a reproducible exploit

We do not currently offer a paid bug bounty. We acknowledge publicly and credit researchers who help us in good faith.

Shared responsibilities

Security is a shared-responsibility model. The table below lists what we do and what we expect you to do.

TopicShield’s responsibilityYour responsibility
Account accessPasswordless one-time links, per-IP + per-account rate limiting, 10-minute idle logoutKeep your email account secure (it is the key to sign-in); enable 2FA on your inbox
API keysHashed at rest; one-time display at creationStore in your secret manager (1Password, env vars). Rotate when teammates leave.
Account sharingStrict single-session enforcementDo not share login credentials. Each user gets their own account.
GitHub PAT (Pro+)Encrypted at rest; revocable from dashboardUse a fine-grained PAT scoped to only the repos you intend to obfuscate. Revoke from GitHub anytime.
Telemetry endpoint URLPer-account, opaque token in the URLTreat as semi-secret. If leaked, attackers could spoof tamper events on your dashboard.
Obfuscation strictness selectionEngine ships every defense; sensible Hard preset by defaultMatch strictness to the value of what you're protecting. Test in a real browser before shipping production code.

Last reviewed: October 2026. This page is versioned in git and updated whenever our posture changes.

Security · Shield