pyjsclear 0.1.0__py3-none-any.whl

pyjsclear/parser.py

@@ -0,0 +1,46 @@
+"""JavaScript parser wrapper around esprima2."""
+
+import re
+
+import esprima
+
+
+_ASYNC_MAP = {'isAsync': 'async', 'allowAwait': 'await'}
+
+
+def _fast_to_dict(obj):
+    """Convert esprima AST objects to plain dicts, ~2x faster than toDict()."""
+    if isinstance(obj, (str, int, float, bool, type(None))):
+        return obj
+    if isinstance(obj, list):
+        return [_fast_to_dict(item) for item in obj]
+    if isinstance(obj, re.Pattern):
+        return {}
+    # Object with __dict__ (esprima node)
+    result_dict = obj if isinstance(obj, dict) else obj.__dict__
+    output = {}
+    for key, value in result_dict.items():
+        if key.startswith('_'):
+            continue
+        if key == 'optional' and value is False:
+            continue
+        key = _ASYNC_MAP.get(key, key)
+        output[key] = _fast_to_dict(value)
+    return output
+
+
+def parse(code):
+    """Parse JavaScript code into an ESTree-compatible AST.
+
+    Returns a Program node (dict).
+    Raises SyntaxError on parse failure.
+    """
+    try:
+        return _fast_to_dict(esprima.parseScript(code))
+    except esprima.Error:
+        try:
+            return _fast_to_dict(esprima.parseModule(code))
+        except Exception as e:
+            raise SyntaxError(f'Failed to parse JavaScript: {e}') from e
+    except Exception as e:
+        raise SyntaxError(f'Failed to parse JavaScript: {e}') from e

pyjsclear/scope.py

