Josh Sisto secures systems, networks, and AI pipelines.

Cybersecurity professional first, builder second. This page is the live demo — a locked-down AI pipeline (a local LLM behind a gated proxy), real-time visitor-recon receipts, browser-side PGP, and a sandboxed Linux box you can boot right here.

Solve the human check to bring him up.

Live demo: browser signal check → PHP gate → streamed AI.

The human check and chat run on JavaScript. With it off, reach Josh through the published identity links below — security.txt lists his contact address.

Solve the check below to reveal it.

What this page reads about your browser

To run the human check and power the chat, this page reads basic, header-level details your browser already sends — screen size, language, timezone, coarse hardware — and sends them only to Josh's local bot, kept for your session and never sold.

The deeper "what your browser leaks" demo — canvas and WebGL hashes, an audio fingerprint, installed fonts — is opt-in: unlock the chat, open "What I can already see about you", then press Reveal to run it.

Optional — saves your chat history and lesson progress. Works with Gmail or any email.

Hands-on

Labs — live tools you can run now

Break the bot, boot a throwaway box, and audit a real domain. Everything here is sandboxed — nothing you do touches Josh's systems.

Meet the Gatekeeper

Tools the bot can actually run

It isn't just a chatbot — it drives a fixed, read-only toolkit of SSRF-hardened recon and offline decoders against Josh's own engine (the same one behind the "audit your domain" box). Tap any tool to watch it run in the chat above.

Recon & posture

Attack surface

Email & identity

Decode & crack

This server & guardrails

Red-team the Gatekeeper

Try to jailbreak the bot — or ask how it's fenced in

Its rules live in a server-side prompt your browser never sees, behind a same-origin gate and per-IP caps — and there are no secrets in it to spill (Josh's real infrastructure isn't in there). It held every attack in a 24-shot red-team pass. Tap one and watch it hold, or have it walk you through its own guardrails:

Pass the human check above first — then these run in the live chat. Actually land a leak? Josh wants to hear about it: [email protected].

Live tool — a real shell, fully sandboxed

Boot a throwaway Linux box

Drop into a real, interactive Linux shell — a fresh container that self-destructs the moment you leave. No route to the LAN or internet (by design), unprivileged, on an isolated throwaway VM, capped on CPU, memory, processes, and time. Break it, wipe it — nothing you do here touches Josh's systems.

Tap a scenario to boot straight into it:

Tap a tile above to boot straight into that scenario, or use this button to open the interactive picker. Pass the human check above first. Sessions run ~10 minutes and are limited — be kind to the next visitor.

Blue-team drill

Spot the phish

One call per email — legit or phish? You get the sender, the domain, and the Authentication-Results (SPF/DKIM/DMARC): the same signals email_posture checks. It all runs in your browser.

Score: 0 / 0

Live tool — try it on your own domain

Audit a domain's security posture

Type any public domain and I'll run a read-only external audit — DNSSEC, SPF/DMARC/CAA, TLS version and certificate, and HTTP security headers — then grade it. The scanner is deliberately hardened against SSRF: it refuses IP literals, internal names, and any domain that resolves to a private or reserved address.

Don't trust — verify

Trust — check every claim yourself

Josh's published cryptographic identity, this domain's independently-verifiable posture, and how the whole pipeline is fenced in.

Built like a portfolio piece

What this page is quietly flexing

Streaming AI, fenced in

A same-origin PHP proxy gates every request, rate-limits abuse, clamps history, and streams tokens without exposing the LAN model.

Recon with receipts

IP, VPN flags, user agent, TLS, timezone, screen, and privacy headers are surfaced transparently instead of being hidden in logs.

Crypto-native contact

The page publishes identity material and encrypts sensitive messages to Josh's PGP key in the browser.

Operator habits

The public gag is backed by documented nginx routing, runbooks, challenge logic, and defensive defaults.

Defense in depth

How this AI is fenced in

Every request crosses the same walls, in order. The model never touches the network directly — it can only ask the server to run a fixed, validated set of read-only tools, and a container escape lands on a throwaway box with no route anywhere.

The chat, gated end to end

Your browser same-origin fetch

nginx · TLS strict CSP · rate zone

chat.php gate human check · per-IP cap · hidden prompt · tool allow-list

Local model on the LAN · never exposed

The throwaway box, on a capability bus

Sandbox box --network none

unix socket reverse SSH tunnel

Broker fixed verb allow-list · rate-limited

Recon engines SSRF-hardened · read-only

Same idea in both lanes: the untrusted side (your browser, or a hostile container) can only reach a narrow, validated door — never the model, the LAN, or Josh's origin directly.

Don't trust — verify

Security receipts for this domain

Every line here is observable from the open internet — run the commands and check for yourself.

DNSSEC, validating

Signed with algorithm 13 (ECDSA P-256); public resolvers return the Authenticated-Data flag.

dig +dnssec joshsisto.com

TLS 1.2 / 1.3 only

