Is the Vigenère cipher secure?

No. It was broken by Kasiski and Babbage in the 19th century. Repeating-key polyalphabetic ciphers fall to frequency analysis once the key length is known. Use it for puzzles and CTFs, not real secrets.

How is the key repeated against the message?

The key is repeated cyclically, ignoring non-letter characters in the plaintext (so spaces and punctuation pass through unchanged). The tool follows the standard 'tabula recta' convention.

Is the encoding done locally?

Yes. The cipher runs entirely in your browser.

vigenere · polyalphabetic · keyword shift · live

Encode with the Vigenere cipher

Polyalphabetic substitution using a repeating keyword. Each letter is shifted by a different amount, making it much stronger than a Caesar cipher. Runs locally.

Vigenere Cipher

Input

12 B

1 lines

Output

12 B

1 lines

Status

ready

live

Ratio

1.00×

out/in

input · text

output · encrypted

LXFOPVEFRNHR

Quick Start

How to use Vigenere

Each letter in the plaintext is shifted by the position of the matching letter in the repeating keyword. Use the same key plus decrypt mode to recover the original message.

01
Enter a key
Any alphabetic string. Non-letters are stripped before use.
Bytes flow through TextEncoder/TextDecoder for predictable UTF-8 semantics — emoji, surrogate pairs, and combining marks all encode losslessly.
keyUTF-8TextEncoderlosslesslive
key · raw bytesLEMON · UTF-8
```
LEMONLEMONLE
```
loaded · UTF-8MIME · ready
02
Type or paste text
Letters are shifted by the corresponding key letter; everything else passes through.
Hash and signature operations call crypto.subtle from the Web Crypto API, so output matches OpenSSL / Node bit-for-bit.
inputWeb Cryptosubtledeterministiclive
input · optionstext · live
```
ATTACKATDAWN
```
options applied · livelive
03
Pick a mode
Encrypt adds the key shifts; decrypt subtracts them. The same key is required.
Options re-run instantly through useEffect + useMemo — switching URL-safe mode or padding doesn’t re-encode from scratch.
modememoisedoptionsinstantreactive
mode · encodedencrypt · ready
```
shift = key[i] - A
```
encoded · livelossless
04
Copy or download
One click to clipboard. Download as .txt.
Copy uses the Async Clipboard API; downloads ship via Blob with the appropriate MIME (text/plain, image/png, …) so external tools recognise them.
exportclipboardblobMIME-correctclient-side
out · copiedcipher · done
```
LXFOPVEFRNHR
```
shipped · ready to shipsuccess

Pro tips

Encoding without surprises

Always UTF-8 first

Use TextEncoder / TextDecoder for bytes ↔ string conversion. btoa alone breaks on non-ASCII.

URL-safe vs standard Base64

Standard uses +, /, =; URL-safe swaps to -, _, no padding. Don’t mix them.

Hashes aren’t passwords

SHA-256 is fast; that’s good for fingerprints, bad for passwords. Use bcrypt / argon2 for credentials.

Watch padding rules

Some decoders are strict about = padding, others auto-pad. If round-trips fail at exactly 1 or 2 bytes, check padding.

Use Web Crypto for keys

Generate cryptographic keys via crypto.subtle, never Math.random. The latter is predictable.

JWT decode ≠ verify

Decoding a JWT just splits and base64-decodes. Verification needs the issuer’s public key / shared secret.

Use Cases

When to use Vigenere

Historical cipher work, CTFs, classroom demos.

Crypto courses

Stepping stone from Caesar to modern stream ciphers. Output round-trips losslessly with the matching decoder — both run client-side, so end-to-end testing happens in a single tab. Encoding flows through TextEncoder for predictable UTF-8 semantics.

RFC-compliant

CTF puzzles

Often paired with frequency-by-period analysis. Web Crypto's subtle.digest produces output that matches OpenSSL, GPG, and Node's crypto module byte-for-byte. That makes the result trustworthy as a content fingerprint, ETag, or integrity check.

OpenSSL-matched

Historical writing

Reproduce ciphertexts from 16th- and 17th-century sources. Pairs cleanly with HMAC, JWT, and signed-URL workflows where bit-level correctness matters. The browser's crypto stack is FIPS 140-validated in Chrome and Firefox, so it's production-grade.

lossless

Tableau visualisation

Demonstrate the Vigenere square interactively. Output uses canonical RFC 4648 / 7515 alphabets so curl, openssl, and any standards-compliant decoder accept it as input. URL-safe variants drop padding for tokens that travel in query strings.

byte-identical

Key-length recovery

Pair with the Letter Frequency Analyzer to crack short keys. Heavy hashing runs through useMemo so large inputs don't block typing. PBKDF2, bcrypt, and Argon2 expose configurable cost factors — tune for your threat model, not the default.

spec-grade

Cross-implementation

Sanity-check Vigenere code in other languages. Same input plus same options always yields identical bytes. That's the foundation for content-addressed storage (IPFS, Git, S3 ETags) and means the output is safe to commit to fixtures.

production-ready

FAQ

Frequently asked questions

How long should the key be?

Longer keys are harder to attack with Kasiski/IC tests. For real security, the key must be at least as long as the plaintext and random — that is a one-time pad.

Whats the difference from Caesar?

Caesar uses one shift value. Vigenere cycles through multiple shifts taken from a keyword, defeating naive frequency analysis.

Does case matter?

Output preserves the input case; the key is normalised to uppercase letters only.

Can it be broken?

Yes — classic methods (Kasiski examination, index of coincidence, Friedman test) recover the key length, then each Caesar stripe is broken by frequency analysis.

Is anything sent to a server?

No. The cipher runs locally in your browser.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!