knightcrypt 4.0.0__py3-none-any.whl

knightcrypt/__init__.py

@@ -0,0 +1,53 @@
+"""
+Author: Sancho (@sanchoforza / @gloriasancho on Discord)
+Version: 1.0.0
+License: MIT
+"""
+
+__version__ = "1.0.0"
+__author__ = "Sancho"
+__discord__ = "@sanchoforza / @gloriasancho"
+__license__ = "MIT"
+
+# Import core classes for easy access
+from knightcrypt.obfuscation import KnightObfuscator
+from knightcrypt.cli import main as cli_main
+
+# Optional: Expose key functions for programmatic use
+def encrypt_file(input_path, output_path=None, key="default", level="low"):
+    """
+    Encrypts a Python file using KnightCrypt.
+    
+    Args:
+        input_path (str): Path to the .py file to encrypt.
+        output_path (str): Optional path for the encrypted output.
+        key (str): Encryption key.
+        level (str): Obfuscation level ('low', 'medium', 'high').
+        
+    Returns:
+        str: Path to the generated encrypted file.
+    """
+    obf = KnightObfuscator(key=key, level=level)
+    return obf.encrypt_file(input_path, output_path)
+
+def decrypt_file(enc_path, key="default"):
+    """
+    Decrypts a KnightCrypt encrypted file.
+    
+    Args:
+        enc_path (str): Path to the .kn encrypted file.
+        key (str): Decryption key.
+        
+    Returns:
+        str: The decrypted source code.
+    """
+    from knightcrypt.runtime import KnightRuntime
+    runtime = KnightRuntime.from_file(enc_path, key)
+    return runtime.decrypt_source()
+ 
+__all__ = [
+    "KnightObfuscator",
+    "encrypt_file",
+    "decrypt_file",
+    "cli_main",
+]

knightcrypt/cli.py

@@ -0,0 +1,39 @@
+# knightcrypt/cli.py
+import sys
+import os
+import argparse
+from knightcrypt.obfuscation import KnightObfuscator
+from knightcrypt.utils import print_banner, log_info, log_success, log_warning, log_error
+
+def main():
+    parser = argparse.ArgumentParser(description="KnightCrypt - Advanced Python Encryption")
+    parser.add_argument("file", help="Python file to encrypt")
+    parser.add_argument("-k", "--key", default="secret", help="Encryption key")
+    parser.add_argument("-o", "--output", help="Output filename (optional)")
+    parser.add_argument("-l", "--level", choices=["low", "medium", "high"], default="high", help="Obfuscation level")
+    
+    args = parser.parse_args()
+    
+    if not os.path.exists(args.file):
+        log_error(f"File not found: {args.file}")
+        sys.exit(1)
+        
+    print_banner()
+    
+    obfuscator = KnightObfuscator(key=args.key, level=args.level)
+    enc_path = obfuscator.encrypt_file(args.file, args.output)
+    
+    # Generate wrapper
+    wrapper_name = os.path.splitext(args.file)[0] + "_run.py"
+    obfuscator.generate_wrapper(enc_path, wrapper_name)
+    
+    log_success(f"Encrypted {args.file} -> {enc_path}")
+    log_success(f"Generated wrapper: {wrapper_name}")
+    log_info(f"Run your app with: python {wrapper_name}")
+    
+    # Display stats
+    if hasattr(obfuscator, 'obfuscation_stats'):
+        log_info(f"Obfuscation Stats: {obfuscator.obfuscation_stats}")
+
+if __name__ == "__main__":
+    main()

knightcrypt/obfuscation.py

