Operation reference¶

This reference contains all 478 operations registered by rxchef. Operation names are accepted case-insensitively and in normalized forms such as to_hex, to-hex, and ToHex. Use rxchef info <NAME> for the same metadata in the terminal and add --json for machine-readable output.

Arguments are positional in the order shown. Omitted arguments use their defaults. CLI values are strings unless prefixed with num:, bool:, hex:, or bytes:. For named arguments use rxchef run <OP> --arg NAME=VALUE.

Modules¶

Bletchley (7 operations)
Charts (5 operations)
Checksums (1 operations)
Ciphers (60 operations)
Code (23 operations)
Compression (19 operations)
Conversion (1 operations)
Crypto (47 operations)
Default (201 operations)
Diff (1 operations)
Encodings (14 operations)
Handlebars (1 operations)
Hashing (21 operations)
Image (28 operations)
Jq (1 operations)
Maps (1 operations)
Media (1 operations)
OCR (1 operations)
PGP (6 operations)
Protobuf (2 operations)
PublicKey (11 operations)
Regex (13 operations)
Serialise (6 operations)
Shellcode (2 operations)
URL (3 operations)
UserAgent (1 operations)
Yara (1 operations)

Bletchley¶

Bombe¶

Emulation of the Bombe machine used at Bletchley Park to attack Enigma.

Input: String
Output: JSON
CLI: rxchef run "Bombe"

#	Argument	Default	Description
1	Model	`3-rotor`	3-rotor or 4-rotor
2	Left-most (4th) rotor	`LEYJVCNIXWPBQMDRTAKZGFUHOS`	Wiring for the 4th rotor
3	Left-hand rotor	`EKMFLGDQVZNTOWYHXUSPAIBRCJ`	Wiring for the left-hand rotor
4	Middle rotor	`AJDKSIRUXBLHWTMCQGZNPYFVOE`	Wiring for the middle rotor
5	Right-hand rotor	`BDFHJLCPRTXVZNYEIWGAKMUSQO`	Wiring for the right-hand rotor
6	Reflector	`AY BR CU DH EQ FS GL IP JX KN MO TZ VW`	Reflector pairs
7	Crib	`<empty>`	Known plaintext
8	Crib offset	`0`	Offset of the crib in the ciphertext
9	Use checking machine	`true`	Whether to use the checking machine

Colossus¶

Analyses an ITA2 teleprinter tape using the five parallel bit channels used by Colossus. The output contains a printable tape transcription, per-channel one-bit counters, and the number of tape characters processed.

Input: String
Output: JSON
CLI: rxchef run "Colossus"
Arguments: none

Enigma¶

Encipher/decipher with the WW2 Enigma machine.

Input: String
Output: String
CLI: rxchef run "Enigma"

#	Argument	Default	Description
1	Model	`3-rotor`	3-rotor or 4-rotor
2	4th Rotor	`<empty>`	Wiring<Steps
3	4th Ring	`A`	A-Z
4	4th Pos	`A`	A-Z
5	Left Rotor	`EKMFLGDQVZNTOWYHXUSPAIBRCJ<R`	Wiring<Steps
6	Left Ring	`A`	A-Z
7	Left Pos	`A`	A-Z
8	Middle Rotor	`AJDKSIRUXBLHWTMCQGZNPYFVOE<F`	Wiring<Steps
9	Middle Ring	`A`	A-Z
10	Middle Pos	`A`	A-Z
11	Right Rotor	`BDFHJLCPRTXVZNYEIWGAKMUSQO<W`	Wiring<Steps
12	Right Ring	`A`	A-Z
13	Right Pos	`A`	A-Z
14	Reflector	`AY BR CU DH EQ FS GL IP JX KN MO TZ VW`	Pairs
15	Plugboard	`<empty>`	Pairs
16	Strict	`true`	Boolean

Lorenz¶

The Lorenz SZ40/42 cipher attachment was a WW2 German rotor cipher machine.

Input: String
Output: String
CLI: rxchef run "Lorenz"

#	Argument	Default	Description
1	Model	`SZ40`	SZ40, SZ42a, SZ42b
2	Wheel Pattern	`KH Pattern`	KH, ZMUG, BREAM, etc.
3	KT-Schalter	`false`	Enable the SZ42a Klartext feedback switch
4	Mode	`Send`	Send or Receive
5	Input Type	`Plaintext`	Plaintext or ITA2
6	Output Type	`Plaintext`	Plaintext or ITA2
7	ITA2 Format	`5/8/9`	5/8/9 or +/-/.
8	Psi1 start	`1`	1-43
9	Psi2 start	`1`	1-47
10	Psi3 start	`1`	1-51
11	Psi4 start	`1`	1-53
12	Psi5 start	`1`	1-59
13	Mu37 start	`1`	1-37
14	Mu61 start	`1`	1-61
15	Chi1 start	`1`	1-41
16	Chi2 start	`1`	1-31
17	Chi3 start	`1`	1-29
18	Chi4 start	`1`	1-26
19	Chi5 start	`1`	1-23
20	Psi1 lugs	`.x...xx.x.x..xxx.x.x.xxxx.x.x.x.x.x..x.xx.x`	43 long
21	Psi2 lugs	`.xx.x.xxx..x.x.x..x.xx.x.xxx.x....x.xx.x.x.x..x`	47 long
22	Psi3 lugs	`.x.x.x..xxx....x.x.xx.x.x.x..xxx.x.x..x.x.xx..x.x.x`	51 long
23	Psi4 lugs	`.xx...xxxxx.x.x.xx...x.xx.x.x..x.x.xx.x..x.x.x.x.x.x.`	53 long
24	Psi5 lugs	`xx...xx.x..x.xx.x...x.x.x.x.x.x.x.x.xx..xxxx.x.x...xx.x..x.`	59 long
25	Mu37 lugs	`x.x.x.x.x.x...x.x.x...x.x.x...x.x....`	37 long
26	Mu61 lugs	`.xxxx.xxxx.xxx.xxxx.xx....xxx.xxxx.xxxx.xxxx.xxxx.xxx.xxxx...`	61 long
27	Chi1 lugs	`.x...xxx.x.xxxx.x...x.x..xxx....xx.xxxx..`	41 long
28	Chi2 lugs	`x..xxx...x.xxxx..xx..x..xx.xx..`	31 long
29	Chi3 lugs	`..xx..x.xxx...xx...xx..xx.xx.`	29 long
30	Chi4 lugs	`xx..x..xxxx..xx.xxx....x..`	26 long
31	Chi5 lugs	`xx..xx....xxxx.x..x.x..`	23 long

Multiple Bombe¶

Emulation of the Bombe machine used to attack Enigma. This version carries out multiple Bombe runs to handle unknown rotor configurations.

Input: String
Output: JSON
CLI: rxchef run "Multiple Bombe"

#	Argument	Default	Description
1	Standard Enigmas	`German Service Enigma (First - 3 rotor)`	Preset rotor configurations
2	Main rotors	`<empty>`	Newline separated rotor wirings
3	4th rotor	`<empty>`	Newline separated 4th rotor wirings
4	Reflectors	`<empty>`	Newline separated reflector pairs
5	Crib	`<empty>`	Known plaintext
6	Crib offset	`0`	Offset of the crib in the ciphertext
7	Use checking machine	`true`	Whether to use the checking machine

SIGABA¶

Encipher/decipher with the WW2 SIGABA machine.

SIGABA, otherwise known as ECM Mark II, was used by the United States for message encryption during WW2 up to the 1950s. It was developed in the 1930s by the US Army and Navy, and has up to this day never been broken. Consisting of 15 rotors: 5 cipher rotors and 10 rotors (5 control rotors and 5 index rotors) controlling the stepping of the cipher rotors, the rotor stepping for SIGABA is much more complex than other rotor machines of its time, such as Enigma. All example rotor wirings are random example sets.

To configure rotor wirings, for the cipher and control rotors enter a string of letters which map from A to Z, and for the index rotors enter a sequence of numbers which map from 0 to 9. Note that encryption is not the same as decryption, so first choose the desired mode.

Note: Whilst this has been tested against other software emulators, it has not been tested against hardware.

Input: String
Output: String
CLI: rxchef run "SIGABA"

#	Argument	Default	Description
1	1st cipher rotor	`SRGWANHPJZFXVIDQCEUKBYOLMT`	Rotor wiring
2	1st cipher rotor reversed	`false`	Reversed orientation
3	1st cipher rotor initial value	`A`	Initial value
4	2nd cipher rotor	`SRGWANHPJZFXVIDQCEUKBYOLMT`	Rotor wiring
5	2nd cipher rotor reversed	`false`	Reversed orientation
6	2nd cipher rotor initial value	`A`	Initial value
7	3rd cipher rotor	`SRGWANHPJZFXVIDQCEUKBYOLMT`	Rotor wiring
8	3rd cipher rotor reversed	`false`	Reversed orientation
9	3rd cipher rotor initial value	`A`	Initial value
10	4th cipher rotor	`SRGWANHPJZFXVIDQCEUKBYOLMT`	Rotor wiring
11	4th cipher rotor reversed	`false`	Reversed orientation
12	4th cipher rotor initial value	`A`	Initial value
13	5th cipher rotor	`SRGWANHPJZFXVIDQCEUKBYOLMT`	Rotor wiring
14	5th cipher rotor reversed	`false`	Reversed orientation
15	5th cipher rotor initial value	`A`	Initial value
16	1st control rotor	`SRGWANHPJZFXVIDQCEUKBYOLMT`	Rotor wiring
17	1st control rotor reversed	`false`	Reversed orientation
18	1st control rotor initial value	`A`	Initial value
19	2nd control rotor	`SRGWANHPJZFXVIDQCEUKBYOLMT`	Rotor wiring
20	2nd control rotor reversed	`false`	Reversed orientation
21	2nd control rotor initial value	`A`	Initial value
22	3rd control rotor	`SRGWANHPJZFXVIDQCEUKBYOLMT`	Rotor wiring
23	3rd control rotor reversed	`false`	Reversed orientation
24	3rd control rotor initial value	`A`	Initial value
25	4th control rotor	`SRGWANHPJZFXVIDQCEUKBYOLMT`	Rotor wiring
26	4th control rotor reversed	`false`	Reversed orientation
27	4th control rotor initial value	`A`	Initial value
28	5th control rotor	`SRGWANHPJZFXVIDQCEUKBYOLMT`	Rotor wiring
29	5th control rotor reversed	`false`	Reversed orientation
30	5th control rotor initial value	`A`	Initial value
31	1st index rotor	`6201348957`	Rotor wiring
32	1st index rotor initial value	`0`	Initial value
33	2nd index rotor	`6201348957`	Rotor wiring
34	2nd index rotor initial value	`0`	Initial value
35	3rd index rotor	`6201348957`	Rotor wiring
36	3rd index rotor initial value	`0`	Initial value
37	4th index rotor	`6201348957`	Rotor wiring
38	4th index rotor initial value	`0`	Initial value
39	5th index rotor	`6201348957`	Rotor wiring
40	5th index rotor initial value	`0`	Initial value
41	SIGABA mode	`Encrypt`	Encrypt or Decrypt

Typex¶

Encipher/decipher with the WW2 Typex machine.

Input: String
Output: String
CLI: rxchef run "Typex"

#	Argument	Default	Description
1	1st rotor	`MCYLPQUVRXGSAOWNBJEZDTFKHI<BFHNQUW`	Wiring<Steps
2	1st rotor reversed	`false`	Boolean
3	1st rotor ring setting	`A`	A-Z
4	1st rotor initial value	`A`	A-Z
5	2nd rotor	`KHWENRCBISXJQGOFMAPVYZDLTU<BFHNQUW`	Wiring<Steps
6	2nd rotor reversed	`false`	Boolean
7	2nd rotor ring setting	`A`	A-Z
8	2nd rotor initial value	`A`	A-Z
9	3rd rotor	`BYPDZMGIKQCUSATREHOJNLFWXV<BFHNQUW`	Wiring<Steps
10	3rd rotor reversed	`false`	Boolean
11	3rd rotor ring setting	`A`	A-Z
12	3rd rotor initial value	`A`	A-Z
13	4th rotor	`ZANJCGDLVHIXOBRPMSWQUKFYET<BFHNQUW`	Wiring<Steps
14	4th rotor reversed	`false`	Boolean
15	4th rotor ring setting	`A`	A-Z
16	4th rotor initial value	`A`	A-Z
17	5th rotor	`QXBGUTOVFCZPJIHSWERYNDAMLK<BFHNQUW`	Wiring<Steps
18	5th rotor reversed	`false`	Boolean
19	5th rotor ring setting	`A`	A-Z
20	5th rotor initial value	`A`	A-Z
21	Reflector	`AN BC FG IE KD LU MH OR TS VZ WQ XJ YP`	Pairs
22	Plugboard	`ABCDEFGHIJKLMNOPQRSTUVWXYZ`	A-Z (26 chars)
23	Typex keyboard emulation	`None`	None, Encrypt, Decrypt
24	Strict output	`true`	Boolean

Charts¶

Entropy¶

Shannon Entropy, in the context of information theory, is a measure of the rate at which information is produced by a source of data. 8 is the maximum, representing highly unstructured, random data. English language text usually falls somewhere between 3.5 and 5. Properly encrypted or compressed data should have an entropy of over 7.5.

Input: Bytes
Output: String
CLI: rxchef run "Entropy"

#	Argument	Default	Description
1	Chunk size	`0`	Size of each chunk for scanning entropy. 0 means calculate for whole input.

Heatmap chart¶

A heatmap is a graphical representation of data where the individual values contained in a matrix are represented as colors.

Input: String
Output: HTML
CLI: rxchef run "Heatmap chart"

#	Argument	Default	Description
1	Record delimiter	`Line feed`	The record delimiter
2	Field delimiter	`Comma`	The field delimiter
3	Number of vertical bins	`25`	Number of vertical bins
4	Number of horizontal bins	`25`	Number of horizontal bins
5	Use column headers as labels	`true`	Use column headers as labels
6	X label	`<empty>`	X label
7	Y label	`<empty>`	Y label
8	Draw bin edges	`false`	Draw bin edges
9	Min colour value	`white`	Min colour value
10	Max colour value	`black`	Max colour value

Hex Density chart¶

Hex density charts are used in a similar way to scatter charts, however rather than rendering tens of thousands of points, it groups the points into a few hundred hexagons to show the distribution.

Input: String
Output: HTML
CLI: rxchef run "Hex Density chart"

#	Argument	Default	Description
1	Record delimiter	`\\n`	Delimiter between records
2	Field delimiter	`,`	Delimiter between fields
3	Pack radius	`25`	Radius of the hexagons
4	Draw radius	`15`	Radius of the hexagons to draw
5	Use column headers as labels	`true`	Whether to use the first row as headers
6	X label	`<empty>`	Label for the X axis
7	Y label	`<empty>`	Label for the Y axis
8	Draw hexagon edges	`false`	Whether to draw edges around hexagons
9	Min colour value	`#ffffff`	Colour for low density
10	Max colour value	`#000000`	Colour for high density
11	Draw empty hexagons within data boundaries	`false`	Whether to draw empty hexagons

Scatter chart¶

Plots two-variable data as single points on a graph.

Input: String
Output: HTML
CLI: rxchef run "Scatter chart"

#	Argument	Default	Description
1	Record delimiter	`Line feed`	The record delimiter
2	Field delimiter	`Comma`	The field delimiter
3	Use column headers as labels	`true`	Use column headers as labels
4	X label	`<empty>`	X label
5	Y label	`<empty>`	Y label
6	Colour	`blue`	The colour of the points
7	Point radius	`5`	The radius of the points
8	Use colour from third column	`false`	Use colour from third column

Series chart¶

A time series graph is a line graph of repeated measurements taken over regular time intervals.

Input: String
Output: HTML
CLI: rxchef run "Series chart"

#	Argument	Default	Description
1	Record delimiter	`\\n`	Character(s) that separate records
2	Field delimiter	`,`	Character(s) that separate fields
3	X label	`<empty>`	Label for the X axis
4	Point radius	`1`	Radius of points in the graph
5	Series colours	`mediumseagreen, dodgerblue, tomato`	Comma-separated list of colours for each series

Checksums¶

CRC32¶

CRC32 (Cyclic Redundancy Check) is a hash function that produces a 32-bit checksum. It is widely used for error detection in digital networks and storage devices.

Input: Bytes
Output: String
CLI: rxchef run "CRC32"

#	Argument	Default	Description
1	Polynomial	`IEEE`	CRC polynomial (default: IEEE)
2	Initial Value	`0xFFFFFFFF`	Initial CRC value (default: 0xFFFFFFFF)
3	Reflect Input	`true`	Reflect input bytes (true/false)
4	Reflect Output	`true`	Reflect output CRC (true/false)
5	XOR Output	`0xFFFFFFFF`	XOR output with this value (default: 0xFFFFFFFF)

Ciphers¶

A1Z26 Cipher Decode¶

Converts alphabet order numbers into their corresponding alphabet character.

e.g. 1 becomes a and 2 becomes b.

Input: String
Output: String
CLI: rxchef run "A1Z26 Cipher Decode"

#	Argument	Default	Description
1	Delimiter	`Space`	Delimiter between numbers
2	Check format	`true`	Automatically detect delimiter from input format

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.

Input: String
Output: String
CLI: rxchef run "A1Z26 Cipher Encode"

#	Argument	Default	Description
1	Delimiter	`Space`	Delimiter between numbers

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.

Input: Bytes
Output: Bytes
CLI: rxchef run "AES Decrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Decryption key (16, 24, or 32 bytes)
2	IV	`<empty>`	Initialization Vector (16 bytes, optional, defaults to null)
3	Mode	`CBC`	Cipher mode (CBC, CFB, OFB, CTR, GCM, ECB)
4	Input	`Hex`	Input encoding (Hex, Raw)
5	Output	`Raw`	Output encoding (Raw, Hex)
6	GCM Tag	`<empty>`	GCM authentication tag (optional)
7	Additional Authenticated Data	`<empty>`	AAD for GCM mode (optional)

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.

Input: Bytes
Output: Bytes
CLI: rxchef run "AES Encrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Encryption key (16, 24, or 32 bytes)
2	IV	`<empty>`	Initialization Vector (16 bytes, optional, defaults to null)
3	Mode	`CBC`	Cipher mode (CBC, CFB, OFB, CTR, GCM, ECB)
4	Input	`Raw`	Input encoding (Raw, Hex)
5	Output	`Hex`	Output encoding (Hex, Raw)
6	Additional Authenticated Data	`<empty>`	AAD for GCM mode (optional)

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.

Input: Bytes
Output: Bytes
CLI: rxchef run "AES Key Unwrap"

#	Argument	Default	Description
1	Key (KEK)	`<empty>`	Key-encryption key (16, 24, or 32 bytes)
2	IV	`a6a6a6a6a6a6a6a6`	Initialization Vector (8 bytes, defaults to a6a6a6a6a6a6a6a6)
3	Input	`Hex`	Input encoding (Raw, Hex)
4	Output	`Hex`	Output encoding (Raw, Hex)

AES Key Wrap¶

A key wrapping algorithm defined in RFC3394, which is used to protect keys in untrusted storage or communications, using AES.

Input: Bytes
Output: Bytes
CLI: rxchef run "AES Key Wrap"

#	Argument	Default	Description
1	Key (KEK)	`<empty>`	Key-encryption key (16, 24, or 32 bytes)
2	IV	`a6a6a6a6a6a6a6a6`	Initialization Vector (8 bytes, defaults to a6a6a6a6a6a6a6a6)
3	Input	`Hex`	Input encoding (Raw, Hex)
4	Output	`Hex`	Output encoding (Raw, Hex)

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.

Input: String
Output: String
CLI: rxchef run "Affine Cipher Decode"

#	Argument	Default	Description
1	a	`1`	Multiplier parameter (must be coprime to 26)
2	b	`0`	Shift parameter

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 a simple mathematical function, (ax + b) % 26, and converted back to a letter.

Input: String
Output: String
CLI: rxchef run "Affine Cipher Encode"

#	Argument	Default	Description
1	a	`1`	Multiplier parameter (must be coprime to 26)
2	b	`0`	Shift parameter

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.

Input: String
Output: String
CLI: rxchef run "Atbash Cipher"
Arguments: none

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.

Input: String
Output: String
CLI: rxchef run "Bifid Cipher Decode"

#	Argument	Default	Description
1	Keyword	`<empty>`	The keyword to use for the Polybius square

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.

Input: String
Output: String
CLI: rxchef run "Bifid Cipher Encode"

#	Argument	Default	Description
1	Keyword	`<empty>`	The keyword to use for the Polybius square

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.

Input: Bytes
Output: Bytes
CLI: rxchef run "Blowfish Decrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Decryption key (4-56 bytes)
2	IV	`<empty>`	Initialization Vector (8 bytes for non-ECB modes, optional)
3	Mode	`CBC`	Cipher mode (CBC, CFB, OFB, CTR, ECB)
4	Input	`Hex`	Input encoding (Hex, Raw)
5	Output	`Raw`	Output encoding (Raw, Hex)

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.

Input: Bytes
Output: Bytes
CLI: rxchef run "Blowfish Encrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Encryption key (4-56 bytes)
2	IV	`<empty>`	Initialization Vector (8 bytes for non-ECB modes, optional)
3	Mode	`CBC`	Cipher mode (CBC, CFB, OFB, CTR, ECB)
4	Input	`Raw`	Input encoding (Raw, Hex)
5	Output	`Hex`	Output encoding (Hex, Raw)

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.

Input: String
Output: String
CLI: rxchef run "Caesar Box Cipher"

#	Argument	Default	Description
1	Box Height	`1`	Number of rows in the transposition box

Cetacean Cipher Decode¶

Decode Cetacean Cipher input.

e.g. EEEEEEEEEeeEeEEEEEEEEEEEEeeEeEEe becomes hi

Input: String
Output: String
CLI: rxchef run "Cetacean Cipher Decode"
Arguments: none

Cetacean Cipher Encode¶

Converts any input into Cetacean Cipher.

e.g. hi becomes EEEEEEEEEeeEeEEEEEEEEEEEEeeEeEEe

Input: String
Output: String
CLI: rxchef run "Cetacean Cipher Encode"
Arguments: none

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.

Input: String
Output: String
CLI: rxchef run "ChaCha"

#	Argument	Default	Description
1	Key	`<empty>`	The encryption key (16 or 32 bytes)
2	Nonce	`<empty>`	The nonce (8 or 12 bytes)
3	Counter	`0`	Initial counter value
4	Rounds	`20`	Number of rounds (20, 12, or 8)
5	Input	`Hex`	Format of input data
6	Output	`Raw`	Format of output data

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.

Input: Bytes
Output: Bytes
CLI: rxchef run "DES Decrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Decryption key (8 bytes)
2	IV	`<empty>`	Initialization Vector (8 bytes, optional, defaults to null)
3	Mode	`CBC`	Cipher mode (CBC, CFB, OFB, CTR, ECB, CBC/NoPadding, ECB/NoPadding)
4	Input	`Hex`	Input encoding (Hex, Raw)
5	Output	`Raw`	Output encoding (Raw, Hex)

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.

Input: String
Output: Bytes
CLI: rxchef run "DES Encrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Encryption key (8 bytes)
2	IV	`<empty>`	Initialization Vector (8 bytes)
3	Mode	`CBC`	Cipher mode (CBC, CFB, OFB, CTR, ECB)
4	Input	`Raw`	Input encoding (Raw, Hex)
5	Output	`Hex`	Output encoding (Hex, Raw)

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.

Input: String
Output: String
CLI: rxchef run "Derive EVP key"

#	Argument	Default	Description
1	Passphrase	`<empty>`	The passphrase to derive the key from.
2	Key size	`128`	The length of the key to generate in bits.
3	Iterations	`1`	The number of times the hash function is applied.
4	Hashing function	`MD5`	The hash function to use.
5	Salt	`<empty>`	The salt to use. If empty, a random salt will be generated.

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.

Input: String
Output: String
CLI: rxchef run "Derive PBKDF2 key"

#	Argument	Default	Description
1	Passphrase	`<empty>`	The passphrase to derive the key from
2	Key size	`128`	The size of the derived key in bits
3	Iterations	`1`	The number of iterations to perform
4	Hashing function	`SHA256`	The hashing function to use
5	Salt	`<empty>`	The salt to use (if empty, a random one will be generated)

