Security & Privacy

Generate strong, random passwords with customizable length, character sets, and complexity requirements.

Analyze password strength with entropy scoring, crack-time estimates, and improvement suggestions.

Create cryptographically random strings for API keys, tokens, salts, and unique identifiers.

Create QR codes for URLs, text, Wi-Fi credentials, vCards, and more with customizable size and colors.

Scan and decode QR codes from uploaded images or your device camera to extract embedded data.

Compute MD5, SHA-1, SHA-256, and SHA-512 checksums to verify file integrity and detect tampering.

Encrypt and decrypt text using AES-256, RSA, or other ciphers with password-based key derivation.

Create encrypted, self-destructing messages with expiration timers and single-view access links.

Generate a customizable privacy policy for your website or app covering GDPR, CCPA, and cookie disclosures.

Build a compliant cookie policy detailing cookie types, purposes, and user consent options.

Encrypted password storage using AES-256 with a master password. All data in localStorage - zero-knowledge, no server.

Hide secret text messages inside images using LSB encoding. Upload an image to encode or decode hidden text.

Generate TOTP codes from a secret key (RFC 6238). Verify codes and test your 2FA setup in real time.

Strip GPS coordinates and location data from photos for privacy protection.

Hide and extract secret text messages within image files using LSB encoding.

Calculate perceptual hash, MD5, SHA-256, and other hashes of image files.

Generate memorable passphrases from random words with customizable word count, separators, and capitalization.

Generate random PIN codes of configurable length with options to avoid sequential or repeated digits.

Check if a password has appeared in known data breaches using k-anonymity with the HIBP API hash prefix.

Generate random AES-128, AES-256, and RSA key pairs using the Web Crypto API for development and testing.

Generate MD5 hash digests from text or file input using client-side cryptographic operations.

Compute SHA-1 hash values from text or files entirely in the browser using the WebCrypto API.

Generate SHA-256 cryptographic hash digests from text or file input using the WebCrypto API.

Compute SHA-512 hash values from text or files with hex, base64, and binary output formats.

Generate SHA-384 cryptographic hashes from text or file input using the WebCrypto API.

Generate bcrypt password hashes with configurable cost factor and verify passwords against existing hashes.

Automatically detect and identify the type of a hash string (MD5, SHA-1, SHA-256, bcrypt, etc.) by analyzing its format.

Verify file or text integrity by comparing computed hash values against expected hash digests.

Generate HMAC (Hash-based Message Authentication Code) signatures using SHA-256, SHA-512, or SHA-1 with a secret key.

Calculate MD5, SHA-1, SHA-256, and CRC32 checksums for files to verify download integrity.

Compute cryptographic hash digests for files of any size using streaming WebCrypto operations with progress tracking.

Encrypt and decrypt text using AES-256-GCM with password-derived keys via PBKDF2, entirely in the browser.

Generate RSA key pairs and encrypt/decrypt messages using RSA-OAEP with the WebCrypto API.

Encrypt and decrypt files of any type using AES-256-GCM with password-based key derivation, processed entirely client-side.

Encrypt and decrypt text messages using multiple cipher algorithms including AES, ChaCha20, and Triple DES.

Generate PGP/GPG public and private key pairs with configurable key size and algorithm using OpenPGP.js.

Encrypt and decrypt messages using PGP public/private keys with OpenPGP.js, fully client-side.

Verify PGP/GPG digital signatures against public keys and sign messages with private keys.

Generate Certificate Signing Requests (CSR) with custom subject fields and RSA/EC key pairs in the browser.

Decode and inspect Certificate Signing Request (CSR) files to view subject, key details, and extensions.

Convert certificates and keys between PEM (Base64 text) and DER (binary) encoding formats.

Generate self-signed X.509 certificates with custom subject, validity period, and key algorithm for development use.

Create and sign JSON Web Tokens with custom claims, expiration, and HMAC or RSA signing algorithms.

Validate JWT signatures using HMAC secrets or RSA/EC public keys and check claim expiration and audience.