@@ -0,0 +1,189 @@
+# knightcrypt/obfuscator.py
+import ast
+import marshal
+import os
+import zlib
+import random
+import string
+import struct
+from knightcrypt.utils import log_info, log_success, log_warning
+
+class VariableRenamer(ast.NodeTransformer):
+    """Renames all variables to random hex strings."""
+    def __init__(self):
+        self.counter = 0
+    
+    def _new_name(self):
+        name = f"_0x{self.counter:x}"
+        self.counter += 1
+        return name
+
+    def visit_Name(self, node):
+        if isinstance(node.ctx, (ast.Store, ast.Load)):
+            new_node = ast.Name(id=self._new_name(), ctx=node.ctx)
+            ast.copy_location(new_node, node)
+            return new_node
+        return node
+
+    def visit_FunctionDef(self, node):
+        # Rename function arguments too
+        for arg in node.args.args:
+            arg.arg = self._new_name()
+        return self.generic_visit(node)
+
+class StringEncryptor(ast.NodeTransformer):
+    """Encrypts all string literals using XOR."""
+    def __init__(self, key="default"):
+        self.key = key
+    
+    def visit_Str(self, node):
+        original_str = node.s
+        encrypted_bytes = bytes([ord(c) ^ ord(self.key[i % len(self.key)]) for i, c in enumerate(original_str)])
+        # Return a call to a helper function that decrypts at runtime
+        # For simplicity, we'll just replace with a decrypted constant
+        # In a real scenario, you'd generate a decryption function
+        return ast.Constant(value=original_str) # Simplified for demo
+
+class ControlFlowFlattener(ast.NodeVisitor):
+    """
+    Converts basic blocks into a switch-case style loop.
+    This makes static analysis very difficult.
+    """
+    def __init__(self):
+        self.blocks = []
+        self.current_block_id = 0
+    
+    def visit_If(self, node):
+        # Create two blocks: one for True, one for False
+        true_block_id = self.current_block_id + 1
+        false_block_id = self.current_block_id + 2
+        
+        self.blocks.append({
+            'id': self.current_block_id,
+            'type': 'if',
+            'condition': ast.unparse(node.test),
+            'true_target': true_block_id,
+            'false_target': false_block_id,
+            'body': [ast.dump(stmt) for stmt in node.body],
+            'orelse': [ast.dump(stmt) for stmt in node.orelse]
+        })
+        
+        self.current_block_id += 3
+        self.visit_children(node)
+
+    def visit_Assign(self, node):
+        self.blocks.append({
+            'id': self.current_block_id,
+            'type': 'assign',
+            'target': ast.unparse(node.targets[0]),
+            'value': ast.unparse(node.value),
+            'next': self.current_block_id + 1
+        })
+        self.current_block_id += 1
+
+    def visit_children(self, node):
+        for child in ast.iter_child_nodes(node):
+            self.visit(child)
+
+    def generate_switch_code(self):
+        """Generates Python code for a switch-case loop."""
+        code = "state = 0\nwhile True:\n"
+        for block in self.blocks:
+            indent = "    "
+            if block['type'] == 'if':
+                code += f"{indent}if state == {block['id']}:\n"
+                code += f"{indent}    if {block['condition']}:\n"
+                code += f"{indent}        state = {block['true_target']}\n"
+                code += f"{indent}    else:\n"
+                code += f"{indent}        state = {block['false_target']}\n"
+            elif block['type'] == 'assign':
+                code += f"{indent}if state == {block['id']}:\n"
+                code += f"{indent}    {block['target']} = {block['value']}\n"
+                code += f"{indent}    state = {block['next']}\n"
+        code += "    break\n"
+        return code
+
+class KnightObfuscator:
+    def __init__(self, key="default_key", level="high"):
+        self.key = key
+        self.level = level  # low, medium, high
+        self.obfuscation_stats = {}
+
+    def obfuscate_source(self, source_code):
+        tree = ast.parse(source_code)
+        
+        # Step 1: Rename Variables
+        renamer = VariableRenamer()
+        tree = renamer.visit(tree)
+        self.obfuscation_stats['variables_renamed'] = renamer.counter
+        
+        # Step 2: Encrypt Strings (Simplified)
+        encryptor = StringEncryptor(key=self.key)
+        tree = encryptor.visit(tree)
+        
+        # Step 3: Flatten Control Flow (if level is high)
+        if self.level == "high":
+            flattener = ControlFlowFlattener()
+            flattener.visit(tree)
+            switch_code = flattener.generate_switch_code()
+            # Append the switch code to the end of the source
+            source_code = source_code + "\n" + switch_code
+            
+        # Step 4: Add Opaque Predicates
+        predicate = "if (hash(str(__name__)) % 2 == 0): pass\n"
+        source_code = predicate + source_code
+        
+        return source_code
+
+    def encrypt_file(self, input_path, output_path=None):
+        if output_path is None:
+            output_path = input_path.replace('.py', '_enc.kn')
+            
+        with open(input_path, 'r') as f:
+            source = f.read()
+            
+        # Obfuscate
+        obfuscated_source = self.obfuscate_source(source)
+        
+        # Compile to bytecode
+        code_obj = compile(obfuscated_source, input_path, 'exec')
+        
+        # Marshal and Compress
+        marshaled = marshal.dumps(code_obj)
+        compressed = zlib.compress(marshaled)
+        
+        # Encrypt with XOR
+        encrypted = bytes([b ^ ord(self.key[i % len(self.key)]) for i, b in enumerate(compressed)])
+        
+        # Write output with header
+        header = len(self.key).to_bytes(2, 'big')
+        key_bytes = self.key.encode('utf-8')
+        
+        with open(output_path, 'wb') as f:
+            f.write(header)
+            f.write(key_bytes)
+            f.write(encrypted)
+            
+        return output_path
+
+    def generate_wrapper(self, enc_filepath, wrapper_name="run_knight.py"):
+        wrapper_content = '''
+import sys
+import os
+from knightcrypt.runtime import load_and_run
+
+def main():
+    enc_path = os.path.join(os.path.dirname(__file__), "{enc_filename}")
+    key = "{key}"
+    try:
+        load_and_run(enc_path, key)
+    except Exception as e:
+        print(f"[-] KnightCrypt Runtime Error: {{e}}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()
+'''.format(enc_filename=os.path.basename(enc_filepath), key=self.key)
+        
+        with open(wrapper_name, 'w') as f:
+            f.write(wrapper_content)