ECDSA Sign¶

Sign a plaintext message with a PEM encoded EC key.

Input: String
Output: String
CLI: rxchef run "ECDSA Sign"

#	Argument	Default	Description
1	ECDSA Private Key (PEM)	`-----BEGIN EC PRIVATE KEY-----`	The PEM encoded ECDSA private key
2	Message Digest Algorithm	`SHA-256`	The hash algorithm to use
3	Output Format	`ASN.1 HEX`	The format of the output signature

ECDSA Signature Conversion¶

Convert an ECDSA signature between hex, asn1 and json.

Input: String
Output: String
CLI: rxchef run "ECDSA Signature Conversion"

#	Argument	Default	Description
1	Input Format	`Auto`	The format of the input signature
2	Output Format	`ASN.1 HEX`	The desired output format

ECDSA Verify¶

Verify a message against a signature and a public PEM encoded EC key.

Input: String
Output: String
CLI: rxchef run "ECDSA Verify"

#	Argument	Default	Description
1	Input Format	`Auto`	The format of the input signature
2	Message Digest Algorithm	`SHA-256`	The hash algorithm to use
3	ECDSA Public Key (PEM)	`-----BEGIN PUBLIC KEY-----`	The PEM encoded ECDSA public key
4	Message	`<empty>`	The message to verify
5	Message format	`Raw`	The format of the message

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.

Input: String
Output: String
CLI: rxchef run "GOST Decrypt"

#	Argument	Default	Description
1	Key	`<empty>`	The decryption key.
2	IV	`<empty>`	The initialization vector.
3	Input type	`Hex`	Type of input data
4	Output type	`Raw`	Type of output data
5	Algorithm	`GOST R 34.12 (Magma, 2015)`	GOST version
6	sBox	`E-TEST`	S-Box to use (1989 only)
7	Block mode	`ECB`	Mode of operation
8	Key meshing mode	`NO`	Key meshing
9	Padding	`NO`	Padding scheme

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.

Input: Bytes
Output: Bytes
CLI: rxchef run "GOST Encrypt"

#	Argument	Default	Description
1	Key	`<empty>`	The encryption key.
2	IV	`<empty>`	The initialization vector.
3	Input type	`Raw`	Input encoding (Raw, Hex)
4	Output type	`Hex`	Output encoding (Hex, Raw)
5	Algorithm	`GOST 28147 (1989)`	The GOST algorithm to use.
6	sBox	`E-TEST`	The sBox to use (only for GOST 28147 (1989)).
7	Block mode	`ECB`	The block cipher mode to use.
8	Key meshing mode	`NO`	The key meshing mode to use.
9	Padding	`PKCS5`	The padding scheme to use.

GOST Key Unwrap¶

A decryptor for keys wrapped using one of the GOST block ciphers.

Input: String
Output: String
CLI: rxchef run "GOST Key Unwrap"

#	Argument	Default	Description
1	Key	`<empty>`	The decryption key.
2	User Key Material	`<empty>`	UKM
3	Input type	`Hex`	Type of input data
4	Output type	`Raw`	Type of output data
5	Algorithm	`GOST R 34.12 (Magma, 2015)`	GOST version
6	sBox	`E-TEST`	S-Box to use (1989 only)
7	Key wrapping	`NO`	Key wrapping mode

GOST Key Wrap¶

A key wrapping algorithm for protecting keys in untrusted storage using one of the GOST block ciphers.

Input: Bytes
Output: Bytes
CLI: rxchef run "GOST Key Wrap"

#	Argument	Default	Description
1	Key	`<empty>`	The Key Encryption Key (KEK).
2	User Key Material	`<empty>`	User Key Material (UKM).
3	Input type	`Raw`	Input encoding (Raw, Hex)
4	Output type	`Hex`	Output encoding (Hex, Raw)
5	Algorithm	`GOST 28147 (1989)`	The GOST algorithm to use.
6	sBox	`E-TEST`	The sBox to use (only for GOST 28147 (1989)).
7	Key wrapping	`NO`	The key wrapping mode.

GOST Sign¶

Sign a plaintext message (calculate MAC) using one of the GOST block ciphers.

Input: Bytes
Output: Bytes
CLI: rxchef run "GOST Sign"

#	Argument	Default	Description
1	Key	`<empty>`	The encryption key.
2	IV	`<empty>`	The initialization vector.
3	Input type	`Raw`	Input encoding (Raw, Hex)
4	Output type	`Hex`	Output encoding (Hex, Raw)
5	Algorithm	`GOST 28147 (1989)`	The GOST algorithm to use.
6	sBox	`E-TEST`	The sBox to use (only for GOST 28147 (1989)).
7	MAC length	`32`	The length of the MAC in bits.

GOST Verify¶

Verify the signature of a plaintext message using one of the GOST block ciphers. Enter the signature in the MAC field.

Input: String
Output: String
CLI: rxchef run "GOST Verify"

#	Argument	Default	Description
1	Key	`<empty>`	The decryption key.
2	IV	`<empty>`	The initialization vector.
3	MAC	`<empty>`	The signature/MAC to verify.
4	Input type	`Raw`	Type of input data
5	Algorithm	`GOST R 34.12 (Magma, 2015)`	GOST version
6	sBox	`E-TEST`	S-Box to use (1989 only)

Generate ECDSA Key Pair¶

Generate an ECDSA key pair with a given Curve.

Input: String
Output: String
CLI: rxchef run "Generate ECDSA Key Pair"

#	Argument	Default	Description
1	Elliptic Curve	`P-256`	Curve to use
2	Output Format	`PEM`	Format of the output keys

Generate RSA Key Pair¶

Generate an RSA key pair with a given number of bits.

Input: String
Output: String
CLI: rxchef run "Generate RSA Key Pair"

#	Argument	Default	Description
1	RSA Key Length	`2048`	RSA Key Length
2	Output Format	`PEM`	Output Format

Pseudo-Random Integer Generator¶

A cryptographically-secure pseudo-random number generator (PRNG). Generates random integers within a specified range. The supported range of integers is from -(2^53 - 1) to (2^53 - 1).

Input: String
Output: Bytes
CLI: rxchef run "Pseudo-Random Integer Generator"

#	Argument	Default	Description
1	Number of Integers	`1`	How many integers to generate
2	Min Value	`0`	Minimum value (inclusive)
3	Max Value	`99`	Maximum value (inclusive)
4	Delimiter	`Space`	Delimiter between integers
5	Output	`Decimal`	Output format (Raw, Hex, Decimal)

Pseudo-Random Number Generator¶

A cryptographically-secure pseudo-random number generator (PRNG). This operation uses a cryptographically secure RNG.

Input: String
Output: Bytes
CLI: rxchef run "Pseudo-Random Number Generator"

#	Argument	Default	Description
1	Number of bytes	`32`	How many bytes to generate
2	Output as	`Hex`	Output format (Hex, Integer, Byte array, Raw)

RC2 Decrypt¶

RC2 (also known as ARC2) is a symmetric-key block cipher designed by Ron Rivest in 1987. Supports CBC mode (8-byte IV) or ECB mode (empty IV). Uses PKCS#7 padding.

Input: Bytes
Output: Bytes
CLI: rxchef run "RC2 Decrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Decryption key as UTF-8 or hex (prefix 0x for hex)
2	IV	`<empty>`	Initialization vector (8 bytes for CBC, empty for ECB)
3	Input	`Hex`	Input encoding: Hex or Raw
4	Output	`Raw`	Output encoding: Raw or Hex

RC2 Encrypt¶

RC2 (also known as ARC2) is a symmetric-key block cipher designed by Ron Rivest in 1987. Supports CBC mode (8-byte IV) or ECB mode (empty IV). Uses PKCS#7 padding.

Input: Bytes
Output: Bytes
CLI: rxchef run "RC2 Encrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Encryption key as UTF-8 or hex (prefix 0x for hex)
2	IV	`<empty>`	Initialization vector (8 bytes for CBC, empty for ECB)
3	Input	`Raw`	Input encoding: Raw or Hex
4	Output	`Hex`	Output encoding: Hex or Raw

RC4¶

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.

Input: Bytes
Output: Bytes
CLI: rxchef run "RC4"

#	Argument	Default	Description
1	Key	`<empty>`	Passphrase/key as UTF-8 string or hex (prefix 0x for hex)
2	Input format	`Raw`	Input encoding: Raw or Hex
3	Output format	`Hex`	Output encoding: Raw or Hex

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.

Input: Bytes
Output: String
CLI: rxchef run "RC4 Drop"

#	Argument	Default	Description
1	Key	`<empty>`	Passphrase/key as UTF-8 string or hex (prefix 0x for hex)
2	Input format	`Raw`	Input encoding: Raw or Hex
3	Output format	`Hex`	Output encoding: Raw or Hex
4	Number of dwords to drop	`192`	Number of 4-byte dwords to discard from keystream start (default: 192)

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.

Input: String
Output: String
CLI: rxchef run "RC6 Decrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Key
2	IV	`<empty>`	IV
3	Mode	`CBC`	Mode
4	Input	`Hex`	Input format
5	Output	`Raw`	Output format
6	Padding	`PKCS5`	Padding scheme
7	Word Size	`32`	Word size in bits (8-256)
8	Rounds	`20`	Number of rounds (1-255)

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.

Input: String
Output: String
CLI: rxchef run "RC6 Encrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Key
2	IV	`<empty>`	IV
3	Mode	`CBC`	Mode
4	Input	`Raw`	Input format
5	Output	`Hex`	Output format
6	Padding	`PKCS5`	Padding scheme
7	Word Size	`32`	Word size in bits (8-256)
8	Rounds	`20`	Number of rounds (1-255)

ROT13¶

Rotates each letter by 13 positions in the alphabet. ROT13 is a simple Caesar cipher.

Input: String
Output: String
CLI: rxchef run "ROT13"

#	Argument	Default	Description
1	Rotate lower case chars	`true`	Apply rotation to a-z
2	Rotate upper case chars	`true`	Apply rotation to A-Z
3	Rotate digits	`false`	Apply ROT5 to digits 0-9
4	Amount	`13`	Amount to rotate (default 13)

ROT13 Brute Force¶

Tries all 25 rotation values for ROT13 and outputs each result.

Input: String
Output: String
CLI: rxchef run "ROT13 Brute Force"

#	Argument	Default	Description
1	Sample length	`100`	Max characters from each result to show
2	Sample offset	`0`	Start offset in input
3	Print spaces	`true`	Print spaces between results
4	Print letter score	`false`	Include letter frequency score

ROT47¶

Substitutes characters in the printable ASCII range (0x21-0x7E) by rotating each by 47 positions.

Input: String
Output: String
CLI: rxchef run "ROT47"
Arguments: none

RSA Decrypt¶

Decrypt an RSA encrypted message with a PEM encoded private key.

Input: String
Output: String
CLI: rxchef run "RSA Decrypt"

#	Argument	Default	Description
1	RSA Private Key (PEM)	`-----BEGIN RSA PRIVATE KEY-----`	RSA Private Key (PEM)
2	Key Password	`<empty>`	Key Password
3	Encryption Scheme	`RSA-OAEP`	Encryption Scheme
4	Message Digest Algorithm	`SHA-256`	Message Digest Algorithm (for OAEP)

RSA Encrypt¶

Encrypt a message with a PEM encoded RSA public key.

Input: String
Output: String
CLI: rxchef run "RSA Encrypt"

#	Argument	Default	Description
1	RSA Public Key (PEM)	`-----BEGIN RSA PUBLIC KEY-----`	RSA Public Key (PEM)
2	Encryption Scheme	`RSA-OAEP`	Encryption Scheme
3	Message Digest Algorithm	`SHA-256`	Message Digest Algorithm (for OAEP)

RSA Sign¶

Sign a plaintext message with a PEM encoded RSA key.

Input: String
Output: String
CLI: rxchef run "RSA Sign"

#	Argument	Default	Description
1	RSA Private Key (PEM)	`-----BEGIN RSA PRIVATE KEY-----`	RSA Private Key (PEM)
2	Key Password	`<empty>`	Password for the private key (if encrypted)
3	Message Digest Algorithm	`SHA-256`	Message Digest Algorithm

RSA Verify¶

Verify a message against a signature and a public PEM encoded RSA key.

Input: String
Output: String
CLI: rxchef run "RSA Verify"

#	Argument	Default	Description
1	RSA Public Key (PEM)	`-----BEGIN RSA PUBLIC KEY-----`	RSA Public Key (PEM)
2	Message	`<empty>`	Message to verify
3	Message format	`Raw`	Format of the message
4	Message Digest Algorithm	`SHA-256`	Message Digest Algorithm

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 RFC3447
little-endian: compatible with Crypto++

Input: String
Output: String
CLI: rxchef run "Rabbit"

#	Argument	Default	Description
1	Key	`<empty>`	128-bit key
2	IV	`<empty>`	64-bit IV
3	Endianness	`Big`	Big or Little
4	Input	`Raw`	Raw or Hex
5	Output	`Raw`	Raw or Hex

Rail Fence Cipher Decode¶

Decodes Strings that were created using the Rail fence Cipher provided a key and an offset.

Input: String
Output: String
CLI: rxchef run "Rail Fence Cipher Decode"

#	Argument	Default	Description
1	Key	`2`	Number of rails (must be >= 2)
2	Offset	`0`	Offset value

Rail Fence Cipher Encode¶

Encodes Strings using the Rail fence Cipher provided a key and an offset.

Input: String
Output: String
CLI: rxchef run "Rail Fence Cipher Encode"

#	Argument	Default	Description
1	Key	`2`	Number of rails (must be >= 2)
2	Offset	`0`	Offset value

SM4 Decrypt¶

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.

Input: String
Output: Bytes
CLI: rxchef run "SM4 Decrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Decryption key (16 bytes, 128 bits)
2	IV	`<empty>`	Initialization Vector (16 bytes for CBC/CFB/OFB/CTR modes)
3	Mode	`CBC`	Cipher mode (CBC, CFB, OFB, CTR, ECB, CBC/NoPadding, ECB/NoPadding)
4	Input	`Hex`	Input encoding (Raw, Hex)
5	Output	`Raw`	Output encoding (Raw, Hex)

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.

Input: String
Output: Bytes
CLI: rxchef run "SM4 Encrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Encryption key (16 bytes, 128 bits)
2	IV	`<empty>`	Initialization Vector (16 bytes for CBC/CFB/OFB/CTR modes)
3	Mode	`CBC`	Cipher mode (CBC, CFB, OFB, CTR, ECB, CBC/NoPadding, ECB/NoPadding)
4	Input	`Raw`	Input encoding (Raw, Hex)
5	Output	`Hex`	Output encoding (Hex, Raw)

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.

Input: String
Output: Bytes
CLI: rxchef run "Salsa20"

#	Argument	Default	Description
1	Key	`<empty>`	Key (16 or 32 bytes)
2	Nonce	`<empty>`	Nonce (8 bytes)
3	Counter	`0`	Initial counter value
4	Rounds	`20`	Number of rounds (20, 12, or 8)
5	Input	`Raw`	Input format (Raw, Hex)
6	Output	`Raw`	Output format (Raw, Hex)

Triple DES Decrypt¶

Decrypts data using Triple DES (3DES). Key must be 16 or 24 bytes. IV must be 8 bytes for CBC mode. Modes supported: CBC, ECB. Input/output can be Hex or Raw.

Input: String
Output: String
CLI: rxchef run "Triple DES Decrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Decryption key (16 or 24 bytes). Encoding: Hex, UTF8, Latin1, Base64
2	Key encoding	`Hex`	Encoding of the key: Hex, UTF8, Latin1, Base64
3	IV	`<empty>`	Initialization vector (8 bytes for CBC). Encoding: Hex, UTF8, Latin1, Base64
4	IV encoding	`Hex`	Encoding of the IV: Hex, UTF8, Latin1, Base64
5	Mode	`CBC`	Cipher mode: CBC, ECB, CBC/NoPadding, ECB/NoPadding
6	Input	`Hex`	Input encoding: Hex, Raw
7	Output	`Raw`	Output encoding: Raw, Hex

Triple DES Encrypt¶

Encrypts data using Triple DES (3DES). Key must be 16 or 24 bytes. IV must be 8 bytes for CBC mode. Modes supported: CBC, ECB. Input/output can be Raw or Hex.

Input: String
Output: String
CLI: rxchef run "Triple DES Encrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Encryption key (16 or 24 bytes). Encoding: Hex, UTF8, Latin1, Base64
2	Key encoding	`Hex`	Encoding of the key: Hex, UTF8, Latin1, Base64
3	IV	`<empty>`	Initialization vector (8 bytes for CBC). Encoding: Hex, UTF8, Latin1, Base64
4	IV encoding	`Hex`	Encoding of the IV: Hex, UTF8, Latin1, Base64
5	Mode	`CBC`	Cipher mode: CBC, ECB
6	Input	`Raw`	Input encoding: Raw, Hex
7	Output	`Hex`	Output encoding: Hex, Raw

Vigenre 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.

Input: String
Output: String
CLI: rxchef run "Vigenre Decode"

#	Argument	Default	Description
1	Key	`<empty>`	Key for the Vigenre cipher (letters only)

Vigenre 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.

Input: String
Output: String
CLI: rxchef run "Vigenre Encode"

#	Argument	Default	Description
1	Key	`<empty>`	Key for the Vigenre cipher (letters only)

XSalsa20¶

XSalsa is an extended-nonce Salsa stream cipher designed by Daniel J. Bernstein. It uses a 32-byte key, a 24-byte nonce, and a 64-bit block counter. The standard 20-round cipher and reduced-round XSalsa12 and XSalsa8 variants are supported.

Input: String
Output: String
CLI: rxchef run "XSalsa20"

#	Argument	Default	Description
1	Key	`<empty>`	Key to use for encryption/decryption
2	Nonce	`<empty>`	Nonce to use
3	Counter	`0`	Starting counter value
4	Rounds	`20`	Number of rounds
5	Input	`Raw`	Input format
6	Output	`Raw`	Output format

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).

Input: Bytes
Output: Bytes
CLI: rxchef run "XXTEA Decrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Key for XXTEA decryption

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).

Input: Bytes
Output: Bytes
CLI: rxchef run "XXTEA Encrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Key for XXTEA encryption

Code¶

CSS Beautify¶

Indents and prettifies Cascading Style Sheets (CSS) code.

Input: String
Output: String
CLI: rxchef run "CSS Beautify"

#	Argument	Default	Description
1	Indent string		String to use for each level of indentation

CSS Minify¶

Compresses Cascading Style Sheets (CSS) code by removing unnecessary whitespace and optionally stripping block comments.

Input: String
Output: String
CLI: rxchef run "CSS Minify"

#	Argument	Default	Description
1	Preserve comments	`false`	Keep CSS block comments in output

CSS selector¶

Extract information from an HTML document with a CSS selector

Input: String
Output: String
CLI: rxchef run "CSS selector"

#	Argument	Default	Description
1	CSS selector	`<empty>`	The CSS selector query.
2	Delimiter	`\\n`	The character(s) to delimit the output.

From MessagePack¶

Converts MessagePack encoded data to JSON. MessagePack is a computer data interchange format. It is a binary form for representing simple data structures like arrays and associative arrays.

Input: Bytes
Output: JSON
CLI: rxchef run "From MessagePack"
Arguments: none

Generic Code Beautify¶

Attempts to pretty print C-style languages such as C, C++, C#, Java, PHP, JavaScript etc.

This will not do a perfect job, and the resulting code may not work any more. This operation is designed purely to make obfuscated or minified code more easy to read and understand.

Things which will not work properly:

For loop formatting
Do-While loop formatting
Switch/Case indentation
Certain bit shift operators

Input: String
Output: String
CLI: rxchef run "Generic Code Beautify"
Arguments: none

JPath expression¶

Extract information from a JSON object with a JPath query.

Input: String
Output: String
CLI: rxchef run "JPath expression"

#	Argument	Default	Description
1	Query	`<empty>`	The JPath query to run
2	Result delimiter	`\\n`	The delimiter to use between results

JSON Beautify¶

Indents and pretty prints JavaScript Object Notation (JSON) code.

Input: String
Output: String
CLI: rxchef run "JSON Beautify"

#	Argument	Default	Description
1	Indent string		String used for indentation (e.g. tab or spaces)
2	Sort Object Keys	`false`	Sort keys in JSON objects alphabetically

JSON Minify¶

Compresses JavaScript Object Notation (JSON) code.

Input: String
Output: String
CLI: rxchef run "JSON Minify"
Arguments: none

JavaScript Beautify¶

Parses and pretty prints valid JavaScript code. Note: This implementation uses heuristic-based formatting as a full JS parser is not available.

Input: String
Output: String
CLI: rxchef run "JavaScript Beautify"

#	Argument	Default	Description
1	Indent string		String to use for each level of indentation

JavaScript Minify¶

Safely reduces JavaScript source by removing lexical comments, blank lines, and redundant horizontal whitespace while preserving quoted strings, template literals, escapes, and comment-like text inside them.

Input: String
Output: String
CLI: rxchef run "JavaScript Minify"
Arguments: none

JavaScript Parser¶

Parses JavaScript and returns a SWC Abstract Syntax Tree as JSON. Optional source locations, byte ranges, tokens, comments, and recoverable parser errors can be included.

Input: String
Output: String
CLI: rxchef run "JavaScript Parser"

#	Argument	Default	Description
1	Location info	`false`	Include line and column location information
2	Range info	`false`	Include range information
3	Include tokens array	`false`	Include tokens array
4	Include comments array	`false`	Include comments array
5	Report errors and try to continue	`false`	Report errors and try to continue

Jsonata Query¶

Optional backend unavailable

This operation is feature-gated and unavailable in the minimal documentation build. See the feature matrix for the required Cargo feature.

Query and transform JSON data using jaq. Jsonata is not natively available in Rust, so jaq is used as an alternative. Enable with: --features jsonata

Input: JSON
Output: JSON
CLI: rxchef run "Jsonata Query"

#	Argument	Default	Description
1	Query	`.`	The jaq query to run

Render Markdown¶

Renders Markdown as safe HTML. Raw HTML is escaped, URLs can be linked automatically, fenced code blocks can be syntax-highlighted, and links can open in a new tab.

Input: String
Output: HTML
CLI: rxchef run "Render Markdown"

#	Argument	Default	Description
1	Autoconvert URLs to links	`false`	Autoconvert URLs to links
2	Enable syntax highlighting	`true`	Highlight strings, numbers, comments, and common language keywords in fenced code blocks
3	Open links in new tab.	`false`	Adds target="_blank" to links.

SQL Beautify¶

Indents and prettifies Structured Query Language (SQL) code.

Input: String
Output: String
CLI: rxchef run "SQL Beautify"

#	Argument	Default	Description
1	Indent string	`\\t`	String used for indentation (e.g. tab or spaces)

SQL Minify¶

Compresses Structured Query Language (SQL) code.

Input: String
Output: String
CLI: rxchef run "SQL Minify"
Arguments: none

Syntax highlighter¶

Adds syntax highlighting to a range of source code languages. Note that this will not indent the code. Use one of the 'Beautify' operations for that.

Input: String
Output: HTML
CLI: rxchef run "Syntax highlighter"

#	Argument	Default	Description
1	Language	`auto detect`	Language to highlight

To Camel case¶

Converts the input string to camel case.

Camel case is all lower case except letters after word boundaries which are uppercase.

e.g. thisIsCamelCase

Input: String
Output: String
CLI: rxchef run "To Camel case"

#	Argument	Default	Description
1	Attempt to be context aware	`false`	Attempt to nicely transform variable and function names.

To Kebab case¶

Converts the input string to kebab case.

Kebab case is all lower case with dashes as word boundaries.

e.g. this-is-kebab-case

'Attempt to be context aware' will make the operation attempt to nicely transform variable and function names.

Input: String
Output: String
CLI: rxchef run "To Kebab case"

#	Argument	Default	Description
1	Attempt to be context aware	`false`	Attempt to nicely transform variable and function names.

To MessagePack¶

Converts JSON to MessagePack encoded byte buffer. MessagePack is a computer data interchange format. It is a binary form for representing simple data structures like arrays and associative arrays.

Input: JSON
Output: Bytes
CLI: rxchef run "To MessagePack"
Arguments: none

