Ciphers
67 operations. Call any of them with cyberchef_bake, or pre-load them
with CYBERCHEF_TOOL_SURFACE=all.
A1Z26 Cipher Decode
Section titled “A1Z26 Cipher Decode”Converts alphabet order numbers into their corresponding alphabet character.e.g. 1 becomes a and 2 becomes b.
- Tool name:
cyberchef_a1z26_cipher_decode - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
delimiter |
option | Space |
A1Z26 Cipher Encode
Section titled “A1Z26 Cipher Encode”Converts alphabet characters into their corresponding alphabet order number.e.g. a becomes 1 and b becomes 2.Non-alphabet characters are dropped.
- Tool name:
cyberchef_a1z26_cipher_encode - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
delimiter |
option | Space |
AES Decrypt
Section titled “AES Decrypt”Advanced Encryption Standard (AES) is a U.S. Federal Information Processing Standard (FIPS). It was selected after a 5-year process where 15 competing designs were evaluated.Key: The following algorithms will be used based on the size of the key:16 bytes = AES-12824 bytes = AES-19232 bytes = AES-256IV: The Initialization Vector should be 16 bytes long. If not entered, it will default to 16 null bytes.Padding: In CBC and ECB mode, PKCS#7 padding will be used as a default.GCM Tag: This field is ignored unless ‘GCM’ mode is used.
- Tool name:
cyberchef_aes_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
iv_length |
number | 16 |
mode |
argSelector | CBC |
input_arg |
option | Hex |
output |
option | Raw |
gcm_tag |
toggleString | {"option":"Hex","string":""} |
additional_authenticated_data |
toggleString | {"option":"Hex","string":""} |
iv_from_input |
argSelector | Off |
AES Encrypt
Section titled “AES Encrypt”Advanced Encryption Standard (AES) is a U.S. Federal Information Processing Standard (FIPS). It was selected after a 5-year process where 15 competing designs were evaluated.Key: The following algorithms will be used based on the size of the key:16 bytes = AES-12824 bytes = AES-19232 bytes = AES-256You can generate a password-based key using one of the KDF operations.IV: The Initialization Vector should be 16 bytes long. If not entered, it will default to 16 null bytes.Padding: In CBC and ECB mode, PKCS#7 padding will be used.
- Tool name:
cyberchef_aes_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
argSelector | CBC |
input_arg |
option | Raw |
output |
option | Hex |
additional_authenticated_data |
toggleString | {"option":"Hex","string":""} |
include_iv_in_output |
option | Off |
AES Key Unwrap
Section titled “AES Key Unwrap”Decryptor for a key wrapping algorithm defined in RFC3394, which is used to protect keys in untrusted storage or communications, using AES.This algorithm uses an AES key (KEK: key-encryption key) and a 64-bit IV to decrypt 64-bit blocks.
- Tool name:
cyberchef_aes_key_unwrap - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key_kek |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":"a6a6a6a6a6a6a6a6"} |
input_arg |
option | Hex |
output |
option | Hex |
AES Key Wrap
Section titled “AES Key Wrap”A key wrapping algorithm defined in RFC3394, which is used to protect keys in untrusted storage or communications, using AES.This algorithm uses an AES key (KEK: key-encryption key) and a 64-bit IV to encrypt 64-bit blocks.
- Tool name:
cyberchef_aes_key_wrap - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key_kek |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":"a6a6a6a6a6a6a6a6"} |
input_arg |
option | Hex |
output |
option | Hex |
Affine Cipher Decode
Section titled “Affine Cipher Decode”The Affine cipher is a type of monoalphabetic substitution cipher. To decrypt, each letter in an alphabet is mapped to its numeric equivalent, decrypted by a mathematical function, and converted back to a letter.
- Tool name:
cyberchef_affine_cipher_decode - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
a |
number | 1 |
b |
number | 0 |
Affine Cipher Encode
Section titled “Affine Cipher Encode”The Affine cipher is a type of monoalphabetic substitution cipher, wherein each letter in an alphabet is mapped to its numeric equivalent, encrypted using simple mathematical function, (ax + b) % 26, and converted back to a letter.
- Tool name:
cyberchef_affine_cipher_encode - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
a |
number | 1 |
b |
number | 0 |
Ascon Decrypt
Section titled “Ascon Decrypt”Ascon-AEAD128 authenticated decryption as standardised in NIST SP 800-232. Decrypts ciphertext and verifies the authentication tag. Decryption will fail if the ciphertext or associated data has been tampered with.Key: Must be exactly 16 bytes (128 bits).Nonce: Must be exactly 16 bytes (128 bits). Must match the nonce used during encryption.Associated Data: Must match the associated data used during encryption. Any mismatch will cause authentication failure.
- Tool name:
cyberchef_ascon_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
nonce |
toggleString | {"option":"Hex","string":""} |
associated_data |
toggleString | {"option":"Hex","string":""} |
input_arg |
option | Hex |
output |
option | Raw |
Ascon Encrypt
Section titled “Ascon Encrypt”Ascon-AEAD128 authenticated encryption as standardised in NIST SP 800-232. Ascon is a family of lightweight authenticated encryption algorithms designed for constrained devices such as IoT sensors and embedded systems.Key: Must be exactly 16 bytes (128 bits).Nonce: Must be exactly 16 bytes (128 bits). Should be unique for each encryption with the same key. Never reuse a nonce with the same key.Associated Data: Optional additional data that is authenticated but not encrypted. Useful for including metadata like headers or timestamps.The output includes both the ciphertext and a 128-bit authentication tag.
- Tool name:
cyberchef_ascon_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
nonce |
toggleString | {"option":"Hex","string":""} |
associated_data |
toggleString | {"option":"Hex","string":""} |
input_arg |
option | Raw |
output |
option | Hex |
Atbash Cipher
Section titled “Atbash Cipher”Atbash is a mono-alphabetic substitution cipher originally used to encode the Hebrew alphabet. It has been modified here for use with the Latin alphabet.
- Tool name:
cyberchef_atbash_cipher - Input / output:
string→string - Arguments: none
Bifid Cipher Decode
Section titled “Bifid Cipher Decode”The Bifid cipher is a cipher which uses a Polybius square in conjunction with transposition, which can be fairly difficult to decipher without knowing the alphabet keyword.
- Tool name:
cyberchef_bifid_cipher_decode - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
keyword |
string | — |
Bifid Cipher Encode
Section titled “Bifid Cipher Encode”The Bifid cipher is a cipher which uses a Polybius square in conjunction with transposition, which can be fairly difficult to decipher without knowing the alphabet keyword.
- Tool name:
cyberchef_bifid_cipher_encode - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
keyword |
string | — |
Blowfish Decrypt
Section titled “Blowfish Decrypt”Blowfish is a symmetric-key block cipher designed in 1993 by Bruce Schneier and included in a large number of cipher suites and encryption products. AES now receives more attention.IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
- Tool name:
cyberchef_blowfish_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Hex |
output |
option | Raw |
Blowfish Encrypt
Section titled “Blowfish Encrypt”Blowfish is a symmetric-key block cipher designed in 1993 by Bruce Schneier and included in a large number of cipher suites and encryption products. AES now receives more attention.IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.
- Tool name:
cyberchef_blowfish_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Raw |
output |
option | Hex |
Caesar Box Cipher
Section titled “Caesar Box Cipher”Caesar Box is a transposition cipher used in the Roman Empire, in which letters of the message are written in rows in a square (or a rectangle) and then, read by column.
- Tool name:
cyberchef_caesar_box_cipher - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
box_height |
number | 1 |
Cetacean Cipher Decode
Section titled “Cetacean Cipher Decode”Decode Cetacean Cipher input. e.g. EEEEEEEEEeeEeEEEEEEEEEEEEeeEeEEe becomes hi
- Tool name:
cyberchef_cetacean_cipher_decode - Input / output:
string→string - Arguments: none
Cetacean Cipher Encode
Section titled “Cetacean Cipher Encode”Converts any input into Cetacean Cipher. e.g. hi becomes EEEEEEEEEeeEeEEEEEEEEEEEEeeEeEEe
- Tool name:
cyberchef_cetacean_cipher_encode - Input / output:
string→string - Arguments: none
ChaCha
Section titled “ChaCha”ChaCha is a stream cipher designed by Daniel J. Bernstein. It is a variant of the Salsa stream cipher. Several parameterizations exist; ‘ChaCha’ may refer to the original construction, or to the variant as described in RFC-8439. ChaCha is often used with Poly1305, in the ChaCha20-Poly1305 AEAD construction.Key: ChaCha uses a key of 16 or 32 bytes (128 or 256 bits).Nonce: ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).Counter: ChaCha uses a counter of 4 or 8 bytes (32 or 64 bits); together, the nonce and counter must add up to 16 bytes. The counter starts at zero at the start of the keystream, and is incremented at every 64 bytes.
- Tool name:
cyberchef_chacha - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
nonce |
toggleString | {"option":"Hex","string":""} |
counter |
number | 0 |
rounds |
option | 20 |
input_arg |
option | Hex |
output |
option | Raw |
Derive EVP key
Section titled “Derive EVP key”This operation performs a password-based key derivation function (PBKDF) used extensively in OpenSSL. In many applications of cryptography, user security is ultimately dependent on a password, and because a password usually can’t be used directly as a cryptographic key, some processing is required.A salt provides a large set of keys for any given password, and an iteration count increases the cost of producing keys from a password, thereby also increasing the difficulty of attack.If you leave the salt argument empty, a random salt will be generated.
- Tool name:
cyberchef_derive_evp_key - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
passphrase |
toggleString | {"option":"UTF8","string":""} |
key_size |
number | 128 |
iterations |
number | 1 |
hashing_function |
option | SHA1 |
salt |
toggleString | {"option":"Hex","string":""} |
Derive PBKDF2 key
Section titled “Derive PBKDF2 key”PBKDF2 is a password-based key derivation function. It is part of RSA Laboratories’ Public-Key Cryptography Standards (PKCS) series, specifically PKCS #5 v2.0, also published as Internet Engineering Task Force’s RFC 2898.In many applications of cryptography, user security is ultimately dependent on a password, and because a password usually can’t be used directly as a cryptographic key, some processing is required.A salt provides a large set of keys for any given password, and an iteration count increases the cost of producing keys from a password, thereby also increasing the difficulty of attack.If you leave the salt argument empty, a random salt will be generated.
- Tool name:
cyberchef_derive_pbkdf2_key - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
passphrase |
toggleString | {"option":"UTF8","string":""} |
key_size |
number | 128 |
iterations |
number | 1 |
hashing_function |
option | SHA1 |
salt |
toggleString | {"option":"Hex","string":""} |
DES Decrypt
Section titled “DES Decrypt”DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.Key: DES uses a key length of 8 bytes (64 bits).IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.Padding: In CBC and ECB mode, PKCS#7 padding will be used as a default.
- Tool name:
cyberchef_des_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Hex |
output |
option | Raw |
DES Encrypt
Section titled “DES Encrypt”DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.Key: DES uses a key length of 8 bytes (64 bits).You can generate a password-based key using one of the KDF operations.IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.Padding: In CBC and ECB mode, PKCS#7 padding will be used.
- Tool name:
cyberchef_des_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Raw |
output |
option | Hex |
ECDSA Sign
Section titled “ECDSA Sign”Sign a plaintext message with a PEM encoded EC key.
- Tool name:
cyberchef_ecdsa_sign - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
ecdsa_private_key_pem |
text | -----BEGIN EC PRIVATE KEY----- |
message_digest_algorithm |
option | SHA-256 |
output_format |
option | ASN.1 HEX |
ECDSA Signature Conversion
Section titled “ECDSA Signature Conversion”Convert an ECDSA signature between hex, asn1 and json.
- Tool name:
cyberchef_ecdsa_signature_conversion - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
input_format |
option | Auto |
output_format |
option | ASN.1 HEX |
ECDSA Verify
Section titled “ECDSA Verify”Verify a message against a signature and a public PEM encoded EC key.
- Tool name:
cyberchef_ecdsa_verify - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
input_format |
option | Auto |
message_digest_algorithm |
option | SHA-256 |
ecdsa_public_key_pem |
text | -----BEGIN PUBLIC KEY----- |
message |
text | — |
message_format |
option | Raw |
Generate ECDSA Key Pair
Section titled “Generate ECDSA Key Pair”Generate an ECDSA key pair with a given Curve.WARNING: Cryptographic operations in CyberChef should not be relied upon to provide security in any situation. No guarantee is offered for their correctness. We advise you not to use keys generated from CyberChef in operational contexts.
- Tool name:
cyberchef_generate_ecdsa_key_pair - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
elliptic_curve |
option | P-256 |
output_format |
option | PEM |
Generate RSA Key Pair
Section titled “Generate RSA Key Pair”Generate an RSA key pair with a given number of bits.WARNING: Cryptographic operations in CyberChef should not be relied upon to provide security in any situation. No guarantee is offered for their correctness. We advise you not to use keys generated from CyberChef in operational contexts.
- Tool name:
cyberchef_generate_rsa_key_pair - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
rsa_key_length |
option | 1024 |
output_format |
option | PEM |
GOST Decrypt
Section titled “GOST Decrypt”The GOST block cipher (Magma), defined in the standard GOST 28147-89 (RFC 5830), is a Soviet and Russian government standard symmetric key block cipher with a block size of 64 bits. The original standard, published in 1989, did not give the cipher any name, but the most recent revision of the standard, GOST R 34.12-2015 (RFC 7801, RFC 8891), specifies that it may be referred to as Magma. The GOST hash function is based on this cipher. The new standard also specifies a new 128-bit block cipher called Kuznyechik.Developed in the 1970s, the standard had been marked ‘Top Secret’ and then downgraded to ‘Secret’ in 1990. Shortly after the dissolution of the USSR, it was declassified and it was released to the public in 1994. GOST 28147 was a Soviet alternative to the United States standard algorithm, DES. Thus, the two are very similar in structure.
- Tool name:
cyberchef_gost_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
input_type |
option | Hex |
output_type |
option | Raw |
algorithm |
argSelector | GOST 28147 (1989) |
sbox |
option | E-TEST |
block_mode |
option | ECB |
key_meshing_mode |
option | NO |
padding |
option | NO |
GOST Encrypt
Section titled “GOST Encrypt”The GOST block cipher (Magma), defined in the standard GOST 28147-89 (RFC 5830), is a Soviet and Russian government standard symmetric key block cipher with a block size of 64 bits. The original standard, published in 1989, did not give the cipher any name, but the most recent revision of the standard, GOST R 34.12-2015 (RFC 7801, RFC 8891), specifies that it may be referred to as Magma. The GOST hash function is based on this cipher. The new standard also specifies a new 128-bit block cipher called Kuznyechik.Developed in the 1970s, the standard had been marked ‘Top Secret’ and then downgraded to ‘Secret’ in 1990. Shortly after the dissolution of the USSR, it was declassified and it was released to the public in 1994. GOST 28147 was a Soviet alternative to the United States standard algorithm, DES. Thus, the two are very similar in structure.
- Tool name:
cyberchef_gost_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
input_type |
option | Raw |
output_type |
option | Hex |
algorithm |
argSelector | GOST 28147 (1989) |
sbox |
option | E-TEST |
block_mode |
option | ECB |
key_meshing_mode |
option | NO |
padding |
option | NO |
GOST Key Unwrap
Section titled “GOST Key Unwrap”A decryptor for keys wrapped using one of the GOST block ciphers.
- Tool name:
cyberchef_gost_key_unwrap - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
user_key_material |
toggleString | {"option":"Hex","string":""} |
input_type |
option | Hex |
output_type |
option | Raw |
algorithm |
argSelector | GOST 28147 (1989) |
sbox |
option | E-TEST |
key_wrapping |
option | NO |
GOST Key Wrap
Section titled “GOST Key Wrap”A key wrapping algorithm for protecting keys in untrusted storage using one of the GOST block cipers.
- Tool name:
cyberchef_gost_key_wrap - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
user_key_material |
toggleString | {"option":"Hex","string":""} |
input_type |
option | Raw |
output_type |
option | Hex |
algorithm |
argSelector | GOST 28147 (1989) |
sbox |
option | E-TEST |
key_wrapping |
option | NO |
GOST Sign
Section titled “GOST Sign”Sign a plaintext message using one of the GOST block ciphers.
- Tool name:
cyberchef_gost_sign - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
input_type |
option | Raw |
output_type |
option | Hex |
algorithm |
argSelector | GOST 28147 (1989) |
sbox |
option | E-TEST |
mac_length |
number | 32 |
GOST Verify
Section titled “GOST Verify”Verify the signature of a plaintext message using one of the GOST block ciphers. Enter the signature in the MAC field.
- Tool name:
cyberchef_gost_verify - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mac |
toggleString | {"option":"Hex","string":""} |
input_type |
option | Raw |
algorithm |
argSelector | GOST 28147 (1989) |
sbox |
option | E-TEST |
PRESENT Decrypt
Section titled “PRESENT Decrypt”PRESENT is an ultra-lightweight block cipher designed for constrained environments such as RFID tags and sensor networks. It operates on 64-bit blocks and supports 80-bit or 128-bit keys with 31 rounds. Standardised in ISO/IEC 29192-2:2019.When using CBC mode, the PKCS#7 padding scheme is used.
- Tool name:
cyberchef_present_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Hex |
output |
option | Raw |
padding |
option | PKCS5 |
PRESENT Encrypt
Section titled “PRESENT Encrypt”PRESENT is an ultra-lightweight block cipher designed for constrained environments such as RFID tags and sensor networks. It operates on 64-bit blocks and supports 80-bit or 128-bit keys with 31 rounds. Standardised in ISO/IEC 29192-2:2019.When using CBC mode, the PKCS#7 padding scheme is used.
- Tool name:
cyberchef_present_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Raw |
output |
option | Hex |
padding |
option | PKCS5 |
Pseudo-Random Integer Generator
Section titled “Pseudo-Random Integer Generator”A cryptographically-secure pseudo-random number generator (PRNG).Generates random integers within a specified range using the browser’s built-in crypto.getRandomValues() method if available.The supported range of integers is from -(2^53 - 1) to (2^53 - 1).
- Tool name:
cyberchef_pseudo_random_integer_generator - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
number_of_integers |
number | 1 |
min_value |
number | 0 |
max_value |
number | 99 |
delimiter |
option | Space |
output |
option | Raw |
Pseudo-Random Number Generator
Section titled “Pseudo-Random Number Generator”A cryptographically-secure pseudo-random number generator (PRNG).This operation uses the browser’s built-in crypto.getRandomValues() method if available. If this cannot be found, it falls back to a Fortuna-based PRNG algorithm.
- Tool name:
cyberchef_pseudo_random_number_generator - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
number_of_bytes |
number | 32 |
output_as |
option | Hex |
Rabbit
Section titled “Rabbit”Rabbit is a high-speed stream cipher introduced in 2003 and defined in RFC 4503.The cipher uses a 128-bit key and an optional 64-bit initialization vector (IV).big-endian: based on RFC4503 and RFC3447little-endian: compatible with Crypto++
- Tool name:
cyberchef_rabbit - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
endianness |
option | Big |
input_arg |
option | Raw |
output |
option | Raw |
Rail Fence Cipher Decode
Section titled “Rail Fence Cipher Decode”Decodes Strings that were created using the Rail fence Cipher provided a key and an offset
- Tool name:
cyberchef_rail_fence_cipher_decode - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
number | 2 |
offset |
number | 0 |
Rail Fence Cipher Encode
Section titled “Rail Fence Cipher Encode”Encodes Strings using the Rail fence Cipher provided a key and an offset
- Tool name:
cyberchef_rail_fence_cipher_encode - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
number | 2 |
offset |
number | 0 |
RC2 Decrypt
Section titled “RC2 Decrypt”RC2 (also known as ARC2) is a symmetric-key block cipher designed by Ron Rivest in 1987. ‘RC’ stands for ‘Rivest Cipher’.Key: RC2 uses a variable size key.IV: To run the cipher in CBC mode, the Initialization Vector should be 8 bytes long. If the IV is left blank, the cipher will run in ECB mode.Padding: In both CBC and ECB mode, PKCS#7 padding will be used.
- Tool name:
cyberchef_rc2_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
input_arg |
option | Hex |
output |
option | Raw |
RC2 Encrypt
Section titled “RC2 Encrypt”RC2 (also known as ARC2) is a symmetric-key block cipher designed by Ron Rivest in 1987. ‘RC’ stands for ‘Rivest Cipher’.Key: RC2 uses a variable size key.You can generate a password-based key using one of the KDF operations.IV: To run the cipher in CBC mode, the Initialization Vector should be 8 bytes long. If the IV is left blank, the cipher will run in ECB mode.Padding: In both CBC and ECB mode, PKCS#7 padding will be used.
- Tool name:
cyberchef_rc2_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
input_arg |
option | Raw |
output |
option | Hex |
RC4 (also known as ARC4) is a widely-used stream cipher designed by Ron Rivest. It is used in popular protocols such as SSL and WEP. Although remarkable for its simplicity and speed, the algorithm’s history doesn’t inspire confidence in its security.
- Tool name:
cyberchef_rc4 - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
passphrase |
toggleString | {"option":"UTF8","string":""} |
input_format |
option | Latin1 |
output_format |
option | Latin1 |
RC4 Drop
Section titled “RC4 Drop”It was discovered that the first few bytes of the RC4 keystream are strongly non-random and leak information about the key. We can defend against this attack by discarding the initial portion of the keystream. This modified algorithm is traditionally called RC4-drop.
- Tool name:
cyberchef_rc4_drop - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
passphrase |
toggleString | {"option":"UTF8","string":""} |
input_format |
option | Latin1 |
output_format |
option | Latin1 |
number_of_dwords_to_drop |
number | 192 |
RC6 Decrypt
Section titled “RC6 Decrypt”RC6 is a symmetric key block cipher derived from RC5. It was designed by Ron Rivest, Matt Robshaw, Ray Sidney, and Yiqun Lisa Yin to meet the requirements of the AES competition, and was one of the five finalists.RC6 is parameterised as RC6-w/r/b where w is word size in bits (any multiple of 8 from 8-256), r is the number of rounds (1-255), and b is the key length in bytes. The standard AES submission uses w=32, r=20. Common word sizes: 8, 16, 32 (standard), 64, 128.IV: The Initialisation Vector should be 4*w/8 bytes (e.g. 16 bytes for w=32). If not entered, it will default to null bytes.Padding: In CBC and ECB mode, the PKCS#7 padding scheme is used.
- Tool name:
cyberchef_rc6_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Hex |
output |
option | Raw |
padding |
option | PKCS5 |
word_size |
number | 32 |
rounds |
number | 20 |
RC6 Encrypt
Section titled “RC6 Encrypt”RC6 is a symmetric key block cipher derived from RC5. It was designed by Ron Rivest, Matt Robshaw, Ray Sidney, and Yiqun Lisa Yin to meet the requirements of the AES competition, and was one of the five finalists.RC6 is parameterised as RC6-w/r/b where w is word size in bits (any multiple of 8 from 8-256), r is the number of rounds (1-255), and b is the key length in bytes. The standard AES submission uses w=32, r=20. Common word sizes: 8, 16, 32 (standard), 64, 128.IV: The Initialisation Vector should be 4*w/8 bytes (e.g. 16 bytes for w=32). If not entered, it will default to null bytes.Padding: In CBC and ECB mode, the PKCS#7 padding scheme is used.
- Tool name:
cyberchef_rc6_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Raw |
output |
option | Hex |
padding |
option | PKCS5 |
word_size |
number | 32 |
rounds |
number | 20 |
RSA Decrypt
Section titled “RSA Decrypt”Decrypt an RSA encrypted message with a PEM encoded private key.
- Tool name:
cyberchef_rsa_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
rsa_private_key_pem |
text | -----BEGIN RSA PRIVATE KEY----- |
key_password |
text | — |
encryption_scheme |
argSelector | RSA-OAEP |
message_digest_algorithm |
option | SHA-1 |
RSA Encrypt
Section titled “RSA Encrypt”Encrypt a message with a PEM encoded RSA public key.
- Tool name:
cyberchef_rsa_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
rsa_public_key_pem |
text | -----BEGIN RSA PUBLIC KEY----- |
encryption_scheme |
argSelector | RSA-OAEP |
message_digest_algorithm |
option | SHA-1 |
RSA Sign
Section titled “RSA Sign”Sign a plaintext message with a PEM encoded RSA key.
- Tool name:
cyberchef_rsa_sign - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
rsa_private_key_pem |
text | -----BEGIN RSA PRIVATE KEY----- |
key_password |
text | — |
message_digest_algorithm |
option | SHA-1 |
RSA Verify
Section titled “RSA Verify”Verify a message against a signature and a public PEM encoded RSA key.
- Tool name:
cyberchef_rsa_verify - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
rsa_public_key_pem |
text | -----BEGIN RSA PUBLIC KEY----- |
message |
text | — |
message_format |
option | Raw |
message_digest_algorithm |
option | SHA-1 |
Salsa20
Section titled “Salsa20”Salsa20 is a stream cipher designed by Daniel J. Bernstein and submitted to the eSTREAM project; Salsa20/8 and Salsa20/12 are round-reduced variants. It is closely related to the ChaCha stream cipher.Key: Salsa20 uses a key of 16 or 32 bytes (128 or 256 bits).Nonce: Salsa20 uses a nonce of 8 bytes (64 bits).Counter: Salsa uses a counter of 8 bytes (64 bits). The counter starts at zero at the start of the keystream, and is incremented at every 64 bytes.
- Tool name:
cyberchef_salsa20 - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
nonce |
toggleString | {"option":"Hex","string":""} |
counter |
number | 0 |
rounds |
option | 20 |
input_arg |
option | Hex |
output |
option | Raw |
SM4 Decrypt
Section titled “SM4 Decrypt”SM4 is a 128-bit block cipher, currently established as a national standard (GB/T 32907-2016) of China.
- Tool name:
cyberchef_sm4_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Raw |
output |
option | Hex |
SM4 Encrypt
Section titled “SM4 Encrypt”SM4 is a 128-bit block cipher, currently established as a national standard (GB/T 32907-2016) of China. Multiple block cipher modes are supported. When using CBC or ECB mode, the PKCS#7 padding scheme is used.
- Tool name:
cyberchef_sm4_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Raw |
output |
option | Hex |
TEA Decrypt
Section titled “TEA Decrypt”TEA (Tiny Encryption Algorithm) is a block cipher designed by David Wheeler and Roger Needham in 1994. It operates on 64-bit blocks using a 128-bit key and performs 32 cycles (64 Feistel rounds) with the DELTA constant 0x9E3779B9 derived from the golden ratio.TEA is notable for its simplicity and compact implementation, making it frequently encountered in malware analysis and CTF challenges. Despite its elegance, TEA has known weaknesses including equivalent keys and susceptibility to related-key attacks, leading to successors XTEA and XXTEA.Key: Must be exactly 16 bytes (128 bits).IV: The Initialisation Vector should be 8 bytes (64 bits). If not entered, it will default to null bytes.Padding: In CBC and ECB mode, the PKCS#5 padding scheme is used.
- Tool name:
cyberchef_tea_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Hex |
output |
option | Raw |
padding |
option | PKCS5 |
TEA Encrypt
Section titled “TEA Encrypt”TEA (Tiny Encryption Algorithm) is a block cipher designed by David Wheeler and Roger Needham in 1994. It operates on 64-bit blocks using a 128-bit key and performs 32 cycles (64 Feistel rounds) with the DELTA constant 0x9E3779B9 derived from the golden ratio.TEA is notable for its simplicity and compact implementation, making it frequently encountered in malware analysis and CTF challenges. Despite its elegance, TEA has known weaknesses including equivalent keys and susceptibility to related-key attacks, leading to successors XTEA and XXTEA.Key: Must be exactly 16 bytes (128 bits).IV: The Initialisation Vector should be 8 bytes (64 bits). If not entered, it will default to null bytes.Padding: In CBC and ECB mode, the PKCS#5 padding scheme is used.
- Tool name:
cyberchef_tea_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Raw |
output |
option | Hex |
padding |
option | PKCS5 |
Triple DES Decrypt
Section titled “Triple DES Decrypt”Triple DES applies DES three times to each block to increase key size.Key: Triple DES uses a key length of 24 bytes (192 bits).IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.Padding: In CBC and ECB mode, PKCS#7 padding will be used as a default.
- Tool name:
cyberchef_triple_des_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Hex |
output |
option | Raw |
Triple DES Encrypt
Section titled “Triple DES Encrypt”Triple DES applies DES three times to each block to increase key size.Key: Triple DES uses a key length of 24 bytes (192 bits).You can generate a password-based key using one of the KDF operations.IV: The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.Padding: In CBC and ECB mode, PKCS#7 padding will be used.
- Tool name:
cyberchef_triple_des_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Raw |
output |
option | Hex |
Twofish Decrypt
Section titled “Twofish Decrypt”Twofish is a symmetric key block cipher designed by Bruce Schneier. It was one of the five AES finalists. Twofish operates on 128-bit blocks and supports key sizes of 128, 192, or 256 bits with 16 rounds of a Feistel network.When using CBC or ECB mode, the PKCS#7 padding scheme is used.
- Tool name:
cyberchef_twofish_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Hex |
output |
option | Raw |
padding |
option | PKCS5 |
Twofish Encrypt
Section titled “Twofish Encrypt”Twofish is a symmetric key block cipher designed by Bruce Schneier. It was one of the five AES finalists. Twofish operates on 128-bit blocks and supports key sizes of 128, 192, or 256 bits with 16 rounds of a Feistel network.When using CBC or ECB mode, the PKCS#7 padding scheme is used.
- Tool name:
cyberchef_twofish_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Raw |
output |
option | Hex |
padding |
option | PKCS5 |
Vigenère Decode
Section titled “Vigenère Decode”The Vigenere cipher is a method of encrypting alphabetic text by using a series of different Caesar ciphers based on the letters of a keyword. It is a simple form of polyalphabetic substitution.
- Tool name:
cyberchef_vigen_re_decode - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
string | — |
Vigenère Encode
Section titled “Vigenère Encode”The Vigenere cipher is a method of encrypting alphabetic text by using a series of different Caesar ciphers based on the letters of a keyword. It is a simple form of polyalphabetic substitution.
- Tool name:
cyberchef_vigen_re_encode - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
string | — |
XSalsa20
Section titled “XSalsa20”XSalsa20 is a variant of the Salsa20 stream cipher designed by Daniel J. Bernstein; XSalsa uses longer nonces.Key: XSalsa20 uses a key of 16 or 32 bytes (128 or 256 bits).Nonce: XSalsa20 uses a nonce of 24 bytes (192 bits).Counter: XSalsa uses a counter of 8 bytes (64 bits). The counter starts at zero at the start of the keystream, and is incremented at every 64 bytes.
- Tool name:
cyberchef_xsalsa20 - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
nonce |
toggleString | {"option":"Hex","string":""} |
counter |
number | 0 |
rounds |
option | 20 |
input_arg |
option | Hex |
output |
option | Raw |
XTEA Decrypt
Section titled “XTEA Decrypt”XTEA (eXtended Tiny Encryption Algorithm) is a block cipher designed by David Wheeler and Roger Needham in 1997 as a successor to TEA, correcting several weaknesses identified in the original algorithm. It operates on 64-bit blocks using a 128-bit key with an improved key schedule that uses sum-dependent key word selection to resist related-key attacks.XTEA retains the simplicity and compact implementation of TEA whilst providing significantly improved security. It is frequently encountered in malware analysis and CTF challenges due to its straightforward implementation.Key: Must be exactly 16 bytes (128 bits).IV: The Initialisation Vector should be 8 bytes (64 bits). If not entered, it will default to null bytes.Rounds: The recommended number of rounds is 32 (default). The reference implementation by Wheeler & Needham accepts a configurable round count.Padding: In CBC and ECB mode, the PKCS#5 padding scheme is used.
- Tool name:
cyberchef_xtea_decrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Hex |
output |
option | Raw |
padding |
option | PKCS5 |
rounds |
number | 32 |
XTEA Encrypt
Section titled “XTEA Encrypt”XTEA (eXtended Tiny Encryption Algorithm) is a block cipher designed by David Wheeler and Roger Needham in 1997 as a successor to TEA, correcting several weaknesses identified in the original algorithm. It operates on 64-bit blocks using a 128-bit key with an improved key schedule that uses sum-dependent key word selection to resist related-key attacks.XTEA retains the simplicity and compact implementation of TEA whilst providing significantly improved security. It is frequently encountered in malware analysis and CTF challenges due to its straightforward implementation.Key: Must be exactly 16 bytes (128 bits).IV: The Initialisation Vector should be 8 bytes (64 bits). If not entered, it will default to null bytes.Rounds: The recommended number of rounds is 32 (default). The reference implementation by Wheeler & Needham accepts a configurable round count.Padding: In CBC and ECB mode, the PKCS#5 padding scheme is used.
- Tool name:
cyberchef_xtea_encrypt - Input / output:
string→string
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
iv |
toggleString | {"option":"Hex","string":""} |
mode |
option | CBC |
input_arg |
option | Raw |
output |
option | Hex |
padding |
option | PKCS5 |
rounds |
number | 32 |
XXTEA Decrypt
Section titled “XXTEA Decrypt”Corrected Block TEA (often referred to as XXTEA) is a block cipher designed to correct weaknesses in the original Block TEA. XXTEA operates on variable-length blocks that are some arbitrary multiple of 32 bits in size (minimum 64 bits). The number of full cycles depends on the block size, but there are at least six (rising to 32 for small block sizes). The original Block TEA applies the XTEA round function to each word in the block and combines it additively with its leftmost neighbour. Slow diffusion rate of the decryption process was immediately exploited to break the cipher. Corrected Block TEA uses a more involved round function which makes use of both immediate neighbours in processing each word in the block.
- Tool name:
cyberchef_xxtea_decrypt - Input / output:
ArrayBuffer→ArrayBuffer
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |
XXTEA Encrypt
Section titled “XXTEA Encrypt”Corrected Block TEA (often referred to as XXTEA) is a block cipher designed to correct weaknesses in the original Block TEA. XXTEA operates on variable-length blocks that are some arbitrary multiple of 32 bits in size (minimum 64 bits). The number of full cycles depends on the block size, but there are at least six (rising to 32 for small block sizes). The original Block TEA applies the XTEA round function to each word in the block and combines it additively with its leftmost neighbour. Slow diffusion rate of the decryption process was immediately exploited to break the cipher. Corrected Block TEA uses a more involved round function which makes use of both immediate neighbours in processing each word in the block.
- Tool name:
cyberchef_xxtea_encrypt - Input / output:
ArrayBuffer→ArrayBuffer
| Argument | Type | Default |
|---|---|---|
key |
toggleString | {"option":"Hex","string":""} |