@@ -0,0 +1,283 @@
+"""Variable scope and binding analysis for ESTree ASTs."""
+
+from .utils.ast_helpers import _CHILD_KEYS
+from .utils.ast_helpers import get_child_keys
+
+
+class Binding:
+    """Represents a variable binding in a scope."""
+
+    __slots__ = ('name', 'node', 'kind', 'scope', 'references', 'assignments')
+
+    def __init__(self, name, node, kind, scope):
+        self.name = name
+        self.node = node  # The declaration node
+        self.kind = kind  # 'var', 'let', 'const', 'function', 'param'
+        self.scope = scope
+        self.references = []  # List of (node, parent, key, index) where name is referenced
+        self.assignments = []  # List of assignment nodes
+
+    @property
+    def is_constant(self):
+        """True if the binding is never reassigned after declaration."""
+        if self.kind == 'const':
+            return True
+        if self.kind == 'function':
+            return len(self.assignments) == 0
+        # var/let/param: constant if exactly one init and no reassignments
+        return len(self.assignments) == 0
+
+
+class Scope:
+    """Represents a lexical scope."""
+
+    __slots__ = ('parent', 'node', 'bindings', 'children', 'is_function')
+
+    def __init__(self, parent, node, is_function=False):
+        self.parent = parent
+        self.node = node
+        self.bindings = {}  # name -> Binding
+        self.children = []
+        self.is_function = is_function
+        if parent:
+            parent.children.append(self)
+
+    def add_binding(self, name, node, kind):
+        binding = Binding(name, node, kind, self)
+        self.bindings[name] = binding
+        return binding
+
+    def get_binding(self, name):
+        """Look up a binding, walking up the scope chain."""
+        if name in self.bindings:
+            return self.bindings[name]
+        if self.parent:
+            return self.parent.get_binding(name)
+        return None
+
+    def get_own_binding(self, name):
+        return self.bindings.get(name)
+
+
+def _nearest_function_scope(scope):
+    """Walk up to the nearest function (or root) scope."""
+    while scope and not scope.is_function:
+        scope = scope.parent
+    return scope
+
+
+def _is_non_reference_identifier(parent, parent_key):
+    """Return True if this Identifier usage is not a variable reference."""
+    if not parent:
+        return False
+    parent_type = parent.get('type')
+    # Property names in member expressions (non-computed)
+    if parent_type == 'MemberExpression' and parent_key == 'property' and not parent.get('computed'):
+        return True
+    # Property keys in object literals (non-computed)
+    if parent_type == 'Property' and parent_key == 'key' and not parent.get('computed'):
+        return True
+    # Function/class names at declaration site
+    if parent_type in ('FunctionDeclaration', 'FunctionExpression', 'ClassDeclaration') and parent_key == 'id':
+        return True
+    # VariableDeclarator id
+    if parent_type == 'VariableDeclarator' and parent_key == 'id':
+        return True
+    return False
+
+
+def _recurse_into_children(node, child_keys_map, callback):
+    """Walk child nodes, calling callback(child_node) for each dict with 'type'."""
+    node_type = node.get('type')
+    child_keys = child_keys_map.get(node_type)
+    if child_keys is None:
+        child_keys = get_child_keys(node)
+    for key in child_keys:
+        child = node.get(key)
+        if child is None:
+            continue
+        if isinstance(child, list):
+            for item in child:
+                if isinstance(item, dict) and 'type' in item:
+                    callback(item)
+        elif isinstance(child, dict) and 'type' in child:
+            callback(child)
+
+
+def build_scope_tree(ast):
+    """Build a scope tree from an AST, collecting bindings and references.
+
+    Returns the root Scope and a dict mapping node id -> Scope.
+    """
+    root_scope = Scope(None, ast, is_function=True)
+    # Maps id(node) -> scope for function/block scope nodes
+    node_scope = {id(ast): root_scope}
+    # We need to collect all declarations first, then references
+    all_scopes = [root_scope]
+
+    def _get_scope_for(node, current_scope):
+        """Get or create the scope for a node."""
+        node_id = id(node)
+        if node_id in node_scope:
+            return node_scope[node_id]
+        return current_scope
+
+    _child_keys_map = _CHILD_KEYS
+
+    def _collect_declarations(node, scope):
+        """Walk the AST collecting variable declarations into scopes."""
+        if not isinstance(node, dict):
+            return
+        node_type = node.get('type')
+        if node_type is None:
+            return
+
+        # Create new scope for functions
+        if node_type in (
+            'FunctionDeclaration',
+            'FunctionExpression',
+            'ArrowFunctionExpression',
+        ):
+            new_scope = Scope(scope, node, is_function=True)
+            node_scope[id(node)] = new_scope
+            all_scopes.append(new_scope)
+
+            # Function name goes in outer scope (for declarations) or inner (for expressions)
+            if node_type == 'FunctionDeclaration' and node.get('id'):
+                scope.add_binding(node['id']['name'], node, 'function')
+            elif node_type == 'FunctionExpression' and node.get('id'):
+                new_scope.add_binding(node['id']['name'], node, 'function')
+
+            # Params go in function scope
+            for param in node.get('params', []):
+                if param.get('type') == 'Identifier':
+                    new_scope.add_binding(param['name'], param, 'param')
+                elif param.get('type') == 'AssignmentPattern' and param.get('left', {}).get('type') == 'Identifier':
+                    new_scope.add_binding(param['left']['name'], param, 'param')
+
+            # Body - use the new scope
+            body = node.get('body')
+            if not body:
+                return
+            if isinstance(body, dict) and body.get('type') == 'BlockStatement':
+                node_scope[id(body)] = new_scope
+                for statement in body.get('body', []):
+                    _collect_declarations(statement, new_scope)
+            else:
+                _collect_declarations(body, new_scope)
+            return
+
+        # Variable declarations
+        if node_type == 'VariableDeclaration':
+            kind = node.get('kind', 'var')
+            # var is function-scoped, let/const are block-scoped
+            target_scope = (_nearest_function_scope(scope) or scope) if kind == 'var' else scope
+            for declaration in node.get('declarations', []):
+                declaration_id = declaration.get('id')
+                if declaration_id and declaration_id.get('type') == 'Identifier':
+                    target_scope.add_binding(declaration_id['name'], declaration, kind)
+                # Handle destructuring patterns
+                _collect_pattern_names(declaration_id, target_scope, kind, declaration)
+            return
+
+        # Block scopes (for, if, etc. with block statements)
+        if node_type == 'BlockStatement' and id(node) not in node_scope:
+            # Only create block scope if parent is not a function (handled above)
+            new_scope = Scope(scope, node)
+            node_scope[id(node)] = new_scope
+            all_scopes.append(new_scope)
+            for statement in node.get('body', []):
+                _collect_declarations(statement, new_scope)
+            return
+
+        if node_type == 'ForStatement':
+            new_scope = Scope(scope, node)
+            node_scope[id(node)] = new_scope
+            all_scopes.append(new_scope)
+            if node.get('init'):
+                _collect_declarations(node['init'], new_scope)
+            if node.get('body'):
+                _collect_declarations(node['body'], new_scope)
+            return
+
+        # Recurse into children
+        _recurse_into_children(node, _child_keys_map, lambda child_node: _collect_declarations(child_node, scope))
+
+    def _collect_pattern_names(pattern, scope, kind, declaration):
+        """Collect binding names from destructuring patterns."""
+        if not isinstance(pattern, dict):
+            return
+        match pattern.get('type', ''):
+            case 'ArrayPattern':
+                for element in pattern.get('elements', []):
+                    if not element:
+                        continue
+                    if element.get('type') == 'Identifier':
+                        scope.add_binding(element['name'], declaration, kind)
+                    else:
+                        _collect_pattern_names(element, scope, kind, declaration)
+            case 'ObjectPattern':
+                for property_node in pattern.get('properties', []):
+                    value_node = property_node.get('value', property_node.get('argument'))
+                    if not value_node:
+                        continue
+                    if value_node.get('type') == 'Identifier':
+                        scope.add_binding(value_node['name'], declaration, kind)
+                    else:
+                        _collect_pattern_names(value_node, scope, kind, declaration)
+            case 'RestElement':
+                argument_node = pattern.get('argument')
+                if argument_node and argument_node.get('type') == 'Identifier':
+                    scope.add_binding(argument_node['name'], declaration, kind)
+            case 'AssignmentPattern':
+                left = pattern.get('left')
+                if left and left.get('type') == 'Identifier':
+                    scope.add_binding(left['name'], declaration, kind)
+
+    _collect_declarations(ast, root_scope)
+
+    # Second pass: collect references and assignments
+    def _collect_references(node, scope, parent=None, parent_key=None, parent_index=None):
+        if not isinstance(node, dict):
+            return
+        node_type = node.get('type')
+        if node_type is None:
+            return
+
+        # Look up scope for this node
+        scope = _get_scope_for(node, scope)
+
+        if node_type == 'Identifier':
+            name = node.get('name', '')
+            if _is_non_reference_identifier(parent, parent_key):
+                return
+
+            binding = scope.get_binding(name)
+            if not binding:
+                return
+            binding.references.append((node, parent, parent_key, parent_index))
+            if parent and parent.get('type') == 'AssignmentExpression' and parent_key == 'left':
+                binding.assignments.append(parent)
+            elif parent and parent.get('type') == 'UpdateExpression':
+                binding.assignments.append(parent)
+            return
+
+        # Recurse — can't use _recurse_into_children here because we need
+        # per-child (key, index) args for reference tracking
+        child_keys = _child_keys_map.get(node_type)
+        if child_keys is None:
+            child_keys = get_child_keys(node)
+        for key in child_keys:
+            child = node.get(key)
+            if child is None:
+                continue
+            if isinstance(child, list):
+                for i, item in enumerate(child):
+                    if isinstance(item, dict) and 'type' in item:
+                        _collect_references(item, scope, node, key, i)
+            elif isinstance(child, dict) and 'type' in child:
+                _collect_references(child, scope, node, key, None)
+
+    _collect_references(ast, root_scope)
+
+    return root_scope, node_scope