To Snake case¶

Converts the input string to snake case.

Snake case is all lower case with underscores as word boundaries.

e.g. this_is_snake_case

Input: String
Output: String
CLI: rxchef run "To Snake case"

#	Argument	Default	Description
1	Attempt to be context aware	`false`	Attempt to nicely transform variable and function names.

XML Beautify¶

Indents and prettifies eXtensible Markup Language (XML) code.

Input: String
Output: String
CLI: rxchef run "XML Beautify"

#	Argument	Default	Description
1	Indent string	`\\t`	The string to use for indentation

XML Minify¶

Compresses eXtensible Markup Language (XML) code.

Input: String
Output: String
CLI: rxchef run "XML Minify"

#	Argument	Default	Description
1	Preserve comments	`false`	Preserve XML comments

XPath expression¶

Extract information from an XML document with an XPath query

Input: String
Output: String
CLI: rxchef run "XPath expression"

#	Argument	Default	Description
1	XPath	`<empty>`	The XPath query
2	Result delimiter	`\\n`	The delimiter to use between results

Compression¶

Bzip2 Compress¶

Bzip2 is a compression library developed by Julian Seward (of GHC fame) that uses the Burrows-Wheeler algorithm. It only supports compressing single files and its compression is slow, however is more effective than Deflate (.gz & .zip).

Input: Bytes
Output: Bytes
CLI: rxchef run "Bzip2 Compress"

#	Argument	Default	Description
1	Block size (100s of kb)	`9`	Block size for compression (1-9)
2	Work factor	`30`	Effort spent on difficult data (0-250, 30 is default)

Bzip2 Decompress¶

Decompresses data using the Bzip2 algorithm.

Input: Bytes
Output: Bytes
CLI: rxchef run "Bzip2 Decompress"

#	Argument	Default	Description
1	Use low-memory, slower decompression algorithm	`false`	Use a slower algorithm that requires less memory

Gunzip¶

Decompresses data which has been compressed using the deflate algorithm with gzip headers.

Input: Bytes
Output: Bytes
CLI: rxchef run "Gunzip"
Arguments: none

Gzip¶

Compresses data using the deflate algorithm with gzip headers. Compression type options: Fixed, Dynamic (default), No compression.

Input: Bytes
Output: Bytes
CLI: rxchef run "Gzip"

#	Argument	Default	Description
1	Compression type	`Dynamic`	Compression level: Dynamic, Best speed, Best compression, No compression
2	Filename (optional)	`<empty>`	Optional filename to embed in the gzip header

LZ4 Compress¶

LZ4 is a lossless data compression algorithm that is focused on compression and decompression speed. It belongs to the LZ77 family of byte-oriented compression schemes.

Input: Bytes
Output: Bytes
CLI: rxchef run "LZ4 Compress"
Arguments: none

LZ4 Decompress¶

LZ4 is a lossless data compression algorithm that is focused on compression and decompression speed. It belongs to the LZ77 family of byte-oriented compression schemes.

Input: Bytes
Output: Bytes
CLI: rxchef run "LZ4 Decompress"
Arguments: none

LZMA Compress¶

Compresses data using the Lempel–Ziv–Markov chain algorithm. Compression mode determines the speed and effectiveness of the compression: 1 is fastest and less effective, 9 is slowest and most effective

Input: Bytes
Output: Bytes
CLI: rxchef run "LZMA Compress"

#	Argument	Default	Description
1	Compression Mode	`7`	Compression mode determines the speed and effectiveness of the compression: 1 is fastest and less effective, 9 is slowest and most effective

LZMA Decompress¶

Decompresses data using the Lempel-Ziv-Markov chain Algorithm.

Input: Bytes
Output: Bytes
CLI: rxchef run "LZMA Decompress"
Arguments: none

LZNT1 Decompress¶

Decompresses data using the LZNT1 algorithm.

Similar to the Windows API RtlDecompressBuffer.

Input: Bytes
Output: Bytes
CLI: rxchef run "LZNT1 Decompress"
Arguments: none

LZString Compress¶

Compress the input with lz-string.

Input: String
Output: String
CLI: rxchef run "LZString Compress"

#	Argument	Default	Description
1	Compression Format	`Standard`	Output format. Only 'Standard' is currently implemented.

LZString Decompress¶

Decompresses data that was compressed with lz-string.

Input: String
Output: String
CLI: rxchef run "LZString Decompress"

#	Argument	Default	Description
1	Compression Format	`Standard`	The format the data was compressed in.

Raw Deflate¶

Compresses data using the raw deflate algorithm without any headers (RFC 1951).

Input: Bytes
Output: Bytes
CLI: rxchef run "Raw Deflate"

#	Argument	Default	Description
1	Compression type	`Dynamic`	Compression level: Dynamic (default), Best speed, Best compression, No compression

Raw Inflate¶

Decompresses data compressed with the raw deflate algorithm (no headers, RFC 1951).

Input: Bytes
Output: Bytes
CLI: rxchef run "Raw Inflate"
Arguments: none

Tar¶

Packs the input into a tarball.

No support for multiple files at this time.

Input: Bytes
Output: Bytes
CLI: rxchef run "Tar"

#	Argument	Default	Description
1	Filename	`file.txt`	Name of the file to be packed

Untar¶

Unpacks a tarball and displays it per file.

Input: Bytes
Output: Bytes
CLI: rxchef run "Untar"
Arguments: none

Unzip¶

Decompresses data using the PKZIP algorithm and displays it per file, with support for passwords.

Input: Bytes
Output: Bytes
CLI: rxchef run "Unzip"

#	Argument	Default	Description
1	Password	`<empty>`	Password for encrypted zip files
2	Verify result	`false`	Verify result (ignored in this port)

Zip¶

Compresses data using the PKZIP algorithm with the given filename.

No support for multiple files at this time.

Input: Bytes
Output: Bytes
CLI: rxchef run "Zip"

#	Argument	Default	Description
1	Filename	`file.txt`	Name of the file to be zipped
2	Comment	`<empty>`	Comment to add to the zip file
3	Password	`<empty>`	Password to protect the zip file (ZipCrypto)
4	Compression method	`Deflate`	Method to use for compression
5	Operating system	`Unix`	OS to set in the zip metadata
6	Compression type	`Dynamic`	Compression level/type (Fixed, Dynamic, None)

Zlib Deflate¶

Compresses data using the deflate algorithm with zlib headers (RFC 1950).

Input: Bytes
Output: Bytes
CLI: rxchef run "Zlib Deflate"

#	Argument	Default	Description
1	Compression type	`Dynamic`	Compression level: Dynamic (default), Best speed, Best compression, No compression

Zlib Inflate¶

Decompresses data compressed with the zlib deflate algorithm (RFC 1950).

Input: Bytes
Output: Bytes
CLI: rxchef run "Zlib Inflate"
Arguments: none

Conversion¶

CSV to JSON¶

Converts a CSV file to JSON format. The first row is used as the header for 'Array of dictionaries' format. Supports quoted fields with embedded delimiters and escaped double-quotes.

Input: String
Output: JSON
CLI: rxchef run "CSV to JSON"

#	Argument	Default	Description
1	Cell delimiter	`,`	Character used to separate fields
2	Row delimiter		Character(s) used to separate rows
3	Format	`Array of dictionaries`	Output format: 'Array of dictionaries' or 'Array of arrays'

Crypto¶

Adler-32 Checksum¶

Adler-32 is a checksum algorithm which was invented by Mark Adler in 1995, and is a modification of the Fletcher checksum. Compared to a cyclic redundancy check of the same length, it trades reliability for speed (preferring the latter).

Input: Bytes
Output: String
CLI: rxchef run "Adler-32 Checksum"
Arguments: none

Analyse UUID¶

Operation for extracting metadata and detecting the version of a given UUID.

Input: String
Output: String
CLI: rxchef run "Analyse UUID"
Arguments: none

Analyse hash¶

Tries to determine information about a given hash and suggests which algorithm may have been used to generate it based on its length.

Input: String
Output: String
CLI: rxchef run "Analyse hash"
Arguments: none

Argon2¶

Argon2 is a key derivation function that was selected as the winner of the Password Hashing Competition in July 2015. It was designed by Alex Biryukov, Daniel Dinu, and Dmitry Khovratovich from the University of Luxembourg.

Input: String
Output: String
CLI: rxchef run "Argon2"

#	Argument	Default	Description
1	Salt	`somesalt`	Salt value
2	Iterations	`3`	Number of iterations
3	Memory (KiB)	`4096`	Memory usage in KiB
4	Parallelism	`1`	Degree of parallelism
5	Hash length (bytes)	`32`	Length of the hash in bytes
6	Type	`Argon2i`	Argon2 type (Argon2i, Argon2d, Argon2id)
7	Output format	`Encoded hash`	Output format (Encoded hash, Hex hash, Raw hash)

Argon2 compare¶

Tests whether the input matches the given Argon2 hash. To test multiple possible passwords, use the 'Fork' operation.

Input: String
Output: String
CLI: rxchef run "Argon2 compare"

#	Argument	Default	Description
1	Encoded hash	`<empty>`	The Argon2 hash to compare against

Bcrypt¶

bcrypt is a password hashing function designed by Niels Provos and David Mazires, based on the Blowfish cipher, and presented at USENIX in 1999. Besides incorporating a salt to protect against rainbow table attacks, bcrypt is an adaptive function: over time, the iteration count (rounds) can be increased to make it slower.

Input: String
Output: String
CLI: rxchef run "Bcrypt"

#	Argument	Default	Description
1	Rounds	`10`	Number of rounds (10-31, default 10)

Bcrypt compare¶

Tests whether the input matches the given bcrypt hash. To test multiple possible passwords, use the Fork operation.

Input: String
Output: String
CLI: rxchef run "Bcrypt compare"

#	Argument	Default	Description
1	Hash	`<empty>`	Bcrypt hash to compare against

Bcrypt parse¶

Parses a bcrypt hash to determine the number of rounds used, the salt, and the password hash.

Input: String
Output: String
CLI: rxchef run "Bcrypt parse"
Arguments: none

CMAC¶

CMAC is a block-cipher based message authentication code algorithm. AES-CMAC uses AES encryption with a 128, 192, or 256-bit key.

Input: Binary
Output: String
CLI: rxchef run "CMAC"

#	Argument	Default	Description
1	Key	`<empty>`	Encryption key (Hex, UTF8, Latin1, or Base64)
2	Encryption algorithm	`AES`	Encryption algorithm (AES)

CTPH¶

Context Triggered Piecewise Hashing, also called Fuzzy Hashing, can match inputs that have homologies. Such inputs have sequences of identical bytes in the same order, although bytes in between these sequences may be different in both content and length.

Input: Bytes
Output: String
CLI: rxchef run "CTPH"
Arguments: none

CipherSaber2 Decrypt¶

CipherSaber is a simple symmetric encryption protocol based on the RC4 stream cipher. It gives reasonably strong protection of message confidentiality, yet it's designed to be simple enough that even novice programmers can memorize the algorithm and implement it from scratch. The first 10 bytes of the input are the initialisation vector (IV).

Input: Bytes
Output: Bytes
CLI: rxchef run "CipherSaber2 Decrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Decryption key
2	Rounds	`20`	Number of key schedule rounds (default 20)

CipherSaber2 Encrypt¶

CipherSaber is a simple symmetric encryption protocol based on the RC4 stream cipher. It gives reasonably strong protection of message confidentiality, yet it's designed to be simple enough that even novice programmers can memorize the algorithm and implement it from scratch. A random 10-byte IV is prepended to the ciphertext output.

Input: Bytes
Output: Bytes
CLI: rxchef run "CipherSaber2 Encrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Encryption key
2	Rounds	`20`	Number of key schedule rounds (default 20)

Compare CTPH hashes¶

Compares two Context Triggered Piecewise Hashing (CTPH) fuzzy hashes to determine the similarity between them on a scale of 0 to 100.

Input: String
Output: String
CLI: rxchef run "Compare CTPH hashes"

#	Argument	Default	Description
1	Delimiter	`Line feed`	Delimiter between the two hashes (Line feed, CRLF, Space, Comma, Semi-colon)

Compare SSDEEP hashes¶

Compares two SSDEEP fuzzy hashes to determine the similarity between them on a scale of 0 to 100.

Input: String
Output: Number
CLI: rxchef run "Compare SSDEEP hashes"

#	Argument	Default	Description
1	Delimiter	`Line feed`	The delimiter separating the two samples

Derive HKDF key¶

A simple Hashed Message Authenticaton Code (HMAC)-based key derivation function (HKDF), defined in RFC5869.

Input: Bytes
Output: String
CLI: rxchef run "Derive HKDF key"

#	Argument	Default	Description
1	Salt	`<empty>`	The salt to use
2	Info	`<empty>`	The info to use
3	Hashing function	`SHA256`	The hashing function to use (SHA1, SHA256, SHA384, SHA512)
4	Extract mode	`with salt`	The extract mode (with salt, no salt, skip)
5	L (number of output octets)	`16`	The number of output octets

Flask Session Decode¶

Decodes the payload of a Flask session cookie (itsdangerous) into JSON.

Input: String
Output: JSON
CLI: rxchef run "Flask Session Decode"

#	Argument	Default	Description
1	View Timestamp	`false`	Include the timestamp in the output

Flask Session Sign¶

Signs a JSON payload to produce a Flask session cookie (itsdangerous HMAC).

Input: JSON
Output: String
CLI: rxchef run "Flask Session Sign"

#	Argument	Default	Description
1	Key	`<empty>`	Secret key (UTF-8)
2	Salt	`cookie-session`	Salt string (default: cookie-session)
3	Algorithm	`sha1`	HMAC algorithm: sha1 or sha256

Flask Session Verify¶

Verifies the HMAC signature of a Flask session cookie (itsdangerous) generated.

Input: String
Output: JSON
CLI: rxchef run "Flask Session Verify"

#	Argument	Default	Description
1	Key	`<empty>`	Secret key (UTF-8)
2	Salt	`cookie-session`	Salt string (default: cookie-session)
3	Algorithm	`sha1`	HMAC algorithm: sha1 or sha256
4	View Timestamp	`true`	Include timestamp in output

Fletcher-16 Checksum¶

The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.

The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.

Input: Bytes
Output: String
CLI: rxchef run "Fletcher-16 Checksum"
Arguments: none

Fletcher-32 Checksum¶

The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.

The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.

Input: Bytes
Output: String
CLI: rxchef run "Fletcher-32 Checksum"
Arguments: none

Fletcher-64 Checksum¶

The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.

The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.

Input: Bytes
Output: String
CLI: rxchef run "Fletcher-64 Checksum"
Arguments: none

Fletcher-8 Checksum¶

The Fletcher checksum is an algorithm for computing a position-dependent checksum devised by John Gould Fletcher at Lawrence Livermore Labs in the late 1970s.

The objective of the Fletcher checksum was to provide error-detection properties approaching those of a cyclic redundancy check but with the lower computational effort associated with summation techniques.

Input: Bytes
Output: String
CLI: rxchef run "Fletcher-8 Checksum"
Arguments: none

Generate UUID¶

Generates an RFC 4122 compliant Universally Unique Identifier (UUID), also known as a Globally Unique Identifier (GUID). Only UUID v4 (random) is supported.

Input: String
Output: String
CLI: rxchef run "Generate UUID"

#	Argument	Default	Description
1	Version	`v4`	UUID version (only v4 is supported)

Generate all checksums¶

Generates all available checksums for the input.

Input: Bytes
Output: String
CLI: rxchef run "Generate all checksums"

#	Argument	Default	Description
1	Length (bits)	`All`	Length of the checksum in bits
2	Include names	`true`	Include the name of the checksum algorithm in the output

Generate all hashes¶

Generates all available hashes and checksums for the input.

Input: Bytes
Output: String
CLI: rxchef run "Generate all hashes"

#	Argument	Default	Description
1	Length (bits)	`All`	Filter hashes by output length
2	Include names	`true`	Include the name of the hash in the output

HAS-160¶

HAS-160 is a cryptographic hash function designed for use with the Korean KCDSA digital signature algorithm.

Input: Bytes
Output: String
CLI: rxchef run "HAS-160"

#	Argument	Default	Description
1	Rounds	`80`	Number of rounds

HASSH Client Fingerprint¶

Generates a HASSH fingerprint to help identify SSH clients based on hashing together values from the Client Key Exchange Init message.

Input: A hex stream of the SSH_MSG_KEXINIT packet application layer from Client to Server.

Input: String
Output: String
CLI: rxchef run "HASSH Client Fingerprint"

#	Argument	Default	Description
1	Input format	`Hex`	Input format
2	Output format	`Hash digest`	Output format

HASSH Server Fingerprint¶

Generates a HASSH fingerprint to help identify SSH servers based on hashing together values from the Server Key Exchange Init message.

Input: A hex stream of the SSH_MSG_KEXINIT packet application layer from Server to Client.

Input: String
Output: String
CLI: rxchef run "HASSH Server Fingerprint"

#	Argument	Default	Description
1	Input format	`Hex`	Input format
2	Output format	`Hash digest`	Output format

HMAC¶

Keyed-Hash Message Authentication Codes (HMAC) are a mechanism for message authentication using cryptographic hash functions.

Input: String
Output: String
CLI: rxchef run "HMAC"

#	Argument	Default	Description
1	Key	`<empty>`	The secret key as UTF-8 text, or explicitly prefixed with hex:/0x or base64:
2	Hashing function	`SHA-256`	Hashing algorithm (MD5, SHA-1, SHA-256, SHA-384, SHA-512)
3	Output encoding	`Hex`	Output encoding (Hex, Base64)

JA3 Fingerprint¶

Generates a JA3 fingerprint to help identify TLS clients based on hashing together values from the Client Hello.

Input: A hex stream of the TLS Client Hello packet application layer.

Input: String
Output: String
CLI: rxchef run "JA3 Fingerprint"

#	Argument	Default	Description
1	Input format	`Hex`	Input format
2	Output format	`Hash digest`	Output format

JA3S Fingerprint¶

Generates a JA3S fingerprint to help identify TLS servers based on hashing together values from the Server Hello.

Input: A hex stream of the TLS Server Hello record application layer.

Input: String
Output: String
CLI: rxchef run "JA3S Fingerprint"

#	Argument	Default	Description
1	Input format	`Hex`	Input format
2	Output format	`Hash digest`	Output format

JA4 Fingerprint¶

Generates a JA4 fingerprint to help identify TLS clients based on hashing together values from the Client Hello.

Input: A hex stream of the TLS or QUIC Client Hello packet application layer.

Input: String
Output: String
CLI: rxchef run "JA4 Fingerprint"

#	Argument	Default	Description
1	Input format	`Hex`	Input format
2	Output format	`JA4`	Output format

JA4Server Fingerprint¶

Generates a JA4Server Fingerprint (JA4S) to help identify TLS servers or sessions based on hashing together values from the Server Hello.

Input: A hex stream of the TLS or QUIC Server Hello packet application layer.

Input: String
Output: String
CLI: rxchef run "JA4Server Fingerprint"

#	Argument	Default	Description
1	Input format	`Hex`	Input format
2	Output format	`JA4S`	Output format

JWT Decode¶

Decodes a JSON Web Token without checking whether the provided secret / private key is valid. Use JWT Verify to check if the signature is valid as well.

Input: String
Output: JSON
CLI: rxchef run "JWT Decode"
Arguments: none

JWT Sign¶

Signs a JSON object as a JSON Web Token using a provided secret key. Supports HMAC algorithms (HS256, HS384, HS512) and None.

Input: JSON
Output: String
CLI: rxchef run "JWT Sign"

#	Argument	Default	Description
1	Private/Secret Key	`secret`	The secret key for HMAC signing
2	Signing algorithm	`HS256`	Algorithm: HS256, HS384, HS512, None

JWT Verify¶

Verifies that a JSON Web Token is valid and has been signed with the provided secret key. Supports HS256, HS384, HS512, and None.

Input: String
Output: JSON
CLI: rxchef run "JWT Verify"

#	Argument	Default	Description
1	Public/Secret Key	`secret`	The secret key used to verify the HMAC signature

LM Hash¶

An LM Hash, or LAN Manager Hash, is a deprecated way of storing passwords on old Microsoft operating systems. It is particularly weak and can be cracked in seconds on modern hardware using rainbow tables.

Input: String
Output: String
CLI: rxchef run "LM Hash"
Arguments: none

LS47 Decrypt¶

This is a slight improvement of the ElsieFour cipher as described by Alan Kaminsky. We use 7x7 characters instead of original (barely fitting) 6x6, to be able to encrypt some structured information. We also describe a simple key-expansion algorithm, because remembering passwords is popular. Similar security considerations as with ElsieFour hold.
The LS47 alphabet consists of following characters: _abcdefghijklmnopqrstuvwxyz.0123456789,-+*/:?!'()
An LS47 key is a permutation of the alphabet that is then represented in a 7x7 grid used for the encryption or decryption.

Input: String
Output: String
CLI: rxchef run "LS47 Decrypt"

#	Argument	Default	Description
1	Password	`<empty>`	The password used to derive the LS47 key
2	Padding	`10`	The number of padding characters to remove from the start of the output

LS47 Encrypt¶

This is a slight improvement of the ElsieFour cipher as described by Alan Kaminsky. We use 7x7 characters instead of original (barely fitting) 6x6, to be able to encrypt some structured information. We also describe a simple key-expansion algorithm, because remembering passwords is popular. Similar security considerations as with ElsieFour hold.
The LS47 alphabet consists of following characters: _abcdefghijklmnopqrstuvwxyz.0123456789,-+*/:?!'()
A LS47 key is a permutation of the alphabet that is then represented in a 7x7 grid used for the encryption or decryption.

Input: String
Output: String
CLI: rxchef run "LS47 Encrypt"

#	Argument	Default	Description
1	Password	`<empty>`	Password used to derive the key
2	Padding	`10`	Amount of random padding to add
3	Signature	`<empty>`	Signature to append to the end of the plaintext

MD6¶

The MD6 (Message-Digest 6) algorithm is a cryptographic hash function. It uses a Merkle tree-like structure to allow for immense parallel computation of hashes for very long inputs.

Input: String
Output: String
CLI: rxchef run "MD6"

#	Argument	Default	Description
1	Size	`256`	Hash size in bits (0-512)
2	Levels	`64`	Number of levels in the Merkle tree
3	Key	`<empty>`	Optional key

NT Hash¶

An NT Hash, sometimes referred to as an NTLM hash, is a method of storing passwords on Windows systems. It works by running MD4 on UTF-16LE encoded input. NTLM hashes are considered weak because they can be brute-forced very easily with modern hardware.

Input: String
Output: String
CLI: rxchef run "NT Hash"
Arguments: none

SM2 Decrypt¶

Decrypts a message utilizing the SM2 standard. SM2 is a public-key cryptography standard used in China.

Input: String
Output: Bytes
CLI: rxchef run "SM2 Decrypt"

#	Argument	Default	Description
1	Private Key	`<empty>`	The private key in hex format (32 bytes)
2	Input Format	`C1C3C2`	The format of the input ciphertext (C1C3C2 or C1C2C3)
3	Curve	`sm2p256v1`	The elliptic curve to use (sm2p256v1)

SM2 Encrypt¶

Encrypts a message utilizing the SM2 standard. SM2 is a public-key cryptography standard used in China.

Input: Bytes
Output: String
CLI: rxchef run "SM2 Encrypt"

#	Argument	Default	Description
1	Public Key X	`<empty>`	Public key component X in hex format (32 bytes)
2	Public Key Y	`<empty>`	Public key component Y in hex format (32 bytes)
3	Output Format	`C1C3C2`	The format of the output ciphertext (C1C3C2 or C1C2C3)
4	Curve	`sm2p256v1`	The elliptic curve to use (sm2p256v1)

SSDEEP¶

SSDEEP is a program for computing context triggered piecewise hashes (CTPH). Also called fuzzy hashes, CTPH can match inputs that have homologies. SSDEEP hashes are now widely used for simple identification purposes (e.g. the 'Basic Properties' section in VirusTotal).

Input: Bytes
Output: String
CLI: rxchef run "SSDEEP"
Arguments: none

Scrypt¶

scrypt is a password-based key derivation function (PBKDF) created by Colin Percival. The algorithm was specifically designed to make it costly to perform large-scale custom hardware attacks by requiring large amounts of memory. Enter the password in the input to generate its hash.