Generate Time-based One-Time Password codes from a secret key, compatible with Google Authenticator and Authy.

Generate HMAC-based One-Time Password codes from a secret key and counter value for two-factor authentication.

Generate secure API keys and access tokens with configurable formats, prefixes, and cryptographic randomness.

Generate cryptographically secure secret keys for JWT signing, HMAC, AES encryption, and other applications.

Generate RSA public/private key pairs with configurable key sizes (2048, 3072, 4096-bit) in PEM format.

Generate Elliptic Curve key pairs (P-256, P-384, P-521) for digital signatures and key exchange.

Generate Ed25519 key pairs for high-performance digital signatures and SSH authentication.

Generate SSH key pairs (RSA, ECDSA, Ed25519) in OpenSSH format with optional passphrase protection.

Calculate the fingerprint of an SSH public key in MD5 and SHA-256 formats for verification.

Configure HTTP Strict Transport Security headers with preload eligibility checking and max-age recommendations.

Build Permissions-Policy (formerly Feature-Policy) headers to control browser feature access for your site.

Generate Subresource Integrity hashes for script and link tags to prevent CDN tampering attacks.

Browse and test common security-focused regex patterns for input validation, XSS prevention, and SQL injection detection.

Test SQL injection patterns against simulated query builders to learn about SQL injection prevention techniques.

Test HTML sanitization by comparing raw input against DOMPurify and browser-native sanitization output.

Temporarily store encrypted text snippets in browser memory with auto-expiry and one-click secure copy.

Generate terms of service agreements customized to your business type, service model, and legal requirements.

Generate a GDPR/CCPA-compliant cookie consent banner with customizable categories, styling, and JavaScript code.

Generate a GDPR-compliant Data Processing Agreement (DPA) for data processor relationships.

Assess CCPA (California Consumer Privacy Act) compliance with an interactive questionnaire and action plan.

Generate JSON Web Keys (JWK) and JWK Sets for RSA, EC, and symmetric key types used in JOSE/JWT.

Convert between JSON Web Key (JWK) format and PEM-encoded public/private keys.

Decode and inspect OAuth 2.0 access tokens, refresh tokens, and ID tokens to view claims and metadata.

Decode and inspect SAML assertions, requests, and responses with XML formatting and attribute extraction.

Validate SAML XML documents against SAML 2.0 schema and check for common configuration errors.

Generate memorable but secure passphrases using the Diceware method with customizable word count and separators.

Verify passwords against bcrypt, scrypt, Argon2, and PBKDF2 hash strings to confirm they match.

Extract and display JWT claims as formatted JSON with registered claim explanations and timestamp conversion.

Generate Apache htpasswd entries with bcrypt, MD5, or SHA-1 password hashing for HTTP basic auth.

Analyze your browser fingerprint uniqueness by testing canvas, WebGL, audio, font, and API-based fingerprinting vectors.

Test if your browser leaks your real IP address through WebRTC APIs even when using a VPN.

Test for DNS leaks that could expose your browsing activity when using a VPN or proxy service.

Comprehensive privacy audit testing tracking protection, cookie handling, fingerprinting resistance, and API exposure.

Check if your browser sends Do Not Track (DNT) and Global Privacy Control (GPC) signals correctly.

Strip all EXIF metadata from photos to protect privacy before sharing, processed entirely in the browser.

Parse and analyze email headers to trace delivery path, check SPF/DKIM/DMARC, and detect spoofing indicators.

Build SPF DNS records with an interactive tool to authorize email senders and prevent spoofing.

Generate DKIM key pairs and DNS TXT records for email authentication and anti-spoofing protection.

Build DMARC DNS records with policy configuration, reporting settings, and alignment mode selection.

Expand shortened URLs to reveal their final destination before clicking, with redirect chain display.

Generate multiple hash types (MD5, SHA-1, SHA-256, SHA-512) from a single text input for easy comparison.

Derive cryptographic keys from passwords using PBKDF2 with configurable iterations, salt, and hash algorithm.

