<<<<<<< HEAD
=======
474534d577a35d3d77e276d4f525af80de8ab7e8
ObfusLite is a comprehensive Python code obfuscation library featuring novel encoding techniques and an enhanced GUI with multi-file support. Protect your Python applications with professional-grade obfuscation suitable for PyInstaller compilation.
- 🔥 Multi-File Batch Processing - Process hundreds of files simultaneously
- 🔗 Smart File Combining - Merge multiple Python files into one (NEW in v1.1.0!)
- 📁 Project Management - Save and load obfuscation projects (
.pyobffiles) - 📊 Code Analysis - Intelligent recommendations based on code complexity
- 🔍 Side-by-Side Comparison - Compare original vs obfuscated code
- 🎨 Template System - Sa 8000 ve and reuse obfuscation configurations
- 📦 Export Options - ZIP archives, CSV reports, detailed logs
- ⚡ Real-time Progress - Track processing status for each file
- 🔧 Professional Workflow - Suitable for enterprise and team environments
- 3 Performance Modes: Fast, Balanced, Full
- Ultra-Fast Encoders: 100x faster than complex algorithms
- Low Memory Usage: < 1MB RAM for most operations
- Batch Processing: Handle multiple files efficiently
- Fast XOR Encoding - Multi-key XOR with compression (Recommended)
- Fast Base64 Encoding - Base64 with character substitution
- Fast Rotation Cipher - Multi-round Caesar cipher
- Fast Hash Encoding - Hash-based chunk encoding
- Fast Binary Manipulation - Bit shifting operations
- Fast Lookup Tables - Character mapping encoding
- Quantum-Inspired Encoding - Uses quantum gate operations and superposition concepts
- DNA Sequence Mapping - Maps code to biological DNA sequences with genetic mutations
- Fractal Pattern Encoding - Encodes data using mathematical fractals and chaos theory
- Neural Network Weight Encoding - Stores code as neural network weights and biases
- Steganographic Hiding - Hides code within innocent-looking data structures
- Runtime Reconstruction - Creates self-modifying code that rebuilds at runtime
- Multi-dimensional Tensor Encoding - Uses tensor operations and linear algebra
- ✅ Lightning Fast - Process large files in milliseconds
- ✅ Multi-File Support - Batch process entire projects
- ✅ Project Management - Save and resume complex workflows
- ✅ PyInstaller Compatible - Generates standalone code ready for .exe compilation
- ✅ Multi-layer Protection - Apply multiple obfuscation layers for enhanced security
- ✅ Reversible - Complete deobfuscation capability for legitimate use
- ✅ Novel Algorithms - Unique techniques not found in traditional obfuscators
- ✅ Enhanced GUI - Professional interface with advanced features
- ✅ Team Collaboration - Shareable projects and templates
# Basic installation
pip install obfuslite
# With enhanced GUI support
pip install obfuslite[gui]
# Full installation with all features
pip install obfuslite[full]git clone https://github.com/zinzied/obfuslite.git
cd obfuslite
pip install -e .# For enhanced GUI interface (recommended)
pip install obfuslite[gui]
# For development and testing
pip install obfuslite[dev]
# For advanced techniques (neural, tensor)
pip install obfuslite[full]- Python: 3.8+
- Core: No additional dependencies
- GUI: PyQt6 >= 6.4.0
- Advanced: NumPy >= 1.21.0, SciPy >= 1.9.0
# Launch enhanced GUI with multi-file support
obfuslite gui
# Or use the dedicated GUI command
obfuslite-gui# Obfuscate a single file
obfuslite obfuscate input.py -o output.py -t fast_xor -l 2
# Combine multiple files into one (NEW!)
obfuslite combine main.py --obfuscate -t fast_xor -l 2
# List available techniques
obfuslite list-techniques
# Benchmark performance
obfuslite benchmark input.py
# Get help
obfuslite --helpfrom obfuslite import Obfuscator, quick_obfuscate
# Quick obfuscation (one line!)
standalone_code = quick_obfuscate(your_code, technique='fast_xor', layers=2)
# Advanced usage
obfuscator = Obfuscator()
result = obfuscator.obfuscate(code, technique='fast_xor', layers=2)
standalone_code = obfuscator.create_standalone_file(result)
# Save and run
with open('obfuscated_app.py', 'w') as f:
f.write(standalone_code)ObfusLite now includes powerful file combining functionality that solves the common problem where obfuscated multi-file applications can't find their modules.
# main.py
from utils import helper_function # ❌ Fails after obfuscation
from config import settings # ❌ Import errors
# After obfuscating each file separately, imports break!# Combine all files into one before obfuscating
obfuslite combine main.py --obfuscate
# Creates a single, self-contained file that works perfectly!# Basic combine
obfuslite combine main.py
# Combine with custom output
obfuslite combine main.py -o my_app.py
# Combine and auto-obfuscate
obfuslite combine main.py --obfuscate -t fast_xor -l 2
# Advanced obfuscation
obfuslite combine main.py --obfuscate -t quantum -l 3- Launch GUI:
obfuslite gui - Go to "Combine Files" tab
- Select your main Python file
- Click "Auto-Detect Related Files"
- Configure obfuscation settings
- Click "Combine Files"
- Get a single, working obfuscated file!
- ✅ No Import Issues - Single file, no module dependencies
- ✅ PyInstaller Ready - Perfect for creating executables
- ✅ Auto-Detection - Finds all related Python files automatically
- ✅ Smart Import Filtering - Removes local imports, keeps external ones
- ✅ Progress Tracking - Real-time status in GUI
- ✅ Error Prevention - Syntax validation before obfuscation
- Add Files/Directories: Select multiple Python files or entire directories
- Real-time Progress: Track processing status for each file
- Error Handling: Detailed error reporting and recovery
- ZIP Export: Create compressed archives of results
- Backup Management: Automatic backup of original files
- Save Projects: Store complex multi-file configurations as
.pyobffiles - Load Projects: Resume work on saved projects
- File Tracking: Monitor file status and modifications
- Team Collaboration: Share projects and configurations
- Complexity Analysis: Analyze code structure and complexity
- Smart Recommendations: Get technique suggestions based on code
- Performance Guidance: Optimize settings for your specific needs
- Metrics Visualization: View detailed code statistics
- Side-by-Side View: Compare original vs obfuscated code
- Statistical Analysis: Size ratios, complexity metrics
- Export Reports: Generate comparison reports for documentation
- Save Configurations: Create reusable obfuscation templates
- Quick Apply: One-click application of saved settings
- Team Standards: Maintain consistent obfuscation across projects
- Obfuscate your code using ObfusLite
- Save the standalone code to a .py file
- Compile with PyInstaller:
pyinstaller --onefile obfuscated_app.py
- Use GUI Batch Processing to obfuscate multiple files
- Export as ZIP for organized distribution
- Compile main entry point:
pyinstaller --onefile main_obfuscated.py
The resulting .exe will contain your obfuscated code that reconstructs itself at runtime.
| Technique | Speed | Security | Size Ratio | Best For |
|---|---|---|---|---|
| fast_xor | ⚡⚡⚡⚡⚡ | 🛡️🛡️🛡️ | 1.2x | Development, Testing |
| fast_base64 | ⚡⚡⚡⚡⚡ | 🛡️🛡️ | 1.4x | Quick Protection |
| fast_rotation | ⚡⚡⚡⚡ | 🛡️🛡️🛡️ | 1.3x | Balanced Security |
| quantum | ⚡⚡ | 🛡️🛡️🛡️🛡️🛡️ | 2.1x | Maximum Security |
| neural | ⚡ | 🛡️🛡️🛡️🛡️🛡️ | 2.8x | Research, High-Value |
| tensor | ⚡ | 🛡️🛡️🛡️🛡️🛡️ | 3.2x | Enterprise Security |
- GUI Batch Processing: 50% faster for multiple files
- Project Management: Saves 80% setup time for complex projects
- Template System: Reduces configuration time by 90%
- Maps binary data to quantum state representations
- Uses quantum gate operations (Hadamard, Pauli-X, Y, Z)
- Applies superposition and entanglement concepts
- Encodes data in complex number amplitudes
- Converts code to DNA base sequences (A, T, G, C)
- Applies genetic mutations for additional obfuscation
- Uses codon tables for amino acid encoding
- Includes intron sequences for steganographic hiding
- Utilizes mathematical fractals (Mandelbrot, Julia sets)
- Applies chaos theory and strange attractors
- Maps data to fractal coordinates
- Uses Lorenz attractor and Sierpinski triangle
- Stores code as neural network weights and biases
- Uses multiple layer architectures
- Applies activation functions for transformation
- Includes forward and backward propagation concepts
- Hides code in innocent-looking data:
- Lorem ipsum text
- Configuration files
- Mathematical constants
- Fake database records
- Poetry structures
- Creates self-modifying code
- Uses bytecode assembly
- AST (Abstract Syntax Tree) reconstruction
- Dynamic import mechanisms
- Function composition techniques
- Multi-dimensional array operations
- Matrix multiplication transformations
- Singular Value Decomposition (SVD)
- Fourier and wavelet transforms
- Linear algebra operations
- Technique: Choose from 7 available methods
- Layers: Apply 1-10 layers of obfuscation
- Seed: Set random seed for reproducible results
- Compression: Optional output compression
- Basic (1-2 layers): Fast obfuscation for simple protection
- Standard (3-5 layers): Balanced security and performance
- High (6-10 layers): Maximum security for sensitive code
from obfuslite import quick_obfuscate
code = '''
def hello_world():
print("Hello from ObfusLite!")
return "Protected!"
if __name__ == "__main__":
result = hello_world()
print(f"Result: {result}")
'''
# One-line obfuscation
protected_code = quick_obfuscate(code, technique='fast_xor', layers=2)
# Save and run
with open('protected.py', 'w') as f:
f.write(protected_code)from obfuslite import Obfuscator
import os
obfuscator = Obfuscator()
# Process all Python files in a directory
for root, dirs, files in os.walk('my_project'):
for file in files:
if file.endswith('.py'):
file_path = os.path.join(root, file)
with open(file_path, 'r') as f:
code = f.read()
result = obfuscator.obfuscate(code, technique='fast_xor')
standalone = obfuscator.create_standalone_file(result)
output_path = file_path.replace('.py', '_protected.py')
with open(output_path, 'w') as f:
f.write(standalone)- Launch GUI:
obfuslite gui - Create new project in Project Management tab
- Add files using Batch Processing tab
- Configure obfuscation settings and save as template
- Process all files and export as ZIP
- Save project for future use
- Go to Batch Processing tab
- Click "Add Directory" and select your project folder
- Choose "fast_xor" technique for speed
- Set output directory
- Click "Process All Files"
- Export results as ZIP archive
- Go to Code Analysis tab
- Load your Python file
- Click "Analyze Code"
- Review recommendations
- Apply suggested settings in other tabs
See examples/obfuslite_basic_usage.py for comprehensive examples including:
- Basic obfuscation/deobfuscation
- Advanced features demonstration
- PyInstaller preparation
- Technique comparison
- GUI workflow examples
- ✅ Casual code inspection
- ✅ Simple reverse engineering attempts
- ✅ Automated code analysis tools
- ✅ Source code theft
- ✅ Algorithm discovery
- ❌ Not cryptographically secure against determined attackers
- ❌ Runtime performance overhead due to reconstruction
- ❌ Increased file size due to obfuscation data
- ❌ Debugging becomes more difficult
- Use GUI for complex projects - Leverage batch processing and project management
- Save templates for consistent team workflows
- Combine multiple techniques for enhanced security
- Use high layer counts for sensitive code
- Test thoroughly before deployment
- Backup originals when using batch processing
- Create a new encoder class inheriting from
BaseEncoder - Implement
encode()anddecode()methods - Register with the obfuscator core
- Add to GUI dropdown menu
Example:
from obfuslite.encoders.base import BaseEncoder
class MyCustomEncoder(BaseEncoder):
def encode(self, data: str) -> Dict[str, Any]:
# Your encoding logic here
pass
def decode(self, encoded_data: Any, metadata: Dict[str, Any]) -> str:
# Your decoding logic here
pass
# Register the technique
from obfuslite import Obfuscator
obfuscator = Obfuscator()
obfuscator.register_technique('custom', MyCustomEncoder())- GUI Won't Start: Install PyQt6 with
pip install obfuslite[gui] - Import Errors: Ensure ObfusLite is properly installed
- Memory Issues: Use fast techniques for large files or reduce layer count
- PyInstaller Errors: Check that all dependencies are included
- Batch Processing Fails: Verify file permissions and output directory access
- Use GUI batch processing for multiple files (50% faster)
- Save templates to avoid reconfiguration
- Choose fast techniques for large codebases
- Use fewer layers for faster processing
- Enable ZIP compression for storage efficiency
- Project Management: Save complex configurations as projects
- Template System: Create templates for different security levels
- Batch Processing: Process similar files together for efficiency
- Code Analysis: Use recommendations for optimal settings
ObfusLite is released under the MIT License. Free for personal and commercial use.
Contributions are welcome! Priority areas:
- Enhanced GUI features - New tabs, visualizations, workflows
- New obfuscation techniques - Novel encoding algorithms
- Performance optimizations - Faster processing, lower memory usage
- Better PyInstaller integration - Seamless executable creation
- Documentation improvements - Tutorials, examples, guides
- Documentation: GUI Features Guide
- Examples: examples/
- Issues: GitHub Issues
- Discussions: GitHub Discussions
For issues, questions, or feature requests:
- 🐛 Bug Reports: Create an issue on GitHub
- 💡 Feature Requests: Use GitHub Discussions
- 📚 Documentation: Check the GUI Features Guide
- 🎮 Examples: Run
examples/obfuslite_basic_usage.py
ObfusLite - Professional Python Code Protection Made Simple 🛡️
Note: This obfuscation library is designed for legitimate code protection purposes. Users are responsible for complying with applicable laws and regulations in their jurisdiction.