Input: String
Output: String
CLI: rxchef run "Scrypt"

#	Argument	Default	Description
1	Salt	`<empty>`	Salt
2	Iterations (N)	`16384`	Iterations (N). Must be a power of 2.
3	Memory factor (r)	`8`	Memory factor (r)
4	Parallelization factor (p)	`1`	Parallelization factor (p)
5	Key length	`64`	Key length

TCP/IP Checksum¶

Calculates the checksum for a TCP (Transport Control Protocol) or IP (Internet Protocol) header from an input of raw bytes.

Input: Bytes
Output: String
CLI: rxchef run "TCP/IP Checksum"
Arguments: none

XOR Checksum¶

XOR Checksum splits the input into blocks of a configurable size and performs the XOR operation on these blocks.

Input: Bytes
Output: String
CLI: rxchef run "XOR Checksum"

#	Argument	Default	Description
1	Blocksize	`4`	Number of bytes per block

Default¶

ADD¶

ADD the input with the given key (e.g. fe023da5), MOD 256

Input: Bytes
Output: Bytes
CLI: rxchef run "ADD"

#	Argument	Default	Description
1	Key	`<empty>`	Key to ADD with input

AND¶

AND the input with the given key.

Input: Bytes
Output: Bytes
CLI: rxchef run "AND"

#	Argument	Default	Description
1	Key	`<empty>`	Key to AND with input

Add line numbers¶

Adds line numbers to the output.

Input: String
Output: String
CLI: rxchef run "Add line numbers"

#	Argument	Default	Description
1	Offset	`0`	Starting line number offset

Alternating Caps¶

Alternating caps, also known as studly caps, sticky caps, or spongecase is a form of text notation in which the capitalization of letters varies by some pattern, or arbitrarily. An example of this would be spelling 'alternative caps' as 'aLtErNaTiNg CaPs'.

Input: String
Output: String
CLI: rxchef run "Alternating Caps"
Arguments: none

Bacon Cipher Decode¶

Bacon's cipher or the Baconian cipher is a method of steganography devised by Francis Bacon in 1605. A message is concealed in the presentation of text, rather than its content.

Input: String
Output: String
CLI: rxchef run "Bacon Cipher Decode"

#	Argument	Default	Description
1	Alphabet	`Standard (I=J and U=V)`	Alphabet variant (Standard or Complete)
2	Translation	`0/1`	Translation method (0/1, A/B, Case, or A-M/N-Z)
3	Invert Translation	`false`	Invert 0/1 or A/B

Bacon Cipher Encode¶

Bacon's cipher or the Baconian cipher is a method of steganography devised by Francis Bacon in 1605. A message is concealed in the presentation of text, rather than its content.

Input: String
Output: String
CLI: rxchef run "Bacon Cipher Encode"

#	Argument	Default	Description
1	Alphabet	`Standard (I=J and U=V)`	Alphabet variant (Standard or Complete)
2	Translation	`0/1`	Translation method (0/1 or A/B)
3	Keep extra characters	`false`	Keep non-alphabetic characters
4	Invert Translation	`false`	Invert 0/1 or A/B

Bit shift left¶

Shifts the bits in each byte towards the left by the specified amount.

Input: Bytes
Output: Bytes
CLI: rxchef run "Bit shift left"

#	Argument	Default	Description
1	Amount	`1`	Amount to shift left

Bit shift right¶

Shifts the bits in each byte towards the right by the specified amount.

Input: Bytes
Output: Bytes
CLI: rxchef run "Bit shift right"

#	Argument	Default	Description
1	Amount	`1`	Amount to shift right
2	Type	`Logical shift`	Shift type (Logical or Arithmetic)

Caret/M-decode¶

Decodes caret or M-encoded strings, i.e. ^M turns into a newline, M-^] turns into 0x9d. Sources such as cat -v.

Please be aware that when using cat -v ^_ (caret-underscore) will not be encoded, but represents a valid encoding (namely that of 0x1f).

Input: String
Output: Bytes
CLI: rxchef run "Caret/M-decode"
Arguments: none

Cartesian Product¶

Calculates the cartesian product of multiple sets of data, returning all possible combinations.

Input: String
Output: String
CLI: rxchef run "Cartesian Product"

#	Argument	Default	Description
1	Sample delimiter	`\\n\\n`	Delimiter between sets
2	Item delimiter	`,`	Delimiter between items in a set

Change IP format¶

Convert an IP address from one format to another, e.g. 172.20.23.54 to ac141736

Input: String
Output: String
CLI: rxchef run "Change IP format"

#	Argument	Default	Description
1	Input format	`Dotted Decimal`	Input format: Dotted Decimal, Decimal, Octal, Hex
2	Output format	`Dotted Decimal`	Output format: Dotted Decimal, Decimal, Octal, Hex

Chi Square¶

Calculates the Chi Square distribution of values.

Input: Bytes
Output: Number
CLI: rxchef run "Chi Square"
Arguments: none

Comment¶

Provides a place to write comments within the flow of the recipe. This operation has no computational effect.

Input: String
Output: String
CLI: rxchef run "Comment"

#	Argument	Default	Description
1	Comment	`<empty>`	Comment text

Conditional Jump¶

Conditionally jump forwards or backwards to a Label when the current data matches a regular expression. Backwards jumps are bounded by the configured maximum. Interpreted by integration::bake and all CLI recipe frontends.

Input: String
Output: String
CLI: rxchef run "Conditional Jump"

#	Argument	Default	Description
1	Match (regex)	`<empty>`	The regular expression to match against the data
2	Invert match	`false`	If true, jump when the regex does NOT match
3	Label name	`<empty>`	The name of the label to jump to
4	Maximum jumps (if jumping backwards)	`10`	The maximum number of times to jump backwards to prevent infinite loops

Convert Leet Speak¶

Converts to and from Leet Speak.

Input: String
Output: String
CLI: rxchef run "Convert Leet Speak"

#	Argument	Default	Description
1	Direction	`To Leet Speak`	Direction: To Leet Speak or From Leet Speak

Convert area¶

Converts a unit of area to another format.

Input: String
Output: String
CLI: rxchef run "Convert area"

#	Argument	Default	Description
1	Input units	`Square metre (sq m)`	Input area unit
2	Output units	`Square kilometre (sq km)`	Output area unit

Convert data units¶

Converts a unit of data to another format (bits, bytes, kilobytes, etc.).

Input: String
Output: String
CLI: rxchef run "Convert data units"

#	Argument	Default	Description
1	Input units	`Bytes (B)`	Input data unit
2	Output units	`Kilobytes (kB)`	Output data unit

Convert distance¶

Converts a unit of distance to another format.

Input: String
Output: String
CLI: rxchef run "Convert distance"

#	Argument	Default	Description
1	Input units	`Metres (m)`	Input distance unit
2	Output units	`Kilometres (km)`	Output distance unit

Convert mass¶

Converts a unit of mass to another format.

Input: String
Output: String
CLI: rxchef run "Convert mass"

#	Argument	Default	Description
1	Input units	`Kilograms (kg)`	Input mass unit
2	Output units	`Grams (g)`	Output mass unit

Convert speed¶

Converts a unit of speed to another format.

Input: String
Output: String
CLI: rxchef run "Convert speed"

#	Argument	Default	Description
1	Input units	`Metres per second (m/s)`	Input speed unit
2	Output units	`Kilometres per hour (km/h)`	Output speed unit

Convert to NATO alphabet¶

Converts characters to their representation in the NATO phonetic alphabet.

Input: String
Output: String
CLI: rxchef run "Convert to NATO alphabet"
Arguments: none

Count occurrences¶

Counts the number of times the provided string occurs in the input.

Input: String
Output: Number
CLI: rxchef run "Count occurrences"

#	Argument	Default	Description
1	Search string	`<empty>`	The string to search for

DNS over HTTPS¶

Takes a single domain name and performs a DNS lookup using DNS over HTTPS.

By default, Cloudflare and Google DNS over HTTPS services are supported.

Can be used with any service that supports the GET parameters name and type.

Input: String
Output: JSON
CLI: rxchef run "DNS over HTTPS"

#	Argument	Default	Description
1	Resolver	`https://cloudflare-dns.com/dns-query`	The DNS over HTTPS resolver URL (e.g., Google or Cloudflare).
2	Request Type	`A`	The type of DNS request (A, AAAA, TXT, etc.).
3	Answer Data Only	`false`	If true, only returns the Answer section data values.
4	Disable DNSSEC validation	`false`	Disable DNSSEC validation (Checking Disabled).

DateTime Delta¶

Calculates a new DateTime value given an input DateTime value and a time difference (delta) from the input DateTime value. Uses strftime format strings.

Input: String
Output: HTML
CLI: rxchef run "DateTime Delta"

#	Argument	Default	Description
1	Built in formats	`Standard date and time`	Common datetime formats
2	Input format string	`%d/%m/%Y %H:%M:%S`	strftime format string for parsing and formatting (e.g. %d/%m/%Y %H:%M:%S)
3	Time Operation	`Add`	Whether to add or subtract the delta
4	Days	`0`	Number of days
5	Hours	`0`	Number of hours
6	Minutes	`0`	Number of minutes
7	Seconds	`0`	Number of seconds

Dechunk HTTP response¶

Parses an HTTP response transferred using Transfer-Encoding: Chunked.

Input: String
Output: String
CLI: rxchef run "Dechunk HTTP response"
Arguments: none

Decode NetBIOS Name¶

NetBIOS names as seen across the client interface to NetBIOS are exactly 16 bytes long. Within the NetBIOS-over-TCP protocols, a longer representation is used.

There are two levels of encoding. The first level maps a NetBIOS name into a domain system name. The second level maps the domain system name into the 'compressed' representation required for interaction with the domain name system.

This operation decodes the first level of encoding. See RFC 1001 for full details.

Input: Bytes
Output: Bytes
CLI: rxchef run "Decode NetBIOS Name"

#	Argument	Default	Description
1	Offset	`65`	The offset to use for decoding

Defang IP Addresses¶

Takes an IPv4 or IPv6 address and 'Defangs' it, meaning the IP becomes invalid, removing the risk of accidentally utilising it as an IP address.

Input: String
Output: String
CLI: rxchef run "Defang IP Addresses"
Arguments: none

Defang URL¶

Takes a Universal Resource Locator (URL) and 'Defangs' it; meaning the URL becomes invalid, neutralising the risk of accidentally clicking on a malicious link.

Input: String
Output: String
CLI: rxchef run "Defang URL"

#	Argument	Default	Description
1	Escape dots	`true`	Escape dots in the URL
2	Escape http	`true`	Escape http/https in the URL
3	Escape ://	`true`	Escape :// in the URL
4	Process	`Valid domains and full URLs`	Process option

Detect File Type¶

Attempts to guess the MIME (Multipurpose Internet Mail Extensions) type of the data based on 'magic bytes'.

Input: Bytes
Output: String
CLI: rxchef run "Detect File Type"

#	Argument	Default	Description
1	Images	`true`	Detect image files
2	Video	`true`	Detect video files
3	Audio	`true`	Detect audio files
4	Documents	`true`	Detect document files
5	Applications	`true`	Detect application files
6	Archives	`true`	Detect archive files

Divide¶

Divides a list of numbers. If an item in the string is not a number it is excluded from the list. e.g. 0x0a 8 .5 becomes 2.5

Input: String
Output: String
CLI: rxchef run "Divide"

#	Argument	Default	Description
1	Delimiter	`Line feed`	Character that separates numbers in the input

Drop bytes¶

Cuts a slice of the specified number of bytes out of the data. Negative values are allowed.

Input: Bytes
Output: Bytes
CLI: rxchef run "Drop bytes"

#	Argument	Default	Description
1	Start	`0`	Starting byte position (can be negative)
2	Length	`5`	Number of bytes to drop (can be negative)
3	Apply to each line	`false`	Apply drop to each line separately

Drop nth bytes¶

Drops every nth byte starting with a given byte.

Input: Bytes
Output: Bytes
CLI: rxchef run "Drop nth bytes"

#	Argument	Default	Description
1	Drop every	`4`	Drop every nth byte
2	Starting at	`0`	Starting byte offset
3	Apply to each line	`false`	If true, apply to each line separately

ELF Info¶

Implements readelf-like functionality. This operation will extract the ELF Header, Program Headers, Section Headers and Symbol Table for an ELF file.

Input: Bytes
Output: String
CLI: rxchef run "ELF Info"
Arguments: none

Encode NetBIOS Name¶

NetBIOS names as seen across the client interface to NetBIOS are exactly 16 bytes long. Within the NetBIOS-over-TCP protocols, a longer representation is used.

There are two levels of encoding. The first level maps a NetBIOS name into a domain system name. The second level maps the domain system name into the 'compressed' representation required for interaction with the domain name system.

This operation carries out the first level of encoding. See RFC 1001 for full details.

Input: Bytes
Output: Bytes
CLI: rxchef run "Encode NetBIOS Name"

#	Argument	Default	Description
1	Offset	`65`	The offset value used for encoding

Escape Unicode Characters¶

Converts characters to their unicode-escaped notations.

Supports the prefixes:

\u
%u
U+

e.g. becomes \u03C3\u03BF\u03C5

Input: String
Output: String
CLI: rxchef run "Escape Unicode Characters"

#	Argument	Default	Description
1	Prefix	`\\u`	The prefix to use for each escape sequence
2	Encode all chars	`false`	If true, all characters will be escaped. If false, only non-printable ASCII characters will be escaped.
3	Padding	`4`	The number of hex digits to pad to
4	Uppercase hex	`true`	Whether to use uppercase hex digits

Escape string¶

Escapes special characters in a string so that they do not cause conflicts. For example, Don't stop me now becomes Don\'t stop me now.

Supports the following escape sequences:

\n (Line feed/newline)
\r (Carriage return)
\t (Horizontal tab)
\b (Backspace)
\f (Form feed)
\xnn (Hex, where n is 0-f)
\ (Backslash)
\' (Single quote)
\" (Double quote)
\unnnn (Unicode character)
\u{nnnnnn} (Unicode code point)

Input: String
Output: String
CLI: rxchef run "Escape string"

#	Argument	Default	Description
1	Escape level	`Special chars`	The level of escaping to perform
2	Escape quote	`Single`	Which type of quote to escape
3	JSON compatible	`false`	Whether to ensure the output is JSON compatible
4	ES6 compatible	`true`	Whether to use ES6 unicode escape sequences (\u{...})
5	Uppercase hex	`false`	Whether to use uppercase hex digits

Expand alphabet range¶

Expand an alphabet range string into a list of the characters in that range.

e.g. a-z becomes abcdefghijklmnopqrstuvwxyz.

Input: String
Output: String
CLI: rxchef run "Expand alphabet range"

#	Argument	Default	Description
1	Delimiter	`<empty>`	The delimiter to use between each character

Extract Files¶

Carves PNG, JPEG, GIF, PDF, and ZIP signatures from binary input. Matching payloads are returned in a deterministic binary envelope with an ASCII file-type header before each payload.

Input: Bytes
Output: Bytes
CLI: rxchef run "Extract Files"

#	Argument	Default	Description
1	Images	`true`	Extract images
2	Documents	`true`	Extract documents
3	Archives	`true`	Extract archives
4	Ignore failed extractions	`true`	Ignore failed extractions
5	Minimum File Size	`100`	Minimum file size to extract

Extract ID3¶

This operation extracts ID3 metadata from an MP3 file.

Input: Bytes
Output: JSON
CLI: rxchef run "Extract ID3"
Arguments: none

Fang URL¶

Takes a 'Defanged' Universal Resource Locator (URL) and 'Fangs' it. Meaning, it removes the alterations (defanged) that render it useless so that it can be used again.

Input: String
Output: String
CLI: rxchef run "Fang URL"

#	Argument	Default	Description
1	Restore dots	`true`	Restore [.] to .
2	Restore hxxp	`true`	Restore hxxp to http
3	Restore scheme separator	`true`	Restore [://] to ://

Fernet Decrypt¶

Fernet is a symmetric encryption method which makes sure that the message encrypted cannot be manipulated/read without the key. It uses URL safe encoding for the keys. Fernet uses 128-bit AES in CBC mode and PKCS7 padding, with HMAC using SHA256 for authentication. The IV is created from os.random(). Key: The key must be 32 bytes (256 bits) encoded with Base64.

Input: String
Output: String
CLI: rxchef run "Fernet Decrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Base64url-encoded 32-byte Fernet key

Fernet Encrypt¶

Fernet is a symmetric encryption method which makes sure that the message encrypted cannot be manipulated/read without the key. It uses URL safe encoding for the keys. Fernet uses 128-bit AES in CBC mode and PKCS7 padding, with HMAC using SHA256 for authentication. The IV is created from os.random(). Key: The key must be 32 bytes (256 bits) encoded with Base64.

Input: String
Output: String
CLI: rxchef run "Fernet Encrypt"

#	Argument	Default	Description
1	Key	`<empty>`	Base64url-encoded 32-byte Fernet key

File Tree¶

Creates a file tree from a list of file paths (similar to the tree command in Linux)

Input: String
Output: String
CLI: rxchef run "File Tree"

#	Argument	Default	Description
1	File Path Delimiter	`/`	Delimiter between path components
2	Delimiter	`Line feed`	Delimiter between entries

Fork¶

Split the input on the specified delimiter and run subsequent recipe operations on each branch separately until Merge. This flow-control operation is interpreted by integration::bake and all CLI recipe frontends.

Input: String
Output: String
CLI: rxchef run "Fork"

#	Argument	Default	Description
1	Split delimiter	`\\n`	The delimiter to split the input on
2	Merge delimiter	`\\n`	The delimiter to join outputs with
3	Ignore errors	`false`	Continue processing even if a branch fails

Format MAC addresses¶

Displays given MAC addresses in multiple different formats. Expects addresses separated by newlines, spaces, or commas.

Input: String
Output: String
CLI: rxchef run "Format MAC addresses"

#	Argument	Default	Description
1	Output case	`Both`	Both, Upper only, or Lower only
2	No delimiter	`true`	Output format with no delimiter (e.g. AABBCCDDEEFF)
3	Dash delimiter	`true`	Output format with dashes (e.g. AA-BB-CC-DD-EE-FF)
4	Colon delimiter	`true`	Output format with colons (e.g. AA:BB:CC:DD:EE:FF)
5	Cisco style	`false`	Output Cisco dot notation (e.g. AABB.CCDD.EEFF)
6	IPv6 interface ID	`false`	Output as IPv6 interface identifier

Frequency distribution¶

Displays the distribution of bytes in the data as a frequency table.

Input: Bytes
Output: String
CLI: rxchef run "Frequency distribution"

#	Argument	Default	Description
1	Show 0%s	`true`	Include bytes that do not appear in the input
2	Show ASCII	`true`	Include ASCII character column

From BCD¶

Binary-Coded Decimal (BCD) is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of bits, usually four or eight. Special bit patterns are sometimes used for a sign.

Input: String
Output: String
CLI: rxchef run "From BCD"

#	Argument	Default	Description
1	Scheme	`8 4 2 1`	The BCD encoding scheme
2	Packed	`true`	Whether the BCD is packed (two digits per byte)
3	Signed	`false`	Whether the BCD is signed (trailing sign nibble)
4	Input format	`Nibbles`	The format of the input data

From Base¶

Converts a number to decimal from a given numerical base (radix 2-36).

Input: String
Output: String
CLI: rxchef run "From Base"

#	Argument	Default	Description
1	Radix	`36`	The base of the input number (2-36)

From Base32¶

Base32 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers. It uses a smaller set of characters than Base64, usually the uppercase alphabet and the numbers 2 to 7.

Input: String
Output: Bytes
CLI: rxchef run "From Base32"

#	Argument	Default	Description
1	Alphabet	`A-Z2-7`	The Base32 alphabet
2	Remove non-alphabet chars	`true`	Remove characters not in the alphabet before decoding

From Base45¶

Base45 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers. The high number base results in shorter strings than with the decimal or hexadecimal system. Base45 is optimized for usage with QR codes.

Input: String
Output: Bytes
CLI: rxchef run "From Base45"

#	Argument	Default	Description
1	Alphabet	`0-9A-Z $%*+-./:`	The Base45 alphabet
2	Remove non-alphabet chars	`true`	Remove characters not in the alphabet before decoding

From Base58¶

Base58 (similar to Base64) is a notation for encoding arbitrary byte data. It differs from Base64 by removing easily misread characters (i.e. l, I, 0 and O) to improve human readability. This operation decodes data from an ASCII string back into its raw form.

Input: String
Output: Bytes
CLI: rxchef run "From Base58"

#	Argument	Default	Description
1	Alphabet	`123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz`	The Base58 alphabet
2	Remove non-alphabet chars	`true`	Remove characters not in the alphabet before decoding

From Base62¶

Base62 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers. The high number base results in shorter strings than with the decimal or hexadecimal system.

Input: String
Output: Bytes
CLI: rxchef run "From Base62"

#	Argument	Default	Description
1	Alphabet	`0-9A-Za-z`	The Base62 alphabet

From Base64¶

Base64 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers. This operation decodes data from an ASCII Base64 string back into its raw format.

Input: String
Output: Bytes
CLI: rxchef run "From Base64"

#	Argument	Default	Description
1	Alphabet	`A-Za-z0-9+/=`	The Base64 alphabet
2	Remove non-alphabet chars	`true`	Remove characters not in the alphabet before decoding
3	Strict mode	`false`	Throw an error if the input is not perfectly formatted

From Base85¶

Base85 (also called Ascii85) is a notation for encoding arbitrary byte data. It is usually more efficient than Base64.

This operation decodes data from an ASCII string (with an alphabet of your choosing, presets included).

e.g. BOu!rD]j7BEbo7 becomes hello world

Base85 is commonly used in Adobe's PostScript and PDF file formats.

Input: String
Output: Bytes
CLI: rxchef run "From Base85"

#	Argument	Default	Description
1	Alphabet	`!-u`	The Base85 alphabet
2	Remove non-alphabet chars	`true`	Remove characters not in the alphabet before decoding
3	All-zero group char	`z`	Character representing an all-zero group (default 'z')

From Base92¶

Base92 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers.

Input: String
Output: Bytes
CLI: rxchef run "From Base92"
Arguments: none

From Bech32¶

Bech32 is an encoding scheme primarily used for Bitcoin SegWit addresses (BIP-0173). It uses a 32-character alphabet that excludes easily confused characters (1, b, i, o) and includes a checksum for error detection.

Bech32m (BIP-0350) is an updated version used for Bitcoin Taproot addresses.

Auto-detect will attempt Bech32 first, then Bech32m if the checksum fails.

Output format options allow you to see the Human-Readable Part (HRP) along with the decoded data.

Input: String
Output: String
CLI: rxchef run "From Bech32"

#	Argument	Default	Description
1	Encoding	`Auto-detect`	The Bech32 encoding variant
2	Output Format	`Raw`	The format of the output

From Binary¶

Converts a binary string back into its raw form. e.g. '01001000 01101001' becomes 'Hi'

Input: String
Output: Bytes
CLI: rxchef run "From Binary"

#	Argument	Default	Description
1	Delimiter	`Space`	The delimiter between binary groups (Space, Comma, Semi-colon, Colon, Line feed, CRLF, None)
2	Byte Length	`8`	Number of bits per byte (default 8)

From Braille¶

Converts six-dot braille symbols to text.

Input: String
Output: String
CLI: rxchef run "From Braille"
Arguments: none

From Case Insensitive Regex¶

Converts a case-insensitive regex string to a case sensitive regex string by collapsing [xX] character class pairs into single characters.

Input: String
Output: String
CLI: rxchef run "From Case Insensitive Regex"
Arguments: none

From Charcode¶

Converts unicode character codes back into text.

Input: String
Output: Bytes
CLI: rxchef run "From Charcode"

#	Argument	Default	Description
1	Delimiter	`Space`	The character code delimiter
2	Base	`16`	The numerical base of the codes

From Decimal¶

Converts the data from an ordinal integer array back into its raw form.

Input: String
Output: Bytes
CLI: rxchef run "From Decimal"

#	Argument	Default	Description
1	Delimiter	`Space`	The character code delimiter
2	Support signed values	`false`	Support negative values (signed 8-bit integers)