Generate Argon2id password hashes with configurable memory, iterations, and parallelism parameters.

Generate scrypt password hashes with configurable CPU/memory cost parameters and salt generation.

Create and verify digital signatures using RSA-PSS or ECDSA with the WebCrypto API.

Calculate Shannon entropy of text or data to measure randomness and information content in bits.

Generate cryptographically secure random numbers within custom ranges using the Web Crypto API.

Overwrite file contents with random data before deletion to prevent recovery, using client-side processing.

Decode ASN.1/DER encoded data into a human-readable tree structure for certificate and key inspection.

Convert between PKCS#12 (.pfx/.p12) and PEM format certificates and private keys.

Generate OpenSSL commands for common operations like CSR creation, certificate conversion, and key generation.

Generate secure SSL/TLS configuration for Apache, Nginx, and HAProxy with modern cipher suite recommendations.

Browse and search TLS cipher suites with security ratings, protocol compatibility, and recommendation status.

Check if a password has been exposed in data breaches using k-anonymity hash prefix matching via HIBP.

Generate customized web application security checklists based on your tech stack, deployment, and compliance needs.

Interactive reference for OWASP Top 10 vulnerabilities with examples, mitigations, and code snippets.

Search and browse Common Vulnerabilities and Exposures entries with severity scores and affected products.

Calculate the brute-force resistance of encryption keys by key length, algorithm, and estimated attacker capability.

Generate encrypted one-time links for sharing passwords securely with AES-256-GCM encryption in URL fragments.

Encode messages using various methods including zero-width characters, invisible ink Unicode, and whitespace encoding.

Generate secure backup/recovery codes for two-factor authentication with configurable format and quantity.

Generate QR codes for TOTP authenticator app setup with configurable issuer, account, and algorithm parameters.

Generate OpenVPN client and server configuration files with customizable encryption, routing, and DNS settings.

Generate WireGuard VPN configuration files with key pair generation and peer configuration.

Generate firewall rules for iptables, nftables, UFW, and Windows Firewall with an interactive rule builder.

Build IP access control lists for web servers and firewalls with CIDR support and rule ordering.

Generate RSA key pairs specifically formatted for JWT RS256 signing with PEM and JWK output.

Compare two hash values side-by-side with visual highlighting of matching and differing characters.

Parse and validate otpauth:// URIs used by authenticator apps to extract TOTP/HOTP configuration parameters.

Parse and analyze GPG/PGP public keys to display key ID, fingerprint, user IDs, subkeys, and expiration.

Build X.509 certificates with custom extensions, SANs, key usage, and extended key usage fields.

Verify that a certificate and private key match by comparing their public key modulus fingerprints.

Apply XOR cipher operations with single-byte and multi-byte keys with hex input/output and key analysis.

Calculate brute-force attack times based on hash rate, password complexity, and character set size.

Scan a website's HTTP response headers and grade its security posture with actionable improvement suggestions.

Mask sensitive data (emails, phone numbers, credit cards, SSNs) in text with configurable masking patterns.

Detect personally identifiable information (emails, phones, SSNs, addresses) in text using pattern matching.

Validate credit card numbers using the Luhn algorithm with card network detection and BIN lookup.

Paste any cryptographic key (RSA, EC, Ed25519) to inspect key type, size, curve, and public key components.

Scan text or code for accidentally exposed secrets like API keys, tokens, passwords, and private keys using pattern matching.

Obfuscate JavaScript code to make it harder to reverse-engineer with variable renaming and control flow transformations.

Derive cryptographic keys from passwords using PBKDF2, HKDF, and scrypt with configurable parameters.

Generate SHA-3 (Keccak) hash values in SHA3-224, SHA3-256, SHA3-384, and SHA3-512 variants.

Generate BLAKE2b and BLAKE2s hash values with configurable digest length and key parameters.

Generate RIPEMD-160 hash values from text or file input, commonly used in Bitcoin address derivation.

Search public PGP keyservers for encryption keys by email, name, or key ID via public APIs.