pyjsclear/transforms/aa_decode.py

@@ -0,0 +1,83 @@
+"""AAEncode decoder.
+
+AAEncode encodes JavaScript using Japanese-style emoticons.
+This decoder reverses the encoding by replacing emoticon patterns
+with their numeric values, then converting octal/hex to characters.
+"""
+
+import re
+
+
+# The 16 AAEncode symbol table entries (indices 0-15)
+_AA_SYMBOLS = [
+    '(c^_^o)',
+    '(\uff9f\u0398\uff9f)',
+    '((o^_^o) - (\uff9f\u0398\uff9f))',
+    '(o^_^o)',
+    '(\uff9f\uff70\uff9f)',
+    '((\uff9f\uff70\uff9f) + (\uff9f\u0398\uff9f))',
+    '((o^_^o) +(o^_^o))',
+    '((\uff9f\uff70\uff9f) + (o^_^o))',
+    '((\uff9f\uff70\uff9f) + (\uff9f\uff70\uff9f))',
+    '((\uff9f\uff70\uff9f) + (\uff9f\uff70\uff9f) + (\uff9f\u0398\uff9f))',
+    '(\uff9f\u0414\uff9f) .\uff9f\u03c9\uff9f\uff89',
+    '(\uff9f\u0414\uff9f) .\uff9f\u0398\uff9f\uff89',
+    "(\uff9f\u0414\uff9f) ['c']",
+    '(\uff9f\u0414\uff9f) .\uff9f\uff70\uff9f\uff89',
+    '(\uff9f\u0414\uff9f) .\uff9f\u0414\uff9f\uff89',
+    '(\uff9f\u0414\uff9f) [\uff9f\u0398\uff9f]',
+]
+
+# Detection pattern: AAEncoded code contains these characteristic markers
+_AA_DETECT_RE = re.compile(r'\(\uff9f\u0414\uff9f\)\s*\[\uff9f\u03b5\uff9f\]')  # (ﾟДﾟ)[ﾟεﾟ]
+
+# Unicode marker for hex characters (code points > 127)
+_UNICODE_MARKER = '(o\uff9f\uff70\uff9fo)+ '
+
+
+def is_aa_encoded(code):
+    """Check if code is AAEncoded."""
+    return bool(_AA_DETECT_RE.search(code))
+
+
+def aa_decode(code):
+    """Decode AAEncoded JavaScript. Returns decoded string or None on failure."""
+    if not is_aa_encoded(code):
+        return None
+
+    try:
+        text = code
+        # Replace each symbol with its numeric value
+        for i, symbol in enumerate(_AA_SYMBOLS):
+            search = symbol + '+ '
+            replacement = str(i) if i <= 7 else format(i, 'x')
+            text = text.replace(search, replacement)
+
+        # Remove the trailing execution wrapper
+        text = text.replace("(\uff9f\u0414\uff9f)[\uff9fo\uff9f]) (\uff9f\u0398\uff9f)) ('_');", '')
+        text = text.replace(
+            "(\uff9f\u0414\uff9f)[\uff9fo\uff9f])(\uff9f\u0398\uff9f))((\uff9f\u0398\uff9f)+(\uff9f\u0414\uff9f)[\uff9f\u03b5\uff9f]+((\uff9f\uff70\uff9f)+(\uff9f\u0398\uff9f))+(\uff9f\u0398\uff9f)+(\uff9f\u0414\uff9f)[\uff9fo\uff9f]);",
+            '',
+        )
+
+        # Split on the escape marker
+        parts = text.split('(\uff9f\u0414\uff9f)[\uff9f\u03b5\uff9f]+')
+
+        result = ''
+        for part in parts[1:]:  # Skip the preamble
+            part = part.strip()
+            if not part:
+                continue
+            if part.startswith(_UNICODE_MARKER):
+                # Unicode character: parse as hex
+                hex_str = part[len(_UNICODE_MARKER) :].strip().rstrip('+').strip()
+                result += chr(int(hex_str, 16))
+            else:
+                # ASCII character: parse as octal
+                octal_str = part.strip().rstrip('+').strip()
+                if octal_str:
+                    result += chr(int(octal_str, 8))
+
+        return result if result else None
+    except (ValueError, IndexError):
+        return None