From Float¶

Convert from IEEE754 Floating Point Numbers to raw bytes.

Input: String
Output: Bytes
CLI: rxchef run "From Float"

#	Argument	Default	Description
1	Endianness	`Big Endian`	Big Endian or Little Endian
2	Size	`Float (4 bytes)`	Float (4 bytes) or Double (8 bytes)
3	Delimiter	`Space`	Delimiter separating float values (Space, Comma, etc.)

From Hex¶

Converts a hexadecimal byte string back into its raw value.

Input: String
Output: Bytes
CLI: rxchef run "From Hex"

#	Argument	Default	Description
1	Delimiter	`Auto`	The hexadecimal delimiter

From Hex Content¶

Translates hexadecimal bytes in text back to raw bytes. e.g. 'foo|3d|bar' becomes 'foo=bar'.

Input: String
Output: Bytes
CLI: rxchef run "From Hex Content"
Arguments: none

From Hexdump¶

Attempts to convert a hexdump back into raw data. This operation supports many different hexdump variations, but probably not all. Make sure you verify that the data it gives you is correct before continuing analysis.

Input: String
Output: Bytes
CLI: rxchef run "From Hexdump"
Arguments: none

From Modhex¶

Converts a modhex byte string back into its raw value. Modhex is used in YubiKey.

Input: String
Output: Bytes
CLI: rxchef run "From Modhex"

#	Argument	Default	Description
1	Delimiter	`Auto`	Delimiter between modhex pairs (None, Space, Comma, Semi-colon, Colon, Line feed, CRLF)

From Morse Code¶

Translates Morse Code into (upper case) alphanumeric characters.

Input: String
Output: String
CLI: rxchef run "From Morse Code"

#	Argument	Default	Description
1	Letter delimiter	`Space`	The delimiter between letters
2	Word delimiter	`Line feed`	The delimiter between words

From Octal¶

Converts an octal byte string back into its raw value. e.g. '110 145 154 154 157' becomes 'Hello'.

Input: String
Output: Bytes
CLI: rxchef run "From Octal"

#	Argument	Default	Description
1	Delimiter	`Space`	Delimiter between octal values (Space, Comma, Semi-colon, Colon, Line feed, CRLF)

From Quoted Printable¶

Converts QP-encoded text back to standard text. This format is a content transfer encoding common in email messages.

Input: String
Output: Bytes
CLI: rxchef run "From Quoted Printable"
Arguments: none

From UNIX Timestamp¶

Converts a UNIX timestamp to a datetime string.

Input: Number
Output: String
CLI: rxchef run "From UNIX Timestamp"

#	Argument	Default	Description
1	Units	`Seconds (s)`	The unit of the timestamp

Fuzzy Match¶

Conducts a fuzzy search to find a pattern within the input based on weighted criteria.

Input: String
Output: HTML
CLI: rxchef run "Fuzzy Match"

#	Argument	Default	Description
1	Search	`<empty>`	Pattern to search for
2	Sequential bonus	`15`	Bonus for adjacent matches
3	Separator bonus	`30`	Bonus if match occurs after a separator
4	Camel bonus	`30`	Bonus if match is uppercase and previous is lower
5	First letter bonus	`15`	Bonus if the first letter is matched
6	Leading letter penalty	`-5`	Penalty applied for every letter in the input before the first match
7	Max leading letter penalty	`-15`	Maxiumum penalty for leading letters
8	Unmatched letter penalty	`-1`	Unmatched letter penalty

Generate De Bruijn Sequence¶

Generates rolling keycode combinations given a certain alphabet size (k) and key length (n). The result is a De Bruijn sequence B(k,n).

Input: String
Output: String
CLI: rxchef run "Generate De Bruijn Sequence"

#	Argument	Default	Description
1	Alphabet size (k)	`2`	Size of the alphabet (2-9)
2	Key length (n)	`3`	Length of each key (2 or more)

Generate HOTP¶

The HMAC-based One-Time Password algorithm (HOTP) is an algorithm that computes a one-time password from a shared secret key and an incrementing counter.

Input: Bytes
Output: String
CLI: rxchef run "Generate HOTP"

#	Argument	Default	Description
1	Name	`<empty>`	Label for the HOTP
2	Code length	`6`	Number of digits in the code
3	Counter	`0`	Counter value

Generate Lorem Ipsum¶

Generate varying length lorem ipsum placeholder text. Length type: Paragraphs, Sentences, Words, Bytes.

Input: String
Output: String
CLI: rxchef run "Generate Lorem Ipsum"

#	Argument	Default	Description
1	Length	`3`	Number of units to generate
2	Length in	`Paragraphs`	Unit type: Paragraphs, Sentences, Words, Bytes

Generate TOTP¶

The Time-based One-Time Password algorithm (TOTP) is an algorithm that computes a one-time password from a shared secret key and the current time. It has been adopted as Internet Engineering Task Force standard RFC 6238, is the cornerstone of Initiative For Open Authentication (OAUTH), and is used in a number of two-factor authentication systems. A TOTP is an HOTP where the counter is the current time.

Enter the secret as the input or leave it blank for a random secret to be generated. T0 and T1 are in seconds.

Input: Bytes
Output: String
CLI: rxchef run "Generate TOTP"

#	Argument	Default	Description
1	Name	`<empty>`	The name of the account
2	Code length	`6`	The number of digits in the generated code
3	Epoch offset (T0)	`0`	The epoch offset in seconds
4	Interval (T1)	`30`	The time interval in seconds

Get All Casings¶

Outputs all possible casing variations of a string. Limited to inputs with at most 20 alphabetic characters to avoid excessive output.

Input: String
Output: String
CLI: rxchef run "Get All Casings"
Arguments: none

Get Time¶

Generates a timestamp showing the amount of time since the UNIX epoch (1970-01-01 00:00:00 UTC). Granularity options: Nanoseconds (ns), Microseconds (us), Milliseconds (ms), Seconds (s).

Input: String
Output: Number
CLI: rxchef run "Get Time"

#	Argument	Default	Description
1	Granularity	`Milliseconds (ms)`	Time unit: Nanoseconds (ns), Microseconds (us), Milliseconds (ms), Seconds (s)

Group IP addresses¶

Groups a list of IP addresses into subnets. Supports both IPv4 and IPv6 addresses.

Input: String
Output: String
CLI: rxchef run "Group IP addresses"

#	Argument	Default	Description
1	Delimiter	`Line feed`	The delimiter between IP addresses
2	Subnet (CIDR)	`24`	The CIDR subnet mask to group by
3	Only show the subnets	`false`	Only show the resulting subnets, not the individual IP addresses

HTML To Text¶

Converts HTML to readable plain text by stripping tags and decoding common HTML entities.

Input: HTML
Output: String
CLI: rxchef run "HTML To Text"
Arguments: none

HTTP request¶

Makes an HTTP request and returns the response.

Input: String
Output: String
CLI: rxchef run "HTTP request"

#	Argument	Default	Description
1	Method	`GET`	HTTP method
2	URL	`<empty>`	The URL to request
3	Headers	`<empty>`	Request headers (Key: Value)
4	Mode	`Cross-Origin Resource Sharing`	CORS mode (ignored in Rust)
5	Show response metadata	`false`	Include status and headers in output

Hamming Distance¶

In information theory, the Hamming distance between two strings of equal length is the number of positions at which the corresponding symbols are different.

Input: String
Output: String
CLI: rxchef run "Hamming Distance"

#	Argument	Default	Description
1	Delimiter	`\\n\\n`	Delimiter between strings
2	Unit	`Byte`	Unit: Byte or Bit
3	Input type	`Raw string`	Input type: Raw string or Hex

Haversine distance¶

Returns the distance between two pairs of GPS latitude and longitude co-ordinates in metres. Input format: lat1, lng1, lat2, lng2

Input: String
Output: Number
CLI: rxchef run "Haversine distance"
Arguments: none

Head¶

Like the UNIX head utility. Gets the first n lines. You can select all but the last n lines by entering a negative value for n. The delimiter can be changed so that instead of lines, fields are selected instead.

Input: String
Output: String
CLI: rxchef run "Head"

#	Argument	Default	Description
1	Delimiter	`Line feed`	Record delimiter: Line feed, CRLF, Comma, etc.
2	Number	`10`	Number of lines to take. Negative value = all but last n.

IPv6 Transition Addresses¶

Converts IPv4 addresses to their IPv6 Transition addresses. IPv6 Transition addresses can also be converted back into their original IPv4 address. MAC addresses can also be converted into the EUI-64 format, this can them be appended to your IPv6 /64 range to obtain a full /128 address.

Transition technologies enable translation between IPv4 and IPv6 addresses or tunneling to allow traffic to pass through the incompatible network, allowing the two standards to coexist.

Only /24 ranges and currently handled. Remove headers to easily copy out results.

Input: String
Output: String
CLI: rxchef run "IPv6 Transition Addresses"

#	Argument	Default	Description
1	Ignore ranges	`true`	If checked, input ranges will be ignored.
2	Remove headers	`false`	Remove headers to easily copy out results.

Index of Coincidence¶

Index of Coincidence (IC) is the probability of two randomly selected characters being the same.

Input: String
Output: Number
CLI: rxchef run "Index of Coincidence"
Arguments: none

JSON to CSV¶

Converts JSON data to a CSV based on the definition in RFC 4180.

Input: JSON
Output: String
CLI: rxchef run "JSON to CSV"

#	Argument	Default	Description
1	Cell delimiter	`,`	The character(s) to use to separate cells
2	Row delimiter	`\\r\\n`	The character(s) to use to separate rows

JSON to YAML¶

Format a JSON object into YAML

Input: JSON
Output: String
CLI: rxchef run "JSON to YAML"
Arguments: none

Jump¶

Jump forwards or backwards to a Label in a recipe. Backwards jumps are bounded by the configured maximum. Interpreted by integration::bake and all CLI recipe frontends.

Input: String
Output: String
CLI: rxchef run "Jump"

#	Argument	Default	Description
1	Label name	`<empty>`	The name of the label to jump to
2	Maximum jumps (if jumping backwards)	`10`	The maximum number of times to jump backwards to prevent infinite loops

Label¶

Provides a location for conditional and fixed jumps to redirect execution to.

Input: String
Output: String
CLI: rxchef run "Label"

#	Argument	Default	Description
1	Name	`<empty>`	The name of the label

Levenshtein Distance¶

Levenshtein Distance (also known as Edit Distance) is a string metric to measure a difference between two strings that counts operations (insertions, deletions, and substitutions) on single character that are required to change one string to another.

Input: String
Output: String
CLI: rxchef run "Levenshtein Distance"

#	Argument	Default	Description
1	Sample delimiter	`\\n`	Delimiter separating the two input samples
2	Insertion cost	`1`	Cost of inserting a character
3	Deletion cost	`1`	Cost of deleting a character
4	Substitution cost	`1`	Cost of substituting a character

Luhn Checksum¶

The Luhn mod N algorithm using the english alphabet. The Luhn mod N algorithm is an extension to the Luhn algorithm (also known as mod 10 algorithm) that allows it to work with sequences of values in any even-numbered base.

Input: String
Output: String
CLI: rxchef run "Luhn Checksum"

#	Argument	Default	Description
1	Radix	`10`	The base/radix to use (must be even, 2-36)

MIME Decoding¶

Enables the decoding of MIME message header extensions for non-ASCII text

Input: String
Output: String
CLI: rxchef run "MIME Decoding"
Arguments: none

Magic¶

The Magic operation attempts to detect various properties of the input data and suggests which operations could help to make more sense of it.

Input: Bytes
Output: JSON
CLI: rxchef run "Magic"

#	Argument	Default	Description
1	Depth	`3`	Maximum number of levels of recursion
2	Intensive mode	`false`	Brute-force XOR, bit rotates, etc.
3	Extensive language support	`false`	Compare byte frequencies to a large number of languages
4	Crib (known plaintext string or regex)	`<empty>`	Filter results by matching this string or regex

Mean¶

Computes the mean (average) of a number list. If an item in the string is not a number it is excluded from the list. e.g. 0x0a 8 .5 .5 becomes 4.75

Input: String
Output: String
CLI: rxchef run "Mean"

#	Argument	Default	Description
1	Delimiter	`Line feed`	Character that separates numbers in the input

Median¶

Computes the median of a number list. If an item in the string is not a number it is excluded from the list. e.g. 0x0a 8 1 .5 becomes 4.5

Input: String
Output: String
CLI: rxchef run "Median"

#	Argument	Default	Description
1	Delimiter	`Line feed`	Character that separates numbers in the input

Merge¶

Consolidate all branches back into a single trunk. The opposite of Fork. Unticking the Merge All checkbox will only consolidate all branches up to the nearest Fork/Subsection.

Input: String
Output: String
CLI: rxchef run "Merge"

#	Argument	Default	Description
1	Merge All	`true`	Consolidate all branches back into a single trunk.

Microsoft Script Decoder¶

Decodes Microsoft Encoded Script files that have been encoded with Microsoft's custom encoding. These are often VBS (Visual Basic Script) files that are encoded and renamed with a '.vbe' extention or JS (JScript) files renamed with a '.jse' extention.

Input: String
Output: String
CLI: rxchef run "Microsoft Script Decoder"
Arguments: none

Multiply¶

Multiplies a list of numbers. If an item in the string is not a number it is excluded from the list. e.g. 0x0a 8 .5 becomes 40

Input: String
Output: String
CLI: rxchef run "Multiply"

#	Argument	Default	Description
1	Delimiter	`Line feed`	Character that separates numbers in the input

NOT¶

Returns the inverse of each byte.

Input: Bytes
Output: Bytes
CLI: rxchef run "NOT"
Arguments: none

Numberwang¶

Based on the popular gameshow by Mitchell and Webb.

Input: String
Output: String
CLI: rxchef run "Numberwang"
Arguments: none

OR¶

OR the input with the given key.

Input: Bytes
Output: Bytes
CLI: rxchef run "OR"

#	Argument	Default	Description
1	Key	`<empty>`	Key to OR with input

Offset checker¶

Compares multiple inputs (separated by the specified delimiter) and marks characters which appear at the same position in all samples. Matching characters are shown in [brackets].

Input: String
Output: String
CLI: rxchef run "Offset checker"

#	Argument	Default	Description
1	Sample delimiter	`\\n\\n`	String used to separate samples in the input

P-list Viewer¶

In the macOS, iOS, NeXTSTEP, and GNUstep programming frameworks, property list files are files that store serialized objects. Property list files use the filename extension .plist, and thus are often referred to as p-list files.

This operation displays plist files in a human readable format.

Input: String
Output: String
CLI: rxchef run "P-list Viewer"
Arguments: none

PEM to Hex¶

Converts PEM (Privacy Enhanced Mail) format to a hexadecimal DER (Distinguished Encoding Rules) string.

Input: String
Output: String
CLI: rxchef run "PEM to Hex"
Arguments: none

PHP Deserialize¶

Deserializes PHP serialized data, outputting keyed arrays as JSON.

This function does not support object tags.

Example:
a:2:{s:1:"a";i:10;i:0;a:1:{s:2:"ab";b:1;}}
becomes
{"a": 10,0: {"ab": true}}

Output valid JSON: JSON doesn't support integers as keys, whereas PHP serialization does. Enabling this will cast these integers to strings. This will also escape backslashes.

Input: String
Output: String
CLI: rxchef run "PHP Deserialize"

#	Argument	Default	Description
1	Output valid JSON	`true`	JSON doesn't support integers as keys, whereas PHP serialization does. Enabling this will cast these integers to strings. This will also escape backslashes.

PHP Serialize¶

Performs PHP serialization on JSON data.

This function does not support object tags.

Since PHP doesn't distinguish dicts and arrays, this operation is not always symmetric to PHP Deserialize.

Example:
[5,"abc",true]
becomes
a:3:{i:0;i:5;i:1;s:3:"abc";i:2;b:1;}



Input: JSON
Output: String
CLI: rxchef run "PHP Serialize"
Arguments: none

Pad lines¶
Add the specified number of the specified character to the beginning or end of each line.

Input: String
Output: String
CLI: rxchef run "Pad lines"




#
Argument
Default
Description




1
Position
Start
Where to add padding: Start or End


2
Length
5
Number of padding characters to add


3
Character

Character to use for padding



Parity Bit¶
A parity bit, or check bit, is the simplest form of error detection. It is a bit which is added to a string of bits and represents if the number of 1's in the binary string is an even number or odd number.

Input: Bytes
Output: Bytes
CLI: rxchef run "Parity Bit"




#
Argument
Default
Description




1
Mode
Even Parity
Even or Odd parity


2
Position
Start
Start or End


3
Encode or Decode
Encode
Encode or Decode


4
Delimiter
<empty>
Delimiter for blocks



Parse DateTime¶
Parses a DateTime string using strftime format specifiers and displays detailed date/time information including day of year, week number, quarter, and leap year status. Format uses strftime tokens (e.g. %d/%m/%Y %H:%M:%S).

Input: String
Output: String
CLI: rxchef run "Parse DateTime"




#
Argument
Default
Description




1
Input format string
%d/%m/%Y %H:%M:%S
strftime format string (e.g. %d/%m/%Y %H:%M:%S)


2
Input timezone
UTC
Timezone name (currently UTC only)



Parse Ethernet frame¶
Parses an Ethernet frame and shows the deduced values: Source and Destination MAC, optional VLAN IDs, and the inner packet payload.

Input: String
Output: String
CLI: rxchef run "Parse Ethernet frame"




#
Argument
Default
Description




1
Input type
Hex
Raw bytes or Hex string


2
Return type
Text output
Text output, Packet data, or Packet data (hex)



Parse IP range¶
Given a CIDR range (e.g. 10.0.0.0/24), a hyphenated range (e.g. 10.0.0.0 - 10.0.1.0), or a single IP address, this operation provides network information and enumerates all IP addresses in the range. IPv6 is supported but not enumerated.

Input: String
Output: String
CLI: rxchef run "Parse IP range"




#
Argument
Default
Description




1
Include network info
true
Show network/mask/host information


2
Enumerate IP addresses
true
List every IP in the range


3
Allow large queries
false
Allow ranges larger than 65536



Parse IPv4 header¶
Parses an IPv4 packet header and displays each field in a readable format including version, IHL, DSCP, ECN, total length, identification, flags, fragment offset, TTL, protocol, checksum, source and destination IP addresses, and options if present.

Input: String
Output: String
CLI: rxchef run "Parse IPv4 header"




#
Argument
Default
Description




1
Input format
Hex
Hex or Raw


2
Output format
Table
Table, Data (hex), or Data (raw)



Parse IPv6 address¶
Displays the longhand and shorthand versions of a valid IPv6 address, identifies reserved ranges including loopback, link-local, multicast, Teredo, 6to4, and unique local addresses, and detects EUI-64 interface identifiers.

Input: String
Output: String
CLI: rxchef run "Parse IPv6 address"
Arguments: none

Parse SSH Host Key¶
Parses a SSH host key and extracts fields from it.
The key type can be:
ssh-rsa
ssh-dss
ecdsa-sha2
ssh-ed25519
The key format can be either Hex or Base64.

Input: String
Output: String
CLI: rxchef run "Parse SSH Host Key"




#
Argument
Default
Description




1
Input Format
Auto
The format of the input key



Parse TCP¶
Parses a TCP header and payload (if present).

Input: String
Output: JSON
CLI: rxchef run "Parse TCP"




#
Argument
Default
Description




1
Input format
Hex
The format of the input data



Parse TLS record¶
Parses one or more TLS records into JSON, including content type, protocol version, declared length, truncation state, handshake type and exact payload bytes. Encrypted and handshake-specific payloads remain hex-encoded.

Input: Bytes
Output: JSON
CLI: rxchef run "Parse TLS record"
Arguments: none

Parse TLV¶
Converts a Type-Length-Value (TLV) encoded string into a JSON object. Can optionally include a Key / Type entry.

Input: Bytes
Output: JSON
CLI: rxchef run "Parse TLV"




#
Argument
Default
Description




1
Type/Key size
1
Size of the type/key field in bytes


2
Length size
1
Size of the length field in bytes


3
Use BER
false
Use Basic Encoding Rules for length field



Parse UDP¶
Parses a UDP header and payload (if present).

Input: String
Output: JSON
CLI: rxchef run "Parse UDP"




#
Argument
Default
Description




1
Input format
Hex
Format of the input data



Parse UNIX file permissions¶
Given a UNIX/Linux file permission string in octal or textual format, this operation explains which permissions are granted to which user groups.

Input should be in either octal (e.g. 755) or textual (e.g. drwxr-xr-x) format.

Input: String
Output: String
CLI: rxchef run "Parse UNIX file permissions"
Arguments: none

Parse colour code¶
Converts a colour code in a standard format to other standard formats and displays the colour itself.

Example inputs
#d9edf7
rgba(217,237,247,1)
hsla(200,65%,91%,1)
cmyk(0.12, 0.04, 0.00, 0.03)


Input: String
Output: HTML
CLI: rxchef run "Parse colour code"
Arguments: none

Play Media¶
Plays the input as audio or video depending on the type.

Tags: sound, movie, mp3, mp4, mov, webm, wav, ogg

Input: String
Output: Bytes
CLI: rxchef run "Play Media"




#
Argument
Default
Description




1
Input format
Raw
Input format of the media



Power Set¶
Calculates all the subsets of a set.

Input: String
Output: String
CLI: rxchef run "Power Set"




#
Argument
Default
Description




1
Item delimiter
,
Delimiter between items



RAKE¶
Rapid Keyword Extraction (RAKE)

RAKE is a domain-independent keyword extraction algorithm in Natural Language Processing.

The list of stop words are from the NLTK python package

Input: String
Output: String
CLI: rxchef run "RAKE"




#
Argument
Default
Description




1
Word Delimiter (Regex)
\\s
Word Delimiter (Regex)


2
Sentence Delimiter (Regex)
\\.\\s\|\\n
Sentence Delimiter (Regex)


3
Stop Words
i,me,my,myself,we,our,ours,ourselves,you,you're,you've,you'll,you'd,your,yours,yourself,yourselves,he,him,his,himself,she,she's,her,hers,herself,it,it's,its,itsef,they,them,their,theirs,themselves,what,which,who,whom,this,that,that'll,these,those,am,is,are,was,were,be,been,being,have,has,had,having,do,does',did,doing,a,an,the,and,but,if,or,because,as,until,while,of,at,by,for,with,about,against,between,into,through,during,before,after,above,below,to,from,up,down,in,out,on,off,over,under,again,further,then,once,here,there,when,where,why,how,all,any,both,each,few,more,most,other,some,such,no,nor,not,only,own,same,so,than,too,very,s,t,can,will,just,don,don't,should,should've,now,d,ll,m,o,re,ve,y,ain,aren,aren't,couldn,couldn't,didn,didn't,doesn,doesn't,hadn,hadn't,hasn,hasn't,haven,haven't,isn,isn't,ma,mightn,mightn't,mustn,mustn't,needn,needn't,shan,shan't,shouldn,shouldn't,wasn,wasn't,weren,weren't,won,won't,wouldn,wouldn't
Stop Words (comma separated)



ROT47 Brute Force¶
Try all meaningful amounts for ROT47. Optionally you can enter your known plaintext (crib) to filter the result.

Input: Bytes
Output: String
CLI: rxchef run "ROT47 Brute Force"




#
Argument
Default
Description




1
Sample length
100
Number of bytes to sample from input


2
Sample offset
0
Byte offset to start sampling


3
Print amount
true
Prefix each result with its rotation amount (true/false)


4
Crib (known plaintext string)
<empty>
Filter results to those containing this string



ROT8000¶
The simple Caesar-cypher encryption that replaces each Unicode character with the one 0x8000 places forward or back along the alphabet. Valid BMP codepoints are rotated; others pass through unchanged.

Input: String
Output: String
CLI: rxchef run "ROT8000"
Arguments: none

Remove Diacritics¶
Replaces accented characters with their latin character equivalent. Accented characters are made up of Unicode combining characters, so unicode text formatting such as strikethroughs and underlines will also be removed.

Input: String
Output: String
CLI: rxchef run "Remove Diacritics"
Arguments: none

Remove line numbers¶
Removes line numbers from the output if they can be trivially detected.

Input: String
Output: String
CLI: rxchef run "Remove line numbers"
Arguments: none