Generate QR codes containing AES-encrypted data that requires a password to decode the embedded message.

Evaluate the privacy risk of your website or app by answering questions about data collection and processing practices.

Generate Data Protection Impact Assessment templates with risk matrices and mitigation planning sections.

Generate security incident response plan templates customized to your organization type and compliance requirements.

Generate RFC 9116 compliant security.txt files with contact, encryption, acknowledgments, and policy fields.

Generate DNS CAA records to control which Certificate Authorities can issue certificates for your domain.

Check a domain's email security setup by looking up SPF, DKIM, DMARC, and MTA-STS DNS records.

Generate MTA-STS policy files and DNS records to enforce TLS for incoming email connections.

Generate Brand Indicators for Message Identification DNS records to display your logo in email clients.

Benchmark WebCrypto API encryption and hashing performance in your browser across different algorithms and key sizes.

Build Permissions-Policy HTTP headers to control browser feature access for camera, microphone, and geolocation.

Select and configure the optimal Referrer-Policy header with comparison of all policy options and their effects.

Encrypt and decrypt text using AES, DES, and other algorithms with key and IV configuration options.

Generate RSA public/private key pairs using the Web Crypto API with configurable key sizes.

Generate Certificate Signing Requests with organization, domain, and key information using Web Crypto API.

Encrypt and decrypt files or text with AES-128, AES-192, or AES-256 in CBC, CTR, or GCM mode using Web Crypto API.

Generate RSA-2048, RSA-3072, or RSA-4096 key pairs in PEM format for signing and encryption, entirely in-browser.

Encrypt and decrypt data using ChaCha20-Poly1305 AEAD cipher with authenticated encryption and nonce management.

Encrypt any file with AES-256-GCM and a password-derived key. Download the encrypted blob or decrypt it back.

Encrypt short messages with an RSA public key and decrypt with the private key using OAEP padding.

Apply XOR cipher to text or binary data with a repeating key. Visualize bitwise operations step by step.

Encode and decode messages using the Vigenere polyalphabetic cipher with frequency analysis and key-length detection.

Encrypt and decrypt with Caesar shift cipher. Includes brute-force attack showing all 26 rotations simultaneously.

Generate cryptographically random one-time pads and encrypt messages with provably unbreakable XOR encryption.

Interactive Enigma machine simulation with configurable rotors, reflectors, and plugboard. Encrypt messages like WWII operators.

Compute SHA3-224, SHA3-256, SHA3-384, SHA3-512, and SHAKE hashes for text or files using the Keccak sponge construction.

Generate BLAKE2b, BLAKE2s, and BLAKE3 hashes for text or files. Compare speeds against SHA-256 in real time.

Derive keys from passwords using Argon2id with configurable memory cost, time cost, and parallelism parameters.

Derive cryptographic keys from passwords using PBKDF2 with SHA-256 or SHA-512 and configurable iteration counts.

Derive keys using scrypt with configurable N, r, p parameters. Visualize memory-hardness and compare with PBKDF2.

Generate bcrypt password hashes with configurable cost factor and verify passwords against existing hashes.

Compute HMAC-SHA256, HMAC-SHA384, HMAC-SHA512 message authentication codes for text or files and verify signatures.

Paste any hash and automatically identify its type (MD5, SHA-1, SHA-256, bcrypt, Argon2, etc.) by format and length.

Compute CRC-32, CRC-16, and Adler-32 checksums for text or file data with polynomial configuration options.

Benchmark hash functions (MD5, SHA-1, SHA-256, SHA-3, BLAKE3) in your browser and compare throughput in real time.

Sign and verify messages with ECDSA using P-256, P-384, or P-521 curves via Web Crypto API.

Sign documents with RSA-PSS and verify signatures. Supports RSA-2048 through RSA-4096 key sizes.

Generate Ed25519 key pairs, sign messages, and verify signatures using the EdDSA algorithm with Curve25519.

