pyjsclear 0.1.0__py3-none-any.whl

pyjsclear/transforms/expression_simplifier.py

@@ -0,0 +1,403 @@
+"""Evaluate static unary/binary expressions to literals."""
+
+import math
+
+from ..traverser import traverse
+from ..utils.ast_helpers import is_literal
+from ..utils.ast_helpers import make_literal
+from .base import Transform
+
+
+# Sentinel to distinguish JS null (Literal value=None) from JS undefined
+# (Identifier name='undefined'). Python None represents undefined.
+_JS_NULL = object()
+
+_RESOLVABLE_UNARY = {'-', '+', '!', '~', 'typeof', 'void'}
+_RESOLVABLE_BINARY = {
+    '==',
+    '!=',
+    '===',
+    '!==',
+    '<',
+    '<=',
+    '>',
+    '>=',
+    '<<',
+    '>>',
+    '>>>',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '**',
+    '|',
+    '^',
+    '&',
+}
+
+
+class ExpressionSimplifier(Transform):
+    """Simplify constant unary/binary expressions to literals."""
+
+    def execute(self):
+        self._simplify_unary_binary()
+        self._simplify_conditionals()
+        self._simplify_awaits()
+        return self.has_changed()
+
+    def _simplify_unary_binary(self):
+        """Fold constant unary and binary expressions."""
+
+        def enter(node, parent, key, index):
+            match node.get('type', ''):
+                case 'UnaryExpression':
+                    result = self._simplify_unary(node)
+                case 'BinaryExpression':
+                    result = self._simplify_binary(node)
+                case _:
+                    return
+            if result is not None:
+                self.set_changed()
+                return result
+
+        traverse(self.ast, {'enter': enter})
+
+    def _simplify_conditionals(self):
+        """Convert test ? false : true → !test."""
+
+        def enter(node, parent, key, index):
+            if node.get('type') != 'ConditionalExpression':
+                return
+            cons = node.get('consequent')
+            alt = node.get('alternate')
+            if is_literal(cons) and cons.get('value') is False and is_literal(alt) and alt.get('value') is True:
+                self.set_changed()
+                return {
+                    'type': 'UnaryExpression',
+                    'operator': '!',
+                    'prefix': True,
+                    'argument': node['test'],
+                }
+
+        traverse(self.ast, {'enter': enter})
+
+    def _simplify_awaits(self):
+        """Simplify await (0x0, expr) → await expr."""
+
+        def enter(node, parent, key, index):
+            if node.get('type') != 'AwaitExpression':
+                return
+            arg = node.get('argument')
+            if not isinstance(arg, dict) or arg.get('type') != 'SequenceExpression':
+                return
+            exprs = arg.get('expressions', [])
+            if len(exprs) <= 1:
+                return
+            node['argument'] = exprs[-1]
+            self.set_changed()
+
+        traverse(self.ast, {'enter': enter})
+
+    def _simplify_unary(self, node):
+        operator = node.get('operator', '')
+        if operator not in _RESOLVABLE_UNARY:
+            return None
+        # Skip negative numeric literals (already in normal form)
+        if (
+            operator == '-'
+            and is_literal(node.get('argument'))
+            and isinstance(node['argument'].get('value'), (int, float))
+        ):
+            return None
+
+        argument = node.get('argument')
+        argument = self._simplify_expr(argument)
+        value, ok = self._get_resolvable_value(argument)
+        if not ok:
+            return None
+
+        try:
+            result = self._apply_unary(operator, value)
+        except Exception:
+            return None
+        return self._value_to_node(result)
+
+    def _simplify_binary(self, node):
+        operator = node.get('operator', '')
+        if operator not in _RESOLVABLE_BINARY:
+            return None
+
+        left = self._simplify_expr(node.get('left'))
+        right = self._simplify_expr(node.get('right'))
+
+        left_value, left_resolved = self._get_resolvable_value(left)
+        right_value, right_resolved = self._get_resolvable_value(right)
+
+        if not (left_resolved and right_resolved):
+            # Convert x - (-y) to x + y
+            if operator == '-' and self._is_negative_numeric(right):
+                node['right'] = right['argument']
+                node['operator'] = '+'
+                return node
+            return None
+
+        try:
+            result = self._apply_binary(operator, left_value, right_value)
+        except Exception:
+            return None
+        return self._value_to_node(result)
+
+    def _simplify_expr(self, node):
+        if not isinstance(node, dict):
+            return node
+        match node.get('type', ''):
+            case 'UnaryExpression':
+                result = self._simplify_unary(node)
+                return result if result is not None else node
+            case 'BinaryExpression':
+                result = self._simplify_binary(node)
+                return result if result is not None else node
+        return node
+
+    def _is_negative_numeric(self, node):
+        return (
+            isinstance(node, dict)
+            and node.get('type') == 'UnaryExpression'
+            and node.get('operator') == '-'
+            and is_literal(node.get('argument'))
+            and isinstance(node['argument'].get('value'), (int, float))
+        )
+
+    def _get_resolvable_value(self, node):
+        if not isinstance(node, dict):
+            return None, False
+        match node.get('type', ''):
+            case 'Literal':
+                if node.get('regex'):
+                    return None, False
+                value = node.get('value')
+                # Literal with value None is JS null, not undefined
+                return (_JS_NULL if value is None else value), True
+            case 'UnaryExpression' if node.get('operator') == '-':
+                arg = node.get('argument')
+                if is_literal(arg) and isinstance(arg.get('value'), (int, float)):
+                    return -arg['value'], True
+            case 'Identifier' if node.get('name') == 'undefined':
+                return None, True
+            case 'ArrayExpression' if len(node.get('elements', [])) == 0:
+                return [], True
+            case 'ObjectExpression' if len(node.get('properties', [])) == 0:
+                return {}, True
+        return None, False
+
+    def _apply_unary(self, operator, value):
+        match operator:
+            case '-':
+                return -self._js_to_number(value)
+            case '+':
+                return self._js_to_number(value)
+            case '!':
+                return not self._js_truthy(value)
+            case '~':
+                n = self._js_to_number(value)
+                if isinstance(n, float) and math.isnan(n):
+                    return -1  # ~NaN → -1
+                return ~int(n)
+            case 'typeof':
+                return self._js_typeof(value)
+            case 'void':
+                return None  # JS undefined
+
+    def _apply_binary(self, operator, left, right):
+        match operator:
+            case '+':
+                if isinstance(left, str) or isinstance(right, str):
+                    return self._js_to_string(left) + self._js_to_string(right)
+                return self._js_to_number(left) + self._js_to_number(right)
+            case '-':
+                return self._js_to_number(left) - self._js_to_number(right)
+            case '*':
+                return self._js_to_number(left) * self._js_to_number(right)
+            case '/':
+                result = self._js_to_number(right)
+                if result == 0:
+                    raise ValueError('division by zero')
+                return self._js_to_number(left) / result
+            case '%':
+                result = self._js_to_number(right)
+                if result == 0:
+                    raise ValueError('mod by zero')
+                return self._js_to_number(left) % result
+            case '**':
+                return self._js_to_number(left) ** self._js_to_number(right)
+            case '|':
+                return self._js_to_int32(left) | self._js_to_int32(right)
+            case '&':
+                return self._js_to_int32(left) & self._js_to_int32(right)
+            case '^':
+                return self._js_to_int32(left) ^ self._js_to_int32(right)
+            case '<<':
+                return self._js_to_int32(left) << (self._js_to_int32(right) & 31)
+            case '>>':
+                return self._js_to_int32(left) >> (self._js_to_int32(right) & 31)
+            case '>>>':
+                left_operand = self._js_to_int32(left) & 0xFFFFFFFF
+                result = self._js_to_int32(right) & 31
+                return left_operand >> result
+            case '==' | '!=':
+                eq = self._js_abstract_eq(left, right)
+                return eq if operator == '==' else not eq
+            case '===' | '!==':
+                eq = self._js_strict_eq(left, right)
+                return eq if operator == '===' else not eq
+            case '<':
+                return self._js_compare(left, right) < 0
+            case '<=':
+                return self._js_compare(left, right) <= 0
+            case '>':
+                return self._js_compare(left, right) > 0
+            case '>=':
+                return self._js_compare(left, right) >= 0
+            case _:
+                raise ValueError(f'Unknown operator: {operator}')
+
+    def _js_abstract_eq(self, left, right):
+        """JS == (null and undefined are equal to each other only)."""
+        if (left is None or left is _JS_NULL) and (right is None or right is _JS_NULL):
+            return True
+        if left is _JS_NULL or right is _JS_NULL:
+            return False
+        return left == right
+
+    def _js_strict_eq(self, left, right):
+        """JS === (null !== undefined)."""
+        if left is _JS_NULL:
+            return right is _JS_NULL
+        if right is _JS_NULL:
+            return False
+        return left == right and type(left) == type(right)
+
+    def _js_truthy(self, value):
+        if value is None or value is _JS_NULL:
+            return False
+        match value:
+            case bool():
+                return value
+            case int() | float():
+                return value != 0 and not (isinstance(value, float) and math.isnan(value))
+            case str():
+                return len(value) > 0
+            case list() | dict():
+                return True
+            case _:
+                return bool(value)
+
+    def _js_typeof(self, value):
+        if value is _JS_NULL:
+            return 'object'  # typeof null === 'object' in JS
+        if value is None:
+            return 'undefined'
+        match value:
+            case bool():
+                return 'boolean'
+            case int() | float():
+                return 'number'
+            case str():
+                return 'string'
+            case list() | dict():
+                return 'object'
+            case _:
+                return 'undefined'
+
+    def _js_to_int32(self, value):
+        """Coerce to 32-bit integer (for bitwise ops)."""
+        return int(self._js_to_number(value))
+
+    def _js_to_number(self, value):
+        if value is _JS_NULL:
+            return 0  # Number(null) → 0
+        if value is None:
+            return float('nan')  # Number(undefined) → NaN
+        match value:
+            case bool():
+                return 1 if value else 0
+            case int() | float():
+                return value
+            case str():
+                try:
+                    return (
+                        int(value)
+                        if value.isdigit() or (value.startswith('-') and value[1:].isdigit())
+                        else float(value)
+                    )
+                except (ValueError, IndexError):
+                    return 0
+            case list():
+                return 0
+            case _:
+                return 0
+
+    def _js_to_string(self, value):
+        if value is _JS_NULL:
+            return 'null'
+        if value is None:
+            return 'undefined'
+        match value:
+            case bool():
+                return 'true' if value else 'false'
+            case int() | float():
+                return str(int(value)) if isinstance(value, float) and value == int(value) else str(value)
+            case str():
+                return value
+            case list():
+                return ''
+            case dict():
+                return '[object Object]'
+            case _:
+                return str(value)
+
+    def _js_compare(self, left, right):
+        # JS compares strings lexicographically, not numerically
+        if isinstance(left, str) and isinstance(right, str):
+            if left < right:
+                return -1
+            if left > right:
+                return 1
+            return 0
+        left_num = self._js_to_number(left)
+        right_num = self._js_to_number(right)
+        # NaN comparisons always return false in JS; returning NaN
+        # ensures < <= > >= all evaluate to False in the caller.
+        if isinstance(left_num, float) and math.isnan(left_num):
+            return float('nan')
+        if isinstance(right_num, float) and math.isnan(right_num):
+            return float('nan')
+        if left_num < right_num:
+            return -1
+        if left_num > right_num:
+            return 1
+        return 0
+
+    def _value_to_node(self, value):
+        if value is _JS_NULL:
+            return make_literal(None)  # null literal
+        if value is None:
+            return {'type': 'Identifier', 'name': 'undefined'}
+        match value:
+            case bool():
+                return make_literal(value)
+            case int() | float():
+                if isinstance(value, float) and (value != value or math.isinf(value)):
+                    return None
+                if value < 0:
+                    return {
+                        'type': 'UnaryExpression',
+                        'operator': '-',
+                        'prefix': True,
+                        'argument': make_literal(abs(value)),
+                    }
+                return make_literal(value)
+            case str():
+                return make_literal(value)
+        return None