Remove null bytes¶
Removes all null bytes (0x00) from the input.

Input: Bytes
Output: Bytes
CLI: rxchef run "Remove null bytes"
Arguments: none

Remove whitespace¶
Optionally removes all spaces, carriage returns, line feeds, tabs and form feeds from the input data. This operation also supports the removal of full stops which are sometimes used to represent non-printable bytes in ASCII output.

Input: String
Output: String
CLI: rxchef run "Remove whitespace"




#
Argument
Default
Description




1
Spaces
true
Remove spaces


2
Carriage returns (\r)
true
Remove carriage returns


3
Line feeds (\n)
true
Remove line feeds


4
Tabs
true
Remove tabs


5
Form feeds (\f)
true
Remove form feeds


6
Full stops
false
Remove full stops



Return¶
End execution of operations at this point in the recipe.

Input: String
Output: String
CLI: rxchef run "Return"
Arguments: none

Reverse¶
Reverses the input string. The 'By' argument controls whether the reversal operates on individual bytes, Unicode characters, or whole lines.

Input: Bytes
Output: Bytes
CLI: rxchef run "Reverse"




#
Argument
Default
Description




1
By
Character
Byte, Character, or Line



Rotate left¶
Rotates each byte to the left by the number of bits specified, optionally carrying the excess bits over to the next byte. Currently only supports 8-bit values.

Input: Bytes
Output: Bytes
CLI: rxchef run "Rotate left"




#
Argument
Default
Description




1
Amount
1
Number of bits to rotate left


2
Carry through
false
If true, carry bits from one byte to the next across all bytes



Rotate right¶
Rotates each byte to the right by the number of bits specified, optionally carrying the excess bits over to the next byte. Currently only supports 8-bit values.

Input: Bytes
Output: Bytes
CLI: rxchef run "Rotate right"




#
Argument
Default
Description




1
Amount
1
Number of bits to rotate right


2
Carry through
false
If true, carry bits from one byte to the next across all bytes



SUB¶
SUB the input with the given key (e.g. fe023da5), MOD 256

Input: Bytes
Output: Bytes
CLI: rxchef run "SUB"




#
Argument
Default
Description




1
Key
<empty>
Key to SUB from input bytes


2
Scheme
Standard
Scheme (Standard, Input differential, Output differential)


3
Null preserving
false
If true, bytes that are 0 or equal to the key byte are not modified



Scan for Embedded Files¶
Scans the data for potential embedded files by looking for magic bytes at all offsets. This operation is prone to false positives.

Input: Bytes
Output: String
CLI: rxchef run "Scan for Embedded Files"




#
Argument
Default
Description




1
Images
true
Scan for image files


2
Video
true
Scan for video files


3
Audio
true
Scan for audio files


4
Documents
true
Scan for document files


5
Applications
true
Scan for application files


6
Archives
true
Scan for archive files



Set Difference¶
Calculates the difference, or relative complement, of two sets.

Input: String
Output: String
CLI: rxchef run "Set Difference"




#
Argument
Default
Description




1
Sample delimiter
\\n\\n
Delimiter separating the two input sets


2
Item delimiter
,
Delimiter separating items within each set



Set Intersection¶
Calculates the intersection of two sets.

Input: String
Output: String
CLI: rxchef run "Set Intersection"




#
Argument
Default
Description




1
Sample delimiter
\\n\\n
Delimiter separating the two input sets


2
Item delimiter
,
Delimiter separating items within each set



Set Union¶
Calculates the union of two sets.

Input: String
Output: String
CLI: rxchef run "Set Union"




#
Argument
Default
Description




1
Sample delimiter
\\n\\n
Delimiter separating the two input sets


2
Item delimiter
,
Delimiter separating items within each set



Show Base64 Offsets¶
Show the possible Base64 offsets for a given string.

Input: String
Output: HTML
CLI: rxchef run "Show Base64 Offsets"




#
Argument
Default
Description




1
Alphabet
A-Za-z0-9+/=
The Base64 alphabet to use


2
URL Safe
false
Use URL-safe Base64 alphabet


3
Format
Base64
The format of the input string



Shuffle¶
Randomly reorders input elements.

Input: String
Output: String
CLI: rxchef run "Shuffle"




#
Argument
Default
Description




1
Delimiter
Line feed
Line feed, CRLF, Space, Comma, etc.



Sleep¶
Sleep causes the recipe to wait for a specified number of milliseconds before continuing execution.

Input: Bytes
Output: Bytes
CLI: rxchef run "Sleep"




#
Argument
Default
Description




1
Time (ms)
1000
Number of milliseconds to sleep



Sort¶
Alphabetically sorts strings separated by the specified delimiter. The IP address option supports IPv4 only.

Input: String
Output: String
CLI: rxchef run "Sort"




#
Argument
Default
Description




1
Delimiter
Line feed
Line feed, CRLF, Space, Comma, Semi-colon, Colon, Tab, None


2
Reverse
false
Sort in reverse order


3
Order
Alphabetical (case sensitive)
Alphabetical (case sensitive), Alphabetical (case insensitive), IP address, Numeric, Numeric (hexadecimal), Length



Split¶
Splits a string into sections around a given delimiter.

Input: String
Output: String
CLI: rxchef run "Split"




#
Argument
Default
Description




1
Split delimiter
Comma
Delimiter to split on (e.g. Comma, Line feed, or literal string)


2
Join delimiter
Line feed
Delimiter to rejoin with (e.g. Line feed, CRLF)



Standard Deviation¶
Computes the standard deviation of a number list. If an item in the string is not a number it is excluded from the list. e.g. 0x0a 8 .5 becomes 4.089281382128433

Input: String
Output: String
CLI: rxchef run "Standard Deviation"




#
Argument
Default
Description




1
Delimiter
Line feed
Character that separates numbers in the input



Strip HTML tags¶
Removes all HTML tags from the input. Optionally removes indentation and excess line breaks.

Input: String
Output: String
CLI: rxchef run "Strip HTML tags"




#
Argument
Default
Description




1
Remove indentation
true
Remove leading whitespace from lines


2
Remove excess line breaks
true
Collapse multiple blank lines



Strip HTTP headers¶
Removes HTTP headers from a request or response by looking for the first instance of a double newline.

Input: String
Output: String
CLI: rxchef run "Strip HTTP headers"
Arguments: none

Strip IPv4 header¶
Strips the IPv4 header from an IPv4 packet, outputting the payload.

Input: Bytes
Output: Bytes
CLI: rxchef run "Strip IPv4 header"
Arguments: none

Strip TCP header¶
Strips the TCP header from a TCP segment, outputting the payload.

Input: Bytes
Output: Bytes
CLI: rxchef run "Strip TCP header"
Arguments: none

Strip UDP header¶
Strips the UDP header from a UDP datagram, outputting the payload.

Input: Bytes
Output: Bytes
CLI: rxchef run "Strip UDP header"
Arguments: none

Subsection¶
Select input sections using a regular expression and run subsequent recipe operations on every match until Merge. Non-matching bytes remain unchanged. Interpreted by integration::bake and all CLI recipe frontends.

Input: String
Output: String
CLI: rxchef run "Subsection"




#
Argument
Default
Description




1
Section (regex)
<empty>
The regex to select the subsection with


2
Case sensitive matching
true
Whether the regex match should be case sensitive


3
Global matching
true
Whether to match all occurrences


4
Ignore errors
false
Whether to ignore errors in subsequent operations



Substitute¶
A substitution cipher allowing you to specify bytes to replace with other byte values. This can be used to create Caesar ciphers but is more powerful as any byte value can be substituted, not just letters, and the substitution values need not be in order.

Enter the bytes you want to replace in the Plaintext field and the bytes to replace them with in the Ciphertext field.

Non-printable bytes can be specified using string escape notation. For example, a line feed character can be written as either \n or \x0a.

Byte ranges can be specified using a hyphen. For example, the sequence 0123456789 can be written as 0-9.

Note that blackslash characters are used to escape special characters, so will need to be escaped themselves if you want to use them on their own (e.g.\).

Input: String
Output: String
CLI: rxchef run "Substitute"




#
Argument
Default
Description




1
Plaintext
ABCDEFGHIJKLMNOPQRSTUVWXYZ
The bytes you want to replace


2
Ciphertext
XYZABCDEFGHIJKLMNOPQRSTUVW
The bytes to replace them with


3
Ignore case
false
If true, the case of the input character is preserved.



Subtract¶
Subtracts a list of numbers. If an item in the string is not a number it is excluded from the list. e.g. 0x0a 8 .5 becomes 1.5

Input: String
Output: String
CLI: rxchef run "Subtract"




#
Argument
Default
Description




1
Delimiter
Line feed
Character that separates numbers in the input



Sum¶
Adds together a list of numbers. If an item in the string is not a number it is excluded from the list. e.g. 0x0a 8 .5 becomes 18.5

Input: String
Output: String
CLI: rxchef run "Sum"




#
Argument
Default
Description




1
Delimiter
Line feed
Character that separates numbers in the input



Swap case¶
Converts uppercase letters to lowercase ones, and lowercase ones to uppercase ones.

Input: String
Output: String
CLI: rxchef run "Swap case"
Arguments: none

Swap endianness¶
Switches the data from big-endian to little-endian or vice-versa. Data can be read in as hexadecimal or raw bytes. It will be returned in the same format as it is entered.

Input: String
Output: String
CLI: rxchef run "Swap endianness"




#
Argument
Default
Description




1
Data format
Raw
Input/output format: Hex or Raw


2
Word length (bytes)
4
Number of bytes per word


3
Pad incomplete words
true
If true, pad incomplete words with zero bytes



Symmetric Difference¶
Calculates the symmetric difference of two sets.

Input: String
Output: String
CLI: rxchef run "Symmetric Difference"




#
Argument
Default
Description




1
Sample delimiter
\\n\\n
Delimiter separating the two input sets


2
Item delimiter
,
Delimiter separating items within each set



Tail¶
Like the UNIX tail utility. Gets the last n lines. Optionally you can select all lines after line n by entering a negative value for n. The delimiter can be changed so that instead of lines, fields are selected instead.

Input: String
Output: String
CLI: rxchef run "Tail"




#
Argument
Default
Description




1
Delimiter
Line feed
Record delimiter: Line feed, CRLF, Comma, etc.


2
Number
10
Number of lines to take from the end. Negative = all after line n.



Take bytes¶
Takes a slice of the specified number of bytes from the data. Negative values are allowed.

Input: Bytes
Output: Bytes
CLI: rxchef run "Take bytes"




#
Argument
Default
Description




1
Start
0
Starting byte position (negative counts from end)


2
Length
5
Number of bytes to take (negative reverses direction)


3
Apply to each line
false
If true, apply operation to each line separately



Take nth bytes¶
Takes every nth byte starting with a given byte.

Input: Bytes
Output: Bytes
CLI: rxchef run "Take nth bytes"




#
Argument
Default
Description




1
Take every
4
Take every nth byte


2
Starting at
0
Starting byte offset


3
Apply to each line
false
If true, apply to each line separately



Text-Integer Conversion¶
Converts between text strings and large integers. Text is interpreted as a big-endian sequence of character codes.

Input: String
Output: String
CLI: rxchef run "Text-Integer Conversion"




#
Argument
Default
Description




1
Output format
String
String, Decimal, or Hexadecimal



To BCD¶
Binary-Coded Decimal (BCD) is a class of binary encodings of decimal numbers where each decimal digit is represented by a fixed number of bits, usually four or eight. Special bit patterns are sometimes used for a sign.

Input: String
Output: String
CLI: rxchef run "To BCD"




#
Argument
Default
Description




1
Scheme
8 4 2 1
The BCD encoding scheme


2
Packed
true
Whether to pack two digits per byte


3
Signed
false
Whether to include a trailing sign nibble


4
Output format
Nibbles
Nibbles, Bytes, or Raw



To Base¶
Converts a decimal number to a given numerical base (radix 2-36).

Input: String
Output: String
CLI: rxchef run "To Base"




#
Argument
Default
Description




1
Radix
36
The base to convert to (2-36)



To Base32¶
Base32 is a notation for encoding arbitrary byte data using a restricted set of symbols.

Input: Bytes
Output: String
CLI: rxchef run "To Base32"




#
Argument
Default
Description




1
Alphabet
A-Z2-7=
The Base32 alphabet



To Base45¶
Base45 is optimized for usage with QR codes.

Input: Bytes
Output: String
CLI: rxchef run "To Base45"




#
Argument
Default
Description




1
Alphabet
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:
The Base45 alphabet



To Base58¶
Base58 is a notation for encoding arbitrary byte data, removing easily misread characters.

Input: Bytes
Output: String
CLI: rxchef run "To Base58"




#
Argument
Default
Description




1
Alphabet
123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz
The Base58 alphabet



To Base62¶
Base62 is a notation for encoding arbitrary byte data using 0-9A-Za-z.

Input: Bytes
Output: String
CLI: rxchef run "To Base62"




#
Argument
Default
Description




1
Alphabet
0-9A-Za-z
The Base62 alphabet



To Base64¶
Base64 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers.

Input: Bytes
Output: String
CLI: rxchef run "To Base64"




#
Argument
Default
Description




1
Alphabet
A-Za-z0-9+/=
The Base64 alphabet



To Base85¶
Base85 (also called Ascii85) is a notation for encoding arbitrary byte data. It is usually more efficient than Base64.

Input: Bytes
Output: String
CLI: rxchef run "To Base85"




#
Argument
Default
Description




1
Alphabet
!-u
The Base85 alphabet


2
Include delimiter
false
Adds a <~ and ~> delimiter to the start and end of the data.



To Base92¶
Base92 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers.

Input: String
Output: Bytes
CLI: rxchef run "To Base92"
Arguments: none

To Bech32¶
Bech32 is an encoding scheme primarily used for Bitcoin SegWit addresses (BIP-0173). It uses a 32-character alphabet that excludes easily confused characters (1, b, i, o) and includes a checksum for error detection.

Bech32m (BIP-0350) is an updated version that fixes a weakness in the original Bech32 checksum and is used for Bitcoin Taproot addresses.

The Human-Readable Part (HRP) identifies the network or purpose (e.g., 'bc' for Bitcoin mainnet, 'tb' for testnet, 'age' for AGE encryption keys).

Maximum output length is 90 characters as per specification.

Input: Bytes
Output: String
CLI: rxchef run "To Bech32"




#
Argument
Default
Description




1
Human-Readable Part (HRP)
bc
Human-Readable Part (HRP)


2
Encoding
Bech32
Encoding


3
Input Format
Raw bytes
Input Format


4
Mode
Generic
Mode


5
Witness Version
0
Witness Version (0-16)



To Binary¶
Displays the input data as a binary string. e.g. 'Hi' becomes '01001000 01101001'

Input: Bytes
Output: String
CLI: rxchef run "To Binary"




#
Argument
Default
Description




1
Delimiter
Space
The delimiter between binary groups (Space, Comma, Semi-colon, Colon, Line feed, CRLF, None)


2
Byte Length
8
Number of bits per byte (default 8)



To Braille¶
Converts text to six-dot braille symbols.

Input: String
Output: String
CLI: rxchef run "To Braille"
Arguments: none

To Case Insensitive Regex¶
Converts a case-sensitive regex string into a case-insensitive regex string in case the i flag is unavailable to you.

e.g. Mozilla/[0-9].[0-9] . becomes [mM][oO][zZ][iI][lL][lL][aA]/[0-9].[0-9] .

Input: String
Output: String
CLI: rxchef run "To Case Insensitive Regex"
Arguments: none

To Charcode¶
Converts text to its unicode character code equivalent.

Input: String
Output: String
CLI: rxchef run "To Charcode"




#
Argument
Default
Description




1
Delimiter
Space
The character code delimiter


2
Base
16
The numerical base of the codes (2-36)



To Decimal¶
Converts the input data to an ordinal integer array. e.g. 'Hello' becomes '72 101 108 108 111'.

Input: Bytes
Output: String
CLI: rxchef run "To Decimal"




#
Argument
Default
Description




1
Delimiter
Space
The delimiter between decimal values


2
Support signed values
false
Whether to treat bytes as signed (-128 to 127)



To Float¶
Convert to IEEE754 Floating Point Numbers.

Input: Bytes
Output: String
CLI: rxchef run "To Float"




#
Argument
Default
Description




1
Endianness
Big Endian
Big Endian or Little Endian


2
Size
Float (4 bytes)
Float (4 bytes) or Double (8 bytes)


3
Delimiter
Space
Delimiter to join float values (Space, Comma, etc.)



To Hex¶
Converts the input string to hexadecimal bytes separated by the specified delimiter.

Input: Bytes
Output: String
CLI: rxchef run "To Hex"




#
Argument
Default
Description




1
Delimiter
Space
Delimiter between hex bytes (Space, Comma, Semi-colon, Colon, Line feed, CRLF, None, 0x with comma, \x)


2
Bytes per line
0
Number of bytes per output line (0 = no wrapping)



To Hex Content¶
Converts special characters in a string to hexadecimal using SNORT pipe notation. e.g. 'foo=bar' becomes 'foo|3d|bar'.

Input: Bytes
Output: String
CLI: rxchef run "To Hex Content"




#
Argument
Default
Description




1
Convert
Only special chars
Only special chars, Only special chars including spaces, or All chars


2
Print spaces between bytes
false
Add spaces between hex bytes inside pipes



To Hexdump¶
Creates a hexdump of the input data, displaying both the hexadecimal values of each byte and an ASCII representation alongside.

Input: Bytes
Output: String
CLI: rxchef run "To Hexdump"




#
Argument
Default
Description




1
Width
16
Number of bytes per row (must be >= 1)


2
Upper case hex
false
Display hex bytes in upper case


3
Include final length
false
Append the total byte count as a final line


4
UNIX format
false
Use UNIX printable character subset for ASCII column



To Lower case¶
Converts every character in the input to lower case.

Input: String
Output: String
CLI: rxchef run "To Lower case"
Arguments: none

To Modhex¶
Converts the input string to modhex bytes separated by the specified delimiter.

Input: Bytes
Output: String
CLI: rxchef run "To Modhex"




#
Argument
Default
Description




1
Delimiter
Space
Delimiter between modhex pairs (None, Space, Comma, Semi-colon, Colon, Line feed, CRLF)


2
Bytes per line
0
Number of bytes per output line (0 = no limit)



To Morse Code¶
Translates alphanumeric characters into International Morse Code.

Ignores non-Morse characters.

e.g. SOS becomes ... --- ...

Input: String
Output: String
CLI: rxchef run "To Morse Code"




#
Argument
Default
Description




1
Format options
-/.
The characters to use for dots and dashes


2
Letter delimiter
Space
The delimiter between letters


3
Word delimiter
Line feed
The delimiter between words



To Octal¶
Converts the input string to octal bytes separated by the specified delimiter. e.g. 'Hello' becomes '110 145 154 154 157'.

Input: Bytes
Output: String
CLI: rxchef run "To Octal"




#
Argument
Default
Description




1
Delimiter
Space
Delimiter between octal values (Space, Comma, Semi-colon, Colon, Line feed, CRLF)



To Quoted Printable¶
Quoted-Printable, or QP encoding, is an encoding using printable ASCII characters (alphanumeric and the equals sign '=') to transmit 8-bit data over a 7-bit data path or, generally, over a medium which is not 8-bit clean. It is defined as a MIME content transfer encoding for use in email.

QP works by using the equals sign '=' as an escape character. It also limits line length to 76, as some software has limits on line length.

Input: Bytes
Output: String
CLI: rxchef run "To Quoted Printable"
Arguments: none

To Table¶
Data can be split on different characters and rendered as an HTML, ASCII or Markdown table with an optional header row.

Supports the CSV (Comma Separated Values) file format by default. Change the cell delimiter argument to \t to support TSV (Tab Separated Values) or | for PSV (Pipe Separated Values).

You can enter as many delimiters as you like. Each character will be treat as a separate possible delimiter.

Input: String
Output: HTML
CLI: rxchef run "To Table"




#
Argument
Default
Description




1
Cell delimiters
,
Characters used to separate cells


2
Row delimiters
\\r\\n
Characters used to separate rows


3
Make first row header
false
Treat the first row as a header row


4
Format
ASCII
The output format



To UNIX Timestamp¶
Parses a datetime string in UTC and returns the corresponding UNIX timestamp.
e.g. Mon 1 January 2001 11:00:00 becomes 978346800
A UNIX timestamp is a 32-bit value representing the number of seconds since January 1, 1970 UTC (the UNIX epoch).

Input: String
Output: String
CLI: rxchef run "To UNIX Timestamp"




#
Argument
Default
Description




1
Units
Seconds (s)
The unit of the timestamp


2
Treat as UTC
true
Treat the input as UTC


3
Show parsed datetime
true
Show the parsed datetime in the output



To Upper case¶
Converts the input string to upper case, optionally limiting scope to only the first character in each word, sentence or paragraph.

Input: String
Output: String
CLI: rxchef run "To Upper case"




#
Argument
Default
Description




1
Scope
All
All, Word, Sentence, or Paragraph



Translate DateTime Format¶
Parses a datetime string in one format and re-writes it in another. Uses strftime/strptime format strings (e.g. %d/%m/%Y %H:%M:%S). Timezone names are noted but conversion uses UTC unless a numeric offset is embedded in the format.

Input: String
Output: String
CLI: rxchef run "Translate DateTime Format"




#
Argument
Default
Description




1
Input format string
%d/%m/%Y %H:%M:%S
strftime format string for parsing input (e.g. %d/%m/%Y %H:%M:%S)


2
Input timezone
UTC
Timezone of the input datetime (informational; UTC assumed unless offset in format)


3
Output format string
%A %d %B %Y %H:%M:%S
strftime format string for the output (e.g. %A %d %B %Y %H:%M:%S %z)


4
Output timezone
UTC
Timezone for the output datetime (informational; UTC assumed unless offset in format)



UNIX Timestamp to Windows Filetime¶
Converts a UNIX timestamp to a Windows Filetime value.

A Windows Filetime is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 UTC.

A UNIX timestamp is a 32-bit value representing the number of seconds since January 1, 1970 UTC (the UNIX epoch).

This operation also supports UNIX timestamps in milliseconds, microseconds and nanoseconds.

Input: String
Output: String
CLI: rxchef run "UNIX Timestamp to Windows Filetime"




#
Argument
Default
Description




1
Input units
Seconds (s)
Input units


2
Output format
Decimal
Output format



Unescape Unicode Characters¶
Converts unicode-escaped character notation back into raw characters.

Supports the prefixes:
\u
%u
U+
e.g. \u03c3\u03bf\u03c5 becomes 

Input: String
Output: String
CLI: rxchef run "Unescape Unicode Characters"




#
Argument
Default
Description




1
Prefix
\\u
The prefix used for the unicode escape sequence



Unescape string¶
Unescapes characters in a string that have been escaped. For example, Don\'t stop me now becomes Don't stop me now.

Supports the following escape sequences:
\n (Line feed/newline)
\r (Carriage return)
\t (Horizontal tab)
\b (Backspace)
\f (Form feed)
\nnn (Octal, where n is 0-7)
\xnn (Hex, where n is 0-f)
\ (Backslash)
\' (Single quote)
\" (Double quote)
\unnnn (Unicode character)
\u{nnnnnn} (Unicode code point)


Input: String
Output: String
CLI: rxchef run "Unescape string"
Arguments: none

Unicode Text Format¶
Adds Unicode combining characters to change formatting of plaintext.

Input: Bytes
Output: Bytes
CLI: rxchef run "Unicode Text Format"




#
Argument
Default
Description




1
Underline
false
Underline


2
Strikethrough
false
Strikethrough



Unique¶
Removes duplicate strings from the input.

Input: String
Output: String
CLI: rxchef run "Unique"




#
Argument
Default
Description




1
Delimiter
Line feed
Line feed, CRLF, Space, Comma, etc.


2
Display count
false
Prefix each unique item with its occurrence count



VarInt Decode¶
Decodes a VarInt encoded integer. VarInt is an efficient way of encoding variable length integers and is commonly used with Protobuf.

Input: Bytes
Output: String
CLI: rxchef run "VarInt Decode"
Arguments: none

VarInt Encode¶
Encodes a Vn integer as a VarInt. VarInt is an efficient way of encoding variable length integers and is commonly used with Protobuf.