TLS 1.0/1.1 refused, X25519 forward secrecy, HSTS for two years including subdomains.

nmap --script ssl-enum-ciphers -p443 joshsisto.com

Locked-down headers

CSP default-src 'none', nosniff, SAMEORIGIN, and a denied Permissions-Policy.

curl -sI https://joshsisto.com

Mail + CA hardening

SPF and DMARC (p=quarantine) published, CAA restricts issuers, mail on ProtonMail.

dig TXT _dmarc.joshsisto.com +short

Signed identity

A PGP-clear-signed security.txt and published SSH keys verify my signed files and commits.

ssh-keygen -Y verify -f allowed_signers

No inline scripts or styles

This page runs zero inline JavaScript and zero inline CSS — its CSP script-src and style-src both drop 'unsafe-inline'.

curl -sI https://joshsisto.com | grep -i content-security

Cloudflare edge

Served through Cloudflare's global edge — DDoS absorption, TLS, and DNSSEC-signed DNS in front of a hardened origin the internet never touches directly.

curl -sI https://joshsisto.com | grep -i cf-ray

CrowdSec + fail2ban

Behavioral detection auto-bans hostile IPs at the host; the masked tally (scenarios, countries, networks — no IPs) is published live on this page.

curl -s https://joshsisto.com/attack-stats.json

Verify it's really me

Don't take a chatbot's word for it — here's my published cryptographic identity, all in one place.

PGP key fingerprint

294C DF7C 8D18 ABDD 5B8A 0DAA 8CDB 89F8 30BC 60EA

A fingerprint is a short hash of my public key. If a key shows this fingerprint everywhere you look, it's mine.

Don't take my word for any of it — prove it live. The panel below runs five independent checks in your browser against this key, then turns the same lens on you.

Prove it's really me — five ways

Send an encrypted message

Encrypted in your browser with my PGP key — the plaintext never leaves this page. Send the ciphertext straight to me (my server relays it without ever being able to read it), or copy it into your own email.

Full-circle identity proof

Prove it's really me — five independent ways

Every check runs in your browser against my published PGP key — nothing to install, nothing trusted on my word. Work down the list; each one should land on the same fingerprint.

One fingerprint, every source 294C DF7C 8D18 ABDD 5B8A 0DAA 8CDB 89F8 30BC 60EA

0 of 5 checks verified

A message I clear-signed

A short statement I signed with my private key. If it verifies against my public key, only my key could have produced it — and not one byte changed.
My live, signed security.txt

This fetches the real /security.txt (RFC 9116, PGP-clear-signed) and verifies its signature here — proof the file served right now is mine and unaltered.
Auto-discovered by email (WKD)

The Web Key Directory standard lets anyone find my key straight from my address — exactly what gpg --locate-keys [email protected] does. It pulls the key from /.well-known/openpgpkey and checks the fingerprint.
Every source, one fingerprint

This reads the key from pgp.txt, computes its fingerprint in your browser, and confirms it matches the one printed above and the key WKD returned. One key, everywhere you look.
Off my infrastructure entirely

Don't just trust checks hosted on my page. These read the same key from services I don't run — open either and confirm the fingerprint yourself.

keys.openpgp.org Keyoxide

Full circle

Now turn the lens on yourself

You just verified me. The Gatekeeper can run that same published-key discovery on any domain — point pgp_check at yours and watch it do to you what you just did to me.

Learn by doing

Playground — public-key crypto, hands-on

Generate keys, sign and verify, encrypt and decrypt — all in your browser. Nothing is uploaded.

Public-key crypto, hands-on

Verify my signature, then learn how it works by doing it — keys are generated and used entirely in your browser. Nothing is uploaded.

A keypair is a public key you hand out and a private key you guard. The public key locks (encrypts) and checks signatures ; the private key unlocks (decrypts) and signs . Try each piece below.

1 My key & fingerprint

The very key the encrypt box above uses. A fingerprint is a short hash of a public key — compare it across sources (this page, my pgp.txt , a keyserver) to be sure a key is really mine.

2 Verify a signed message

Paste a PGP clear-signed message — if it checks out, the signer's private key made it and not one byte changed. Hit the button for a statement I signed with my key (proof it's really me), or verify one you make in steps 3–4.

Use a different signer's public key

3 Make your own keypair

Generated in your browser — nothing leaves this page. This is a throwaway demo key for learning, not your real identity; for keys you'll actually rely on, make them offline in GnuPG. Guard the private key and its passphrase; the public key is yours to share.

4 Sign & verify with your key

Sign with your private key; anyone verifies with your public key. (Generate a keypair in step 3 first.)

5 Encrypt & decrypt (round-trip)

Encrypt to your public key, then decrypt with your private key + passphrase. This is exactly what the “Send an encrypted message” box does with my key — only the private key can open it.

The range, at a glance

Skills constellation

A star map of what Josh works across — hover to drift it; tap a star to jump to that part of the page.