Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/ishanoshada/encodify
Python Code Encoding Module
https://github.com/ishanoshada/encodify
encode encodify marshal python-encode python-encryption python-marshal python-obfuscate
Last synced: 9 days ago
JSON representation
Python Code Encoding Module
- Host: GitHub
- URL: https://github.com/ishanoshada/encodify
- Owner: Ishanoshada
- License: mit
- Created: 2023-10-22T21:20:34.000Z (about 1 year ago)
- Default Branch: main
- Last Pushed: 2023-11-25T05:24:04.000Z (12 months ago)
- Last Synced: 2024-10-06T00:34:44.933Z (about 1 month ago)
- Topics: encode, encodify, marshal, python-encode, python-encryption, python-marshal, python-obfuscate
- Language: Python
- Homepage: https://pypi.org/project/encodify
- Size: 35.2 KB
- Stars: 8
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Encodify - Python Code Encoding Module
`encodify` is a powerful Python module designed to provide a suite of advanced encoding techniques for Python scripts. These encoding methods encompass compression, base64 encoding, and XOR encryption, allowing users to obfuscate code for enhanced security or distribution.
## Table of Contents
- [Installation](#installation)
- [Usage](#usage)
- [Importing the Module](#importing-the-module)
- [Creating an Encoder Instance](#creating-an-encoder-instance)
- [Encoding Specific Code](#encoding-specific-code)
- [Generating Random Payload](#generating-random-payload)
- [Generating Payload with a Specific Encoding Method](#generating-payload-with-a-specific-encoding-method)
- [Additional Customization](#additional-customization)
- [Advanced Techniques](#advanced-techniques)
- [Examples](#examples)
- [Best Practices and Considerations](#best-practices-and-considerations)
- [License](#license)
## Installation
To integrate `encodify` into your project, you can use `pip`:
```bash
pip install encodify
```
## Usage
### Importing the Module
To employ the functionalities of `encodify`, import the `Encodify` class from the module:
```python
from encodify import Encodify
```
### Creating an Encoder Instance
Instantiate the `Encodify` class to access a wide array of encoding techniques:
```python
encoder = Encodify()
```
### Encoding Specific Code
`encodify` excels at encoding specific Python code snippets. For instance, utilizing the `m1` encoding method:
```python
code_to_encode = "print('Hello, World!')"
encoded_code = encoder.m1(code_to_encode)
```
### Generating Random Payload
For a dynamically selected encoding method, use the `random_payload` method. It produces a randomized payload, increasing the level of code obfuscation:
```python
random_payload = encoder.random_payload("print('Hello, World!')", 2)
```
### Generating Payload with a Specific Encoding Method
Tailor the encoding method to your requirements with the `gen_payload` method. Specify the method number to achieve the desired encoding:
```python
# Choose the encoding method (e.g., m2)
chosen_encoding_method = 2
payload = encoder.gen_payload(chosen_encoding_method, "print('Hello, World!')")
```
### Additional Customization
`encodify` offers extensive customization options. These include string replacements and appending/prepending custom code to the encoded output, allowing for fine-tuned control over the obfuscation process.
### Args for `gen_payload` Function
The `gen_payload` function accepts the following arguments:
- `choice` (int): The chosen encoding technique, determining the applied encoding method. Refer to the module documentation for a complete list of available choices.
- `data` (str): The Python code to be encoded.
- `line` (int, optional): The number of lines for line-based encoding (default is 2). This argument is applicable for specific encoding methods.
- `options` (dict, optional): Further customization options (default is None). This may encompass string replacements or the addition of custom code.
### Available Encoding Methods
```plaintext
+------+---------------------------------------------------+
| No | Encoding Method Description |
+------+---------------------------------------------------+
| 1 | m1: Gzip + Marshal + Base64 |
| 2 | m2: LZMA + Base64 + Marshal |
| 3 | m3: LZMA + Base85 + Marshal |
| 4 | m4: LZMA + Marshal |
| 5 | m5: Base64 + LZMA + Marshal |
| 6 | m6: LZMA + Zlib + Marshal + Base64 |
| 7 | m7: LZMA + Gzip + Marshal + Base64 |
| 8 | m8: LZMA + Marshal |
| 9 | m9: Base64 + Gzip + Marshal + Base64 |
| 10 | m10: Base64 + Gzip + Marshal + LZMA |
| 11 | m11: Base64 + Gzip + Marshal + Base64 |
| 20 | m20: Minify + Base64 + Gzip + Marshal |
| 23 | l1: Line-based Encoding with Base85 |
| 24 | l2: Line-based Encoding with Base85 + LZMA |
| 25 | l25: Line-based Encoding with Base64 + LZMA |
| 26 | l26: Line-based Encoding with Base64 + Codecs |
| 27 | l27: Line-based Encoding with XOR Encryption |
| 28 | l28: Line-based Encoding with Base64 + XOR |
| 29 | l29: Line-based Encoding with Base64 + XOR |
| 30 | l30: Line-based Encoding with XOR + Codecs |
+------+---------------------------------------------------+
```
## Advanced Techniques
`encodify` offers an array of advanced encoding techniques. These include line-based encoding, various combinations of compression, and XOR encryption. For in-depth guidance on these techniques, refer to the module's extensive documentation.
## Examples
Explore some advanced examples showcasing the versatility of `encodify`:
```python
from encodify import Encodify
# Create an instance of Encodify
encoder = Encodify()
# Example 1: Encoding with m2 method
code_to_encode = "for i in range(5):\n print(f'Number: {i}')"
encoded_code_m2 = encoder.m2(code_to_encode)
# Example 2: Encoding with l1 method
line_based_code = "print('Hello, World!')"
encoded_line_based_code = encoder.l1(line_based_code, 3)
# Example 3: Generating a random payload
random_payload = encoder.random_payload("print('Hello, World!')", 2)
# Example 4: Generating a payload with a specific encoding method (m11)
chosen_encoding_method = 11
payload_m11 = encoder.gen_payload(chosen_encoding_method, "print('Hello, World!')")
# Example 5: Customizing output with options
options = {
"replace_strings": {"print": "display"},
"prepend_code": "import datetime\n",
"append_code": "\nprint(f'Execution Time: {datetime.datetime.now()}')"
}
customized_payload = encoder.gen_payload(1, "print('Hello, World!')", options=options)
```
## Best Practices and Considerations
1. **Use Responsibly**: This module is primarily intended for educational purposes. Use it responsibly and within the boundaries of applicable laws and ethical guidelines.
2. **Testing and Verification**: Always test the encoded code to ensure it functions as expected.
3. **Documentation**: Document the encoding method used and keep a record for future reference.
**Repository Views** 
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.