Input: String
Output: Bytes
CLI: rxchef run "VarInt Encode"
Arguments: none

Windows Filetime to UNIX Timestamp¶
Converts a Windows Filetime value to a UNIX timestamp.

A Windows Filetime is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 UTC.

A UNIX timestamp is a 32-bit value representing the number of seconds since January 1, 1970 UTC (the UNIX epoch).

This operation also supports UNIX timestamps in milliseconds, microseconds and nanoseconds.

Input: String
Output: String
CLI: rxchef run "Windows Filetime to UNIX Timestamp"




#
Argument
Default
Description




1
Output units
Seconds (s)
Units for the output timestamp


2
Input format
Decimal
Format of the input filetime



Wrap¶
Wraps the input text at a specified number of characters per line.

Input: String
Output: String
CLI: rxchef run "Wrap"




#
Argument
Default
Description




1
Line Width
64
Number of characters per line



XKCD Random Number¶
RFC 1149.5 specifies 4 as the standard IEEE-vetted random number.

Input: String
Output: Number
CLI: rxchef run "XKCD Random Number"
Arguments: none

XOR¶
XOR the input with the given key.

Input: Bytes
Output: Bytes
CLI: rxchef run "XOR"




#
Argument
Default
Description




1
Key
<empty>
Key to XOR with input


2
Scheme
Standard
Scheme (Standard, Input differential, Output differential, Cascade)


3
Null preserving
false
If true, preserve null bytes



XOR Brute Force¶
Enumerate all possible XOR solutions. Optionally enter a string that you expect to find in the plaintext to filter results (crib).

Input: Bytes
Output: String
CLI: rxchef run "XOR Brute Force"




#
Argument
Default
Description




1
Key length
1
Length of the XOR key in bytes (1..=2 recommended)


2
Sample length
100
Number of bytes of input to process


3
Sample offset
0
Byte offset to start sampling from


4
Scheme
Standard
Standard, Input differential, or Output differential


5
Null preserving
false
Do not XOR null bytes or bytes equal to the key


6
Print key
true
Prefix each result with the key used


7
Output as hex
false
Output results as hex instead of text


8
Crib (known plaintext string)
<empty>
Filter results to those containing this string



YAML to JSON¶
Convert YAML to JSON

Input: String
Output: JSON
CLI: rxchef run "YAML to JSON"
Arguments: none

Diff¶
Diff¶
Compares two inputs (separated by the specified delimiter) and highlights the differences between them.

Input: String
Output: HTML
CLI: rxchef run "Diff"




#
Argument
Default
Description




1
Sample delimiter
\\n\\n
Delimiter separating the two input samples


2
Show added
true
Show added text (wrapped in  tags)


3
Show removed
true
Show removed text (wrapped in  tags)


4
Show subtraction
false
Show unchanged text


5
Ignore whitespace
false
Ignore leading/trailing whitespace when comparing


6
Ignore case
false
Perform case-insensitive comparison



Encodings¶
AMF Decode¶
Action Message Format (AMF) is a binary format used to serialize object graphs such as ActionScript objects and XML, or send messages between an Adobe Flash client and a remote service, usually a Flash Media Server or third party alternatives.

Input: Bytes
Output: JSON
CLI: rxchef run "AMF Decode"




#
Argument
Default
Description




1
Format
AMF3
AMF format (AMF0 or AMF3)



AMF Encode¶
Action Message Format (AMF) is a binary format used to serialize object graphs such as ActionScript objects and XML, or send messages between an Adobe Flash client and a remote service, usually a Flash Media Server or third party alternatives.

Input: JSON
Output: Bytes
CLI: rxchef run "AMF Encode"




#
Argument
Default
Description




1
Format
AMF3
AMF format (AMF0 or AMF3)



Citrix CTX1 Decode¶
Decodes strings in a Citrix CTX1 password format to plaintext.

Input: String
Output: String
CLI: rxchef run "Citrix CTX1 Decode"
Arguments: none

Citrix CTX1 Encode¶
Encodes strings to Citrix CTX1 password format.

Input: String
Output: String
CLI: rxchef run "Citrix CTX1 Encode"
Arguments: none

Decode text¶
Decodes text from the chosen character encoding.

Input: Bytes
Output: String
CLI: rxchef run "Decode text"




#
Argument
Default
Description




1
Encoding
UTF-8 (65001)
The character encoding to decode from.



Encode text¶
Encodes text into the chosen character encoding.

Input: String
Output: Bytes
CLI: rxchef run "Encode text"




#
Argument
Default
Description




1
Encoding
UTF-8 (65001)
The character encoding to encode into.



From HTML Entity¶
Converts HTML entities back to characters.

Input: String
Output: String
CLI: rxchef run "From HTML Entity"
Arguments: none

From Punycode¶
Punycode is a way to represent Unicode with the limited character subset of ASCII supported by the Domain Name System. e.g. 'mnchen-3ya' decodes to 'muenchen'.

Input: String
Output: String
CLI: rxchef run "From Punycode"




#
Argument
Default
Description




1
Internationalised domain name
false
Treat input as a full IDN domain name (xn-- labels)



Normalise Unicode¶
Transform Unicode characters to one of the Normalisation Forms

Input: String
Output: String
CLI: rxchef run "Normalise Unicode"




#
Argument
Default
Description




1
Normal Form
NFD
Unicode Normalisation Form



Rison Decode¶
Rison, a data serialization format optimized for compactness in URIs. Rison is a slight variation of JSON that looks vastly superior after URI encoding. Rison still expresses exactly the same set of data structures as JSON, so data can be translated back and forth without loss or guesswork.

Input: String
Output: JSON
CLI: rxchef run "Rison Decode"




#
Argument
Default
Description




1
Decode Option
Decode
Decode, Decode Object, or Decode Array



Rison Encode¶
Rison, a data serialization format optimized for compactness in URIs. Rison is a slight variation of JSON that looks vastly superior after URI encoding. Rison still expresses exactly the same set of data structures as JSON, so data can be translated back and forth without loss or guesswork.

Input: JSON
Output: String
CLI: rxchef run "Rison Encode"




#
Argument
Default
Description




1
Encode Option
Encode
Encode, Encode Object, Encode Array, or Encode URI



Text Encoding Brute Force¶
Enumerates all supported text encodings for the input, allowing you to quickly spot the correct one.

Input: String
Output: JSON
CLI: rxchef run "Text Encoding Brute Force"




#
Argument
Default
Description




1
Mode
Decode
Mode (Encode or Decode)



To HTML Entity¶
Converts characters to HTML entities

e.g. & becomes &amp;

Input: String
Output: String
CLI: rxchef run "To HTML Entity"




#
Argument
Default
Description




1
Convert all characters
false
Convert all characters to HTML entities


2
Convert to
Named entities
The type of HTML entity to convert to



To Punycode¶
Punycode is a way to represent Unicode with the limited character subset of ASCII supported by the Domain Name System.

Input: String
Output: String
CLI: rxchef run "To Punycode"




#
Argument
Default
Description




1
Internationalised domain name
false
Treat input as a full IDN domain name



Handlebars¶
Template¶
Render a template with Handlebars/Mustache substituting variables using JSON input. Templates will be rendered to plain-text only, to prevent XSS.

Input: JSON
Output: String
CLI: rxchef run "Template"




#
Argument
Default
Description




1
Template definition (.handlebars)
<empty>
The template string



Hashing¶
BLAKE2b¶
Performs BLAKE2b hashing on the input. BLAKE2b is a flavour of the BLAKE cryptographic hash function that is optimized for 64-bit platforms and produces digests of any size between 1 and 64 bytes. Supports the use of an optional key.

Input: Bytes
Output: Bytes
CLI: rxchef run "BLAKE2b"




#
Argument
Default
Description




1
Size
512
Output size in bits (512, 384, 256, 160, 128)


2
Output Encoding
Hex
Output encoding (Hex, Base64, Raw)


3
Key
<empty>
Optional key for keyed hashing



BLAKE2s¶
Performs BLAKE2s hashing on the input. BLAKE2s is a flavour of the BLAKE cryptographic hash function that is optimized for 8- to 32-bit platforms and produces digests of any size between 1 and 32 bytes. Supports the use of an optional key.

Input: Bytes
Output: Bytes
CLI: rxchef run "BLAKE2s"




#
Argument
Default
Description




1
Size
256
Output size in bits (256, 160, 128)


2
Output Encoding
Hex
Output encoding (Hex, Base64, Raw)


3
Key
<empty>
Optional key for keyed hashing



BLAKE3¶
Hashes the input using BLAKE3 (UTF-8 encoded), with an optional key (also UTF-8), and outputs the result in hexadecimal format.

Input: String
Output: String
CLI: rxchef run "BLAKE3"




#
Argument
Default
Description




1
Size (bytes)
32
Output size in bytes


2
Key
<empty>
Optional key for keyed hashing



CRC Checksum¶
A Cyclic Redundancy Check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data. Supports CRC-8, CRC-16, and CRC-32 variants.

Input: Bytes
Output: String
CLI: rxchef run "CRC Checksum"




#
Argument
Default
Description




1
Algorithm
CRC-32
CRC algorithm to use



Convert co-ordinate format¶
Converts geographical coordinates between different formats.

Supported formats:
Degrees Minutes Seconds (DMS)
Degrees Decimal Minutes (DDM)
Decimal Degrees (DD)
Geohash
Military Grid Reference System (MGRS)
Ordnance Survey National Grid (OSNG)
Universal Transverse Mercator (UTM)

The operation can try to detect the input co-ordinate format and delimiter automatically, but this may not always work correctly.

Input: String
Output: String
CLI: rxchef run "Convert co-ordinate format"




#
Argument
Default
Description




1
Input Format
Auto
Format of the input coordinates


2
Input Delimiter
Auto
Delimiter separating the coordinates


3
Output Format
Decimal Degrees
Format to convert to


4
Output Delimiter
Space
Delimiter for the output


5
Include Compass Directions
None
Include N/S/E/W


6
Precision
3
Precision of the result



GOST Hash¶
The GOST hash function, defined in the standards GOST R 34.11-94 and GOST 34.311-95 is a 256-bit cryptographic hash function. It was initially defined in the Russian national standard GOST R 34.11-94 Information Technology  Cryptographic Information Security  Hash Function. The equivalent standard used by other member-states of the CIS is GOST 34.311-95.
This function must not be confused with a different Streebog hash function, which is defined in the new revision of the standard GOST R 34.11-2012.
The GOST hash function is based on the GOST block cipher.

Input: Bytes
Output: String
CLI: rxchef run "GOST Hash"




#
Argument
Default
Description




1
Algorithm
GOST 28147 (1994)
The GOST hash algorithm version to use.


2
Digest length
256
The length of the digest to produce (only for Streebog).


3
sBox
E-TEST
GOST94 parameter set: E-TEST/D-TEST (test) or CryptoPro/D-A



Keccak¶
The Keccak hash algorithm was designed by Guido Bertoni, Joan Daemen, Michael Peeters, and Gilles Van Assche, building upon RadioGatan. It was selected as the winner of the SHA-3 design competition. This version of the algorithm is Keccak[c=2d] and differs from the SHA-3 specification.

Input: Bytes
Output: String
CLI: rxchef run "Keccak"




#
Argument
Default
Description




1
Size
512
Output size in bits: 512, 384, 256, or 224



MD2¶
MD2 (Message-Digest 2) is a cryptographic hash function developed by Ronald Rivest in 1989. The algorithm is optimized for 8-bit computers. Although MD2 is no longer considered secure, it remains in use in public key infrastructures as part of certificates generated with MD2 and RSA.

Input: Bytes
Output: String
CLI: rxchef run "MD2"
Arguments: none

MD4¶
MD4 (Message-Digest 4) is a cryptographic hash function developed by Ronald Rivest in 1990. The digest length is 128 bits. The algorithm has influenced later designs, such as MD5, SHA-1, and RIPEMD algorithms. The security of MD4 has been severely compromised.

Input: Bytes
Output: String
CLI: rxchef run "MD4"
Arguments: none

MD5¶
MD5 (Message-Digest 5) is a widely used hash function. It has been used in a variety of security applications and is also commonly used to check the integrity of files. However, MD5 is not collision resistant and it isn't suitable for applications like SSL/TLS certificates or digital signatures that rely on this property.

Input: Bytes
Output: String
CLI: rxchef run "MD5"
Arguments: none

MurmurHash3¶
Generates a MurmurHash v3 for a string input and an optional seed input

Input: String
Output: Number
CLI: rxchef run "MurmurHash3"




#
Argument
Default
Description




1
Seed
0
Positive integer only


2
Convert to Signed
false
Whether to convert the output to a signed 32-bit integer



RIPEMD¶
RIPEMD (RACE Integrity Primitives Evaluation Message Digest) is a family of cryptographic hash functions developed in Leuven, Belgium. RIPEMD was based upon the design principles used in MD4, and is similar in performance to the more popular SHA-1.

Input: Bytes
Output: String
CLI: rxchef run "RIPEMD"




#
Argument
Default
Description




1
Size
320
Output size in bits (320, 256, 160, or 128)



SHA0¶
SHA-0 is the original 160-bit hash function published in 1993 under the name 'SHA'. It was withdrawn shortly after publication due to an undisclosed 'significant flaw' and replaced by the slightly revised version SHA-1.

Input: Bytes
Output: String
CLI: rxchef run "SHA0"




#
Argument
Default
Description




1
Rounds
80
Number of rounds (minimum 16)



SHA1¶
The SHA (Secure Hash Algorithm) hash functions were designed by the NSA. SHA-1 is the most established of the existing SHA hash functions and it is used in a variety of security applications and protocols. However, SHA-1's collision resistance has been weakening as new attacks are discovered or improved. The message digest algorithm consists, by default, of 80 rounds.

Input: Bytes
Output: String
CLI: rxchef run "SHA1"




#
Argument
Default
Description




1
Rounds
80
Number of rounds (minimum 16)



SHA2¶
The SHA-2 (Secure Hash Algorithm 2) hash functions were designed by the NSA. SHA-2 includes significant changes from its predecessor, SHA-1. The SHA-2 family consists of hash functions with digests (hash values) that are 224, 256, 384 or 512 bits: SHA224, SHA256, SHA384, SHA512. The message digest algorithm for SHA256 variants consists, by default, of 64 rounds, and for SHA512 variants, it is, by default, 160.

Input: Bytes
Output: String
CLI: rxchef run "SHA2"




#
Argument
Default
Description




1
Size
256
Output size (224, 256, 384, 512, 512/256, 512/224)


2
Rounds (SHA-256)
64
Number of rounds for 256/224 (minimum 16)


3
Rounds (SHA-512)
160
Number of rounds for 512/384/224/256 (minimum 32)



SHA3¶
SHA-3 (Secure Hash Algorithm 3) is a cryptographic hash function standard released by NIST on August 5, 2015. SHA-3 is internally quite different from the MD5-like structure of SHA-1 and SHA-2, and is a subset of the Keccak family designed by Guido Bertoni, Joan Daemen, Michal Peeters, and Gilles Van Assche.

Input: Bytes
Output: String
CLI: rxchef run "SHA3"




#
Argument
Default
Description




1
Size
512
Output size in bits (512, 384, 256, or 224)



SHAKE¶
SHAKE is an Extendable Output Function (XOF) of the SHA-3 hash algorithm, part of the Keccak family, allowing for variable output length/size.

Input: Bytes
Output: String
CLI: rxchef run "SHAKE"




#
Argument
Default
Description




1
Capacity
256
Capacity (256 or 128)


2
Size
512
Output size in bytes (minimum 1)



SM3¶
SM3 is a cryptographic hash function used in the Chinese National Standard. SM3 is mainly used in digital signatures, message authentication codes, and pseudorandom number generators. The message digest algorithm consists, by default, of 64 rounds and length of 256.

Input: Bytes
Output: String
CLI: rxchef run "SM3"




#
Argument
Default
Description




1
Output format
Hex
Output format: Hex, Base64, or Raw



SNEFRU¶
Computes the standardized 256-bit, 8-round SNEFRU hash. SNEFRU was designed by Ralph Merkle in 1990; the original shorter-round design is retained in the argument schema for recipe compatibility but rejected because it is cryptographically broken.

Input: Bytes
Output: String
CLI: rxchef run "SNEFRU"




#
Argument
Default
Description




1
Size
256
Output size in bits (supported: 256)


2
Rounds
8
Number of rounds (supported: 8)



Streebog¶
Streebog is a cryptographic hash function defined in the Russian national standard GOST R 34.11-2012 Information Technology  Cryptographic Information Security  Hash Function. It was created to replace an obsolete GOST hash function defined in the old standard GOST R 34.11-94, and as an asymmetric reply to SHA-3 competition by the US National Institute of Standards and Technology.

Input: Bytes
Output: String
CLI: rxchef run "Streebog"




#
Argument
Default
Description




1
Digest length
256
The length of the digest to produce.



Whirlpool¶
Whirlpool is a cryptographic hash function designed by Vincent Rijmen (co-creator of AES) and Paulo S. L. M. Barreto, who first described it in 2000. Whirlpool is the latest revision, released in 2003, fixing a flaw in the diffusion matrix.

Input: Bytes
Output: String
CLI: rxchef run "Whirlpool"




#
Argument
Default
Description




1
Variant
Whirlpool
Hash variant (Whirlpool only)


2
Rounds
10
Number of rounds (1-10)



Image¶
Add Text To Image¶
Adds text onto an image.

Text can be horizontally or vertically aligned, or the position can be manually specified.

Input: Bytes
Output: Bytes
CLI: rxchef run "Add Text To Image"




#
Argument
Default
Description




1
Text
<empty>
The text to add.


2
Horizontal align
None
None, Left, Center, Right


3
Vertical align
None
None, Top, Middle, Bottom


4
X position
0
Manual X position


5
Y position
0
Manual Y position


6
Size
32
Font size


7
Red
255
Red component (0-255)


8
Green
255
Green component (0-255)


9
Blue
255
Blue component (0-255)


10
Alpha
255
Alpha component (0-255)



Blur Image¶
Applies a blur effect to the image.

Gaussian blur is much slower than fast blur, but produces better results.

Input: Bytes
Output: Bytes
CLI: rxchef run "Blur Image"




#
Argument
Default
Description




1
Amount
5
The amount of blur to apply.


2
Type
Fast
The type of blur to apply (Fast or Gaussian).



Contain Image¶
Scales an image to the specified width and height, maintaining the aspect ratio. The image may be letterboxed.

Input: Bytes
Output: Bytes
CLI: rxchef run "Contain Image"




#
Argument
Default
Description




1
Width
100
The width of the contained image


2
Height
100
The height of the contained image


3
Horizontal align
Center
The horizontal alignment of the image within the container


4
Vertical align
Middle
The vertical alignment of the image within the container


5
Resizing algorithm
Bilinear
The algorithm to use when resizing the image


6
Opaque background
true
Whether to use an opaque black background instead of transparency



Convert Image Format¶
Converts an image between different formats. Supported formats:
Joint Photographic Experts Group (JPEG)
Portable Network Graphics (PNG)
Bitmap (BMP)
Tagged Image File Format (TIFF)

Note: GIF files are supported for input, but cannot be outputted.

Input: Bytes
Output: Bytes
CLI: rxchef run "Convert Image Format"




#
Argument
Default
Description




1
Output Format
JPEG
The format to convert the image to


2
JPEG Quality
80
The quality of the JPEG output (1-100)


3
PNG Filter Type
Auto
The filter type to use for PNG output


4
PNG Deflate Level
9
The deflate level to use for PNG output (0-9)



Cover Image¶
Scales the image to the given width and height, keeping the aspect ratio. The image may be clipped.

Input: Bytes
Output: Bytes
CLI: rxchef run "Cover Image"




#
Argument
Default
Description




1
Width
100
The width of the covered image


2
Height
100
The height of the covered image


3
Horizontal align
Center
The horizontal alignment of the image within the cover area


4
Vertical align
Middle
The vertical alignment of the image within the cover area


5
Resizing algorithm
Bilinear
The algorithm to use when resizing the image



Crop Image¶
Crops an image to the specified region, or automatically crops edges.

Autocrop
Automatically crops same-colour borders from the image.

Autocrop tolerance
A percentage value for the tolerance of colour difference between pixels.

Only autocrop frames
Only crop real frames (all sides must have the same border)

Symmetric autocrop
Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)

Autocrop keep border
The number of pixels of border to leave around the image.

Input: Bytes
Output: Bytes
CLI: rxchef run "Crop Image"




#
Argument
Default
Description




1
X Position
0
The x-coordinate of the top-left corner of the crop area


2
Y Position
0
The y-coordinate of the top-left corner of the crop area


3
Width
10
The width of the crop area


4
Height
10
The height of the crop area


5
Autocrop
false
Whether to automatically crop borders


6
Autocrop tolerance (%)
2
The tolerance for color difference when autocropping


7
Only autocrop frames
true
Only crop if all sides have the same border


8
Symmetric autocrop
false
Force autocrop to be symmetric


9
Autocrop keep border (px)
0
The number of pixels of border to leave



Dither Image¶
Apply Floyd-Steinberg black-and-white dithering to a PNG, JPEG, GIF, BMP, TIFF, or WebP image. The result is encoded as PNG.

Input: Bytes
Output: Bytes
CLI: rxchef run "Dither Image"
Arguments: none

Extract EXIF¶
Extracts EXIF data from an image.
EXIF data is metadata embedded in images (JPEG, JPG, TIFF) and audio files.
EXIF data from photos usually contains information about the image file itself as well as the device used to create it.

Input: Bytes
Output: String
CLI: rxchef run "Extract EXIF"
Arguments: none

Extract LSB¶
Extracts the Least Significant Bit data from each pixel in an image. This is a common way to hide data in Steganography.

Input: Bytes
Output: Bytes
CLI: rxchef run "Extract LSB"




#
Argument
Default
Description




1
Colour Pattern #1
R
Colour to extract from


2
Colour Pattern #2
<empty>
Colour to extract from


3
Colour Pattern #3
<empty>
Colour to extract from


4
Colour Pattern #4
<empty>
Colour to extract from


5
Pixel Order
Row
Order to process pixels


6
Bit
0
Bit to extract (0-7)



Extract RGBA¶
Extracts each pixel's RGBA value in an image. These are sometimes used in Steganography to hide text or data.

Input: Bytes
Output: String
CLI: rxchef run "Extract RGBA"




#
Argument
Default
Description




1
Delimiter

The delimiter between values.


2
Include Alpha
true
Whether to include the alpha channel.



Flip Image¶
Flips an image along its X or Y axis.

Input: Bytes
Output: Bytes
CLI: rxchef run "Flip Image"




#
Argument
Default
Description




1
Axis
Horizontal
The axis to flip along



Generate Image¶
Generates an image using the input as pixel values.

Input: Bytes
Output: Bytes
CLI: rxchef run "Generate Image"




#
Argument
Default
Description




1
Mode
Greyscale
Pixel representation mode


2
Pixel Scale Factor
8
Scale factor for pixels


3
Pixels per row
64
Width of the image in pixels



Generate QR Code¶
Generates a Quick Response (QR) code from the input text.

Input: String
Output: Bytes
CLI: rxchef run "Generate QR Code"




#
Argument
Default
Description




1
Image Format
PNG
Format of the QR code image


2
Module size (px)
5
Size of each module in pixels


3
Margin (num modules)
4
Margin around the QR code in modules


4
Error correction
Medium
Error correction level



Image Brightness / Contrast¶
Adjust the brightness or contrast of an image.

Input: Bytes
Output: Bytes
CLI: rxchef run "Image Brightness / Contrast"




#
Argument
Default
Description




1
Brightness
0
The amount to adjust the brightness by. (-100 to 100)


2
Contrast
0
The amount to adjust the contrast by. (-100 to 100)



Image Filter¶
Applies a greyscale or sepia filter to an image.

Input: Bytes
Output: Bytes
CLI: rxchef run "Image Filter"




#
Argument
Default
Description




1
Filter type
Greyscale
The filter to apply.



Image Hue/Saturation/Lightness¶
Adjusts the hue / saturation / lightness (HSL) values of an image.

Input: Bytes
Output: Bytes
CLI: rxchef run "Image Hue/Saturation/Lightness"




#
Argument
Default
Description




1
Hue
0
The amount to adjust the hue by (degrees).