pyjsclear/transforms/anti_tamper.py

@@ -0,0 +1,106 @@
+"""Remove anti-tamper, self-defending, and debug protection patterns.
+
+Detects common obfuscator.io patterns:
+- Self-defending functions (check if code was modified)
+- Debug protection (infinite debugger loops)
+- Console output disabling
+"""
+
+import re
+
+from ..generator import generate
+from ..traverser import REMOVE
+from ..traverser import traverse
+from .base import Transform
+
+
+class AntiTamperRemover(Transform):
+    """Remove self-defending, debug protection, and console-disabling code."""
+
+    rebuild_scope = True
+
+    # Patterns to match in generated code for suspicious IIFEs
+    _SELF_DEFENDING_PATTERNS = [
+        re.compile(r'constructor\s*\(\s*\)\s*\.\s*constructor\s*\('),
+        re.compile(r'toString\s*\(\s*\)\s*\.\s*search'),
+        re.compile(r'prototype\s*\.\s*toString'),
+        re.compile(r'__proto__'),
+    ]
+
+    _DEBUG_PATTERNS = [
+        re.compile(r'\bdebugger\b'),
+        re.compile(r'setInterval\s*\('),
+    ]
+
+    _CONSOLE_PATTERNS = [
+        re.compile(r'console\s*\[\s*[\'"](?:log|warn|error|info|debug|trace|exception|table)'),
+        re.compile(r'console\s*\.\s*(?:log|warn|error|info|debug|trace|exception|table)\s*='),
+    ]
+
+    @staticmethod
+    def _extract_iife_call(expr):
+        """Extract a CallExpression from an IIFE pattern."""
+        if expr.get('type') == 'CallExpression':
+            return expr
+        if expr.get('type') == 'UnaryExpression' and expr.get('argument', {}).get('type') == 'CallExpression':
+            return expr.get('argument')
+        return None
+
+    def _matches_anti_tamper_pattern(self, src):
+        """Check if source matches any anti-tamper pattern."""
+        for pattern in self._SELF_DEFENDING_PATTERNS:
+            if pattern.search(src):
+                return True
+        if any(p.search(src) for p in self._DEBUG_PATTERNS):
+            if re.search(r'\bdebugger\b', src) and (re.search(r'\bwhile\b|\bfor\b|\bsetInterval\b', src)):
+                return True
+        for pattern in self._CONSOLE_PATTERNS:
+            if pattern.search(src):
+                return True
+        return False
+
+    def execute(self):
+        nodes_to_remove = []
+
+        def enter(node, parent, key, index):
+            if node.get('type') != 'ExpressionStatement':
+                return
+            expr = node.get('expression')
+            if not expr:
+                return
+
+            call = self._extract_iife_call(expr)
+            if not call:
+                return
+
+            callee = call.get('callee')
+            if not callee:
+                return
+            if callee.get('type') not in (
+                'FunctionExpression',
+                'ArrowFunctionExpression',
+            ):
+                return
+
+            try:
+                source_code = generate(callee)
+            except Exception:
+                return
+
+            if self._matches_anti_tamper_pattern(source_code):
+                nodes_to_remove.append(node)
+
+        traverse(self.ast, {'enter': enter})
+
+        # Remove flagged nodes
+        if nodes_to_remove:
+            remove_set = set(id(n) for n in nodes_to_remove)
+
+            def remover(node, parent, key, index):
+                if id(node) in remove_set:
+                    self.set_changed()
+                    return REMOVE
+
+            traverse(self.ast, {'enter': remover})
+
+        return self.has_changed()

