3 |
2 |
3 |
41 |
42 | This is equivalent to
43 |
44 | ```python
45 | from chepy import Chepy
46 |
47 | file_path = "/tmp/demo/encoding"
48 |
49 | print(
50 | Chepy(file_path)
51 | .load_file()
52 | .reverse()
53 | .rot_13()
54 | .from_base64()
55 | .from_base32()
56 | .hexdump_to_str()
57 | .o
58 | )
59 |
60 | ```
61 |
62 | ## Chepy vs Cyberchef
63 |
64 | #### Advantages
65 | - Chepy is pure python with a supporting and accessible python api
66 | - Chepy has a CLI
67 | - Chepy CLI has full autocompletion.
68 | - Supports pe, elf, and other various file format specific parsing.
69 | - Extendable via [plugins](https://chepy-plugins.readthedocs.io/en/latest/)
70 | - Infinitely scalable as it can leverage the full Python library.
71 | - Chepy can interface with the full Cyberchef web app to a certain degree. It is easy to move from Chepy to Cyberchef if need be.
72 | - The Chepy python library is significantly faster than the Cyberchef Node library.
73 | - Works with HTTP/S requests without CORS issues.
74 | - `magic` support via the Chepy ML plugin.
75 |
76 | #### Disadvantages
77 | - Chepy does not offer every single thing that Cyberchef does
78 |
79 |
80 | ## Installation
81 | Chepy can be installed in a few ways.
82 |
83 | ### Pypi
84 | ```bash
85 | pip3 install chepy
86 | # optionally with extra requirements
87 | pip3 install chepy[extras]
88 | ```
89 |
90 | ### Git
91 | ```bash
92 | git clone --recursive https://github.com/securisec/chepy.git
93 | cd chepy
94 | pip3 install -e .
95 | # I use -e here so that if I update later with git pull, I dont have it install it again (unless dependencies have changed)
96 | ```
97 |
98 |
102 |
103 | #### Standalone binary
104 | One can build Chepy to be a standalone binary also. This includes packaging all the dependencies together.
105 | ```bash
106 | git clone https://github.com/securisec/chepy.git
107 | cd chepy
108 | pip install .
109 | pip install pyinstaller
110 | pyinstaller cli.py --name chepy --onefile
111 | ```
112 | The binary will be in the dist/ folder.
113 |
114 | ### Plugins
115 | [Check here for plugins docs](https://chepy-plugins.readthedocs.io/en/latest/)
116 |
117 | ### Used by
118 | [Remnux linux](https://docs.remnux.org/discover-the-tools/examine+static+properties/deobfuscation#chepy)
119 |
120 | ```eval_rst
121 | .. toctree::
122 | :maxdepth: 3
123 | :caption: Contents:
124 |
125 | usage.md
126 | examples.md
127 | cli.rst
128 | chepy.md
129 | core.md
130 | modules.rst
131 | extras.rst
132 | plugins.md
133 | pullrequest.md
134 | config.md
135 | faq.md
136 |
137 |
138 | Indices and tables
139 | ==================
140 |
141 | * :ref:`genindex`
142 | * :ref:`modindex`
143 | * :ref:`search`
144 | ```
145 |
--------------------------------------------------------------------------------
/TODO:
--------------------------------------------------------------------------------
1 | Fix:
2 |
3 | Code:
4 | ☐ add more examples in docstrings
5 | ☐ Luhn validator https://guptaavi352.medium.com/ctflearn-writeups-9f247c2fe94c
6 |
7 | New ideas:
8 | ☐ rubber ducky encode/decode
9 | ☐ save registers https://t.co/pBNRufibY8?amp=1
10 | ☐ cbor encode/decode https://github.com/agronholm/cbor2 (plugin)
11 | ☐ fuzzy search
12 | ☐ 🚧 pgp, generate, encrypt, decrypt, verify
13 | ☐ swap little and big endian
14 | ☐ ignore error method
15 | ☐ swap bytes
16 | ☐ homophonic decoder
17 | ☐ append method for core to add data to the state
18 | ☐ qr create
19 | ☐ random from state
20 | ☐ ascii shift cipher kqfl ? snyjHYK"8fwymdxf~xdm8qq5$ = niteCTF{3arth_says_h3ll0} somewhat
21 | ☐ ✨ affine bruteforce
22 | ☐ ✨ zero-width encode
23 | ☐ ✨ hill cipher encode/decode/brute
24 | ☐ 💡 maybe a decorator function to convert all inputs into bytes when possible? this will allow for a consistant bytes approach to all functions
25 | ☐ ✨ amf encode/decode
26 | ☐ ✨ aes cmac
27 | ☐ ✨ whitespace encoding https://www.dcode.fr/whitespace-language
28 | ☐ beaufort
29 | ☐ 🔥 update python_requires in setup.py on python version change
30 | ☐ update base85 https://github.com/gorakhargosh/mom/blob/master/mom/codec/base85.py#L343
31 |
32 | Bug:
33 |
34 | Extras:
35 | ☐ xor two files
36 |
37 | Cli:
38 | ☐ optionally show output window in a split screen window
39 | ☐ lower the chepy prompt lower. that empty space is not being used
40 | ☐ write to file with prompt toolkit path autocomplete
41 | ☐ pipe input to chepy
42 |
43 | Enhance:
44 |
45 | Plugins:
46 |
47 | Misc:
48 | ☐ cyberchef recipe to chepy recipe converter
49 |
50 | Archive:
51 | ✔ @high disable plugins from code
52 | ✔ 🐙 update config to use envars for plugins
53 | ✔ register support in callstack
54 | ✔ ecb no padding in aes/des
55 | ✔ update ml model with different spacing for hex, binary etc
56 |
--------------------------------------------------------------------------------
/all_tests.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | function check_test {
4 | "$@"
5 | local status=$?
6 | if [ $status -ne 0 ]; then
7 | echo -e "\n\033[31;7m$1 Failed" >&2
8 | exit
9 | fi
10 | return $status
11 | }
12 |
13 | # pytest and coverage
14 | check_test pytest --disable-pytest-warnings --cov=chepy --cov-config=.coveragerc tests/
15 |
16 | # pytest plugins
17 | check_test pytest --disable-pytest-warnings tests_plugins/
18 |
19 | # bandit
20 | check_test bandit --recursive chepy/ --ignore-nosec --skip B101,B413,B303,B310,B112,B304,B320,B410,B404
21 |
22 | # docs
23 | check_test make -C docs/ clean html
24 |
25 | # plugin docs
26 | check_test make -C ~/dev/chepy_plugins/docs clean html
27 |
28 | # build docker
29 | # check_test docker build -t chepy .
30 |
--------------------------------------------------------------------------------
/chepy/__init__.py:
--------------------------------------------------------------------------------
1 | import pretty_errors
2 | from docstring_parser import parse as _doc_parse
3 | from types import FunctionType
4 |
5 | from .modules.aritmeticlogic import AritmeticLogic
6 | from .modules.codetidy import CodeTidy
7 | from .modules.compression import Compression
8 | from .modules.dataformat import DataFormat
9 | from .modules.datetimemodule import DateTime
10 | from .modules.encryptionencoding import EncryptionEncoding
11 | from .modules.extractors import Extractors
12 | from .modules.hashing import Hashing
13 | from .modules.language import Language
14 | from .modules.links import Links
15 | from .modules.networking import Networking
16 | from .modules.other import Other
17 | from .modules.publickey import Publickey
18 | from .modules.search import Search
19 | from .modules.utils import Utils
20 | from .modules.internal.colors import cyan
21 |
22 | from .config import ChepyConfig
23 |
24 | _plugins = ChepyConfig().load_plugins()
25 |
26 |
27 | class Chepy(
28 | AritmeticLogic,
29 | CodeTidy,
30 | Compression,
31 | DataFormat,
32 | DateTime,
33 | EncryptionEncoding,
34 | Extractors,
35 | Hashing,
36 | Language,
37 | Links,
38 | Networking,
39 | Other,
40 | Publickey,
41 | Search,
42 | Utils,
43 | *_plugins
44 | ):
45 | """Chepy class that exposes all functionality of Chepy and its plugins."""
46 |
47 | pass
48 |
49 |
50 | def show_plugins(): # pragma: no cover
51 | hold = {}
52 | for p in _plugins:
53 | hold[p.__name__] = [
54 | name
55 | for name, attr in vars(p).items()
56 | if isinstance(attr, FunctionType) and not name.startswith("_")
57 | ]
58 | return hold
59 |
60 |
61 | def search_chepy_methods(search: str) -> None: # pragma: no cover
62 | """Search for Chepy methods
63 |
64 | Args:
65 | search (str): String to search for
66 | """
67 | methods = dir(Chepy)
68 | for method in methods:
69 | if search in method and not method.startswith("_"):
70 | docs = _doc_parse(getattr(Chepy, method).__doc__).short_description
71 | print(cyan(method), docs)
72 |
--------------------------------------------------------------------------------
/chepy/__init__.pyi:
--------------------------------------------------------------------------------
1 | from typing import Dict, List
2 |
3 | from .modules.aritmeticlogic import AritmeticLogic
4 | from .modules.codetidy import CodeTidy
5 | from .modules.compression import Compression
6 | from .modules.dataformat import DataFormat
7 | from .modules.datetimemodule import DateTime
8 | from .modules.encryptionencoding import EncryptionEncoding
9 | from .modules.extractors import Extractors
10 | from .modules.hashing import Hashing
11 | from .modules.language import Language
12 | from .modules.links import Links
13 | from .modules.multimedia import Multimedia
14 | from .modules.networking import Networking
15 | from .modules.other import Other
16 | from .modules.publickey import Publickey
17 | from .modules.search import Search
18 | from .modules.utils import Utils
19 |
20 | class Chepy(
21 | AritmeticLogic,
22 | CodeTidy,
23 | Compression,
24 | DataFormat,
25 | DateTime,
26 | EncryptionEncoding,
27 | Extractors,
28 | Hashing,
29 | Language,
30 | Links,
31 | Multimedia,
32 | Networking,
33 | Other,
34 | Publickey,
35 | Search,
36 | Utils,
37 | ): ...
38 |
39 | def search_chepy_methods(search: str) -> None: ...
40 | def show_plugins() -> Dict[str, List[str]]: ...
41 |
--------------------------------------------------------------------------------
/chepy/__version__.py:
--------------------------------------------------------------------------------
1 | __version__ = "7.4.0" # pragma: no cover
2 | __author__ = "@securisec" # pragma: no cover
3 |
--------------------------------------------------------------------------------
/chepy/__version__.pyi:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/securisec/chepy/94da185ee9b1700f32da75028b2909fc83a1aeb9/chepy/__version__.pyi
--------------------------------------------------------------------------------
/chepy/config.py:
--------------------------------------------------------------------------------
1 | import sys
2 | import os
3 | import logging
4 | import importlib
5 | import inspect
6 | import pkgutil
7 | import json
8 | from pathlib import Path
9 | from configparser import ConfigParser
10 |
11 |
12 | class ChepyConfig(object):
13 | def __init__(self):
14 | home = Path.home()
15 | self.chepy_dir = (
16 | Path(".chepy").resolve()
17 | if Path(".chepy").exists()
18 | else Path(home / ".chepy")
19 | )
20 | self.chepy_conf = Path(self.chepy_dir / "chepy.conf")
21 |
22 | if not self.chepy_conf.exists(): # pragma: no cover
23 | self.chepy_dir.mkdir(exist_ok=True)
24 | c = ConfigParser()
25 |
26 | c["Plugins"] = {
27 | "EnablePlugins": "false",
28 | "PluginPath": str(Path(__file__).parent / "chepy_plugins"),
29 | }
30 | c["Cli"] = {}
31 | cli_options = c["Cli"]
32 | cli_options["history_path"] = str(self.chepy_dir / "chepy_history")
33 | cli_options["prompt_char"] = ">"
34 | cli_options["prompt_colors"] = "#00ffff #ff0000 #ffd700"
35 | cli_options["show_rprompt"] = "false"
36 | cli_options["prompt_rprompt"] = "#00ff48"
37 | cli_options["prompt_bottom_toolbar"] = "#000000"
38 | cli_options["prompt_toolbar_version"] = "#00ff48"
39 | cli_options["prompt_toolbar_states"] = "#60cdd5"
40 | cli_options["prompt_toolbar_buffers"] = "#ff00ff"
41 | cli_options["prompt_toolbar_type"] = "#ffd700"
42 | cli_options["prompt_toolbar_plugins"] = "#ffccbc"
43 | cli_options["prompt_toolbar_errors"] = "#ff0000"
44 | cli_options["prompt_cli_method"] = "#ffd700"
45 | cli_options["prompt_plugin_method"] = "#30d8ff"
46 | cli_options["cli_info_color"] = "#c2c2ff"
47 | cli_options["prompt_search_background"] = "#00aaaa #000000"
48 | cli_options["prompt_search_fuzzy"] = "#00aaaa"
49 |
50 | Path(str(self.chepy_dir / "chepy_history")).touch()
51 | if not self.chepy_conf.exists():
52 | with open(str(self.chepy_conf), "w") as f:
53 | c.write(f)
54 |
55 | self.config = ConfigParser()
56 | self.config.read(str(self.chepy_conf))
57 |
58 | plugin_path = self.__get_conf_value("None", "PluginPath", "Plugins")
59 | self.enable_plugins = json.loads(
60 | self.__get_conf_value("false", "EnablePlugins", "Plugins")
61 | )
62 |
63 | plugin_envar = os.environ.get("CHEPY_PLUGINS", "")
64 | if plugin_envar == "true":
65 | self.enable_plugins = True
66 | elif plugin_envar != "":
67 | self.enable_plugins = False
68 |
69 | if self.enable_plugins:
70 | if plugin_path != "None":
71 | self.plugin_path = Path(plugin_path).expanduser().resolve()
72 | else:
73 | self.plugin_path = Path(plugin_path)
74 | else:
75 | self.plugin_path = Path("None")
76 |
77 | self.history_path = self.__get_conf_value(
78 | str(self.chepy_dir / "chepy_history"), "history_path"
79 | )
80 | self.prompt_char = self.__get_conf_value(">", "prompt_char")
81 | self.prompt_colors = self.__get_conf_value(
82 | "#00ffff #ff0000 #ffd700", "prompt_colors"
83 | )
84 | self.show_rprompt = json.loads(self.__get_conf_value("false", "show_rprompt"))
85 | self.prompt_rprompt = self.__get_conf_value("#00ff48", "prompt_rprompt")
86 | self.prompt_bottom_toolbar = self.__get_conf_value(
87 | "#000000", "prompt_bottom_toolbar"
88 | )
89 | self.prompt_toolbar_version = self.__get_conf_value(
90 | "#00ff48", "prompt_toolbar_version"
91 | )
92 | self.prompt_toolbar_states = self.__get_conf_value(
93 | "#60cdd5", "prompt_toolbar_states"
94 | )
95 | self.prompt_toolbar_buffers = self.__get_conf_value(
96 | "#ff00ff", "prompt_toolbar_buffers"
97 | )
98 | self.prompt_toolbar_type = self.__get_conf_value(
99 | "#ffd700", "prompt_toolbar_type"
100 | )
101 | self.prompt_toolbar_plugins = self.__get_conf_value(
102 | "#ffccbc", "prompt_toolbar_plugins"
103 | )
104 | self.prompt_toolbar_errors = self.__get_conf_value(
105 | "#ff0000", "prompt_toolbar_errors"
106 | )
107 | self.prompt_search_background = self.__get_conf_value(
108 | "#00aaaa #000000", "prompt_search_background"
109 | )
110 | self.prompt_search_fuzzy = self.__get_conf_value(
111 | "#00aaaa", "prompt_search_fuzzy"
112 | )
113 | self.prompt_cli_method = self.__get_conf_value("#ffd700", "prompt_cli_method")
114 | self.prompt_plugin_method = self.__get_conf_value(
115 | "#30d8ff", "prompt_plugin_method"
116 | )
117 | self.cli_info_color = self.__get_conf_value("#c2c2ff", "cli_info_color")
118 |
119 | def __get_conf_value(self, default: str, option: str, section: str = "Cli"):
120 | if self.config.has_section(section):
121 | if self.config.has_option(section, option):
122 | return self.config[section][option]
123 | else:
124 | return default
125 | else:
126 | return default
127 |
128 | def load_plugins(self): # pragma: no cover
129 | plugins = []
130 | if self.plugin_path.stem != "None":
131 | sys.path.append(str(self.plugin_path))
132 |
133 | my_plugins = [
134 | importlib.import_module(name)
135 | for finder, name, ispkg in pkgutil.iter_modules()
136 | if (name.startswith("chepy_") and name != "chepy_plugins")
137 | ]
138 |
139 | for plugin in my_plugins:
140 | try:
141 | klass, mod = inspect.getmembers(plugin, inspect.isclass)[0]
142 | loaded = getattr(plugin, klass)
143 | plugins.append(loaded)
144 | except:
145 | logging.warning(f"Error loading {plugin.__name__}")
146 | return plugins
147 |
--------------------------------------------------------------------------------
/chepy/config.pyi:
--------------------------------------------------------------------------------
1 | from typing import Any
2 |
3 | class ChepyConfig:
4 | chepy_dir: Any = ...
5 | chepy_conf: Any = ...
6 | config: Any = ...
7 | enable_plugins: Any = ...
8 | plugin_path: Any = ...
9 | history_path: Any = ...
10 | prompt_char: Any = ...
11 | prompt_colors: Any = ...
12 | show_rprompt: Any = ...
13 | prompt_rprompt: Any = ...
14 | prompt_bottom_toolbar: Any = ...
15 | prompt_toolbar_version: Any = ...
16 | prompt_toolbar_states: Any = ...
17 | prompt_toolbar_buffers: Any = ...
18 | prompt_toolbar_type: Any = ...
19 | prompt_toolbar_plugins: Any = ...
20 | prompt_toolbar_errors: Any = ...
21 | prompt_cli_method: Any = ...
22 | prompt_plugin_method: Any = ...
23 | cli_info_color: Any = ...
24 | def __init__(self) -> None: ...
25 | def load_plugins(self): ...
26 |
--------------------------------------------------------------------------------
/chepy/core.pyi:
--------------------------------------------------------------------------------
1 | import logging
2 | from typing import Any, List, Mapping, Tuple, Union, TypeVar, Literal, Callable, Dict
3 |
4 | jsonpickle: Any
5 |
6 | ChepyCoreT = TypeVar('ChepyCoreT', bound='ChepyCore')
7 |
8 | class ChepyDecorators:
9 | @staticmethod
10 | def call_stack(func: Any, *args: Any, **kwargs: Any): ...
11 | @staticmethod
12 | def is_stdout(func: Any, *args: Any, **kwargs: Any): ...
13 |
14 | class ChepyCore:
15 | states: Any = ...
16 | buffers: Any = ...
17 | write: Any = ...
18 | bake: Any = ...
19 | cyberchef: Any = ...
20 | read_file: Any = ...
21 | log_level: Any = ...
22 | log_format: str = ...
23 | _registers: Dict[str, Union[str, bytes]] = ...
24 | _log: logging.Logger = ...
25 | def __init__(self, *data: Any) -> None: ...
26 | def _convert_to_bytes(self) -> bytes: ...
27 | def _to_bytes(self, data: Any) -> bytes: ...
28 | def _convert_to_bytearray(self) -> bytearray: ...
29 | def _convert_to_str(self) -> str: ...
30 | def _convert_to_int(self) -> int: ...
31 | def _str_to_bytes(self, s: str) -> bytes: ...
32 | def _get_nested_value(self: ChepyCoreT, data: dict, key:str, split_by: str=".") -> Any: ...
33 | def _bytes_to_str(self, s: bytes) -> str: ...
34 | @property
35 | def state(self): ...
36 | @state.setter
37 | def state(self: ChepyCoreT, val: Any) -> None: ...
38 | def fork(self: ChepyCoreT, methods: List[Union[Tuple[Union[str, Callable], dict], Tuple[Union[str, Callable[None, ChepyCoreT]],]]]) -> ChepyCoreT: ...
39 | def for_each(self: ChepyCoreT, methods: List[Union[Tuple[Union[str, Callable], Dict[str, Any]], Tuple[Union[str, Callable[None, ChepyCoreT]],]]], merge: Union[str, bytes, None]=None) -> ChepyCoreT: ...
40 | def set_state(self: ChepyCoreT, data: Any) -> ChepyCoreT: ...
41 | def create_state(self: ChepyCoreT): ...
42 | def copy_state(self: ChepyCoreT, index: int=...) -> ChepyCoreT: ...
43 | def change_state(self: ChepyCoreT, index: int) -> ChepyCoreT: ...
44 | def switch_state(self: ChepyCoreT, index: int) -> ChepyCoreT: ...
45 | def delete_state(self: ChepyCoreT, index: int) -> ChepyCoreT: ...
46 | def get_state(self: ChepyCoreT, index: int) -> ChepyCoreT: ...
47 | def save_buffer(self: ChepyCoreT, index: int=...) -> ChepyCoreT: ...
48 | def load_buffer(self: ChepyCoreT, index: int) -> ChepyCoreT: ...
49 | def delete_buffer(self: ChepyCoreT, index: int) -> ChepyCoreT: ...
50 | def substring(self: ChepyCoreT, pattern: str, group: int=...) -> ChepyCoreT: ...
51 | @property
52 | def o(self): ...
53 | @property
54 | def out(self: ChepyCoreT) -> ChepyCoreT: ...
55 | def out_as_any(self: ChepyCoreT) -> str: ...
56 | def get_by_index(self: ChepyCoreT, *indexes: int) -> ChepyCoreT: ...
57 | def get_by_key(self: ChepyCoreT, *keys: Union[str, bytes], py_style: bool=False, split_key: Union[str, None] = '.') -> ChepyCoreT: ...
58 | def copy_to_clipboard(self: ChepyCoreT) -> None: ...
59 | def copy(self: ChepyCoreT) -> None: ...
60 | def web(self: ChepyCoreT, magic: bool=..., cyberchef_url: str=...) -> None: ...
61 | def http_request(self: ChepyCoreT, method: str=..., params: dict=..., json: dict=..., headers: dict=..., cookies: dict=...) -> ChepyCoreT: ...
62 | def load_from_url(self: ChepyCoreT, method: str=..., params: dict=..., json: dict=..., headers: dict=..., cookies: dict=...) -> ChepyCoreT: ...
63 | def load_dir(self: ChepyCoreT, pattern: str=...) -> ChepyCoreT: ...
64 | def load_file(self: ChepyCoreT, binary_mode: bool=..., encoding: Union[str, None]=...) -> ChepyCoreT: ...
65 | def write_to_file(self: ChepyCoreT, path: str) -> None: ...
66 | def write_binary(self: ChepyCoreT, path: str) -> None: ...
67 | @property
68 | def recipe(self) -> List[Dict[str, Union[str, Dict[str, Any]]]]: ...
69 | def run_recipe(self: ChepyCoreT, recipes: List[Mapping[str, Union[str, Mapping[str, Any]]]]) -> ChepyCoreT: ...
70 | def save_recipe(self: ChepyCoreT, path: str) -> ChepyCoreT: ...
71 | def load_recipe(self: ChepyCoreT, path: str) -> ChepyCoreT: ...
72 | def run_script(self: ChepyCoreT, path: str, save_state: bool=...) -> ChepyCoreT: ...
73 | def loop(self: ChepyCoreT, iterations: int, callback: Union[str, Callable], args: dict=...) -> ChepyCoreT: ...
74 | def loop_list(self: ChepyCoreT, callback: Union[str, Callable], args: dict=...) -> ChepyCoreT: ...
75 | def loop_dict(self: ChepyCoreT, keys: list, callback: Union[str, Callable], args: dict=...) -> ChepyCoreT: ...
76 | def debug(self: ChepyCoreT, verbose: bool=...) -> ChepyCoreT: ...
77 | def reset(self: ChepyCoreT) -> ChepyCoreT: ...
78 | def print(self: ChepyCoreT) -> ChepyCoreT: ...
79 | def load_command(self: ChepyCoreT) -> ChepyCoreT: ...
80 | def pretty(self: ChepyCoreT, indent: int=...) -> ChepyCoreT: ...
81 | def plugins(self: ChepyCoreT, enable: Literal['true', 'false']) -> None: ...
82 | def set_plugin_path(self: ChepyCoreT, path: str) -> None: ...
83 | def subsection(self: ChepyCoreT, pattern: str, methods: List[Tuple[Union[str, object], dict]], group: int=...) -> ChepyCoreT: ...
84 | def callback(self: ChepyCoreT, callback_function: Callable[[Any], Any]) -> ChepyCoreT: ...
85 | def register(self: ChepyCoreT, pattern: Union[str, bytes], ignore_case: bool=False, multiline: bool=False, dotall: bool=False, unicode: bool=False, extended: bool=False) -> ChepyCoreT: ...
86 | def prefix(self: ChepyCoreT, data: Union[str, bytes]) -> ChepyCoreT: ...
87 | def suffix(self: ChepyCoreT, data: Union[str, bytes]) -> ChepyCoreT: ...
88 | def get_register(self: ChepyCoreT, key: str) -> Union[str, bytes]: ...
89 | def set_register(self: ChepyCoreT, key: str, val: Union[str, bytes]) -> ChepyCoreT: ...
90 | def dump_json(self: ChepyCoreT) -> ChepyCoreT: ...
91 | def walk_dir(self: ChepyCoreT) -> ChepyCoreT: ...
92 | def search_dir(self: ChepyCoreT, pattern: Union[str, bytes]) -> ChepyCoreT: ...
93 |
--------------------------------------------------------------------------------
/chepy/extras/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/securisec/chepy/94da185ee9b1700f32da75028b2909fc83a1aeb9/chepy/extras/__init__.py
--------------------------------------------------------------------------------
/chepy/extras/__init__.pyi:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/securisec/chepy/94da185ee9b1700f32da75028b2909fc83a1aeb9/chepy/extras/__init__.pyi
--------------------------------------------------------------------------------
/chepy/extras/bruteforce.py:
--------------------------------------------------------------------------------
1 | import zipfile
2 | from pathlib import Path
3 |
4 |
5 | def _expand_path(path):
6 | return str(Path(path).expanduser().absolute())
7 |
8 |
9 | def zip_password_bruteforce(path: str, wordlist: str) -> str:
10 | z = zipfile.ZipFile(_expand_path(path))
11 | with open(_expand_path(wordlist)) as f:
12 | for password in f:
13 | password = password.strip().encode()
14 | try:
15 | z.setpassword(password)
16 | z.testzip()
17 | return password
18 | except RuntimeError: # pragma: no cover
19 | continue
20 |
--------------------------------------------------------------------------------
/chepy/extras/bruteforce.pyi:
--------------------------------------------------------------------------------
1 | def zip_password_bruteforce(path: str, wordlist: str) -> str: ...
2 |
--------------------------------------------------------------------------------
/chepy/extras/characters.py:
--------------------------------------------------------------------------------
1 | from string import ascii_lowercase, ascii_uppercase, digits
2 |
3 |
4 | def base64_char_sets() -> dict:
5 | """Get various combinations of base64 character sets
6 |
7 | Returns:
8 | dict: Dict of various char sets
9 | """
10 | return {
11 | "standard": ascii_uppercase + ascii_lowercase + digits + "+/=", # A-Za-z0-9+/=
12 | "url_safe": ascii_uppercase + ascii_lowercase + digits + "-_", # A-Za-z0-9-_
13 | "filename_safe": ascii_uppercase
14 | + ascii_lowercase
15 | + digits
16 | + "+\\-=", # A-Za-z0-9+\-=
17 | "itoa64": "./"
18 | + digits
19 | + ascii_uppercase
20 | + ascii_lowercase
21 | + "=", # ./0-9A-Za-z=
22 | "xml": ascii_uppercase + ascii_lowercase + digits + "_.", # A-Za-z0-9_.
23 | "y64": ascii_uppercase + ascii_lowercase + digits + "._-", # A-Za-z0-9._-
24 | "z64": digits + ascii_lowercase + ascii_uppercase + "+/=", # 0-9a-zA-Z+/=
25 | "radix64": digits + ascii_uppercase + ascii_lowercase + "+/=", # 0-9A-Za-z+/=
26 | "uuencoding": " -_",
27 | "xxencoding": "+\\-"
28 | + digits
29 | + ascii_uppercase
30 | + ascii_lowercase, # +\-0-9A-Za-z
31 | "unix_crypt": "./" + digits + ascii_uppercase + ascii_lowercase, # ./0-9A-Za-z
32 | }
33 |
--------------------------------------------------------------------------------
/chepy/extras/characters.pyi:
--------------------------------------------------------------------------------
1 | def base64_char_sets() -> dict: ...
2 |
--------------------------------------------------------------------------------
/chepy/extras/combinatons.py:
--------------------------------------------------------------------------------
1 | import itertools
2 | from typing import List, Any, Iterator
3 |
4 |
5 | def generate_combo(
6 | words: List[Any], min_length: int = 0, max_length: int = None, join_by: str = None
7 | ) -> Iterator[tuple]:
8 | """Creates all possible combinations from the `words` being passed.
9 | Returns a generator. `length` controls the length of the permutations.
10 |
11 | Args:
12 | words (List[Any]): List of strings.
13 | min_length (int, optional): Minimum length of permutations. By default, 0 which
14 | will generate all
15 | max_length (int, optional): Maximum length of permutations.
16 | By default, it is the length of the `words` list
17 |
18 | Returns:
19 | Iterator[tuple]: A generator containing tuples of combinations
20 | """
21 | if min_length > 0 and max_length is not None:
22 | for L in range(min_length, max_length + 1):
23 | for subset in itertools.permutations(words, L):
24 | yield join_by.join(subset) if join_by is not None else subset
25 | elif max_length is None:
26 | for L in range(min_length, len(words) + 1):
27 | for subset in itertools.permutations(words, L):
28 | yield join_by.join(subset) if join_by is not None else subset
29 | else:
30 | for subset in itertools.permutations(words, max_length):
31 | yield join_by.join(subset) if join_by is not None else subset
32 |
33 |
34 | def hex_chars() -> list:
35 | """Returns an array of all the hex characters
36 |
37 | Returns:
38 | list: List of all hex characters
39 | """
40 | return list("{:02x}".format(x) for x in range(0, 256))
41 |
42 |
--------------------------------------------------------------------------------
/chepy/extras/combinatons.pyi:
--------------------------------------------------------------------------------
1 | from typing import Any, Iterator, List
2 |
3 | def generate_combo(words: List[Any], min_length: int=..., max_length: int=..., join_by: str=...) -> Iterator[tuple]: ...
4 | def hex_chars() -> list: ...
5 |
--------------------------------------------------------------------------------
/chepy/extras/crypto.py:
--------------------------------------------------------------------------------
1 | import json
2 | import lazy_import
3 | from typing import Iterator, Dict, List, Union
4 | from binascii import hexlify, unhexlify
5 | from itertools import cycle
6 | from urllib.request import urlopen
7 | RSA = lazy_import.lazy_module("Crypto.PublicKey.RSA")
8 |
9 | from .combinatons import generate_combo, hex_chars
10 | from chepy import Chepy
11 |
12 |
13 | def factordb(n: int) -> dict: # pragma: no cover
14 | """Query the factordb api and get primes if available
15 |
16 | Args:
17 | n (int): n is the modulus for the public key and the private keys
18 |
19 | Returns:
20 | dict: response from api as a dictionary. None if status code is not 200
21 | """
22 | res = urlopen("http://factordb.com/api/?query={}".format(str(n)))
23 | if res.status != 200:
24 | return None
25 | return json.loads(res.read().decode())
26 |
27 |
28 | def construct_private_key(
29 | n: int, e: int, d: int, format: str = "PEM", passphrase: str = None
30 | ) -> str: # pragma: no cover
31 | """Construct a private key given n, e and d
32 |
33 | Args:
34 | n (int): n
35 | e (int): e
36 | d (int): d
37 | format (str, optional): Supports PEM, DER and OpenSSH. Defaults to "PEM".
38 | passphrase (str, optional): [description]. Defaults to None.
39 |
40 | Returns:
41 | str: Private key
42 | """
43 | valid_formats = ["PEM", "DER", "OpenSSH"]
44 | assert format in valid_formats, "Valid formats are {}".format(
45 | " ".join(valid_formats)
46 | )
47 | priv = RSA.construct((n, e, d))
48 | return priv.export_key(format=format, passphrase=passphrase)
49 |
50 |
51 | def xor_bruteforce_multi(
52 | data: str, min: int = 0, max: int = None, errors: str = "backslashreplace"
53 | ) -> Iterator[Dict[str, str]]:
54 | """Bruteforce multibyte xor encryption. For faster results, use pypy3.
55 | It is important to set the min and max values if the key size is known.
56 |
57 | Args:
58 | data (str): XORed data
59 | min (int, optional): Minimum key length. Default will start at 1 byte
60 | . Defaults to 0.
61 | max (int, optional): Maximum key length. Maximum value is 257 bytes. Defaults to None.
62 | errors (str, optional): How should the errors be handled? Defaults to backslashreplace.
63 | Valid options are replace, ignore, backslashreplace
64 |
65 | Returns:
66 | Iterator[Dict[str, str]]: A dictionary where key is key, and value is xored data
67 |
68 | Yields:
69 | Iterator[Dict[str, str]]: A generator which contains a dictionary with the
70 | keys: `key` and `out`
71 | """
72 | for key in generate_combo(
73 | hex_chars(), min_length=min, max_length=max, join_by=""
74 | ): # pragma: no cover
75 | yield {
76 | "key": key,
77 | "out": Chepy(data).xor(key).bytearray_to_str(errors=errors).o,
78 | }
79 |
80 |
81 | def xor_repeating_key(
82 | data1: bytes, data2: bytes, min: int = 1, max: int = 257
83 | ) -> Union[bytes, None]: # pragma: no cover
84 | """Recover repeating key xor keys.
85 |
86 | Args:
87 | data1 (bytes): File 1 path
88 | data2 (bytes): File 2 path
89 | min (int, optional): Min chars to test. Defaults to 1.
90 | max (int, optional): Max chars to test. Defaults to 257.
91 |
92 | Returns:
93 | Union[bytes, None]: Key as hex bytes or None if no key found
94 | """
95 |
96 | def find_same(s: bytes):
97 | i = (s + s).find(s, 1, -1)
98 | return None if i == -1 else s[:i]
99 |
100 | for i in range(min, max):
101 | d1 = data1[:i]
102 |
103 | d2 = data2[:i]
104 |
105 | x = bytes(a ^ b for a, b in zip(d1, d2))
106 | o = find_same(x)
107 | if o is not None:
108 | return o
109 |
110 |
111 | def xor(data: bytes, key: bytes) -> bytes: # pragma: no cover
112 | """XOR data with a hex key
113 |
114 | Args:
115 | data (bytes): Data to be xored
116 | key (bytes): Hex key to xor data with
117 |
118 | Returns:
119 | bytes: XORed data
120 |
121 | Example:
122 | >>> xor(b"hello", unhexlify(b"aabbccdd"))
123 | b'c2dea0b1c5'
124 | """
125 | return hexlify(bytes(a ^ b for a, b in zip(data, cycle(key))))
126 |
127 |
128 | def one_time_pad_crib(
129 | cipherText1: Union[bytes, str], cipherText2: Union[bytes, str], crib: bytes
130 | ) -> List[str]:
131 | """One time pad crib attack.
132 |
133 | Args:
134 | cipherText1 (Union[bytes, str]): Cipher text 1 as hex
135 | cipherText2 (Union[bytes, str]): Cipher text 2 as hex
136 | crib (bytes): Crib (known text) as bytes
137 |
138 | Returns:
139 | List[str]: List of possible plaintexts
140 | """
141 | cipherText1 = unhexlify(cipherText1)
142 | cipherText2 = unhexlify(cipherText2)
143 | xored = bytearray(a ^ b for a, b in zip(cipherText1, cipherText2))
144 | hold = []
145 | for offset in range(0, len(xored) - len(crib) + 1):
146 | piece = xored[offset : offset + len(crib)]
147 | piece = bytearray(a ^ b for a, b in zip(crib, piece))
148 | if all(32 <= c <= 126 for c in piece):
149 | piece = (
150 | ("." * offset)
151 | + piece.decode()
152 | + ("." * (len(xored) - len(crib) - offset))
153 | )
154 | hold.append(piece)
155 | return hold
156 |
157 |
158 | def generate_rsa_keypair(
159 | bits: int = 1024, passphrase: str = None
160 | ) -> Dict[str, dict]: # pragma: no cover
161 | """Generates an RSA keypair with the specified number of bits.
162 |
163 | Args:
164 | bits: The number of bits for the RSA keypair.
165 |
166 | Returns:
167 | A tuple of the RSA public key and RSA private key, both in PEM format.
168 | """
169 |
170 | keypair = RSA.generate(bits)
171 | return {
172 | "pem": {
173 | "public": keypair.publickey().exportKey("PEM"),
174 | "private": keypair.exportKey("PEM", passphrase=passphrase),
175 | },
176 | "der": {
177 | "public": keypair.publickey().exportKey("DER"),
178 | "private": keypair.exportKey("DER", passphrase=passphrase),
179 | },
180 | }
181 |
--------------------------------------------------------------------------------
/chepy/extras/crypto.pyi:
--------------------------------------------------------------------------------
1 | from typing import Dict, Iterator, Union, Any
2 |
3 | def factordb(n: int) -> dict: ...
4 | def construct_private_key(n: int, e: int, d: int, format: str=..., passphrase: str=...) -> str: ...
5 | def xor_bruteforce_multi(data: str, min: int=..., max: int=..., errors: str=...) -> Iterator[Dict[str, str]]: ...
6 | def xor_repeating_key(data1:bytes, data2: bytes, min: int =..., max: int = ...) -> Union[bytes, None]: ...
7 | def generate_rsa_keypair(bits: int=..., passphrase: str=...) -> Dict[str, Dict[str, Any]] : ...
--------------------------------------------------------------------------------
/chepy/extras/misc.py:
--------------------------------------------------------------------------------
1 | import collections
2 | import math
3 | from typing import Any
4 |
5 |
6 | def shannon_entropy(data: Any, unit="shannon") -> float:
7 | """Calculate the Shannon entropy of any data type. Units
8 | could be `natural`, `shannon` or `hartley`
9 |
10 | - 0 represents no randomness (i.e. all the bytes in the data have the same value)
11 | whereas 8, the maximum, represents a completely random string.
12 | - Standard English text usually falls somewhere between 3.5 and 5.
13 | - Properly encrypted or compressed data of a reasonable length should have an entropy of over 7.5.
14 |
15 | Args:
16 | data (Any): Any data type
17 | unit (str, optional): Unit type. Defaults to "shannon".
18 |
19 | Returns:
20 | float: Calculated entropy
21 | """
22 | base = {"shannon": 2.0, "natural": math.exp(1), "hartley": 10.0}
23 |
24 | if len(data) <= 1: # pragma: no cover
25 | return 0
26 |
27 | counts = collections.Counter()
28 |
29 | for d in data:
30 | counts[d] += 1
31 |
32 | ent = 0
33 |
34 | probs = [float(c) / len(data) for c in counts.values()]
35 | for p in probs:
36 | if p > 0.0:
37 | ent -= p * math.log(p, base[unit])
38 |
39 | return ent
40 |
41 |
42 | def index_of_coincidence(data: Any) -> float:
43 | """Index of Coincidence (IC) is the probability of two randomly
44 | selected characters being the same.
45 |
46 | - 0 represents complete randomness (all characters are unique), whereas 1 represents no randomness (all characters are identical).
47 | - English text generally has an IC of between 0.67 to 0.78.
48 | - 'Random' text is determined by the probability that each letter occurs the same number of times as another.
49 |
50 | `Reference This domain is for use in illustrative examples in documents. You may use this 42 | domain in literature without prior coordination or asking for permission.
43 | 44 | 45 |