fastcrypter 2.3.0__py3-none-any.whl

fastcrypter/__init__.py

@@ -0,0 +1,285 @@
+"""
+🚀 fastCrypter - Professional Compression and Encryption Library
+
+A powerful Python package for secure data compression and encryption
+using modern cryptographic algorithms and compression techniques with
+native C/C++ acceleration for maximum performance.
+
+Author: Mmdrza
+Version: 2.0.0
+License: MIT
+"""
+
+__version__ = "2.3.0"
+__author__ = "Mmdrza"
+__email__ = "pymmdrza@gmail.com"
+__license__ = "MIT"
+
+# Core imports
+from .core.compressor import Compressor, CompressionAlgorithmType, CompressionLevel
+from .core.encryptor import Encryptor, EncryptionAlgorithmType
+from .core.key_manager import KeyManager
+from .core.custom_encoder import CustomEncoder
+
+# High-level interfaces
+from .secure_compressor import SecureCompressor
+from .file_encryptor import FileEncryptor
+from .advanced_encryptor import AdvancedEncryptor
+
+# Enhanced components with native acceleration
+try:
+    from .core.enhanced_compressor import EnhancedCompressor
+    ENHANCED_AVAILABLE = True
+except ImportError:
+    ENHANCED_AVAILABLE = False
+
+# Native library support
+try:
+    from .native.native_loader import (
+        get_native_manager, get_crypto_core, get_hash_algorithms, 
+        is_native_available, NativeLibraryManager
+    )
+    NATIVE_SUPPORT = True
+except ImportError:
+    NATIVE_SUPPORT = False
+
+# Exceptions
+from .exceptions import (
+    EncrypterError,
+    CompressionError,
+    EncryptionError,
+    ValidationError,
+    KeyError,
+    ErrorCodes,
+)
+
+__all__ = [
+    # Version info
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    
+    # Core classes
+    "Compressor",
+    "Encryptor", 
+    "KeyManager",
+    "CustomEncoder",
+    
+    # High-level interfaces
+    "SecureCompressor",
+    "FileEncryptor",
+    "AdvancedEncryptor",
+    
+    # Algorithm types
+    "CompressionAlgorithmType",
+    "CompressionLevel",
+    "EncryptionAlgorithmType",
+    
+    # Exceptions
+    "EncrypterError",
+    "CompressionError",
+    "EncryptionError",
+    "ValidationError",
+    "KeyError",
+    "ErrorCodes",
+    
+    # Feature flags
+    "ENHANCED_AVAILABLE",
+    "NATIVE_SUPPORT",
+]
+
+# Add enhanced components if available
+if ENHANCED_AVAILABLE:
+    __all__.append('EnhancedCompressor')
+
+# Add native library components if available
+if NATIVE_SUPPORT:
+    __all__.extend([
+        'get_native_manager',
+        'get_crypto_core', 
+        'get_hash_algorithms',
+        'is_native_available',
+        'NativeLibraryManager'
+    ])
+
+# Package metadata
+PACKAGE_INFO = {
+    "name": "fastCrypter",
+    "version": __version__,
+    "description": "Professional compression and encryption library with native C/C++ acceleration",
+    "author": __author__,
+    "email": __email__,
+    "license": __license__,
+    "url": "https://github.com/Pymmdrza/fastCrypter",
+    "keywords": [
+        "encryption", "compression", "security", "cryptography",
+        "aes", "chacha20", "rsa", "zlib", "lzma", "brotli",
+        "native", "performance", "c++", "custom-encoding", "fast"
+    ],
+    "features": {
+        "enhanced_compressor": ENHANCED_AVAILABLE,
+        "native_acceleration": NATIVE_SUPPORT,
+        "custom_encoding": True,
+        "multiple_algorithms": True,
+        "file_encryption": True,
+    }
+}
+
+
+def get_version_info():
+    """Get comprehensive version and feature information."""
+    info = PACKAGE_INFO.copy()
+    
+    if NATIVE_SUPPORT:
+        try:
+            manager = get_native_manager()
+            native_info = manager.get_info()
+            info['native_libraries'] = native_info
+        except:
+            info['native_libraries'] = {'error': 'Failed to load native library info'}
+    
+    return info
+
+
+def get_recommended_compressor(password: str, **kwargs):
+    """
+    Get the recommended compressor based on available features.
+    
+    This function automatically selects the best available compressor:
+    - EnhancedCompressor if native libraries are available
+    - SecureCompressor as fallback
+    
+    Args:
+        password (str): Password for encryption.
+        **kwargs: Additional arguments passed to the compressor.
+        
+    Returns:
+        Compressor instance (EnhancedCompressor or SecureCompressor).
+    """
+    if ENHANCED_AVAILABLE and NATIVE_SUPPORT:
+        try:
+            if is_native_available():
+                return EnhancedCompressor(password=password, **kwargs)
+        except:
+            pass
+    
+    # Fallback to standard compressor
+    return SecureCompressor(password=password, **kwargs)
+
+
+def benchmark_available_features(data_size: int = 1024) -> dict:
+    """
+    Benchmark all available features and return performance information.
+    
+    Args:
+        data_size (int): Size of test data in bytes.
+        
+    Returns:
+        dict: Benchmark results for all available features.
+    """
+    import time
+    import secrets
+    
+    results = {
+        'data_size': data_size,
+        'features_tested': [],
+        'performance': {}
+    }
+    
+    test_data = secrets.token_bytes(data_size)
+    password = "BenchmarkPassword123!"
+    
+    # Test standard compressor
+    try:
+        compressor = SecureCompressor(password=password)
+        
+        start_time = time.time()
+        encrypted = compressor.compress_and_encrypt(test_data)
+        decrypted = compressor.decrypt_and_decompress(encrypted)
+        end_time = time.time()
+        
+        results['features_tested'].append('SecureCompressor')
+        results['performance']['standard'] = {
+            'time': end_time - start_time,
+            'correctness': test_data == decrypted,
+            'compression_ratio': len(encrypted) / len(test_data)
+        }
+    except Exception as e:
+        results['performance']['standard'] = {'error': str(e)}
+    
+    # Test enhanced compressor if available
+    if ENHANCED_AVAILABLE:
+        try:
+            enhanced = EnhancedCompressor(password=password)
+            
+            start_time = time.time()
+            encrypted = enhanced.compress_and_encrypt(test_data)
+            decrypted = enhanced.decrypt_and_decompress(encrypted)
+            end_time = time.time()
+            
+            results['features_tested'].append('EnhancedCompressor')
+            results['performance']['enhanced'] = {
+                'time': end_time - start_time,
+                'correctness': test_data == decrypted,
+                'compression_ratio': len(encrypted) / len(test_data),
+                'native_available': enhanced.is_native_available()
+            }
+            
+            # Compare performance
+            if 'standard' in results['performance']:
+                standard_time = results['performance']['standard'].get('time', 0)
+                enhanced_time = results['performance']['enhanced']['time']
+                if enhanced_time > 0:
+                    results['performance']['speedup'] = standard_time / enhanced_time
+            
+        except Exception as e:
+            results['performance']['enhanced'] = {'error': str(e)}
+    
+    # Test native libraries if available
+    if NATIVE_SUPPORT:
+        try:
+            manager = get_native_manager()
+            native_info = manager.get_info()
+            
+            results['features_tested'].append('NativeLibraries')
+            results['performance']['native'] = {
+                'available': native_info.get('crypto_core_loaded', False) or native_info.get('hash_algorithms_loaded', False),
+                'crypto_core': native_info.get('crypto_core_loaded', False),
+                'hash_algorithms': native_info.get('hash_algorithms_loaded', False),
+                'platform': native_info.get('platform', 'unknown')
+            }
+            
+        except Exception as e:
+            results['performance']['native'] = {'error': str(e)}
+    
+    return results
+
+
+# Package initialization message
+def _show_startup_info():
+    """Show package startup information."""
+    features = []
+    
+    if ENHANCED_AVAILABLE:
+        features.append("Enhanced Compressor")
+    
+    if NATIVE_SUPPORT:
+        try:
+            if is_native_available():
+                features.append("Native Acceleration")
+            else:
+                features.append("Native Support (libraries not loaded)")
+        except:
+            features.append("Native Support (error)")
+    
+    if not features:
+        features.append("Standard Features")
+    
+    # Only show in debug mode or if explicitly requested
+    import os
+    if os.environ.get('fastCrypter_SHOW_INFO', '').lower() in ('1', 'true', 'yes'):
+        print(f"🚀 fastCrypter v{__version__} loaded with: {', '.join(features)}")
+
+# Show startup info if requested
+_show_startup_info() 

