diff --git a/crates/untwist-deobfuscate/src/legacy_reach.rs b/crates/untwist-deobfuscate/src/legacy_reach.rs index 466e9d1e..92dc077c 100644 --- a/crates/untwist-deobfuscate/src/legacy_reach.rs +++ b/crates/untwist-deobfuscate/src/legacy_reach.rs @@ -32,6 +32,9 @@ struct Deferral { escape_names: Vec>, escape_names_opened: Vec>, carries_names: bool, + strips: Vec, + strips_failed: bool, + strips_forbidden: bool, reached: bool, } @@ -215,6 +218,84 @@ pub(crate) fn settle_escapes(program: &Program<'_>, scoping: &Scoping) { }); } +fn spans_survive(program: &Program<'_>, spans: &[Span]) -> bool { + let mut surviving = Surviving { + spans, + found: Vec::new(), + unnamed: false, + }; + surviving.visit_program(program); + surviving.unnamed || !surviving.found.is_empty() +} + +pub fn settle_late_escapes(program: &Program<'_>) { + let (names, strips) = DEFERRAL.with(|deferral| { + let mut deferral = deferral.borrow_mut(); + ( + std::mem::take(&mut deferral.escape_names), + std::mem::take(&mut deferral.strips), + ) + }); + if !names.is_empty() { + let mut present = Names::default(); + present.visit_program(program); + let kept: Vec> = names + .into_iter() + .filter(|group| group.iter().any(|name| present.present.contains(name))) + .collect(); + DEFERRAL.with(|deferral| deferral.borrow_mut().escape_names = kept); + } + if !strips.is_empty() && spans_survive(program, &strips) { + DEFERRAL.with(|deferral| deferral.borrow_mut().strips_failed = true); + } +} + +pub fn abandon_strips() { + DEFERRAL.with(|deferral| { + let mut deferral = deferral.borrow_mut(); + if !deferral.strips.is_empty() { + deferral.strips.clear(); + deferral.strips_failed = true; + } + }); +} + +pub(crate) fn strips_allowed() -> bool { + DEFERRAL.with(|deferral| { + let deferral = deferral.borrow(); + deferral.escapes_open && !deferral.strips_forbidden + }) +} + +pub(crate) fn watch_strips(spans: &[Span]) { + DEFERRAL.with(|deferral| deferral.borrow_mut().strips.extend_from_slice(spans)); +} + +pub fn strips_failed() -> bool { + DEFERRAL.with(|deferral| { + let deferral = deferral.borrow(); + deferral.strips_failed || !deferral.strips.is_empty() + }) +} + +pub struct StripsForbidden(bool); + +impl StripsForbidden { + pub fn enter() -> Self { + Self( + DEFERRAL.with(|deferral| { + std::mem::replace(&mut deferral.borrow_mut().strips_forbidden, true) + }), + ) + } +} + +impl Drop for StripsForbidden { + fn drop(&mut self) { + DEFERRAL.with(|deferral| deferral.borrow_mut().strips_forbidden = self.0); + } +} + pub fn round_opened() { DEFERRAL.with(|deferral| { let mut deferral = deferral.borrow_mut(); @@ -448,6 +529,8 @@ pub(crate) fn forget() { deferral.escapes.clear(); deferral.escape_names.clear(); deferral.escape_names_opened.clear(); + deferral.strips.clear(); + deferral.strips_failed = false; }); } diff --git a/crates/untwist-deobfuscate/src/self_defending.rs b/crates/untwist-deobfuscate/src/self_defending.rs index b422e60a..aa622f5e 100644 --- a/crates/untwist-deobfuscate/src/self_defending.rs +++ b/crates/untwist-deobfuscate/src/self_defending.rs @@ -1,6 +1,6 @@ use std::cell::Cell; -use oxc_allocator::Vec as AVec; +use oxc_allocator::{GetAllocator, Vec as AVec}; use oxc_ast::ast::*; use oxc_ast_visit::{walk_js, VisitJs}; use oxc_semantic::Scoping; @@ -10,6 +10,7 @@ use oxc_syntax::reference::ReferenceId; use oxc_syntax::scope::ScopeFlags; use oxc_syntax::symbol::{SymbolFlags, SymbolId}; use rustc_hash::{FxHashMap, FxHashSet}; +use untwist_core::ast_util::edit::StmtEdits; use untwist_core::ast_util::inline::is_plain_function; use untwist_core::ast_util::literal::{is_false_literal, is_true_literal}; use untwist_core::ast_util::matcher::{anonymous_function, call_parts, iife}; @@ -156,18 +157,6 @@ fn unbraced<'k, 'a>(mut statements: &'k [Statement<'a>]) -> &'k [Statement<'a>] statements } -fn guarded_if<'k, 'a>( - body: &[&'k Statement<'a>], -) -> Option<(Option<&'k str>, &'k IfStatement<'a>)> { - match body { - [Statement::IfStatement(statement)] => Some((None, statement)), - [declared, Statement::IfStatement(statement)] => { - Some((Some(bare_name(declared)?), statement)) - } - _ => None, - } -} - fn applied_result<'k, 'a>( live: &[&'k Statement<'a>], declared: &[&str], @@ -210,7 +199,13 @@ fn returns_guarded_apply(function: &Function<'_>, context: &str, fn_name: &str) .iter() .filter(|statement| !is_initialised_inert_local(statement, &shape_names)) .collect(); - let Some((hoisted, statement)) = guarded_if(&guarded) else { + let hoisted: Vec<&str> = guarded.iter().filter_map(|stmt| bare_name(stmt)).collect(); + let rest: Vec<&Statement<'_>> = guarded + .iter() + .copied() + .filter(|stmt| bare_name(stmt).is_none()) + .collect(); + let [Statement::IfStatement(statement)] = rest.as_slice() else { return false; }; if identifier_name(&statement.test) != Some(fn_name) || statement.alternate.is_some() { @@ -219,7 +214,10 @@ fn returns_guarded_apply(function: &Function<'_>, context: &str, fn_name: &str) let Statement::BlockStatement(block) = &statement.consequent else { return false; }; - if hoisted.is_some_and(|name| [context, fn_name, "arguments"].contains(&name)) { + if hoisted + .iter() + .any(|name| [context, fn_name, "arguments"].contains(name)) + { return false; } let mut declared: Vec<&str> = block.body.iter().filter_map(bare_name).collect(); @@ -380,6 +378,10 @@ fn controller_shape(expr: &Expression<'_>, apply: Apply) -> bool { inner_matches(inner, flag, apply) } +pub(crate) fn is_loose_call_controller(expr: &Expression<'_>) -> bool { + controller_shape(expr, Apply::AnyKey) +} + fn loose_controller_declaration(stmt: &Statement<'_>) -> Option { let (id, init) = single_declarator(stmt)?; if !controller_shape(init?, Apply::AnyKey) { @@ -1691,7 +1693,8 @@ fn remove<'a>(program: &mut Program<'a>, spans: &[Span], cx: &mut Cx<'a, '_>, pa return; } }; - cx.changed_by(applied); + let emptied = remove_emptied_shells(program, spans, cx); + cx.changed_by(applied + emptied); if partial && applied > 0 { note_provisional_removal(); } @@ -1702,3 +1705,59 @@ fn remove<'a>(program: &mut Program<'a>, spans: &[Span], cx: &mut Cx<'a, '_>, pa ); } } + +struct EmptiedShells<'s> { + removed: &'s [Span], + found: Vec, +} + +impl<'a> VisitJs<'a> for EmptiedShells<'_> { + fn visit_statement(&mut self, it: &Statement<'a>) { + let span = it.span(); + let held = self + .removed + .iter() + .any(|inner| span.start <= inner.start && inner.end <= span.end && span != *inner); + if !held { + return; + } + if is_empty_shell(it) { + self.found.push(span); + return; + } + walk_js::walk_statement(self, it); + } +} + +fn is_empty_shell(stmt: &Statement<'_>) -> bool { + let Statement::ExpressionStatement(stmt) = stmt else { + return false; + }; + let Some((function, arguments)) = iife(&stmt.expression) else { + return false; + }; + arguments.is_empty() + && has_no_params(function) + && is_plain_function(function) + && function + .body + .as_ref() + .is_some_and(|body| body.directives.is_empty() && body.statements.is_empty()) +} + +fn remove_emptied_shells<'a>( + program: &mut Program<'a>, + removed: &[Span], + cx: &mut Cx<'a, '_>, +) -> usize { + let mut shells = EmptiedShells { + removed, + found: Vec::new(), + }; + shells.visit_program(program); + let mut removals = StmtEdits::new(); + for span in shells.found { + removals.remove(span); + } + removals.apply(program, cx.allocator(), cx.scoping_mut()) +} diff --git a/crates/untwist-deobfuscate/src/string_array/mod.rs b/crates/untwist-deobfuscate/src/string_array/mod.rs index 16f3e0a4..3055a0a2 100644 --- a/crates/untwist-deobfuscate/src/string_array/mod.rs +++ b/crates/untwist-deobfuscate/src/string_array/mod.rs @@ -60,6 +60,7 @@ mod prologue_inline; mod reach; mod single_use; mod states_class; +mod wrapper_runners; use aliases::{resolve_array_aliases, search_aliases}; @@ -775,6 +776,13 @@ impl<'a> Pass<'a> for FindStringArray { } fn enter_program(&mut self, program: &mut Program<'a>, cx: &mut Cx<'a, '_>) { + if cx.opts.unsafe_transforms { + let stripped = wrapper_runners::strip_wrapper_runners(program, cx); + if stripped > 0 { + cx.changed_by(stripped); + return; + } + } if !self.legacy_searched { if cx.opts.unsafe_transforms { let dropped = states_class::drop_states_classes(program, cx); diff --git a/crates/untwist-deobfuscate/src/string_array/wrapper_runners.rs b/crates/untwist-deobfuscate/src/string_array/wrapper_runners.rs new file mode 100644 index 00000000..e4197af5 --- /dev/null +++ b/crates/untwist-deobfuscate/src/string_array/wrapper_runners.rs @@ -0,0 +1,433 @@ +use oxc_ast::ast::*; +use oxc_ast_visit::{walk_js, walk_mut, VisitJs, VisitMut}; +use oxc_semantic::Scoping; +use oxc_span::{GetSpan, Span}; +use oxc_syntax::operator::{AssignmentOperator, BinaryOperator}; +use oxc_syntax::scope::ScopeFlags; +use oxc_syntax::symbol::SymbolId; +use rustc_hash::{FxHashMap, FxHashSet}; +use untwist_core::ast_util::literal::is_true_literal; +use untwist_core::ast_util::matcher::{call_parts, iife}; +use untwist_core::pass::Cx; + +use crate::bindings::{reference_symbol, resolved_symbol}; +use crate::self_defending::is_loose_call_controller; + +fn is_controller_init(init: Option<&Expression<'_>>) -> bool { + init.is_some_and(|init| is_loose_call_controller(init.without_parentheses())) +} + +struct Controllers<'s> { + scoping: &'s Scoping, + found: FxHashSet, +} + +impl<'a> VisitJs<'a> for Controllers<'_> { + fn visit_variable_declarator(&mut self, it: &VariableDeclarator<'a>) { + if let (BindingPattern::BindingIdentifier(id), true) = + (&it.id, is_controller_init(it.init.as_ref())) + { + if let Some(symbol) = id.symbol_id.get() { + if !self.scoping.symbol_is_mutated(symbol) { + self.found.insert(symbol); + } + } + } + walk_js::walk_variable_declarator(self, it); + } +} + +fn is_callback(expr: &Expression<'_>) -> bool { + match expr.without_parentheses() { + Expression::FunctionExpression(function) => { + function.params.items.is_empty() + && function.params.rest.is_none() + && !function.r#async + && !function.generator + } + Expression::ArrowFunctionExpression(arrow) => { + arrow.params.items.is_empty() && arrow.params.rest.is_none() && !arrow.r#async + } + _ => false, + } +} + +struct Head<'s> { + scoping: &'s Scoping, + controllers: &'s FxHashSet, + local: FxHashSet, + runners: Vec, + called: FxHashSet, +} + +impl Head<'_> { + fn is_controller(&self, expr: &Expression<'_>) -> bool { + reference_symbol(expr.without_parentheses(), self.scoping).is_some_and(|symbol| { + self.controllers.contains(&symbol) || self.local.contains(&symbol) + }) + } + + fn controller_call(&self, expr: &Expression<'_>) -> bool { + let Some((callee, arguments)) = call_parts(expr.without_parentheses()) else { + return false; + }; + let [Argument::ThisExpression(_), callback] = arguments.as_slice() else { + return false; + }; + self.is_controller(callee) && callback.as_expression().is_some_and(is_callback) + } + + fn immediate_run(&self, expr: &Expression<'_>) -> bool { + let Some((callee, arguments)) = call_parts(expr.without_parentheses()) else { + return false; + }; + arguments.is_empty() && self.controller_call(callee) + } + + fn runner_shell(&self, expr: &Expression<'_>) -> bool { + let Some((function, arguments)) = iife(expr.without_parentheses()) else { + return false; + }; + if !arguments.is_empty() + || !function.params.items.is_empty() + || function.params.rest.is_some() + || function.r#async + || function.generator + { + return false; + } + let Some(body) = function.body.as_ref() else { + return false; + }; + let [Statement::ExpressionStatement(only)] = body.statements.as_slice() else { + return false; + }; + body.directives.is_empty() && self.immediate_run(&only.expression) + } + + fn bare_runner_call(&mut self, expr: &Expression<'_>) -> bool { + let Some((callee, arguments)) = call_parts(expr.without_parentheses()) else { + return false; + }; + let Some(symbol) = reference_symbol(callee.without_parentheses(), self.scoping) else { + return false; + }; + arguments.is_empty() && self.runners.contains(&symbol) && self.called.insert(symbol) + } + + fn expression(&mut self, expr: &Expression<'_>) -> bool { + self.runner_shell(expr) || self.immediate_run(expr) || self.bare_runner_call(expr) + } + + fn statement(&mut self, stmt: &Statement<'_>) -> bool { + match stmt { + Statement::ExpressionStatement(node) => self.expression(&node.expression), + Statement::VariableDeclaration(declaration) => declaration + .declarations + .iter() + .all(|declarator| self.declarator(declarator)), + _ => false, + } + } + + fn declarator(&mut self, declarator: &VariableDeclarator<'_>) -> bool { + let BindingPattern::BindingIdentifier(id) = &declarator.id else { + return false; + }; + let Some(symbol) = id.symbol_id.get() else { + return false; + }; + if self.scoping.symbol_is_mutated(symbol) { + return false; + } + let init = declarator.init.as_ref(); + if is_controller_init(init) { + return self.local.insert(symbol); + } + if init.is_some_and(|init| self.controller_call(init)) { + self.runners.push(symbol); + return true; + } + false + } + + fn complete(&self) -> bool { + self.runners + .iter() + .all(|symbol| self.called.contains(symbol)) + } +} + +fn simple_params(function: &Function<'_>) -> Option> { + if function.params.rest.is_some() { + return None; + } + function + .params + .items + .iter() + .map(|item| match (&item.pattern, &item.initializer) { + (BindingPattern::BindingIdentifier(id), None) => id.symbol_id.get(), + _ => None, + }) + .collect() +} + +fn forwarded_call(expr: &Expression<'_>) -> bool { + call_parts(expr.without_parentheses()).is_some_and(|(callee, arguments)| { + matches!(callee.without_parentheses(), Expression::Identifier(_)) && !arguments.is_empty() + }) +} + +struct Candidate { + function: Span, + watched: Option, + removed: Vec, + statements: usize, + sequence: bool, + tracked: Vec, + params: Vec, +} + +fn returned_prefix<'k, 'a>(statements: &'k [Statement<'a>]) -> Vec<&'k Expression<'a>> { + let [Statement::ReturnStatement(returned)] = statements else { + return Vec::new(); + }; + let Some(Expression::SequenceExpression(sequence)) = returned + .argument + .as_ref() + .map(Expression::without_parentheses) + else { + return Vec::new(); + }; + match sequence.expressions.split_last() { + Some((call, prefix)) if forwarded_call(call) => prefix.iter().collect(), + _ => Vec::new(), + } +} + +fn forwarded_target(statements: &[Statement<'_>], scoping: &Scoping) -> Option { + let [Statement::ReturnStatement(returned)] = statements else { + return None; + }; + let call = match returned.argument.as_ref()?.without_parentheses() { + Expression::SequenceExpression(sequence) => sequence.expressions.last()?, + other => other, + }; + if !forwarded_call(call) { + return None; + } + let (callee, _) = call_parts(call.without_parentheses())?; + reference_symbol(callee.without_parentheses(), scoping) +} + +fn builds_a_controller(statements: &[Statement<'_>]) -> bool { + let [Statement::VariableDeclaration(flag), Statement::ReturnStatement(returned)] = statements + else { + return false; + }; + let [declarator] = flag.declarations.as_slice() else { + return false; + }; + let returns_a_runner = matches!( + returned.argument.as_ref().map(Expression::without_parentheses), + Some(Expression::FunctionExpression(inner)) if inner.params.items.len() == 2 + ); + declarator.init.as_ref().is_some_and(is_true_literal) && returns_a_runner +} + +fn shifts_its_index(statements: &[Statement<'_>], params: &[SymbolId], scoping: &Scoping) -> bool { + let Some(Statement::ExpressionStatement(first)) = statements.first() else { + return false; + }; + let Expression::AssignmentExpression(assigned) = &first.expression else { + return false; + }; + let AssignmentTarget::AssignmentTargetIdentifier(target) = &assigned.left else { + return false; + }; + let Expression::BinaryExpression(shifted) = &assigned.right else { + return false; + }; + let index = resolved_symbol(target, scoping); + assigned.operator == AssignmentOperator::Assign + && index.is_some_and(|index| params.first() == Some(&index)) + && shifted.operator == BinaryOperator::Subtraction + && matches!(&shifted.left, Expression::Identifier(id) if resolved_symbol(id, scoping) == index) + && matches!(&shifted.right, Expression::NumericLiteral(_)) +} + +fn candidate( + function: &Function<'_>, + scoping: &Scoping, + controllers: &FxHashSet, +) -> Option { + let params = simple_params(function)?; + let body = function.body.as_ref()?; + let mut scan = Head { + scoping, + controllers, + local: FxHashSet::default(), + runners: Vec::new(), + called: FxHashSet::default(), + }; + let head = body + .statements + .iter() + .take_while(|stmt| scan.statement(stmt)) + .count(); + let rest = &body.statements[head..]; + let watched = match forwarded_target(rest, scoping) { + Some(target) => Some(scoping.symbol_span(target)), + None if shifts_its_index(rest, ¶ms, scoping) => function.id.as_ref().map(|id| id.span), + None if builds_a_controller(rest) => None, + None => return None, + }; + let prefix = returned_prefix(rest); + let fits = prefix.iter().all(|expr| scan.expression(expr)); + if rest.is_empty() || !fits || (head == 0 && prefix.is_empty()) || !scan.complete() { + return None; + } + let mut removed: Vec = body.statements[..head].iter().map(GetSpan::span).collect(); + removed.extend(prefix.iter().map(|expr| expr.span())); + let mut tracked: Vec = scan.local.into_iter().collect(); + tracked.extend(scan.runners); + Some(Candidate { + function: function.span, + watched, + removed, + statements: head, + sequence: !prefix.is_empty(), + tracked, + params, + }) +} + +struct Find<'s> { + scoping: &'s Scoping, + controllers: &'s FxHashSet, + found: Vec, +} + +impl<'a> VisitJs<'a> for Find<'_> { + fn visit_function(&mut self, it: &Function<'a>, flags: ScopeFlags) { + if let Some(found) = candidate(it, self.scoping, self.controllers) { + self.found.push(found); + } + walk_js::walk_function(self, it, flags); + } +} + +struct Escapes<'s> { + scoping: &'s Scoping, + owner: FxHashMap, + params: FxHashSet, + candidates: &'s [Candidate], + spoiled: FxHashSet, +} + +impl<'a> VisitJs<'a> for Escapes<'_> { + fn visit_identifier_reference(&mut self, it: &IdentifierReference<'a>) { + let Some(symbol) = resolved_symbol(it, self.scoping) else { + return; + }; + let Some(&index) = self.owner.get(&symbol) else { + return; + }; + let inside = self.candidates[index] + .removed + .iter() + .any(|span| span.start <= it.span.start && it.span.end <= span.end); + if inside == self.params.contains(&symbol) { + self.spoiled.insert(index); + } + } +} + +struct Strip<'s> { + candidates: &'s [Candidate], + stripped: usize, +} + +impl<'a> VisitMut<'a> for Strip<'_> { + fn visit_function(&mut self, it: &mut Function<'a>, flags: ScopeFlags) { + walk_mut::walk_function(self, it, flags); + let Some(found) = self + .candidates + .iter() + .find(|found| found.function == it.span) + else { + return; + }; + let Some(body) = it.body.as_mut() else { + return; + }; + body.statements.drain(..found.statements); + if found.sequence { + if let Some(Statement::ReturnStatement(returned)) = body.statements.last_mut() { + if let Some(Expression::SequenceExpression(sequence)) = returned.argument.as_mut() { + if let Some(call) = sequence.expressions.pop() { + returned.argument = Some(call); + } + } + } + } + self.stripped += 1; + } +} + +pub(super) fn strip_wrapper_runners<'a>(program: &mut Program<'a>, cx: &Cx<'a, '_>) -> usize { + if !crate::legacy_reach::strips_allowed() { + return 0; + } + let scoping = cx.scoping(); + let mut controllers = Controllers { + scoping, + found: FxHashSet::default(), + }; + controllers.visit_program(program); + let mut find = Find { + scoping, + controllers: &controllers.found, + found: Vec::new(), + }; + find.visit_program(program); + if find.found.is_empty() { + return 0; + } + let mut owner = FxHashMap::default(); + let mut params = FxHashSet::default(); + for (index, found) in find.found.iter().enumerate() { + for symbol in found.tracked.iter().chain(&found.params) { + owner.insert(*symbol, index); + } + params.extend(found.params.iter().copied()); + } + let mut escapes = Escapes { + scoping, + owner, + params, + candidates: &find.found, + spoiled: FxHashSet::default(), + }; + escapes.visit_program(program); + let spoiled = escapes.spoiled; + let kept: Vec = find + .found + .into_iter() + .enumerate() + .filter(|(index, _)| !spoiled.contains(index)) + .map(|(_, found)| found) + .collect(); + if kept.is_empty() { + return 0; + } + let mut strip = Strip { + candidates: &kept, + stripped: 0, + }; + strip.visit_program(program); + let watched: Vec = kept.iter().filter_map(|found| found.watched).collect(); + crate::legacy_reach::watch_strips(&watched); + strip.stripped +} diff --git a/crates/untwist/src/pipeline/input.rs b/crates/untwist/src/pipeline/input.rs index 62d73497..e16b77f1 100644 --- a/crates/untwist/src/pipeline/input.rs +++ b/crates/untwist/src/pipeline/input.rs @@ -240,7 +240,12 @@ impl Pipeline { let carry = untwist_deobfuscate::legacy_reach::NameCarry::enter( self.options.rename == RenameMode::None, ); - let first = self.run_admitted(source, reservation, (room.clone(), reserved)); + let mut first = self.run_admitted(source, reservation, (room.clone(), reserved)); + let _strips = untwist_deobfuscate::legacy_reach::strips_failed().then(|| { + let forbidden = untwist_deobfuscate::legacy_reach::StripsForbidden::enter(); + first = self.rerun(source, reservation, (room.clone(), reserved)); + forbidden + }); drop(carry); drop(rerunnable); let forbidden = untwist_deobfuscate::legacy_reach::unverified() @@ -521,6 +526,9 @@ impl Pipeline { let found = super::decoded::sited(text.len(), layer, recorder.finish()); result.decoded_strings.extend(found); } + if !matches!(staged, Ok(Staged::Done)) { + untwist_deobfuscate::legacy_reach::abandon_strips(); + } match staged { Ok(Staged::Replay) => Step::Replay, Ok(Staged::TypeScript) => Step::Done(None), diff --git a/crates/untwist/src/pipeline/stages.rs b/crates/untwist/src/pipeline/stages.rs index 3dc46706..b85fc91d 100644 --- a/crates/untwist/src/pipeline/stages.rs +++ b/crates/untwist/src/pipeline/stages.rs @@ -449,6 +449,7 @@ impl Pipeline { sem: Semantics, ) -> (Semantics, bool) { settle_layered_observations(site.program, &sem.scoping); + untwist_deobfuscate::legacy_reach::settle_late_escapes(site.program); if !self.options.deobfuscate { return (sem, false); } diff --git a/crates/untwist/tests/data/obfuscator_sweep/runner-in-decoder.js b/crates/untwist/tests/data/obfuscator_sweep/runner-in-decoder.js new file mode 100644 index 00000000..f9b845a0 --- /dev/null +++ b/crates/untwist/tests/data/obfuscator_sweep/runner-in-decoder.js @@ -0,0 +1 @@ +(function(_0xe94000,_0x4fac1e){var _0x18b657=_0xe94000();while(!![]){try{var _0x593c89=parseInt(_0x9f70(0x1f9))/0x1*(parseInt(_0x9f70(0x1f3))/0x2)+parseInt(_0x9f70(0x1f2))/0x3*(-parseInt(_0x9f70(0x1fd))/0x4)+parseInt(_0x9f70(0x1f4))/0x5*(-parseInt(_0x9f70(0x20c))/0x6)+-parseInt(_0x9f70(0x20b))/0x7+parseInt(_0x9f70(0x1ff))/0x8*(parseInt(_0x9f70(0x206))/0x9)+-parseInt(_0x9f70(0x205))/0xa*(-parseInt(_0x9f70(0x204))/0xb)+parseInt(_0x9f70(0x207))/0xc*(parseInt(_0x9f70(0x1f8))/0xd);if(_0x593c89===_0x4fac1e){break;}else{_0x18b657['push'](_0x18b657['shift']());}}catch(_0xc88159){_0x18b657['push'](_0x18b657['shift']());}}}(_0x10d1,0x9cf0d));function greet(_0x49635c){return _0x9f70(0x1ed)+_0x49635c;}console[_0x9f70(0x208)](greet(_0x9f70(0x1f1)));function _0x9f70(_0x199689,_0x2b1dd7){var _0x24ac5d=(function(){var _0x21670e=!![];return function(_0x52871c,_0x5123aa){var _0x429c61=_0x21670e?function(){if(_0x5123aa){var _0x2135ef=_0x5123aa[_0x9f70(0x1f7)](_0x52871c,arguments);_0x5123aa=null;return _0x2135ef;}}:function(){};_0x21670e=![];return _0x429c61;};}());var _0x2a2695=_0x24ac5d(this,function(){var _0x35cefa;try{var _0x22a8f5=Function(_0x9f70(0x202)+_0x9f70(0x1ee)+');');_0x35cefa=_0x22a8f5();}catch(_0x109659){_0x35cefa=window;}var _0x5cb4a0=_0x35cefa[_0x9f70(0x201)]=_0x35cefa[_0x9f70(0x201)]||{};var _0x38cf42=[_0x9f70(0x208),_0x9f70(0x1f6),_0x9f70(0x1fe),_0x9f70(0x20d),_0x9f70(0x203),_0x9f70(0x1ef),_0x9f70(0x1f0)];for(var _0x4e0ad8=0x0;_0x4e0ad8<_0x38cf42[_0x9f70(0x1f5)];_0x4e0ad8++){var _0x3f9b95=_0x24ac5d[_0x9f70(0x20a)][_0x9f70(0x209)][_0x9f70(0x1fa)](_0x24ac5d);var _0x3fdc83=_0x38cf42[_0x4e0ad8];var _0x124fa9=_0x5cb4a0[_0x3fdc83]||_0x3f9b95;_0x3f9b95[_0x9f70(0x1fb)]=_0x24ac5d[_0x9f70(0x1fa)](_0x24ac5d);_0x3f9b95[_0x9f70(0x1fc)]=_0x124fa9[_0x9f70(0x1fc)][_0x9f70(0x1fa)](_0x124fa9);_0x5cb4a0[_0x3fdc83]=_0x3f9b95;}});_0x2a2695();_0x199689=_0x199689-0x1ed;var _0x297118=_0x10d1();var _0x4995e6=_0x297118[_0x199689];return _0x4995e6;}function _0x10d1(){var _0x834001=['hello,\x20','{}.constructor(\x22return\x20this\x22)(\x20)','table','trace','ada','339wIGaPC','898rKlKck','5055VFrbuG','length','warn','apply','5228717BbokOV','179UQpbDy','bind','__proto__','toString','24316udYRBD','info','10237144IkvDwL','done','console','return\x20(function()\x20','exception','92158sJqMpH','30kHRYMX','9MzmhED','36cUgaOy','log','prototype','constructor','7171038gSogCp','1410tXhMGr','error'];_0x10d1=function(){return _0x834001;};return _0x10d1();}console[_0x9f70(0x208)](_0x9f70(0x200)); diff --git a/crates/untwist/tests/data/obfuscator_sweep/runners-in-wrapper.js b/crates/untwist/tests/data/obfuscator_sweep/runners-in-wrapper.js new file mode 100644 index 00000000..5e191fe5 --- /dev/null +++ b/crates/untwist/tests/data/obfuscator_sweep/runners-in-wrapper.js @@ -0,0 +1 @@ +var F=(function(){var b=(function(){var Q=!![];return function(R,S){var T=Q?function(){if(S){var U=S['\x61\x70'+'\x70\x6c'+'\x79'](R,arguments);S=null;return U;}}:function(){};Q=![];return T;};}());var c=(function(){function Q(S,T){var U=b(this,function(){var V;try{var W=Function('\x72\x65'+'\x74\x75'+'\x72\x6e'+'\x20\x28'+'\x66\x75'+'\x6e\x63'+'\x74\x69'+'\x6f\x6e'+'\x28\x29'+'\x20'+('\x7b\x7d'+'\x2e\x63'+'\x6f\x6e'+'\x73\x74'+'\x72\x75'+'\x63\x74'+'\x6f\x72'+'\x28\x22'+'\x72\x65'+'\x74\x75'+'\x72\x6e'+'\x20\x74'+'\x68\x69'+'\x73\x22'+'\x29\x28'+'\x20\x29')+'\x29\x3b');V=W();}catch(a3){V=window;}var X=V['\x63\x6f'+'\x6e\x73'+'\x6f\x6c'+'\x65']=V['\x63\x6f'+'\x6e\x73'+'\x6f\x6c'+'\x65']||{};var Y=['\x6c\x6f'+'\x67','\x77\x61'+'\x72\x6e','\x69\x6e'+'\x66\x6f','\x65\x72'+'\x72\x6f'+'\x72','\x65\x78'+'\x63\x65'+'\x70\x74'+'\x69\x6f'+'\x6e','\x74\x61'+'\x62\x6c'+'\x65','\x74\x72'+'\x61\x63'+'\x65'];for(var Z=0x0;Z>(-(0x744*0x2+0x27d+-0x1103)*a1&-0xcb7*-0x3+0x43*-0x95+-0x1c*-0x8)):a1:-0xe42+-0xd31+-0x1*-0x1b73){a3=W['\x69\x6e'+'\x64\x65'+'\x78\x4f'+'\x66'](a3);}for(var a5=0x20e7+-0x1*-0x21a3+-0x428a,a6=X['\x6c\x65'+'\x6e\x67'+'\x74\x68'];a5>(-(0x744*0x2+0x27d+-0x1103)*a2&-0xcb7*-0x3+0x43*-0x95+-0x1c*-0x8)):a2:-0xe42+-0xd31+-0x1*-0x1b73){a4=X['\x69\x6e'+'\x64\x65'+'\x78\x4f'+'\x66'](a4);}for(var a6=0x20e7+-0x1*-0x21a3+-0x428a,a7=Y['\x6c\x65'+'\x6e\x67'+'\x74\x68'];a6 gzipSync(bytes, { level: 9 }).length;