Generate OpenPGP key pairs (RSA or ECC) with user ID, expiration, and passphrase protection. Export as ASCII-armored text.

Encrypt messages with a PGP public key and decrypt with the private key. Supports ASCII-armored input and output.

Create PGP cleartext signatures and verify signed messages against a public key. Detached signature support included.

Verify code signatures and integrity hashes for downloaded files. Compare expected vs. computed SHA-256 digests.

Generate SSH key pairs (RSA, Ed25519, ECDSA) with configurable bit length. Download public and private keys.

Compute MD5 and SHA-256 fingerprints for SSH public keys. Verify server key authenticity visually.

Simulate Elliptic Curve Diffie-Hellman key exchange between two parties. Visualize the shared secret derivation process.

Interactive visualization of classical Diffie-Hellman key exchange with color-mixing analogy and modular arithmetic steps.

Generate cryptographically secure API keys with configurable prefixes, lengths, and character sets. Copy-ready output.

Store and organize encryption keys locally with labels, expiry dates, and key type metadata. All data in IndexedDB.

Parse PEM-encoded certificates, keys, and CSRs. Display algorithm, key size, subject, issuer, and validity details.

Convert between JWK (JSON Web Key) and PEM formats for RSA and EC keys. Supports PKCS#8 and SPKI formats.

Verify JWT signatures with HMAC, RSA, or ECDSA keys. Check expiration, issuer, audience, and custom claim validation.

Decode and inspect JWT headers, payloads, and signatures with syntax highlighting and human-readable timestamps.

Debug OAuth 2.0 authorization code, implicit, and PKCE flows. Inspect tokens, scopes, and redirect parameters.

Decode and inspect SAML assertions and responses. View XML attributes, conditions, and signature details.

Generate cryptographically secure CSRF tokens with configurable entropy. Includes HTML form snippet and cookie-based patterns.

Generate URL-safe, Base64, or hex-encoded opaque bearer tokens with selectable entropy (128-512 bits).

Split a secret into N shares where any K shares can reconstruct it. Uses polynomial interpolation over a finite field.

Split an image into visual cryptographic shares that reveal the secret only when overlaid. Based on Naor-Shamir scheme.

Interactive demonstration of zero-knowledge proofs. Prove you know a secret without revealing it using graph coloring and cave analogy.

Create binding commitments to values using hash-based commitment schemes. Reveal and verify later without trust.

Split master keys into escrow shares for disaster recovery. Assign custodians and track share distribution.

Analyze your browser fingerprint including canvas, WebGL, audio context, fonts, and navigator properties. See how unique you are.

Scan page source for known tracking pixels, analytics scripts, and third-party beacons. Identify all trackers on a page.

Test and demonstrate canvas fingerprinting techniques. Generate noise-injected canvas to show how defenders work.

Detect WebRTC IP leaks that can expose your real IP address even behind a VPN. Shows local, public, and ICE candidates.

Test for DNS leaks that might reveal your browsing activity to your ISP despite using a VPN or proxy.

Get an overall privacy score for your browser setup based on fingerprint uniqueness, leak tests, and security headers.

Check if your browser sends Do Not Track (DNT) and Global Privacy Control (GPC) signals and whether sites respect them.

Test whether your browser blocks third-party cookies. Explains implications for tracking and privacy.

Scan PDFs, images, and Office files for hidden metadata including author, GPS, edit history, and embedded comments.

Generate realistic but fake identities for testing forms and signups. Names, addresses, emails - all synthetic data.

Look up your current IP address with geolocation, ASN, ISP, and reverse DNS information displayed on a map.

Calculate subnet masks, network addresses, broadcast addresses, and host ranges for IPv4 and IPv6 CIDR blocks.

Visualize CIDR blocks, calculate IP ranges, and check if addresses fall within subnets. Supports IPv4 and IPv6.

Expand shortened IPv6 addresses to full form and compress verbose addresses. Validate and analyze IPv6 notation.

Merge overlapping IP ranges, aggregate CIDR blocks, and minimize firewall rules. Supports allow/deny list optimization.

