Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
83 changes: 83 additions & 0 deletions crates/untwist-deobfuscate/src/legacy_reach.rs
Original file line number Diff line number Diff line change
Expand Up @@ -32,6 +32,9 @@ struct Deferral {
escape_names: Vec<Vec<String>>,
escape_names_opened: Vec<Vec<String>>,
carries_names: bool,
strips: Vec<Span>,
strips_failed: bool,
strips_forbidden: bool,
reached: bool,
}

Expand Down Expand Up @@ -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<Vec<String>> = 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();
Expand Down Expand Up @@ -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;
});
}

Expand Down
91 changes: 75 additions & 16 deletions crates/untwist-deobfuscate/src/self_defending.rs
Original file line number Diff line number Diff line change
@@ -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;
Expand All @@ -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};
Expand Down Expand Up @@ -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],
Expand Down Expand Up @@ -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() {
Expand All @@ -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();
Expand Down Expand Up @@ -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<SymbolId> {
let (id, init) = single_declarator(stmt)?;
if !controller_shape(init?, Apply::AnyKey) {
Expand Down Expand Up @@ -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();
}
Expand All @@ -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<Span>,
}

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())
}
8 changes: 8 additions & 0 deletions crates/untwist-deobfuscate/src/string_array/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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};

Expand Down Expand Up @@ -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);
Expand Down
Loading