pyjsclear/transforms/hex_escapes.py

@@ -0,0 +1,68 @@
+"""Decode \\xHH hex escape sequences in string literals."""
+
+import re
+
+from ..traverser import traverse
+from .base import Transform
+
+
+class HexEscapes(Transform):
+    """Pre-AST regex pass to decode hex escape sequences."""
+
+    def execute(self):
+        # This works on the raw source before/after AST
+        # But since we operate on AST, we decode hex in string literal raw values
+
+        def enter(node, parent, key, index):
+            if node.get('type') != 'Literal' or not isinstance(node.get('value'), str):
+                return
+            raw_string = node.get('raw', '')
+            if '\\x' not in raw_string and '\\u' not in raw_string:
+                return
+            # The value is already decoded by parser, just fix raw
+            value = node['value']
+            new_raw = (
+                '"'
+                + value.replace('\\', '\\\\')
+                .replace('"', '\\"')
+                .replace('\n', '\\n')
+                .replace('\r', '\\r')
+                .replace('\t', '\\t')
+                + '"'
+            )
+            if new_raw != raw_string:
+                node['raw'] = new_raw
+                self.set_changed()
+
+        traverse(self.ast, {'enter': enter})
+        return self.has_changed()
+
+
+def decode_hex_escapes_source(code):
+    """Decode hex escapes in source code string (pre-parse pass).
+
+    Only decodes hex escapes that produce printable characters (0x20-0x7e),
+    excluding the backslash (0x5c) and quote characters which would break
+    string literal syntax. Control characters (newlines, tabs, nulls etc.)
+    are left as \\xHH to avoid breaking the parser.
+    """
+
+    def replace_in_string(match_result):
+        quote = match_result.group(1)
+        content = match_result.group(2)
+
+        # Decode hex escapes, but skip backslash, both quote chars,
+        # and control chars. Quote chars are left for AST-level handling
+        # which normalizes to double quotes like Babel.
+        def replace_hex_in_context(hex_match):
+            value = int(hex_match.group(1), 16)
+            if 0x20 <= value <= 0x7E and value not in (0x22, 0x27, 0x5C):
+                return chr(value)
+            return hex_match.group(0)
+
+        decoded = re.sub(r'\\x([0-9a-fA-F]{2})', replace_hex_in_context, content)
+        return quote + decoded + quote
+
+    # Match string literals and decode hex escapes within them
+    result = re.sub(r"""(['"])((?:(?!\1|\\).|\\.)*?)\1""", replace_in_string, code)
+    return result