Query A, AAAA, MX, TXT, CNAME, NS, SOA, and SRV records for any domain using DNS over HTTPS.

Check DNS propagation across global resolvers. See if your DNS changes have propagated to servers worldwide.

Validate SPF records for email authentication. Build new records with include, ip4, ip6, and redirect mechanisms.

Look up and validate DKIM DNS records for email domain authentication. Verify selector, key type, and key data.

Check DMARC records for email security. Build policies with reject/quarantine/none, reporting URIs, and alignment modes.

Look up MX records for any domain to see mail server priorities, verify mail routing, and detect misconfigurations.

Reference database of common TCP/UDP ports with service names. Test port connectivity to your own servers.

Build Permissions-Policy headers to control browser features like camera, microphone, geolocation, and payment APIs.

Test and configure Referrer-Policy headers. Visualize which referrer information is sent for different policy values.

Test X-Frame-Options and CSP frame-ancestors directives. Demonstrate clickjacking attacks and defenses.

Scan a site for cookie consent compliance. Check if cookies are set before consent and categorize by purpose.

Analyze session token randomness and entropy. Detect patterns, weak PRNGs, and predictable session identifiers.

Visualize the complete SSL certificate chain from leaf to root CA. Check chain completeness and intermediate certificates.

Generate Certificate Signing Requests with subject fields, key type selection, and SAN (Subject Alternative Names).

Generate self-signed X.509 certificates for development and testing. Configure validity period, key usage, and SANs.

Test SQL injection patterns in a local sandbox. Practice detection and learn about parameterized queries.

Generate Subresource Integrity hashes for script and link tags. Paste a CDN URL or file to compute sha256/sha384/sha512.

Generate a standards-compliant security.txt file (RFC 9116) with contact, encryption, acknowledgments, and policy fields.

Detect technologies used by a website: frameworks, CMS, analytics, CDN, hosting, and server software from client-side signals.

Analyze URLs for phishing indicators: homograph attacks, suspicious TLDs, URL shortener chains, and known malicious patterns.

Detect phishing URLs using heuristics: IDN homograph detection, brand impersonation, suspicious subdomains, and path analysis.

Expand shortened URLs (bit.ly, t.co, etc.) and trace the full redirect chain to see the final destination safely.

Detect internationalized domain name (IDN) homograph attacks using confusable Unicode characters that mimic ASCII domains.

Parse and analyze email headers to trace message routing, verify SPF/DKIM/DMARC authentication, and detect spoofing.

Generate a safe preview of any URL showing its title, description, and screenshot without visiting it directly.

Check file hashes (MD5, SHA-1, SHA-256) against known malware databases. Upload a file to compute and verify its hash.

Build YARA rules visually with string patterns, hex patterns, and conditions. Export rules for malware detection scanning.

Extract IOCs from threat reports: IP addresses, domains, URLs, file hashes, email addresses, and Bitcoin wallets.

Parse STIX/TAXII, CSV, and JSON threat intelligence feeds. Normalize IOCs and export in standard formats.

Interactive MITRE ATT&CK matrix viewer. Map techniques to tactics, highlight coverage, and export layer files.

Search for Common Vulnerabilities and Exposures (CVE) by ID. View CVSS scores, descriptions, and affected products.

Calculate CVSS v3.1 and v4.0 vulnerability scores with the full base, temporal, and environmental metric groups.

Generate honeypot tokens (URLs, DNS names, email addresses, files) that alert you when accessed by an attacker.

Analyze network responses and service banners to detect honeypots. Identify telltale signs of deception infrastructure.

Parse and analyze security logs (Apache, Nginx, auth.log). Detect brute force attempts, anomalies, and suspicious patterns.

Parse Apache Combined and Nginx access logs. Visualize top IPs, URIs, status codes, and user agents with charts.

View and filter JSON-structured logs with search, time range selection, severity filtering, and field extraction.

Parse RFC 3164 and RFC 5424 syslog messages. Extract facility, severity, timestamp, hostname, and message fields.