knightcrypt/runtime.py

@@ -0,0 +1,230 @@
+
+import sys
+import os
+import marshal
+import zlib
+import struct
+import hashlib
+import types
+import traceback
+import gc
+import dis
+import time
+import platform
+import subprocess
+import ctypes
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import unpad
+from Crypto.Random import get_random_bytes
+import threading
+import atexit
+
+class KnightRuntimeError(Exception):
+    """Custom exception for KnightCrypt runtime errors."""
+    pass
+
+class KnightRuntime:
+    # Magic bytes to identify valid KnightCrypt files
+    MAGIC_HEADER = b'KNIGHT'
+    VERSION = 1
+    
+    # Known debugger processes
+    DEBUGGER_PROCESSES = ['devenv.exe', 'ida.exe', 'x64dbg.exe', 'ollydbg.exe', 'gdb', 'lldb']
+    
+    def __init__(self, encrypted_data: bytes, key: str):
+        self.encrypted_data = encrypted_data
+        self.key = key
+        self.globals = {}
+        self.locals = {}
+        self._verify_integrity()
+        self._check_debuggers()
+        
+    def _get_key_material(self, password: str) -> tuple:
+        """Derives a 256-bit key and IV from the password using PBKDF2."""
+        salt = b'somegoofyahhshi'  # Fixed salt for consistency in this demo; in production, store it separately or randomize
+        pbkdf2 = hashlib.pbkdf2_hmac('sha256', 
+                                     password.encode('utf-8'), 
+                                     salt, 
+                                     iterations=100000)
+        return pbkdf2[:32], pbkdf2[32:44]  # 32 bytes key + 12 bytes IV
+        
+    def _verify_integrity(self):
+        """Verifies the integrity of the runtime module itself."""
+        # In a production scenario, you would hash the runtime.py file
+        # and compare it against a known good hash embedded here.
+        current_file = os.path.abspath(__file__)
+        with open(current_file, 'rb') as f:
+            content = f.read()
+        current_hash = hashlib.sha256(content).hexdigest()
+        expected_hash = "your_expected_hash_here"  # Replace with actual hash of this file
+        if current_hash != expected_hash:
+            raise KnightRuntimeError("Runtime integrity check failed: File may have been tampered with.")
+        
+    def _check_debuggers(self):
+        """Checks for common debugger processes."""
+        try:
+            if platform.system() == "Windows":
+                import psutil
+                for proc in psutil.process_iter(['name']):
+                    if proc.info['name'].lower() in [db.lower() for db in self.DEBUGGER_PROCESSES]:
+                        raise KnightRuntimeError(f"Debugger detected: {proc.info['name']}")
+            else:
+                # For Linux/Mac, you might use /proc or other methods
+                pass
+        except ImportError:
+            # If psutil is not available, skip this check
+            pass
+            
+    def decrypt_payload(self) -> bytes:
+        """
+        Decrypts the payload using AES-256-GCM.
+        
+        Returns:
+            bytes: Decrypted compressed marshaled code object.
+            
+        Raises:
+            KnightRuntimeError: If decryption fails or integrity check fails.
+        """
+        if not self.encrypted_data:
+            raise KnightRuntimeError("Empty encrypted data")
+            
+        try:
+            # Extract header and ciphertext
+            # Format: [MAGIC(6)] [VERSION(1)] [SALT(8)] [IV(12)] [TAG(16)] [CIPHERTEXT]
+            if len(self.encrypted_data) < 6 + 1 + 8 + 12 + 16:
+                raise KnightRuntimeError("Invalid file format: too short")
+                
+            magic = self.encrypted_data[:6]
+            if magic != self.MAGIC_HEADER:
+                raise KnightRuntimeError(f"Invalid magic header: {magic}")
+                
+            version = self.encrypted_data[6]
+            if version != self.VERSION:
+                raise KnightRuntimeError(f"Unsupported version: {version}")
+                
+            salt = self.encrypted_data[7:15]
+            iv = self.encrypted_data[15:27]
+            tag = self.encrypted_data[27:43]
+            ciphertext = self.encrypted_data[43:]
+            
+            # Derive key from password and salt
+            key, derived_iv = self._get_key_material(self.key)
+            
+            # Use the stored IV for GCM mode
+            cipher = AES.new(key, AES.MODE_GCM, nonce=iv)
+            
+            # Decrypt and verify tag
+            plaintext = cipher.decrypt_and_verify(ciphertext, tag)
+            
+            return plaintext
+            
+        except ValueError as e:
+            raise KnightRuntimeError(f"Decryption failed: Invalid key or corrupted data. {e}")
+        except Exception as e:
+            raise KnightRuntimeError(f"Unexpected error during decryption: {e}")
+            
+    def load_code_object(self, decrypted_data: bytes) -> types.CodeType:
+        """
+        Decompresses and loads the marshaled code object.
+        
+        Args:
+            decrypted_data (bytes): Decrypted compressed data.
+            
+        Returns:
+            types.CodeType: The compiled code object.
+        """
+        try:
+            # Decompress zlib data
+            decompressed = zlib.decompress(decrypted_data)
+            
+            # Load marshaled code object
+            code_obj = marshal.loads(decompressed)
+            
+            if not isinstance(code_obj, types.CodeType):
+                raise KnightRuntimeError("Invalid code object format")
+                
+            return code_obj
+            
+        except Exception as e:
+            raise KnightRuntimeError(f"Failed to load code object: {e}")
+            
+    def execute(self, code_obj: types.CodeType) -> None:
+        """
+        Executes the code object in a controlled environment.
+        
+        Args:
+            code_obj (types.CodeType): The code object to execute.
+        """
+        try:
+            # Create a new frame for isolated execution
+            frame = types.FrameType(
+                code=code_obj,
+                globals=self.globals,
+                locals=self.locals
+            )
+            
+            # Execute the code
+            exec(code_obj, self.globals, self.locals)
+            
+        except Exception as e:
+            print(f"[!] Execution Error: {e}", file=sys.stderr)
+            traceback.print_exc(file=sys.stderr)
+            raise KnightRuntimeError(f"Execution failed: {e}")
+            
+    def run(self) -> None:
+        """Main entry point to decrypt and execute the payload."""
+        try:
+            decrypted_data = self.decrypt_payload()
+            code_obj = self.load_code_object(decrypted_data)
+            self.execute(code_obj)
+        except KnightRuntimeError as e:
+            print(f"[!] KnightCrypt Runtime Error: {e}", file=sys.stderr)
+            sys.exit(1)
+        except Exception as e:
+            print(f"[!] Unexpected Runtime Error: {e}", file=sys.stderr)
+            traceback.print_exc(file=sys.stderr)
+            sys.exit(1)
+        finally:
+            self._cleanup_memory()
+            
+    def _cleanup_memory(self):
+        """Clears sensitive data from memory."""
+        # Clear globals and locals
+        self.globals.clear()
+        self.locals.clear()
+        
+        # Garbage collect
+        gc.collect()
+        
+        # Optionally, overwrite encrypted data with zeros
+        if hasattr(self, 'encrypted_data'):
+            self.encrypted_data = b'\x00' * len(self.encrypted_data)
+
+def load_and_run(filepath: str, key: str) -> None:
+    """
+    Convenience function to load and run an encrypted file.
+    
+    Args:
+        filepath (str): Path to the encrypted .kn file.
+        key (str): Decryption key.
+    """
+    try:
+        with open(filepath, 'rb') as f:
+            encrypted_data = f.read()
+            
+        runtime = KnightRuntime(encrypted_data, key)
+        runtime.run()
+        
+    except FileNotFoundError:
+        print(f"[!] File not found: {filepath}", file=sys.stderr)
+        sys.exit(1)
+    except IOError as e:
+        print(f"[!] I/O Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except KnightRuntimeError as e:
+        print(f"[!] KnightCrypt Runtime Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"[!] Unexpected Error: {e}", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+        sys.exit(1)

knightcrypt/utils.py

@@ -0,0 +1,31 @@
+# knightcrypt/utils.py
+class Colors:
+    HEADER = '\033[95m'
+    BLUE = '\033[94m'
+    CYAN = '\033[96m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+
+def print_banner():
+    print(f"{Colors.CYAN}{'='*50} {Colors.ENDC}")
+    print(f"{Colors.HEADER}  KnightCrypt - Python Library for File Encryption {Colors.ENDC}")
+    print(f"{Colors.CYAN}{'='*50} {Colors.ENDC}")
+    print(f"{Colors.GREEN}[+] Welcome to KnightCrypt! {Colors.ENDC}")
+    print(f"{Colors.YELLOW}[!] Use this library responsibly and ensure you have permission to encrypt/decrypt files. {Colors.ENDC}")
+    print(f"{Colors.CYAN}{'='*50}{Colors.ENDC}")
+
+def log_info(msg):
+    print(f"{Colors.BLUE}[INFO]{Colors.ENDC} {msg}")
+
+def log_success(msg):
+    print(f"{Colors.GREEN}[SUCCESS]{Colors.ENDC} {msg}")
+
+def log_warning(msg):
+    print(f"{Colors.YELLOW}[WARNING]{Colors.ENDC} {msg}")
+
+def log_error(msg):
+    print(f"{Colors.RED}[ERROR]{Colors.ENDC} {msg}")

knightcrypt-4.0.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: knightcrypt
+Version: 4.0.0
+Summary: cool python encryption lib yesyes
+Author: Sancho
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.6
+Requires-Dist: pycryptodome
+Requires-Dist: psutil
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

knightcrypt-4.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+knightcrypt/__init__.py,sha256=dXO26Q5kb1LVxChsX-7bJOk6Ee59a1ZMEqJYb9T-AQ4,1507
+knightcrypt/cli.py,sha256=fV7qRidCL4xFElZRLOz7GEj3z1GPuTsfGkqUcY0S518,1496
+knightcrypt/obfuscation.py,sha256=0DkE8QlJOtmoaCVjlymacXRbUZVZq2YI471uJVPxXP8,6700
+knightcrypt/runtime.py,sha256=oIOb16hU4_2ELnYI3ruhSNIukyC-ALWfYyp1wGMZ0ic,8560
+knightcrypt/utils.py,sha256=vSs4nTC7pL9XWatIaie3be87UAi9pxjkYb5yyEXJjX0,1045
+knightcrypt-4.0.0.dist-info/METADATA,sha256=X9p9_fTDqRGQ_AlZFpuLIAfujf_1vcrWDBJpe0QexZQ,585
+knightcrypt-4.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+knightcrypt-4.0.0.dist-info/entry_points.txt,sha256=TMGcLlvWfwnHxRHCfz_T-tK03GkW2fZ4jLqtBOu53ng,61
+knightcrypt-4.0.0.dist-info/top_level.txt,sha256=WKNDYgL7E6Cb39gowd_4IernmMNbwbLyeXUCUCHRjm0,12
+knightcrypt-4.0.0.dist-info/RECORD,,

knightcrypt-4.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

knightcrypt-4.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+knightcrypt = knightcrypt.knightcrypt:main

knightcrypt-4.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+knightcrypt