2
Saturation
0
The amount to adjust the saturation by (%).


3
Lightness
0
The amount to adjust the lightness by (%).



Image Opacity¶
Adjust the opacity of an image.

Input: Bytes
Output: Bytes
CLI: rxchef run "Image Opacity"




#
Argument
Default
Description




1
Opacity (%)
100
The opacity to set (0-100).



Invert Image¶
Invert the colours of an image.

Input: Bytes
Output: Bytes
CLI: rxchef run "Invert Image"
Arguments: none

Normalise Image¶
Normalise the image colours by stretching the contrast.

Input: Bytes
Output: Bytes
CLI: rxchef run "Normalise Image"
Arguments: none

Parse QR Code¶
Reads an image file and attempts to detect and read a Quick Response (QR) code from the image.

Normalise Image
Attempts to normalise the image before parsing it to improve detection of a QR code.

Input: Bytes
Output: String
CLI: rxchef run "Parse QR Code"




#
Argument
Default
Description




1
Normalise image
false
Attempts to normalise the image before parsing it to improve detection of a QR code.



Randomize Colour Palette¶
Randomizes each colour in an image's colour palette. This can often reveal text or symbols that were previously a very similar colour to their surroundings, a technique sometimes used in Steganography.

Input: Bytes
Output: Bytes
CLI: rxchef run "Randomize Colour Palette"




#
Argument
Default
Description




1
Seed
<empty>
The seed for the randomization.



Remove EXIF¶
Removes EXIF data from a JPEG image.
EXIF data embedded in photos usually contains information about the image file itself as well as the device used to create it.

Input: Bytes
Output: Bytes
CLI: rxchef run "Remove EXIF"
Arguments: none

Render Image¶
Displays the input as an image. Supports the following formats: jpg/jpeg, png, gif, webp, bmp, ico.

Input: Bytes
Output: HTML
CLI: rxchef run "Render Image"




#
Argument
Default
Description




1
Input format
Raw
Raw, Base64, or Hex



Resize Image¶
Resizes an image to the specified width and height values.

Input: Bytes
Output: Bytes
CLI: rxchef run "Resize Image"




#
Argument
Default
Description




1
Width
100
Width of the new image


2
Height
100
Height of the new image


3
Unit type
Pixels
Pixels or Percent


4
Maintain aspect ratio
false
Whether to maintain the aspect ratio


5
Resizing algorithm
Bilinear
The algorithm to use for resizing



Rotate Image¶
Rotates an image by the specified number of degrees.

Input: Bytes
Output: Bytes
CLI: rxchef run "Rotate Image"




#
Argument
Default
Description




1
Rotation amount (degrees)
90
Rotation amount in degrees



Sharpen Image¶
Sharpens an image using the Unsharp Mask algorithm.

Input: Bytes
Output: Bytes
CLI: rxchef run "Sharpen Image"




#
Argument
Default
Description




1
Radius
2
Blur radius for the unsharp mask


2
Amount
1
The amount of sharpening to apply


3
Threshold
10
Luminance difference threshold



Split Colour Channels¶
Splits the given image into its red, green and blue colour channels.

Input: Bytes
Output: Bytes
CLI: rxchef run "Split Colour Channels"
Arguments: none

View Bit Plane¶
Extracts and displays a bit plane of any given image. These show only a single bit from each pixel, and can be used to hide messages in Steganography.

Input: Bytes
Output: Bytes
CLI: rxchef run "View Bit Plane"




#
Argument
Default
Description




1
Colour
Red
The colour channel to view


2
Bit
0
The bit to view



Jq¶
Jq¶
jq is a lightweight and flexible command-line JSON processor.

Input: JSON
Output: String
CLI: rxchef run "Jq"




#
Argument
Default
Description




1
Query
.
The jq query to run


2
Raw
false
If true, the output will be raw strings instead of JSON



Maps¶
Show on map¶
Displays comma-separated coordinates on an OpenStreetMap slippy map. Decimal degrees (DD), degrees/decimal minutes (DDM), and degrees/minutes/seconds (DMS) with N/S/E/W suffixes are converted to decimal degrees. Map tiles require network access in the HTML viewer.

Input: String
Output: HTML
CLI: rxchef run "Show on map"




#
Argument
Default
Description




1
Zoom Level
13
Zoom level of the map (0-20)


2
Input Format
Auto
Format of the input coordinates


3
Input Delimiter
Auto
Delimiter separating the coordinates



Media¶
Extract Audio Metadata¶
Extract common audio metadata across MP3, WAV, FLAC, OGG, etc. Outputs normalized JSON.

Input: Binary
Output: JSON
CLI: rxchef run "Extract Audio Metadata"




#
Argument
Default
Description




1
Filename (optional)
<empty>
Filename


2
Max embedded text bytes
524288
Max text bytes



OCR¶
Optical Character Recognition¶

Optional backend unavailable
This operation is feature-gated and unavailable in the minimal documentation build. See the feature matrix for the required Cargo feature.

Optical character recognition or optical character reader (OCR) is the mechanical or electronic
        conversion of images of typed, handwritten or printed text into machine-encoded text.
    Supported image formats: png, jpg, bmp, pbm.


    Requires Tesseract library. Enable with: --features tesseract



Input: Bytes
Output: String
CLI: rxchef run "Optical Character Recognition"




#
Argument
Default
Description




1
Show confidence
true
Whether to show the confidence level of the OCR


2
OCR Engine Mode
LSTM only
The OCR engine mode to use



PGP¶
Generate PGP Key Pair¶

Optional backend unavailable
This operation is feature-gated and unavailable in the minimal documentation build. See the feature matrix for the required Cargo feature.

Generates a new public/private PGP key pair. Supports RSA (1024/2048/4096) and ECC (256/384/521) key types. Arguments: key type, optional password, optional name, optional email.

Input: String
Output: String
CLI: rxchef run "Generate PGP Key Pair"




#
Argument
Default
Description




1
Key type
RSA-2048
Key type and size: RSA-2048, RSA-4096, ECC-256, ECC-384, ECC-521 (RSA-1024 is rejected as insecure)


2
Password (optional)
<empty>
Passphrase to protect the private key


3
Name (optional)
<empty>
User name for the key identity


4
Email (optional)
<empty>
User email for the key identity



PGP Decrypt¶

Optional backend unavailable
This operation is feature-gated and unavailable in the minimal documentation build. See the feature matrix for the required Cargo feature.

Decrypts a PGP-encrypted message using the recipient's ASCII-armoured private key. Input: ASCII-armoured PGP message. Arguments: private key and optional passphrase.

Input: String
Output: String
CLI: rxchef run "PGP Decrypt"




#
Argument
Default
Description




1
Private key of recipient
<empty>
ASCII-armoured PGP private key


2
Private key passphrase
<empty>
Passphrase for the private key (leave blank if none)



PGP Decrypt and Verify¶

Optional backend unavailable
This operation is feature-gated and unavailable in the minimal documentation build. See the feature matrix for the required Cargo feature.

Decrypts and verifies a PGP signed+encrypted message. Input: ASCII-armoured encrypted PGP message. Arguments: public key of signer, private key of recipient, optional passphrase.

Input: String
Output: String
CLI: rxchef run "PGP Decrypt and Verify"




#
Argument
Default
Description




1
Public key of signer
<empty>
ASCII-armoured PGP public key of the signer


2
Private key of recipient
<empty>
ASCII-armoured PGP private key of the recipient


3
Private key password
<empty>
Passphrase for the private key (leave blank if none)



PGP Encrypt¶

Optional backend unavailable
This operation is feature-gated and unavailable in the minimal documentation build. See the feature matrix for the required Cargo feature.

Encrypts a message using the recipient's ASCII-armoured PGP public key. Input: plaintext message. Arguments: recipient's public key.

Input: String
Output: String
CLI: rxchef run "PGP Encrypt"




#
Argument
Default
Description




1
Public key of recipient
<empty>
ASCII-armoured PGP public key of the recipient



PGP Encrypt and Sign¶

Optional backend unavailable
This operation is feature-gated and unavailable in the minimal documentation build. See the feature matrix for the required Cargo feature.

Encrypts a message to the recipient and signs it with the signer's private key. Input: cleartext to sign. Arguments: private key of signer, optional passphrase, public key of recipient.

Input: String
Output: String
CLI: rxchef run "PGP Encrypt and Sign"




#
Argument
Default
Description




1
Private key of signer
<empty>
ASCII-armoured PGP private key of the signer


2
Private key passphrase
<empty>
Passphrase for the private key (leave blank if none)


3
Public key of recipient
<empty>
ASCII-armoured PGP public key of the recipient



PGP Verify¶

Optional backend unavailable
This operation is feature-gated and unavailable in the minimal documentation build. See the feature matrix for the required Cargo feature.

Verifies a PGP clearsigned or signed+encrypted message using the signer's public key. Input: ASCII-armoured signed PGP message. Arguments: public key of the signer.

Input: String
Output: String
CLI: rxchef run "PGP Verify"




#
Argument
Default
Description




1
Public key of signer
<empty>
ASCII-armoured PGP public key of the signer



Protobuf¶
Protobuf Decode¶
Decodes Protobuf bytes to JSON. With a .proto schema, field names and declared types are used. Without a schema, wire fields are represented by numeric keys.

Input: Bytes
Output: JSON
CLI: rxchef run "Protobuf Decode"




#
Argument
Default
Description




1
Schema (.proto text)
<empty>
Optional .proto schema; the first top-level message is used


2
Show Unknown Fields
false
Show fields not in schema


3
Show Types
false
Show type information



Protobuf Encode¶
Encodes JSON into Protobuf bytes. With a .proto schema, JSON field names and types are resolved from the first top-level message. Without a schema, numeric JSON keys are interpreted as field numbers.

Input: JSON
Output: Bytes
CLI: rxchef run "Protobuf Encode"




#
Argument
Default
Description




1
Schema (.proto text)
<empty>
Optional .proto schema; the first top-level message is used



PublicKey¶
Hex to Object Identifier¶
Converts a hexadecimal string into an object identifier (OID) dotted string.

Input: String
Output: String
CLI: rxchef run "Hex to Object Identifier"
Arguments: none

Hex to PEM¶
Converts a hexadecimal DER (Distinguished Encoding Rules) string into PEM (Privacy Enhanced Mail) format.

Input: String
Output: String
CLI: rxchef run "Hex to PEM"




#
Argument
Default
Description




1
Header string
CERTIFICATE
PEM header/footer label (e.g. CERTIFICATE, RSA PRIVATE KEY)



JWK to PEM¶
Converts Keys in JSON Web Key format to PEM format (PKCS#8).

Input: String
Output: String
CLI: rxchef run "JWK to PEM"
Arguments: none

Object Identifier to Hex¶
Converts an object identifier (OID) into a hexadecimal string representing the DER value octets.

Input: String
Output: String
CLI: rxchef run "Object Identifier to Hex"
Arguments: none

PEM to JWK¶
Converts RSA PUBLIC KEY/PKCS#8 PUBLIC KEY PEM blocks and RSA X.509 certificate public keys to public JSON Web Keys (kty, n, e). Private and elliptic-curve keys are rejected explicitly.

Input: String
Output: String
CLI: rxchef run "PEM to JWK"
Arguments: none

Parse ASN.1 hex string¶
Abstract Syntax Notation One (ASN.1) is a standard and notation that describes rules and structures for representing, encoding, transmitting, and decoding data in telecommunications and computer networking.

This operation parses arbitrary ASN.1 data (encoded as an hex string: use the 'To Hex' operation if necessary) and presents the resulting tree.

Input: String
Output: String
CLI: rxchef run "Parse ASN.1 hex string"




#
Argument
Default
Description




1
Starting index
0
Starting index in the byte array


2
Truncate octet strings longer than
32
Truncate octet strings longer than this value



Parse CSR¶
Parse Certificate Signing Request (CSR) for an X.509 certificate

Input: String
Output: String
CLI: rxchef run "Parse CSR"




#
Argument
Default
Description




1
Input format
PEM
Input format



Parse X.509 CRL¶
Parse Certificate Revocation List (CRL)

Input: String
Output: String
CLI: rxchef run "Parse X.509 CRL"




#
Argument
Default
Description




1
Input format
PEM
Input format of the CRL



Parse X.509 certificate¶
X.509 is an ITU-T standard for a public key infrastructure (PKI) and Privilege Management Infrastructure (PMI). It is commonly involved with SSL/TLS security.

This operation displays the contents of a certificate in a human readable format, similar to the openssl command line tool.

Tags: X509, server hello, handshake

Input: String
Output: String
CLI: rxchef run "Parse X.509 certificate"




#
Argument
Default
Description




1
Input format
PEM
Input format of the certificate



Public Key from Certificate¶
Extracts the Public Key from a Certificate.

Input: String
Output: String
CLI: rxchef run "Public Key from Certificate"
Arguments: none

Public Key from Private Key¶
Extracts the Public Key from a Private Key.

Input: String
Output: String
CLI: rxchef run "Public Key from Private Key"
Arguments: none

Regex¶
Extract IP addresses¶
Extracts all IPv4 and IPv6 addresses.
Warning: Given a string 1.2.3.4.5.6.7.8, this will match 1.2.3.4 and 5.6.7.8 so always check the original input!

Input: String
Output: String
CLI: rxchef run "Extract IP addresses"




#
Argument
Default
Description




1
IPv4
true
Include IPv4 addresses


2
IPv6
false
Include IPv6 addresses


3
Remove local IPv4 addresses
false
Exclude local/private IPv4 addresses


4
Display total
false
Display the total number of addresses found


5
Sort
false
Sort the results


6
Unique
false
Remove duplicate results



Extract MAC addresses¶
Extracts all Media Access Control (MAC) addresses from the input.

Input: String
Output: String
CLI: rxchef run "Extract MAC addresses"




#
Argument
Default
Description




1
Display total
false
Display total found


2
Sort
false
Sort results


3
Unique
false
Remove duplicate results



Extract URLs¶
Extracts Uniform Resource Locators (URLs) from the input. The protocol (http, ftp etc.) is required otherwise there will be far too many false positives.

Input: String
Output: String
CLI: rxchef run "Extract URLs"




#
Argument
Default
Description




1
Display total
false
Display total found


2
Sort
false
Sort results


3
Unique
false
Remove duplicate results



Extract dates¶
Extracts dates in the following formats
yyyy-mm-dd
dd/mm/yyyy
mm/dd/yyyy
Dividers can be any of /, -, . or space

Input: String
Output: String
CLI: rxchef run "Extract dates"




#
Argument
Default
Description




1
Display total
false
Display total found



Extract domains¶
Extracts fully qualified domain names.
Note that this will not include paths. Use Extract URLs to find entire URLs.

Input: String
Output: String
CLI: rxchef run "Extract domains"




#
Argument
Default
Description




1
Display total
false
Display total found


2
Sort
false
Sort results


3
Unique
false
Remove duplicate results


4
Underscore (DMARC, DKIM, etc)
false
Allow underscores in domain labels



Extract email addresses¶
Extracts all email addresses from the input.

Input: String
Output: String
CLI: rxchef run "Extract email addresses"




#
Argument
Default
Description




1
Display total
false
Display total found


2
Sort
false
Sort results


3
Unique
false
Remove duplicate results



Extract file paths¶
Extracts anything that looks like a Windows or UNIX file path.
Note that if UNIX is selected, there will likely be a lot of false positives.

Input: String
Output: String
CLI: rxchef run "Extract file paths"




#
Argument
Default
Description




1
Windows
true
Include Windows file paths


2
UNIX
true
Include UNIX file paths


3
Display total
false
Display the total number of paths found


4
Sort
false
Sort the results


5
Unique
false
Remove duplicate results



Extract hashes¶
Extracts potential hashes based on hash character length

Input: String
Output: String
CLI: rxchef run "Extract hashes"




#
Argument
Default
Description




1
Hash character length
40
The length of the hash in characters


2
All hashes
false
Extract all common hash lengths


3
Display Total
false
Display the total number of hashes found



Filter¶
Splits up the input using the specified delimiter and then filters each branch based on a regular expression.

Input: String
Output: String
CLI: rxchef run "Filter"




#
Argument
Default
Description




1
Delimiter
Line feed
Character(s) to split the input on (Line feed, CRLF, Space, Comma, Semi-colon)


2
Regex
<empty>
Regular expression to filter lines


3
Invert condition
false
Return lines that do NOT match the regex



Find / Replace¶
Replaces all occurrences of the first string with the second. Supports regex, simple string, and extended string modes.

Input: String
Output: String
CLI: rxchef run "Find / Replace"




#
Argument
Default
Description




1
Find
<empty>
The string or regex to find


2
Find type
Simple string
Regex, Extended (\n, \t, \x...), or Simple string


3
Replace
<empty>
The replacement string


4
Global match
true
Replace all occurrences


5
Case insensitive
false
Ignore case when matching


6
Multiline matching
true
^ and $ match start/end of lines


7
Dot matches all
false
Dot also matches newline



Register¶
Extract data from the input into recipe registers using regular expression capture groups. Refer to captures in later operation arguments as $R0, $R1, and so on. Register expansion is implemented by integration::bake and all CLI recipe frontends.

Input: String
Output: String
CLI: rxchef run "Register"




#
Argument
Default
Description




1
Extractor
([\\s\\S]*)
Regular expression capture groups


2
Case insensitive
true
Case insensitive matching


3
Multiline matching
false
Multiline matching


4
Dot matches all
false
Dot matches all



Regular expression¶
Define your own regular expression (regex) to search the input data with, optionally choosing from a list of pre-defined patterns.

Input: String
Output: HTML
CLI: rxchef run "Regular expression"




#
Argument
Default
Description




1
Built in regexes
User defined
Built in regexes


2
Regex
<empty>
Regular expression


3
Case insensitive
true
Case insensitive


4
^ and $ match at newlines
true
^ and $ match at newlines


5
Dot matches all
false
Dot matches all


6
Unicode support
false
Unicode support


7
Astral support
false
Astral support


8
Display total
false
Display total


9
Output format
Highlight matches
Output format



Strings¶
Extracts all strings from the input.

Input: Bytes
Output: String
CLI: rxchef run "Strings"




#
Argument
Default
Description




1
Encoding
Single byte
Single byte, 16-bit littleendian, 16-bit bigendian, All


2
Minimum length
4
Minimum string length


3
Match
All printable chars (A)
Alphanumeric + punctuation (A), All printable chars (A), Null-terminated strings (A), Alphanumeric + punctuation (U), All printable chars (U), Null-terminated strings (U)


4
Display total
false
Display total count of found strings


5
Sort
false
Sort results case-insensitively


6
Unique
false
Remove duplicate results



Serialise¶
Avro to JSON¶
Converts Avro encoded data into JSON.

Input: Bytes
Output: String
CLI: rxchef run "Avro to JSON"




#
Argument
Default
Description




1
Force Valid JSON
true
Wrap multiple records in an array to ensure valid JSON output



BSON deserialise¶
BSON is a computer data interchange format used mainly as a data storage and network transfer format in the MongoDB database. It is a binary form for representing simple data structures, associative arrays (called objects or documents in MongoDB), and various data types of specific interest to MongoDB. The name 'BSON' is based on the term JSON and stands for 'Binary JSON'. Input data should be in a raw bytes format.

Input: Bytes
Output: JSON
CLI: rxchef run "BSON deserialise"
Arguments: none

BSON serialise¶
BSON is a computer data interchange format used mainly as a data storage and network transfer format in the MongoDB database. It is a binary form for representing simple data structures, associative arrays (called objects or documents in MongoDB), and various data types of specific interest to MongoDB. The name 'BSON' is based on the term JSON and stands for 'Binary JSON'. Input data should be valid JSON.

Input: JSON
Output: Bytes
CLI: rxchef run "BSON serialise"
Arguments: none

CBOR Decode¶
Concise Binary Object Representation (CBOR) is a binary data serialization format loosely based on JSON. Like JSON it allows the transmission of data objects that contain namevalue pairs, but in a more concise manner. This increases processing and transfer speeds at the cost of human readability. It is defined in IETF RFC 8949.

Input: Bytes
Output: JSON
CLI: rxchef run "CBOR Decode"
Arguments: none

CBOR Encode¶
Concise Binary Object Representation (CBOR) is a binary data serialization format loosely based on JSON. Like JSON it allows the transmission of data objects that contain namevalue pairs, but in a more concise manner. This increases processing and transfer speeds at the cost of human readability. It is defined in IETF RFC 8949.

Input: JSON
Output: Bytes
CLI: rxchef run "CBOR Encode"
Arguments: none

Parse ObjectID timestamp¶
Parse timestamp from MongoDB/BSON ObjectID hex string. The first 4 bytes of the ObjectID encode a Unix timestamp.

Input: String
Output: String
CLI: rxchef run "Parse ObjectID timestamp"
Arguments: none

Shellcode¶
Disassemble ARM¶

Optional backend unavailable
This operation is feature-gated and unavailable in the minimal documentation build. See the feature matrix for the required Cargo feature.

Disassembles ARM machine code into assembly language.

Supports ARM (32-bit), Thumb, and ARM64 (AArch64) architectures using the Capstone disassembly framework.

Input should be in hexadecimal.

Input: String
Output: String
CLI: rxchef run "Disassemble ARM"




#
Argument
Default
Description




1
Architecture
ARM (32-bit)
The ARM architecture to use.


2
Mode
ARM
The instruction set mode.


3
Endianness
Little Endian
The byte order.


4
Starting address (hex)
0
The address to start disassembling from.


5
Show instruction hex
true
Whether to show the hex bytes of each instruction.


6
Show instruction position
true
Whether to show the address of each instruction.



Disassemble x86¶

Optional backend unavailable
This operation is feature-gated and unavailable in the minimal documentation build. See the feature matrix for the required Cargo feature.

Disassembly is the process of translating machine language into assembly language.

This operation supports 64-bit, 32-bit and 16-bit code written for Intel or AMD x86 processors. It is particularly useful for reverse engineering shellcode.

Input should be in hexadecimal.

Input: String
Output: String
CLI: rxchef run "Disassemble x86"




#
Argument
Default
Description




1
Bit mode
64
The bit mode (64, 32, 16)


2
Compatibility
Full x86 architecture
The compatibility mode (not all supported by Capstone)


3
Code Segment (CS)
0
The code segment (not used by Capstone)


4
Offset (IP)
0
The instruction pointer offset


5
Show instruction hex
true
Whether to show instruction hex


6
Show instruction position
true
Whether to show instruction position



URL¶
Parse URI¶
Pretty prints complicated Uniform Resource Identifier (URI) strings for ease of reading. Particularly useful for Uniform Resource Locators (URLs) with a lot of arguments.

Input: String
Output: String
CLI: rxchef run "Parse URI"
Arguments: none

URL Decode¶
Converts URI/URL percent-encoded characters back to their raw values. e.g. %3d becomes =

Input: String
Output: String
CLI: rxchef run "URL Decode"




#
Argument
Default
Description




1
Treat '+' as space
true
Convert '+' characters to spaces in addition to %20



URL Encode¶
Encodes problematic characters into percent-encoding, a format supported by URIs/URLs.

e.g. = becomes %3d

Input: String
Output: String
CLI: rxchef run "URL Encode"




#
Argument
Default
Description




1
Encode all special chars
false
Encode all characters including those usually allowed in URLs



UserAgent¶
Parse User Agent¶
Attempts to identify and categorise information contained in a user-agent string.

Input: String
Output: String
CLI: rxchef run "Parse User Agent"
Arguments: none

Yara¶
YARA Rules¶

Optional backend unavailable
This operation is feature-gated and unavailable in the minimal documentation build. See the feature matrix for the required Cargo feature.

YARA is a tool developed at VirusTotal, primarily aimed at helping malware researchers to identify and classify malware samples. It matches based on rules specified by the user containing textual or binary patterns and a boolean expression. For help on writing rules, see the YARA documentation.

Input: Bytes
Output: String
CLI: rxchef run "YARA Rules"




#
Argument
Default
Description




1
Rules
<empty>
YARA rules to match against the input


2
Show strings
false
Display the strings that matched


3
Show string lengths
false
Display the lengths of the strings that matched


4
Show metadata
false
Display the metadata for each rule


5
Show counts
true
Display the number of times each rule matched


6
Show rule warnings
true
Display any warnings generated during rule compilation


7
Show console module messages
true
Display any messages from the console module