pyjsclear/transforms/base.py

@@ -0,0 +1,24 @@
+"""Base transform class."""
+
+
+class Transform:
+    """Base class for all AST transforms."""
+
+    # Subclasses can set this to True to trigger scope rebuild after execution
+    rebuild_scope = False
+
+    def __init__(self, ast, scope_tree=None, node_scope=None):
+        self.ast = ast
+        self.scope_tree = scope_tree
+        self.node_scope = node_scope
+        self._changed = False
+
+    def execute(self):
+        """Execute the transform. Returns True if the AST was modified."""
+        raise NotImplementedError
+
+    def set_changed(self):
+        self._changed = True
+
+    def has_changed(self):
+        return self._changed

pyjsclear/transforms/constant_prop.py

@@ -0,0 +1,103 @@
+"""Constant propagation — replace references to constant variables with their literal values."""
+
+from ..scope import build_scope_tree
+from ..traverser import REMOVE
+from ..traverser import SKIP
+from ..traverser import traverse
+from ..utils.ast_helpers import deep_copy
+from ..utils.ast_helpers import is_literal
+from .base import Transform
+
+
+def _should_skip_reference(ref_parent, ref_key):
+    """Return True if this reference should not be replaced with its literal value."""
+    if not ref_parent:
+        return True
+    match ref_parent.get('type'):
+        case 'AssignmentExpression' if ref_key == 'left':
+            return True
+        case 'UpdateExpression':
+            return True
+        case 'VariableDeclarator' if ref_key == 'id':
+            return True
+    return False
+
+
+class ConstantProp(Transform):
+    """Find `const x = <literal>` and replace all references with the literal."""
+
+    rebuild_scope = True
+
+    def execute(self):
+        scope_tree, node_scope = build_scope_tree(self.ast)
+
+        replacements = dict(self._iter_constant_bindings(scope_tree))
+        if not replacements:
+            return False
+
+        bindings_replaced = self._replace_references(replacements)
+        self._remove_fully_propagated(replacements, bindings_replaced)
+        return self.has_changed()
+
+    def _iter_constant_bindings(self, scope):
+        """Yield (binding_id, (binding, literal)) for constant bindings with literal values."""
+        for name, binding in scope.bindings.items():
+            if not binding.is_constant:
+                continue
+            node = binding.node
+            if not isinstance(node, dict) or node.get('type') != 'VariableDeclarator':
+                continue
+            init_val = node.get('init')
+            if not init_val or not is_literal(init_val):
+                continue
+            yield id(binding), (binding, init_val)
+
+        for child in scope.children:
+            yield from self._iter_constant_bindings(child)
+
+    def _replace_references(self, replacements):
+        """Replace all qualifying references with their literal values."""
+        bindings_replaced = set()
+        for bind_id, (binding, literal) in replacements.items():
+            for ref_node, ref_parent, ref_key, ref_index in binding.references:
+                if _should_skip_reference(ref_parent, ref_key):
+                    continue
+                new_node = deep_copy(literal)
+                if ref_index is not None:
+                    ref_parent[ref_key][ref_index] = new_node
+                else:
+                    ref_parent[ref_key] = new_node
+                self.set_changed()
+                bindings_replaced.add(bind_id)
+        return bindings_replaced
+
+    def _remove_fully_propagated(self, replacements, bindings_replaced):
+        """Remove declarations whose bindings were fully propagated."""
+        for bind_id in bindings_replaced:
+            binding = replacements[bind_id][0]
+            if binding.assignments:
+                continue
+            decl_node = binding.node
+            if not isinstance(decl_node, dict):
+                continue
+            if decl_node.get('type') != 'VariableDeclarator':
+                continue
+            self._remove_declarator(decl_node)
+
+    def _remove_declarator(self, declarator_node):
+        """Remove a VariableDeclarator from its parent VariableDeclaration."""
+
+        def enter(node, parent, key, index):
+            if node.get('type') != 'VariableDeclaration':
+                return
+            decls = node.get('declarations', [])
+            for i, declaration in enumerate(decls):
+                if declaration is not declarator_node:
+                    continue
+                decls.pop(i)
+                self.set_changed()
+                if not decls:
+                    return REMOVE
+                return SKIP
+
+        traverse(self.ast, {'enter': enter})