How to use Chepy


Chepy shares the same concept of stacking as Cyberchef. This means different methods can be chained together or stack together like Cyberchef. This concept applies to both the CLI and the python library. Chepy does offer some extras which are not part of the overall Chepy library, but offers handy functionalities. These functionalities are often data generators which cannot really be chained with other methods.

Just like Cyberchef, Chepy is only capable of working with the data that it is provided. What this means is that we cannot give Chepy a bytearray and then try to convert that to upper case. It will throw an error.

Library vs CLI

It is important to keep in mind that Chevy was developed first to be a Python library, and then the CLI was added. There are some functions that are different between the two. It employees a very unique and dynamic CLI implementation. The CLI is self generating and offers autocompletion and built in help. The CLI itself instantiates the Chepy class as a user would when they are using it like a library.

Lets take a look at a quick example. Lets get the HMAC hash of a string. The hmac_hash method in Chepy takes one required argument key. In python code, we would do:

>>> from chepy import Chepy
>>> print(Chepy("A string").hmac_hash(key="secret").o)

In the CLI, we would execute the same thing as: hmac_hash

Notice how both the implementation are very similar. At anytime in the cli, we can type -- to see if the preceding option takes any required or optional arguments.

See more [examples here(‘./


Throughout the documentation, and while using the libraries and cli, you will come across certain words. This section will describe what those words mean as they are important.

  • state Every time a method is called on Chepy, the data has to be stored somewhere for the following methods to be able to access it and use it. This is why almost all methods in Chepy return self. state is the attribute where this data is stored. When developing a plugin for Chepy, all methods should save the final to state before returning self.

  • states Because Chepy library and cli both works with multiple inputs, the main Chepy class is instantiated with *args. Each arg is its own state. You can think of states as tabs in Cyberchef or a browser. Each one is independent of each other.

  • buffers Because the state attribute is always overwritten, we can save the current state in buffers. This is similar to vi buffers. We can always load data from a buffer into the current state.

Input methods

The Chepy class in the library, and nargs in the cli both take *args. This means anything that is used to instantiate the main Chepy class are considered strings. A file path, a url, all are treated as strings.


from chepy import Chepy

c = Chepy("some string", "")

In this example, both some string and are treated as strings. In this case, Chepy has created two states. State index 0 holds some string, and state index 1 holds There are some helpful methods that we can use to manipulate our data.

read_file / load_file

Either of these methods can be used to load a file info chepy. These methods load the content of a file (works with binary files also) and saves them to the buffer.

c = Chepy("/path/to/some/file.txt").read_file()


Chepy will read the entire file to memory, so working with very large files will really slow things down.


The load_dir method is used to load the entire contents of a directory into Chepy. This method optionally takes a pattern argument to specify which files to load. A state is created for each file that matches the pattern in the directory. To load recursively, the pattern **/* can be used.

c = Chepy("/path/to/dir").load_dir("*.txt")

Now we can combine read_file and change_state independently to load whichever file we want into Chepy.


The last way to load data into Chepy is by making an http request. This is a binder to the requests library, and supports most http request methods, with the option to set headers, cookies, body payload etc. A dictionary of the responses body, headers and cookies are saved in the state by default.

c = Chepy("").http_request().get_by_key("body")


The main class for for Chepy is Chepy.

from chepy import Chepy

The Chepy class offers all the chainable / stackable methods in one class. Refer to the docs and examples for more use cases.

Individual modules can also be imported from Chepy. They provided slightly limited functionality, but are tied together. For example, if we only want to use the image processing methods from Chepy, we can do

from chepy.modules.multimedia import Multimedia

The library does provide some extra functionality also which are not accessed by the Chepy class. These extras are documented.


The Chepy cli is accessed by the chepy command which is set to path during the setup process. The cli has all the methods available in the Chepy class, but has some cli specific methods also. The cli autocompletion is color coded to indicate their functionality. Some methods take either required or optional arguments in the cli. These are also auto populated, and this can be seen by using --.

  • default Default methods does not have any background color

  • green Green methods are only available as part of the cli. These methods always start with cli_. These methods also do not change the state.

  • yellow These methods will return the current value of the cli, and can no longer be chained.

cli colors

Output methods

Because most methods in Chepy returns self, if you run type on an output, you will see it is a Chepy object. To get the value out of the state, we can use a few many methods and attributes.

  • o This is an attribute

  • output This is the same as o

>>> Chepy("A").to_hex().o
>>> Chepy("A").to_hex().out
  • out This is a method that will get the current value from state. Same as o and output.

>>> Chepy("A").to_hex().out
  • copy This method will copy the current value of state into the clipboard. For linux, it will require either xsel or xclip

>>> Chepy("A").to_hex().copy()
  • web Open the current Chepy state in Cyberchef itself. This will launch the default browser and put the current state in it.

>>> Chepy("A").to_hex().web()
  • write The write and the write_to_file methods will write the state data to a file. These two methods take an optional argument as_binary which can be set to True to write as a binary file. A complimentary method write_binary is also available which will write directly as binary.

States and Buffers


Think of states as tabs in your browser. Best way to understand states is by following this simple example code.

>>> c = Chepy("AA", "BB")

Currently we have two states, one containing AA and the other containing BB. By default, the 0 index state is loaded which contains AA

>>> c.to_hex()

We call the to_hex method on the current state. Now state index 0 is 4141.


Now we are switching to the state and index 1 which contains BB



Buffers are very similar to states with some key differences.

  • States change every time a method is called, but a buffer never changes.

  • States are automatically created, but buffers are not.

  • Data can be saved in a buffer, and loaded into a state from a buffer.

Lets see an example:

c = Chepy("A").save_buffer()

Now the state contains an A and the buffer contains an A


Now the state contains 41 while the buffer still contains A


Chepy has the concept of recipes which means it can load an run chepy methods from a JSON file. This makes sharing Chepy recipes very easy and prevents code reuse.

Some caveats to recipes are that they do not include some of the methods from ChepyCore. For instance, a recipe cannot write to file, or load or read recipes. Chepy plugins does support recipes also.

Recipes do not support the following operations:

  • fork

If these operations are present on the instance, the recipe will not work.

There are two main methods that handle recipes and they are both part of the Core.


This method is used to save a recipe. This method is also chainable with other methods.


from chepy import Chepy

c = (

This code will create the follow JSON recipe:



This method will load a recipe file, and then run the recipe on it. So based of the previous example, instead of running the whole code, we can simply use:

from chepy import Chepy