pyjsclear/transforms/jj_decode.py

@@ -0,0 +1,91 @@
+"""JJEncode decoder.
+
+JJEncode encodes JavaScript using $ and _ variable manipulations.
+This decoder uses Node.js subprocess since JJEncode requires
+JavaScript execution to fully resolve the symbol table.
+"""
+
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+
+
+# Detection patterns for JJEncode
+_JJENCODE_PATTERNS = [
+    re.compile(r'\$=~\[\];'),
+    re.compile(r'\$\$=\{___:\+\+\$'),
+    re.compile(r'\$\$\$=\(\$\[\$\]\+""\)\[\$\]'),
+    re.compile(r'[\$_]{3,}.*[\[\]]{2,}.*[\+!]{2,}'),
+]
+
+
+def is_jj_encoded(code):
+    """Check if code is JJEncoded."""
+    first_line = code.split('\n', 1)[0]
+    return any(p.search(first_line) for p in _JJENCODE_PATTERNS)
+
+
+def jj_decode(code):
+    """Decode JJEncoded JavaScript using Node.js with Function interception."""
+    if not is_jj_encoded(code):
+        return None
+    return _run_with_function_intercept(code)
+
+
+def jj_decode_via_eval(code):
+    """Simpler fallback: just run the JJEncode in Node with Function intercepted."""
+    return _run_with_function_intercept(code)
+
+
+def _run_with_function_intercept(code):
+    """Run JS code with Function constructor intercepted via Proxy."""
+    node = shutil.which('node')
+    if not node:
+        return None
+
+    js_wrapper = (
+        'var _captured = [];\n'
+        'var _origFunction = Function;\n'
+        'var _handler = {\n'
+        '  apply: function(target, thisArg, args) {\n'
+        '    var body = args[args.length - 1];\n'
+        '    if (typeof body === "string" && body.length > 0) _captured.push(body);\n'
+        '    return target.apply(thisArg, args);\n'
+        '  },\n'
+        '  construct: function(target, args) {\n'
+        '    var body = args[args.length - 1];\n'
+        '    if (typeof body === "string" && body.length > 0) _captured.push(body);\n'
+        '    return new target(...args);\n'
+        '  }\n'
+        '};\n'
+        'var _proxyFn = new Proxy(_origFunction, _handler);\n'
+        'Function = _proxyFn;\n'
+        'Function.prototype.constructor = _proxyFn;\n'
+        'Object.getPrototypeOf(function(){}).constructor = _proxyFn;\n'
+        'try {\n' + code + '\n' + '} catch(e) {}\n'
+        'Function = _origFunction;\n'
+        'Function.prototype.constructor = _origFunction;\n'
+        'if (_captured.length > 0) {\n'
+        '  console.log(_captured[_captured.length - 1]);\n'
+        '}\n'
+    )
+
+    try:
+        fd, tmp_path = tempfile.mkstemp(suffix='.js')
+        try:
+            with os.fdopen(fd, 'w') as f:
+                f.write(js_wrapper)
+            result = subprocess.run(
+                [node, tmp_path],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            output = result.stdout.strip()
+            return output if output else None
+        finally:
+            os.unlink(tmp_path)
+    except (subprocess.TimeoutExpired, subprocess.SubprocessError, OSError):
+        return None

pyjsclear/transforms/jsfuck_decode.py

@@ -0,0 +1,93 @@
+"""JSFUCK decoder.
+
+JSFUCK encodes JavaScript using only []()!+ characters.
+Decoding requires JavaScript execution, so we use Node.js subprocess.
+If Node.js is unavailable, returns None (graceful degradation).
+"""
+
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+
+
+# JSFUCK uses only these characters (plus optional whitespace/semicolons)
+_JSFUCK_RE = re.compile(r'^[\s\[\]\(\)!+;]+$')
+
+
+def is_jsfuck(code):
+    """Check if code is JSFUCK-encoded.
+
+    JSFUCK code consists only of []()!+ characters (with optional whitespace/semicolons).
+    We also require minimum length to avoid false positives.
+    """
+    stripped = code.strip()
+    if len(stripped) < 100:
+        return False
+    # Check if code starts with JSFUCK-style patterns
+    # Some JSFUCK variants have a preamble (like $ = String.fromCharCode(...))
+    # so we check if the majority of the code is JSFUCK chars
+    jsfuck_chars = set('[]()!+ \t\n\r;')
+    jsfuck_count = sum(1 for c in stripped if c in jsfuck_chars)
+    return jsfuck_count / len(stripped) > 0.9
+
+
+def jsfuck_decode(code):
+    """Decode JSFUCK-encoded JavaScript using Node.js. Returns decoded string or None."""
+    node = shutil.which('node')
+    if not node:
+        return None
+
+    stripped = code.strip()
+
+    # Strategy: JSFUCK gets Function via []['flat']['constructor'] or similar
+    # prototype chain access. We intercept by patching Function.prototype.constructor
+    # and wrapping the code to capture what gets passed to Function().
+    js_wrapper = (
+        'var _captured = [];\n'
+        'var _origFunction = Function;\n'
+        # Patch the prototype chain so JSFUCK's []['constructor']['constructor'] is intercepted
+        'var _handler = {\n'
+        '  apply: function(target, thisArg, args) {\n'
+        '    var body = args[args.length - 1];\n'
+        '    if (typeof body === "string" && body.length > 0) _captured.push(body);\n'
+        '    return target.apply(thisArg, args);\n'
+        '  },\n'
+        '  construct: function(target, args) {\n'
+        '    var body = args[args.length - 1];\n'
+        '    if (typeof body === "string" && body.length > 0) _captured.push(body);\n'
+        '    return new target(...args);\n'
+        '  }\n'
+        '};\n'
+        'var _proxyFn = new Proxy(_origFunction, _handler);\n'
+        'Function = _proxyFn;\n'
+        'Function.prototype.constructor = _proxyFn;\n'
+        # Patch common prototype chains JSFUCK uses
+        'Object.getPrototypeOf(function(){}).constructor = _proxyFn;\n'
+        'try {\n' + stripped + '\n' + '} catch(e) {}\n'
+        'Function = _origFunction;\n'
+        'Function.prototype.constructor = _origFunction;\n'
+        'if (_captured.length > 0) {\n'
+        '  console.log(_captured[_captured.length - 1]);\n'
+        '}\n'
+    )
+
+    try:
+        # Write to temp file to avoid shell arg length limits
+        fd, tmp_path = tempfile.mkstemp(suffix='.js')
+        try:
+            with os.fdopen(fd, 'w') as f:
+                f.write(js_wrapper)
+            result = subprocess.run(
+                [node, tmp_path],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            output = result.stdout.strip()
+            return output if output else None
+        finally:
+            os.unlink(tmp_path)
+    except (subprocess.TimeoutExpired, subprocess.SubprocessError, OSError):
+        return None