ChepyCore class¶
The ChepyCore
class for Chepy is primarily used as an interface for all the current modules/classes in Chepy, or for plugin development. The ChepyCore
class is what provides the various attributes like states, buffers, etc and is required to use and extend Chepy.
The most important ChepyCore
attributes and methods are:
state The state is where all objects are always stored when modified by any methods.
_convert_to_* methods These are helper methods that ensures data is being accessed and put in the state in the correct manner. For example,
binasii.unhexlify
requires a bytes like object. We can use
self.state = binasii.unhexlify(self._convert_to_bytes())
This will ensure that the correct data type is being used at all times.
- class chepy.core.ChepyCore(*data)¶
The ChepyCore class for Chepy is primarily used as an interface for all the current modules/classes in Chepy, or for plugin development. The ChepyCore class is what provides the various attributes like states, buffers, etc and is required to use and extend Chepy.
- Parameters
*data (tuple) – The core class takes arbitrary number of arguments as *args.
- states¶
Contains all the current states. Each arg passed to the ChepyCore class will be considered a state.
- Type
dict
- buffers¶
Contains all the current buffers if a buffer is saved.
- Type
dict
- state¶
The data in the current state. The state changes each time a Chepy method is called.
- Type
Any
- Returns
The Chepy object.
- Return type
- _abs_path(path: str)¶
Returns the absolute path by expanding home dir
- Parameters
path (str) – Path to expand
- Returns
Path object
- Return type
object
- _bytes_to_str(s: bytes) str ¶
Converts a bytes to str
- Parameters
s (str) – String
- Returns
String
- Return type
str
- _convert_to_bytearray() bytearray ¶
Attempts to coerce the current state into a bytesarray object
- _convert_to_bytes() bytes ¶
This method is used to coerce the current object in the state variable into a bytes. The method should be called inside any method that operates on a string object instead of calling self.state directly to avoid errors.
- Raises
NotImplementedError – If type coercian isn’t available for the current state type.
- _convert_to_int() int ¶
This method is used to coerce the current object in the state variable into an int. The method should be called inside any method that operates on a int types instead of calling self.state directly to avoid errors.
- Raises
NotImplementedError – If type coercian isn’t available for the current state type.
- _convert_to_str() str ¶
This method is used to coerce the current object in the state variable into bytes. The method should be called inside any method that operates on a bytes object instead of calling self.state directly to avoid errors.
- Raises
NotImplementedError – If type coercian isn’t available for the current state type.
- _error_logger(data: str) None ¶
Just a binding for logger.error
- Parameters
data (str) – Message to log
- Returns
The Chepy object.
- Return type
- _get_nested_value(data, key, split_by='.')¶
Get a dict value based on a string key with dot notation. Supports array indexing. If split_by is None or “”, returns only the first key :param data: Data :type data: dict :param key: Dict key in a dot notation and array :type key: str :param split_by: Chars to split key by. Defaults to “.”. :type split_by: str, optional
- _info_logger(data: str) None ¶
Just a binding for logger.info
- Parameters
data (str) – Message to log
- Returns
The Chepy object.
- Return type
- _load_as_file() object ¶
This method is used when a function or a method expects a file path to load a file. Instead of passing a file path, this method allows passing an io.BytesIO object instead.
- Returns
io.BytesIO object
- Return type
object
- _pickle_class(obj: Any) Any ¶
This method takes another object as an argument and pickels that into a json object using jsonpickel. The return value is a dictionary
- Parameters
obj (Any) – Any object
- Returns
unpickeled JSON as a python object.
- Return type
Any
- _str_to_bytes(s: str) bytes ¶
Converts a str to bytes
- Parameters
s (str) – String
- Returns
Bytes
- Return type
bytes
- _to_bytes(data: Any) bytes ¶
This method is used to coerce data to bytes. The method should be called inside any method that operates on a string object instead of calling self.state directly to avoid errors.
- Raises
NotImplementedError – If type coercian isn’t available for the current state type.
- _warning_logger(data: str) None ¶
Just a binding for logger.warning
- Parameters
data (str) – Message to log
- Returns
The Chepy object.
- Return type
- callback(callback_function: Callable[[Any], Any])¶
Run any user defined python function against the state. This method is not recorded in the recipes
- Parameters
callback_function (Callable[[Any], Any]) – The function to run. The function should take one argument (the state is passed to it). It can return Any
Examples
from chepy import Chepy
- def cb(data):
return data * 2
c = Chepy(‘abc’).callback(cb) # state is now abcabc
- Returns
The Chepy object.
- Return type
- change_state(index: int)¶
Change current state by index
Same behaviour as switch_state
- Parameters
index (int) – Index of new state
- Raises
TypeError – If specified index does not exist
- Returns
The Chepy object.
- Return type
- copy() None ¶
Copy to clipboard
Copy the final output to the clipboard. If an error is raised, refer to the documentation on the error.
- Returns
Copies final output to the clipboard
- Return type
None
- copy_state(index: int = None)¶
Copy the current state to a new state
- Parameters
index (int) – Index of new state. Defaults to next available.
- Returns
The Chepy object.
- Return type
- copy_to_clipboard() None ¶
Copy to clipboard
Copy the final output to the clipboard. If an error is raised, refer to the documentation on the error.
- Returns
Copies final output to the clipboard
- Return type
None
- debug(verbose: bool = False)¶
Debug the current instance of Chepy
This method does not change the state.
- Parameters
verbose (bool, optional) – Show verbose info. Defaults to False.
- Returns
The Chepy object.
- Return type
- delete_buffer(index: int)¶
Delete a buffer item
- Parameters
index (int) – Key of buffer item
- Returns
The Chepy object.
- Return type
- delete_state(index: int)¶
Delete a state specified by the index
- Parameters
index (int) – Index of state
- Returns
The Chepy object.
- Return type
- for_each(methods: List[Tuple[Union[str, object], dict]], merge: Optional[Union[str, bytes]] = None)¶
Run multiple methods on current state if it is a list
Method names in a list of tuples. If using in the cli, this should not contain any spaces.
- Parameters
methods (List[Tuple[Union[str, object], dict]]) – Required. List of tuples
merge (Union[str, bytes, None]) – Merge data with. Defaults to None
- Returns
The Chepy object.
- Return type
Examples
This method takes an array of method names and their args as an list of tuples; the first value of the tuple is the method name as either a string, or as an object, and the second value is a ditionary of arguments. The keys of in the dictionary are method argument names, while the values are argument values.
>>> from chepy import Chepy >>> c = Chepy(['41', '42']) >>> c.for_each([("from_hex",), ("to_hex",)]) >>> # this is how to use fork methods with a string >>> c.for_each([(c.from_hex,), (c.to_hex,)]) >>> # This is how to use fork using methods >>> print(c) ['41', '42']
- fork(methods: List[Tuple[Union[str, object], dict]])¶
Run multiple methods on all available states
Method names in a list of tuples. If using in the cli, this should not contain any spaces.
- Parameters
methods (List[Tuple[Union[str, object], dict]]) – Required. List of tuples
- Returns
The Chepy object.
- Return type
Examples
This method takes an array of method names and their args as an list of tuples; the first value of the tuple is the method name as either a string, or as an object, and the second value is a ditionary of arguments. The keys of in the dictionary are method argument names, while the values are argument values.
>>> from chepy import Chepy >>> c = Chepy("some", "data") >>> c.fork([("to_hex",), ("hmac_hash", {"secret_key": "key"})]) >>> # this is how to use fork methods with a string >>> c.fork([(c.to_hex,), (c.hmac_hash, {"secret_key": "key"})]) >>> # This is how to use fork using methods >>> print(c.states) {0: 'e46dfcf050c0a0d135b73856ab8e3298f9cc4105', 1: '1863d1542629590e3838543cbe3bf6a4f7c706ff'}
- get_by_index(*indexes: int)¶
Get an item by specifying an index. If only one index is specified, the obj is return else a new list is returned
- Parameters
*indexes (int) – Index numbers to get.
- Returns
The Chepy object.
- Return type
- get_by_key(*keys: str, py_style: bool = False, split_key: str = '.')¶
This method support json keys support.
- Parameters
keys (Tuple[Union[Hashable, None]]) – Keys to extract.
split_key (str, optional) – Split nested keys. Defaults to “.”
nested (bool, optional) – If the specified keys are nested. Supports array indexing. Defaults to True
- Returns
The Chepy object.
- Return type
Examples
>>> Chepy({"a":{"b": "c"}}).get_by_key('a.b') >>> 'c'
- get_register(key: str) Union[str, bytes] ¶
Get a value from registers by key
- Parameters
key (str) – Key
- Raises
ValueError – If key does not exist
- Returns
Value of register
- Return type
Union[str, bytes]
- get_state(index: int) Any ¶
Returns the value of the specified state.
This method does not chain with other methods of Chepy
- Parameters
index (int) – The index of the state
- Returns
Any value that is in the specified state
- Return type
Any
- http_request(method: str = 'GET', params: dict = {}, json: dict = None, headers: dict = {}, cookies: dict = {})¶
Make a http/s request
Make a HTTP/S request and work with the data in Chepy. Most common http methods are supported; but some methods may not provide a response body.
- Parameters
method (str, optional) – Request method. Defaults to ‘GET’.
params (dict, optional) – Query Args. Defaults to {}.
json (dict, optional) – Request payload. Defaults to None.
headers (dict, optional) – Headers for request. Defaults to {}.
cookies (dict, optional) – Cookies for request. Defaults to {}.
- Raises
NotImplementedError – If state is not a string or dictionary
requests.RequestException – If response status code is not 200
- Returns
A dictionary containing body, status and headers. The Chepy object.
- Return type
Examples
By default, this methed with make a GET request, But supports most common methods.
>>> c = Chepy("http://example.com").http_request() >>> c.get_by_key("headers")
This method can also be used to make more complex requests by specifying headers, cookies, body data etc.
>>> c = Chepy("https://en4qpftrmznwq.x.pipedream.net") >>> c.http_request( >>> method="POST", >>> headers={"My-header": "some header"}, >>> json={"some": "data"} >>> ) >>> print(c.get_by_key("body")) {"success": true}
- load_buffer(index: int)¶
Load the specified buffer into state
- Parameters
index (int) – Index key of an existing buffer
- Returns
The Chepy object.
- Return type
Examples
>>> c = Chepy("A").save_buffer() >>> # this saves the current value of state to a new buffer >>> c.to_hex() >>> # operate on a state, in this case, convert to hex. >>> c.state "41" >>> c.buffers {0: "A"} >>> c.load_buffer(0) >>> # loads the content of the buffer back into the current state. >>> c.state "A"
- load_command()¶
Run the command in state and get the output
- Returns
The Chepy object.
- Return type
Examples
This method can be used to interface with the shell and Chepy directly by ingesting a commands output in Chepy.
>>> c = Chepy("ls -l").shell_output().o test.html ... test.py
- load_dir(pattern: str = '*')¶
Load all file paths in a directory
- Parameters
pattern (str, optional) – File pattern to match. Defaults to “*”.
- Returns
The Chepy object.
- Return type
- load_file(binary_mode: bool = False, encoding: Optional[str] = None)¶
If a path is provided, load the file
- Parameters
binary_mode (bool, optional) – Force load in binary mode.
encoding (Union[str, None], optional) – Encoding for string.
- Returns
The Chepy object.
- Return type
Examples
>>> c = Chepy("/path/to/file") >>> # at the moment, the state only contains the string "/path/to/file" >>> c.load_file() # this will load the file content into the state
- load_from_url(method: str = 'GET', params: dict = {}, json: dict = None, headers: dict = {}, cookies: dict = {})¶
Load binary content from a url
Most common http methods are supported; but some methods may not provide a response body.
- Parameters
method (str, optional) – Request method. Defaults to ‘GET’.
params (dict, optional) – Query Args. Defaults to {}.
json (dict, optional) – Request payload. Defaults to None.
headers (dict, optional) – Headers for request. Defaults to {}.
cookies (dict, optional) – Cookies for request. Defaults to {}.
- Raises
NotImplementedError – If state is not a string or dictionary
requests.RequestException – If response status code is not 200
- Returns
A bytearray of the response content. The Chepy object.
- Return type
Examples
By default, this methed with make a GET request, But supports most common methods.
>>> c = Chepy("http://example.com/file.png").load_from_url() >>> b'\x89PNG...'
- load_recipe(path: str)¶
Load and run a recipe
- Parameters
path (str) – Path to recipe file
- Returns
The Chepy object.
- Return type
Examples
>>> c = Chepy("some data").load_recipe("/path/to/recipe").out NzM2ZjZkNjUyMDY0NjE3NDYx
- loop(iterations: int, callback: str, args: dict = {})¶
Loop and apply callback n times
- Parameters
iterations (int) – Number of iterations to loop
callback (str) – The Chepy method to loop over
args (dict, optional) – Optional arguments for the callback. Defaults to {}.
- Returns
The Chepy object.
- Return type
Examples
>>> c = Chepy("VmpGb2QxTXhXWGxTYmxKV1lrZDRWVmx0ZEV0alZsSllaVWRHYWxWVU1Eaz0=") >>> c.loop(iterations=6, callback='hmac_hash', args={'key': 'secret'}) securisec
- loop_dict(keys: list, callback: str, args: dict = {})¶
Loop over a dictionary and apply the callback to the value
- Parameters
keys (list) – List of keys to match. If in cli, dont use spaces.
callback (str) – Chepy method as string
args (dict, optional) – Dictionary of args. If in cli, dont use spaces. Defaults to {}.
- Returns
The Chepy object.
- Return type
Examples
>>> c = Chepy({'some': 'hahahaha', 'lol': 'aahahah'}) >>> c.loop_dict(['some'], 'hmac_hash', {'key': 'secret'}).o {'some': '99f77ec06a3c69a4a95371a7888245ba57f47f55', 'lol': 'aahahah'}
We can combine loop_list and loop_dict to loop over a list of dictionaries.
>>> data = [{"some": "val"}, {"some": "another"}, {"lol": "lol"}, {"another": "aaaa"}] >>> c = Chepy(data) >>> c.loop_list("loop_dict", {"keys": ["some", "lol"], "callback": "to_upper_case"}) [ {"some": "VAL"}, {"some": "ANOTHER"}, {"lol": "LOL"}, {"another": "aaaa"}, ]
- loop_list(callback: str, args: dict = {})¶
Loop over an array and run a Chepy method on it
- Parameters
callback (str) – Chepy method as string
args (dict, optional) – Dictionary of args. If in cli, dont use spaces. Defaults to {}.
- Returns
The Chepy object
- Return type
Examples
This method is capable of running a callable from either a string, or a chepy method.
>>> c = Chepy(["an", "array"]) >>> c.loop_list('to_hex').loop_list('hmac_hash', {'key': 'secret'}) ['5cbe6ca2a66b380aec1449d4ebb0d40ac5e1b92e', '30d75bf34740e8781cd4ec7b122e3efd8448e270']
- plugins(enable: str) None ¶
Use this method to enable or disable Chepy plugins.
Valid options are true or false. Once this method completes, it does call sys.exit().
- Parameters
enable (str) – Set to true or false
- Returns
None
- prefix(data: bytes)¶
Add a prefix to the data in state. The state is converted to bytes
- Parameters
data (bytes) – Data to add
- Returns
The Chepy object.
- Return type
- pretty(indent: int = 2)¶
Prettify the state.
- Parameters
indent (int, optional) – Indent level. Defaults to 2.
- Returns
The Chepy object.
- Return type
- register(pattern: Union[str, bytes], ignore_case: bool = False, multiline: bool = False, dotall: bool = False, unicode: bool = False, extended: bool = False)¶
Extract data from the input and store it in registers. Regular expression capture groups are used to select the data to extract.
- Parameters
pattern (Union[str, bytes]) – Required. The regex pattern to search by
ignore_case (bool, optional) – Set case insensitive flag. Defaults to False.
multiline (bool, optional) – ^/$ match start/end. Defaults to False.
dotall (bool, optional) – . matches newline. Defaults to False.
unicode (bool, optional) – Match unicode characters. Defaults to False.
extended (bool, optional) – Ignore whitespace. Defaults to False.
- Returns
The Chepy object.
- Return type
Examples
>>> c = Chepy("hello world") >>> c.register("(hello)\s(world)") >>> c._registers {'$R0': 'hello', '$R1': 'world'}
- run_recipe(recipes: List[Mapping[str, Union[str, Mapping[str, Any]]]])¶
Run a recipe on the state. All arguments including optional needs to be specified for a recipe.
- Parameters
recipes (List[Mapping[str, Union[str, Mapping[str, Any]]]]) – An array of recipes. Recipes are in the format {‘function’: ‘function_name’, ‘args’: {‘arg_name’: ‘arg_val’}}
- Returns
The Chepy object.
- Return type
Examples
>>> c = Chepy('bG9sCg==').run_recipe([{"function":"base64_decode","args":{"custom":None}}]]) >>> lol In this example, we are calling the base64 decode method on the state.
- run_script(path: str, save_state: bool = False)¶
Inject and run a custom script on the state. The custom script must have a function called cpy_script which must take one argument. The state is passed as the argument.
- Parameters
path (str) – Path to custom script
save_state (bool, optional) – Save script output to the state. Defaults to False.
- Returns
The Chepy object.
- Return type
Examples
>>> c = Chepy("A").to_hex().run_script('tests/files/script.py', True) b'4141'
- save_buffer(index: int = None)¶
Save current state in a buffer
Buffers are temporary holding areas for anything that is in the state. The state can change, but the buffer does not. Can be chained with other methods. Use in conjunction with load_buffer to load buffer back into the state.
- Parameters
index (int, optional) – The index to save the state in, defaults to next index if None
- Returns
The Chepy object.
- Return type
- save_recipe(path: str)¶
Save the current recipe
A recipe will be all the previous methods called on the chepy instance along with their args
- Parameters
path (str) – The path to save the recipe
- Returns
The Chepy object.
- Return type
Examples
>>> c = Chepy("some data").to_hex().base64_encode() >>> c.save_recipe("/path/to/recipe) >>> c.out NzM2ZjZkNjUyMDY0NjE3NDYx
- search_dir(pattern: Union[bytes, str])¶
Search all files in a directory. Pattern is case insensitive
- Parameters
pattern (Union[bytes, str]) – regex to search
- Returns
The Chepy object.
- Return type
- set_plugin_path(path: str) None ¶
Use this method to set the path for Chepy plugins.
- Parameters
path (str) – Path to plugins directory
- Returns
None
- set_register(key: str, val: Union[str, bytes])¶
Set the value of a register
- Parameters
key (str) – Key
val (Union[str, bytes]) – Value
- Returns
The Chepy object.
- Return type
- set_state(data: Any)¶
Set any arbitrary values in the current state
This method is simply changing the value of the instantiated state with an arbitrary value.
- Parameters
data (Any) – Any data type
- Returns
The Chepy object.
- Return type
Examples
>>> c = Chepy("some data") >>> print(c.state) some data >>> c.set_state("New data") >>> print(c.state) New data
- subsection(pattern: Union[str, bytes], methods: List[Tuple[Union[str, object], dict]], group: int = 0)¶
Run specified methods over a subsection of the state. This method will always treat the state as bytes.
- Parameters
pattern (Union[str, bytes]) – Regex pattern to match against.
methods (List[Tuple[Union[str, object], dict]]) – Required. List of tuples. The first value of the tuple is the method name, the second value is a dictionary of arguments.
group (int, optional) – Matching group. Defaults to 0.
- Returns
_description_
- Return type
_type_
- substring(pattern: str, group: int = 0)¶
Choose a substring from current state as string
The preceding methods will only run on the substring and not the original state. Group capture is supported.
- Parameters
pattern (str) – Pattern to match.
group (int, optional) – Group to match. Defaults to 0.
- Returns
The Chepy object.
- Return type
- suffix(data: Union[str, bytes])¶
Add a suffix to the data in state. The state is converted to bytes
- Parameters
data (bytes) – Data to add
- Returns
The Chepy object.
- Return type
- switch_state(index: int)¶
Switch current state by index
Same behaviour as change_state
- Parameters
index (int) – Index of new state
- Raises
TypeError – If specified index does not exist
- Returns
The Chepy object.
- Return type
- web(magic: bool = False, cyberchef_url: str = 'https://gchq.github.io/CyberChef/') None ¶
Opens the current string in CyberChef on the browser as hex
- Parameters
magic (bool, optional) – Start with the magic method in CyberChef
cyberchef_url (string, optional) – Base url for Cyberchef
- Returns
Opens the current data in CyberChef
- Return type
None
- write_binary(path: str) None ¶
Save the state to disk. Return None.
- Parameters
path (str) – The file path to save in.
- Returns
Returns None
- Return type
None
Examples
>>> c = Chepy("some data").write_binary('/some/path/file')
- write_to_file(path: str) None ¶
Save the state to disk. Return None.
- Parameters
path (str) – The file path to save in.
- Returns
Returns None
- Return type
None
Examples
>>> c = Chepy("some data").write_to_file('/some/path/file', as_binary=True)
- _current_index¶
Value of the initial state
- _initial_states¶
Holder for the initial state
- _registers¶
Holds register values
- _stack¶
Holds all the methods that are called/chained and their args
- bake¶
Alias for out
- cyberchef¶
Alias for web
- log_format¶
Log format message
- log_level¶
Log level
- property o¶
Get the final output
- Returns
Final output
- Return type
Any
- property out: Any¶
Get the final output
- Returns
Final output
- Return type
Any
- read_file¶
Alias for load_file
- property recipe: List[Dict[str, Union[str, Dict[str, Any]]]]¶
Returns the current recipe. This is a list of dictionaries that contains the method name and the arguments.
- Returns
The recipe.
- Return type
List[Dict[str, Union[str, Dict[str, Any]]]]
- property state¶
- write¶
Alias for write_to_file
- class chepy.core.ChepyDecorators¶
A class to house all the decorators for Chepy
- static call_stack(func)¶
This decorator is used to get the method name and arguments and save it to self.stack. The data from self.stack is predominantly used to save recepies.
- static is_stdout(func)¶
Detect if method is being called from the cli