Parse and analyze user agent strings to identify browser, OS, device type, and bot/crawler signatures.

Convert and analyze timestamps from various formats (Unix, Windows FILETIME, NTFS, HFS+) for digital forensics.

View files as hex dumps with ASCII representation. Search for patterns, identify file magic bytes, and analyze binary data.

Decode Base64 strings to reveal hidden file types. Detect embedded images, scripts, and binary data in encoded strings.

Generate customizable incident response checklists based on NIST 800-61 phases: preparation, detection, containment, recovery.

Build visual timelines for security incidents. Add events with timestamps, categories, and evidence references.

Generate GDPR/CCPA-compliant data breach notification letters. Customize affected data types, timeline, and remediation steps.

Build a tamper-evident hash chain for digital evidence. Each file gets a timestamped hash linked to the previous entry.

Test regular expressions for catastrophic backtracking vulnerabilities. Measure execution time with adversarial inputs.

Library of regex patterns for detecting SSNs, credit cards, API keys, passwords, and PII in text. Test patterns on sample data.

Convert text to hexadecimal and back. Supports ASCII, UTF-8, and raw binary hex with delimiter options.

Convert between Unicode domain names and Punycode (xn--) representations. Detect homograph attack attempts.

Apply ROT13 (letters only) or ROT47 (all printable ASCII) rotation ciphers. Instant encode/decode toggle.

Sanitize HTML input by removing dangerous tags, attributes, and event handlers. Preview safe output in an isolated iframe.

Deobfuscate packed and obfuscated JavaScript code. Detect eval-based packers, hex encoding, and string rotation.

Calculate Shannon entropy of text, files, or byte sequences. Visualize entropy distribution to detect encrypted or compressed data.

Generate cryptographically secure random numbers using Web Crypto API. Supports integer ranges, floats, and byte arrays.

Generate strong passphrases using the Diceware method with EFF word lists. Estimate entropy and crack time.

Generate time-ordered UUID v7 tokens (RFC 9562) and inspect existing UUIDs to extract timestamps and random bits.

Generate compact, URL-safe unique IDs with NanoID algorithm. Configure alphabet, length, and collision probability display.

Calculate TCP flag values (SYN, ACK, FIN, RST, PSH, URG) from decimal, hex, or binary. Visualize flag combinations.

Decode IPv4 and IPv6 packet headers from hex dumps. Visualize fields: version, TTL, protocol, source/destination.

Look up MAC address vendor (OUI) information. Generate random MAC addresses with optional vendor prefix.

Calculate data transfer times, bandwidth requirements, and throughput. Convert between Mbps, MB/s, and transfer durations.

Measure round-trip latency to endpoints using fetch timing API. Graph latency over time and compute statistics.

Upload PCAP files and view packet summaries: protocol distribution, top talkers, connection pairs, and flow statistics.

Build firewall rules visually for iptables, nftables, and cloud security groups. Export as commands or JSON configs.

Calculate Unix file permissions (chmod), AWS IAM policies, and Kubernetes RBAC rules. Visualize access matrices.

Generate secure Nginx server blocks with TLS, HSTS, CSP, rate limiting, and access control configurations.

Generate secure Apache .htaccess and httpd.conf snippets for TLS, headers, mod_security, and access control.

Mask sensitive data in text: credit cards, SSNs, emails, phone numbers, and names. Configurable masking patterns.

Anonymize text by replacing personal names, addresses, phone numbers, and emails with placeholder tokens.

Generate realistic synthetic datasets that preserve statistical properties without containing real personal information.

Assess CCPA/CPRA compliance for California consumer privacy. Evaluate disclosure, opt-out, and deletion requirements.

Generate Data Protection Impact Assessment templates with risk matrices, necessity analysis, and mitigation measures.

Track IT assets with security metadata: OS versions, patch levels, ownership, and classification. Export inventory reports.

Encrypt clipboard text with a passphrase before sharing. Recipient decrypts with the same passphrase. Zero-server design.