fastcrypter/advanced_encryptor.py

@@ -0,0 +1,368 @@
+"""
+Advanced Encryptor - Professional interface for advanced encryption scenarios.
+
+This module provides advanced encryption capabilities with full control
+over algorithms, parameters, and security settings.
+"""
+
+from typing import Union, Optional, Dict, Any, List
+from .core.compressor import Compressor, CompressionAlgorithmType
+from .core.encryptor import Encryptor, EncryptionAlgorithmType
+from .core.key_manager import KeyManager
+from .algorithms import CompressionAlgorithm, EncryptionAlgorithm
+from .exceptions import EncrypterError, ValidationError, ErrorCodes
+
+
+class AdvancedEncryptor:
+    """
+    Advanced encryption interface for professional use.
+    
+    This class provides full control over encryption and compression
+    algorithms, security parameters, and advanced features like
+    streaming encryption and custom algorithm implementations.
+    """
+    
+    def __init__(self,
+                 encryption_algorithm: Union[EncryptionAlgorithmType, str, EncryptionAlgorithm] = EncryptionAlgorithmType.AES_256_GCM,
+                 compression_algorithm: Union[CompressionAlgorithmType, str, CompressionAlgorithm] = CompressionAlgorithmType.ZLIB,
+                 key_derivation_algorithm: str = 'pbkdf2',
+                 key_derivation_iterations: int = 100000,
+                 memory_cost: int = 65536,
+                 parallelism: int = 1,
+                 auto_select_algorithms: bool = False):
+        """
+        Initialize the AdvancedEncryptor.
+        
+        Args:
+            encryption_algorithm: Encryption algorithm to use.
+            compression_algorithm: Compression algorithm to use.
+            key_derivation_algorithm: Key derivation function algorithm.
+            key_derivation_iterations: Number of KDF iterations.
+            memory_cost: Memory cost for Scrypt/Argon2.
+            parallelism: Parallelism factor for Argon2.
+            auto_select_algorithms: Whether to automatically select best algorithms.
+        """
+        self.auto_select = auto_select_algorithms
+        
+        # Initialize key manager
+        self.key_manager = KeyManager(
+            kdf_algorithm=key_derivation_algorithm,
+            iterations=key_derivation_iterations,
+            memory_cost=memory_cost,
+            parallelism=parallelism
+        )
+        
+        # Initialize compressor
+        if isinstance(compression_algorithm, CompressionAlgorithm):
+            # Custom algorithm implementation
+            self.custom_compressor = compression_algorithm
+            self.compressor = None
+        else:
+            self.compressor = Compressor(
+                algorithm=compression_algorithm,
+                auto_select=auto_select_algorithms
+            )
+            self.custom_compressor = None
+        
+        # Initialize encryptor
+        if isinstance(encryption_algorithm, EncryptionAlgorithm):
+            # Custom algorithm implementation
+            self.custom_encryptor = encryption_algorithm
+            self.encryptor = None
+        else:
+            self.encryptor = Encryptor(
+                algorithm=encryption_algorithm,
+                derive_key=True
+            )
+            self.custom_encryptor = None
+        
+        # Store configuration
+        self.config = {
+            'encryption_algorithm': encryption_algorithm,
+            'compression_algorithm': compression_algorithm,
+            'key_derivation_algorithm': key_derivation_algorithm,
+            'key_derivation_iterations': key_derivation_iterations,
+            'memory_cost': memory_cost,
+            'parallelism': parallelism,
+            'auto_select_algorithms': auto_select_algorithms,
+        }
+    
+    def process(self, data: Union[str, bytes], password: str, 
+                operation: str = 'encrypt') -> bytes:
+        """
+        Process data with compression and encryption.
+        
+        Args:
+            data: Data to process.
+            password: Password for encryption.
+            operation: Operation to perform ('encrypt' or 'decrypt').
+            
+        Returns:
+            bytes: Processed data.
+            
+        Raises:
+            EncrypterError: If processing fails.
+            ValidationError: If parameters are invalid.
+        """
+        if operation not in ['encrypt', 'decrypt']:
+            raise ValidationError(
+                "Operation must be 'encrypt' or 'decrypt'",
+                ErrorCodes.INVALID_CONFIGURATION
+            )
+        
+        try:
+            if operation == 'encrypt':
+                return self._encrypt_process(data, password)
+            else:
+                return self._decrypt_process(data, password)
+                
+        except Exception as e:
+            raise EncrypterError(
+                f"Advanced processing failed: {str(e)}",
+                details={"operation": operation, "error": str(e)}
+            )
+    
+    def _encrypt_process(self, data: Union[str, bytes], password: str) -> bytes:
+        """Internal encryption process."""
+        # Convert string to bytes if necessary
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+        
+        # Step 1: Compress data
+        if self.custom_compressor:
+            compressed_data = self.custom_compressor.compress(data)
+        else:
+            compressed_data = self.compressor.compress(data)
+        
+        # Step 2: Encrypt compressed data
+        if self.custom_encryptor:
+            # For custom encryptors, we need to derive the key first
+            key, salt = self.key_manager.derive_key(password)
+            encrypted_data = self.custom_encryptor.encrypt(compressed_data, key)
+            # Add salt to the beginning for custom encryptors
+            return salt + encrypted_data
+        else:
+            return self.encryptor.encrypt(compressed_data, password)
+    
+    def _decrypt_process(self, data: bytes, password: str) -> bytes:
+        """Internal decryption process."""
+        # Step 1: Decrypt data
+        if self.custom_encryptor:
+            # For custom encryptors, extract salt and derive key
+            salt = data[:16]  # Assume 16-byte salt
+            encrypted_data = data[16:]
+            key, _ = self.key_manager.derive_key(password, salt)
+            decrypted_data = self.custom_encryptor.decrypt(encrypted_data, key)
+        else:
+            decrypted_data = self.encryptor.decrypt(data, password)
+        
+        # Step 2: Decompress decrypted data
+        if self.custom_compressor:
+            return self.custom_compressor.decompress(decrypted_data)
+        else:
+            return self.compressor.decompress(decrypted_data)
+    
+    def stream_processor(self, password: str, operation: str = 'encrypt'):
+        """
+        Create a streaming processor for large data.
+        
+        Args:
+            password: Password for encryption.
+            operation: Operation to perform ('encrypt' or 'decrypt').
+            
+        Returns:
+            StreamProcessor: Streaming processor instance.
+        """
+        return StreamProcessor(self, password, operation)
+    
+    def benchmark_algorithms(self, test_data: bytes, password: str) -> Dict[str, Dict[str, Any]]:
+        """
+        Benchmark different algorithm combinations.
+        
+        Args:
+            test_data: Data to use for benchmarking.
+            password: Password for encryption.
+            
+        Returns:
+            Dict[str, Dict[str, Any]]: Benchmark results.
+        """
+        import time
+        
+        results = {}
+        
+        # Test different compression algorithms
+        compression_algos = [
+            CompressionAlgorithmType.ZLIB,
+            CompressionAlgorithmType.LZMA,
+            CompressionAlgorithmType.BROTLI,
+        ]
+        
+        # Test different encryption algorithms
+        encryption_algos = [
+            EncryptionAlgorithmType.AES_256_GCM,
+            EncryptionAlgorithmType.AES_256_CBC,
+            EncryptionAlgorithmType.CHACHA20_POLY1305,
+        ]
+        
+        for comp_algo in compression_algos:
+            for enc_algo in encryption_algos:
+                combo_name = f"{comp_algo.value}+{enc_algo.value}"
+                
+                try:
+                    # Create temporary encryptor
+                    temp_encryptor = AdvancedEncryptor(
+                        encryption_algorithm=enc_algo,
+                        compression_algorithm=comp_algo
+                    )
+                    
+                    # Measure encryption time
+                    start_time = time.time()
+                    encrypted = temp_encryptor.process(test_data, password, 'encrypt')
+                    encrypt_time = time.time() - start_time
+                    
+                    # Measure decryption time
+                    start_time = time.time()
+                    decrypted = temp_encryptor.process(encrypted, password, 'decrypt')
+                    decrypt_time = time.time() - start_time
+                    
+                    # Calculate metrics
+                    compression_ratio = len(encrypted) / len(test_data)
+                    
+                    results[combo_name] = {
+                        'compression_algorithm': comp_algo.value,
+                        'encryption_algorithm': enc_algo.value,
+                        'original_size': len(test_data),
+                        'compressed_encrypted_size': len(encrypted),
+                        'compression_ratio': compression_ratio,
+                        'encrypt_time': encrypt_time,
+                        'decrypt_time': decrypt_time,
+                        'total_time': encrypt_time + decrypt_time,
+                        'throughput_mbps': (len(test_data) / (1024 * 1024)) / (encrypt_time + decrypt_time),
+                        'success': len(decrypted) == len(test_data),
+                    }
+                    
+                except Exception as e:
+                    results[combo_name] = {
+                        'error': str(e),
+                        'success': False,
+                    }
+        
+        return results
+    
+    def get_security_analysis(self) -> Dict[str, Any]:
+        """
+        Get security analysis of current configuration.
+        
+        Returns:
+            Dict[str, Any]: Security analysis results.
+        """
+        analysis = {
+            'encryption_strength': 'Unknown',
+            'compression_efficiency': 'Unknown',
+            'key_derivation_strength': 'Unknown',
+            'overall_security_level': 'Unknown',
+            'recommendations': [],
+        }
+        
+        # Analyze encryption algorithm
+        if self.encryptor:
+            algo = self.encryptor.algorithm
+            if algo in [EncryptionAlgorithmType.AES_256_GCM, EncryptionAlgorithmType.CHACHA20_POLY1305]:
+                analysis['encryption_strength'] = 'Military Grade'
+            elif algo == EncryptionAlgorithmType.AES_256_CBC:
+                analysis['encryption_strength'] = 'High'
+            elif algo == EncryptionAlgorithmType.RSA_4096:
+                analysis['encryption_strength'] = 'Very High'
+        
+        # Analyze key derivation
+        kdf_algo = self.key_manager.kdf_algorithm
+        iterations = self.key_manager.iterations
+        
+        if kdf_algo == 'argon2':
+            analysis['key_derivation_strength'] = 'Excellent'
+        elif kdf_algo == 'scrypt':
+            analysis['key_derivation_strength'] = 'Very Good'
+        elif kdf_algo == 'pbkdf2' and iterations >= 100000:
+            analysis['key_derivation_strength'] = 'Good'
+        else:
+            analysis['key_derivation_strength'] = 'Weak'
+            analysis['recommendations'].append('Increase KDF iterations or use Argon2')
+        
+        # Overall security assessment
+        strengths = [analysis['encryption_strength'], analysis['key_derivation_strength']]
+        if all(s in ['Military Grade', 'Excellent', 'Very High'] for s in strengths):
+            analysis['overall_security_level'] = 'Maximum'
+        elif all(s in ['High', 'Very Good', 'Good'] for s in strengths):
+            analysis['overall_security_level'] = 'High'
+        else:
+            analysis['overall_security_level'] = 'Medium'
+            analysis['recommendations'].append('Consider upgrading algorithms for better security')
+        
+        return analysis
+    
+    def get_info(self) -> Dict[str, Any]:
+        """
+        Get comprehensive information about the AdvancedEncryptor.
+        
+        Returns:
+            Dict[str, Any]: Configuration and analysis information.
+        """
+        info = {
+            'version': '1.0.0',
+            'configuration': self.config,
+            'security_analysis': self.get_security_analysis(),
+        }
+        
+        if self.compressor:
+            info['compressor_info'] = self.compressor.get_info()
+        
+        if self.encryptor:
+            info['encryptor_info'] = self.encryptor.get_info()
+        
+        info['key_manager_info'] = self.key_manager.get_info()
+        
+        return info
+
+
+class StreamProcessor:
+    """
+    Streaming processor for large data encryption/decryption.
+    
+    This class allows processing of large data streams without
+    loading everything into memory at once.
+    """
+    
+    def __init__(self, advanced_encryptor: AdvancedEncryptor, 
+                 password: str, operation: str):
+        """
+        Initialize the StreamProcessor.
+        
+        Args:
+            advanced_encryptor: Parent AdvancedEncryptor instance.
+            password: Password for encryption.
+            operation: Operation to perform ('encrypt' or 'decrypt').
+        """
+        self.encryptor = advanced_encryptor
+        self.password = password
+        self.operation = operation
+        self.chunk_size = 64 * 1024  # 64KB chunks
+    
+    def process(self, chunk: bytes) -> bytes:
+        """
+        Process a data chunk.
+        
+        Args:
+            chunk: Data chunk to process.
+            
+        Returns:
+            bytes: Processed chunk.
+        """
+        return self.encryptor.process(chunk, self.password, self.operation)
+    
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        pass