Create encrypted messages encoded as URL fragments. The secret never touches a server - decryption happens locally.

Encrypt a file with a password and generate a download link containing the encrypted payload as a data URL.

Interactive visualization of the Signal/Double Ratchet protocol. Step through key exchanges, ratchet advances, and message encryption.

Encrypt and decrypt files using the age encryption format. Support for passphrase and X25519 recipient keys.

Validate Ethereum addresses with EIP-55 checksum verification. Detect invalid addresses and mixed-case checksums.

Validate Bitcoin addresses (P2PKH, P2SH, Bech32, Bech32m). Detect address type and check Base58/Bech32 checksums.

Generate BIP-39 mnemonic seed phrases (12/24 words) with entropy validation. Verify existing mnemonics and compute seeds.

Build and visualize Merkle trees from data blocks. Demonstrate proof verification and tamper detection visually.

Interactive blockchain simulator: mine blocks, add transactions, visualize hashing, and demonstrate proof-of-work concepts.

Generate TOTP secret keys with QR codes for authenticator apps. Configure period, digits, and algorithm (SHA-1/SHA-256/SHA-512).

Generate HOTP (HMAC-based One-Time Password) codes with counter-based increments per RFC 4226.

Test WebAuthn registration and authentication flows. Inspect attestation objects, assertions, and credential details.

Test your browser and device support for passkeys (WebAuthn). Check platform authenticator and cross-platform capabilities.

Generate PKCE code_verifier and code_challenge pairs for OAuth 2.0 authorization code flow with S256 method.

Generate and decode HTTP Basic Authentication headers (Base64 user:password). Includes cURL command output.

Test API endpoints with bearer tokens. Send authenticated requests and inspect response headers and status codes.

Validate .env files for syntax errors, missing required variables, duplicate keys, and exposed secrets.

Scan code snippets for accidentally committed secrets: API keys, tokens, passwords, and private keys.

Paste git diffs and detect leaked credentials, tokens, and secrets using pattern-matching rules.

Scan Dockerfiles for security issues: running as root, hardcoded secrets, missing health checks, and insecure base images.

Analyze Kubernetes RBAC configurations (Roles, ClusterRoles, Bindings) for overly permissive or risky access grants.

Scan Terraform HCL files for security misconfigurations: open security groups, public S3 buckets, and missing encryption.

Analyze GitHub Actions workflows for security risks: script injection, unpinned actions, and secret exposure.

Generate customizable Terms of Service agreements covering liability, intellectual property, termination, and dispute resolution.

Generate GDPR-compliant Data Processing Agreements (DPA) with sub-processor lists, security measures, and data transfer terms.

Generate cookie consent banner HTML/CSS/JS with consent categories, preference storage, and GDPR-compliant flows.

Visualize how ECB, CBC, CTR, GCM, and OFB modes work with animated block diagrams showing IV, chaining, and feedback.

Interactive visualization of elliptic curves showing point addition, scalar multiplication, and ECDH key exchange.

Step through AES encryption rounds: SubBytes, ShiftRows, MixColumns, and AddRoundKey with state matrix visualization.

Interactive explainer of public key cryptography concepts: key generation, encryption, signing, and the math behind RSA.

Interactive reference for OWASP Top 10 vulnerabilities with descriptions, examples, mitigations, and code samples.

Decode TLS cipher suite names (e.g., TLS_AES_128_GCM_SHA256) into human-readable components: key exchange, cipher, and hash.

Searchable glossary of 500+ cybersecurity acronyms and terms with definitions, related concepts, and RFC references.

Decode ASN.1 structures in DER or BER encoding. Visualize the TLV (Tag-Length-Value) tree for certificates and keys.

Perform AND, OR, XOR, NOT, shifts, and rotations on binary, hex, or decimal values. Visualize bit patterns.

Test primality using Miller-Rabin algorithm. Generate large primes for cryptographic key generation.

Perform modular exponentiation, GCD, modular inverse, and Chinese Remainder Theorem calculations for cryptography.