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
111 changes: 109 additions & 2 deletions crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/chains.rs
Original file line number Diff line number Diff line change
@@ -1,13 +1,22 @@
use oxc_ast::ast::*;
use oxc_ast::AstKind;
use oxc_syntax::operator::BinaryOperator;
use oxc_syntax::operator::{AssignmentOperator, BinaryOperator};
use oxc_syntax::symbol::SymbolFlags;
use std::borrow::Cow;
use untwist_core::ast_util::js_text::js_text;
use untwist_core::semantic::{is_foreign_global, observers, Observers};

use super::keys::KeyProof;
use super::{member_address, same, str_const, Walker, KIND_DEPTH};

pub(super) const CHAIN_KEYS: [&str; 3] = ["__proto__", "prototype", "constructor"];

pub(super) struct OpenRead<'a> {
object: Option<&'a Expression<'a>>,
key: &'a Expression<'a>,
rewritten: Option<(oxc_syntax::symbol::SymbolId, oxc_allocator::Address)>,
}

const PROTOTYPE_READERS: [&str; 5] = [
"__proto__",
"getPrototypeOf",
Expand Down Expand Up @@ -39,9 +48,19 @@ impl<'s, 'a> Walker<'s, 'a> {
AstKind::ComputedMemberExpression(member) => {
match str_const(&member.expression, self.resolve, KIND_DEPTH) {
Some(key) => self.member_obtains(&key, &member.object),
None => self.constructor_name(&member.object),
None => {
self.note_open_read(Some(&member.object), &member.expression);
self.constructor_name(&member.object)
}
}
}
AstKind::BindingProperty(property) if property.computed => {
self.note_open_key(&property.key)
}
AstKind::AssignmentTargetPropertyProperty(property) if property.computed => {
self.note_open_key(&property.name)
}
AstKind::CallExpression(call) => self.keyed_get(call),
AstKind::StringLiteral(text) => {
!self.member_key_position()
&& !self.decoded_array_text(text.span)
Expand All @@ -59,6 +78,91 @@ impl<'s, 'a> Walker<'s, 'a> {
self.chains_open |= obtained;
}

fn note_open_read(&mut self, object: Option<&'a Expression<'a>>, key: &'a Expression<'a>) {
if !self.plain_store_target() && !self.discarded_read() {
let read = self.open_read(object, key);
self.open_reads.push(read);
}
}

fn note_open_key(&mut self, key: &'a PropertyKey<'a>) -> bool {
if let Some(key) = key.as_expression() {
let read = self.open_read(None, key);
self.open_reads.push(read);
}
false
}

fn keyed_get(&mut self, call: &'a CallExpression<'a>) -> bool {
let Some(member) = call.callee.without_parentheses().as_member_expression() else {
return false;
};
if super::member_key(member, self.resolve).as_deref() != Some("get") {
return false;
}
let spread = call.arguments.iter().take(2).any(Argument::is_spread);
match call.arguments.get(1).and_then(Argument::as_expression) {
_ if spread => true,
Some(_) if self.discarded_read() => false,
Some(key) => {
let object = call.arguments.first().and_then(Argument::as_expression);
let read = self.open_read(object, key);
self.open_reads.push(read);
false
}
None => false,
}
}

fn open_read(
&self,
object: Option<&'a Expression<'a>>,
key: &'a Expression<'a>,
) -> OpenRead<'a> {
OpenRead {
object,
key,
rewritten: self.rewritten_before_here(key),
}
}

fn plain_store_target(&self) -> bool {
let at = self.stack.len() - 1;
let Some((up, child)) = self.parent(at) else {
return false;
};
matches!(self.stack[up], AstKind::AssignmentExpression(assign)
if assign.operator == AssignmentOperator::Assign
&& assign.left.as_member_expression().is_some_and(|target| member_address(target) == child))
}

fn settle_open_reads(&mut self) {
let reads = std::mem::take(&mut self.open_reads);
let trust_symbol = std::mem::replace(&mut self.trust_symbol, false);
self.chains_open |= reads.iter().any(|read| self.open_read_obtains(read));
self.trust_symbol = trust_symbol;
}

fn open_read_obtains(&self, read: &OpenRead<'a>) -> bool {
if let Some(text) = self.key_text(read.key, KIND_DEPTH) {
return CHAIN_KEYS.contains(&text.as_str());
}
if self.numeric_key(read.key, KIND_DEPTH) {
return false;
}
if read
.rewritten
.is_some_and(|(symbol, function)| self.numeric_rewrite(symbol, function))
{
return false;
}
if self.safe_key_param(read.key) {
return false;
}
read.object
.is_none_or(|object| matches!(self.key_proof(object, read.key), KeyProof::Open))
}

fn member_obtains(&self, key: &str, object: &Expression<'a>) -> bool {
match key {
"__proto__" => !self.member_written(),
Expand Down Expand Up @@ -193,6 +297,9 @@ impl<'s, 'a> Walker<'s, 'a> {
}

pub(super) fn settle_chains(&mut self, texts_run: bool) {
if !self.chains_open {
self.settle_open_reads();
}
self.chains_open |= CONSTRUCTORS.iter().any(|root| is_foreign_global(root));
self.builtins_trusted = observers() == Observers::None || !(self.chains_open || texts_run);
self.settle_proto_stores();
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,52 @@
use oxc_ast::AstKind;
use oxc_syntax::operator::{BinaryOperator, UnaryOperator};

use super::holder_uses::harmless_binary;
use super::{same, Walker};

impl<'s, 'a> Walker<'s, 'a> {
pub(super) fn discarded_read(&self) -> bool {
let at = self.stack.len() - 1;
match self.parent(at) {
Some((up, child)) if self.called_by(up, child) => self.discarded(up),
_ => self.discarded(at),
}
}

fn called_by(&self, up: usize, child: oxc_allocator::Address) -> bool {
match self.stack[up] {
AstKind::CallExpression(call) => same(&call.callee, child),
AstKind::NewExpression(new) => same(&new.callee, child),
_ => false,
}
}

fn discarded(&self, at: usize) -> bool {
let Some((up, child)) = self.parent(at) else {
return false;
};
match self.stack[up] {
AstKind::ExpressionStatement(_) => true,
AstKind::UnaryExpression(unary) => match unary.operator {
UnaryOperator::Typeof | UnaryOperator::Void | UnaryOperator::LogicalNot => true,
UnaryOperator::Delete => false,
_ => self.builtins_intact(),
},
AstKind::BinaryExpression(binary) => {
harmless_binary(binary.operator, same(&binary.right, child))
|| (binary.operator != BinaryOperator::Instanceof && self.builtins_intact())
}
AstKind::TemplateLiteral(_) => {
let tagged = up.checked_sub(1).is_some_and(|tag| {
matches!(self.stack[tag], AstKind::TaggedTemplateExpression(_))
});
!tagged && self.builtins_intact()
}
AstKind::IfStatement(statement) => same(&statement.test, child),
AstKind::WhileStatement(statement) => same(&statement.test, child),
AstKind::DoWhileStatement(statement) => same(&statement.test, child),
AstKind::ConditionalExpression(conditional) => same(&conditional.test, child),
_ => false,
}
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -41,7 +41,7 @@ const INSTANCE_CONSTRUCTORS: [&str; 16] = [
"Date", "Error", "Map", "Set", "WeakMap", "WeakSet", "Promise",
];

fn harmless_binary(operator: BinaryOperator, right: bool) -> bool {
pub(super) fn harmless_binary(operator: BinaryOperator, right: bool) -> bool {
matches!(
operator,
BinaryOperator::StrictEquality | BinaryOperator::StrictInequality
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,177 @@
use oxc_allocator::{Address, UnstableAddress};
use oxc_ast::ast::*;
use oxc_ast::AstKind;
use oxc_syntax::symbol::SymbolId;

use super::chains::CHAIN_KEYS;
use super::{same, Walker, KIND_DEPTH};

#[derive(Clone, Copy)]
pub(super) struct ParamSlot {
binding: SymbolId,
index: usize,
function: Option<Address>,
}

impl<'s, 'a> Walker<'s, 'a> {
pub(super) fn collect_param_slots(&mut self, kind: AstKind<'a>) {
let (params, function) = match kind {
AstKind::Function(function) => (&*function.params, Some(function.unstable_address())),
AstKind::ArrowFunctionExpression(arrow) => (&*arrow.params, None),
_ => return,
};
let Some(binding) = self.function_binding(kind) else {
return;
};
if params.rest.is_some() {
return;
}
for (index, param) in params.items.iter().enumerate() {
let (BindingPattern::BindingIdentifier(id), None) =
(&param.pattern, &param.initializer)
else {
continue;
};
if let Some(symbol) = id.symbol_id.get() {
let slot = ParamSlot {
binding,
index,
function,
};
self.param_slots.insert(symbol, slot);
}
}
}

fn function_binding(&self, kind: AstKind<'a>) -> Option<SymbolId> {
let at = self.stack.len() - 1;
if let AstKind::Function(function) = kind {
if function.is_declaration() {
let exported = self.parent(at).is_some_and(|(up, _)| {
matches!(
self.stack[up],
AstKind::ExportNamedDeclaration(_) | AstKind::ExportDefaultDeclaration(_)
)
});
return function
.id
.as_ref()
.and_then(|id| id.symbol_id.get())
.filter(|_| !exported);
}
if super::self_named(function, self.scoping) {
return None;
}
}
let (up, child) = self.parent(at)?;
let AstKind::VariableDeclarator(declarator) = self.stack[up] else {
return None;
};
let BindingPattern::BindingIdentifier(id) = &declarator.id else {
return None;
};
declarator
.init
.as_ref()
.filter(|init| same(init, child))
.and_then(|_| id.symbol_id.get())
}

pub(super) fn collect_callee(&mut self, id: &IdentifierReference<'a>) {
let Some(symbol) = self.symbol(id) else {
return;
};
let at = self.stack.len() - 1;
let Some((up, child)) = self.parent(at) else {
return;
};
if let AstKind::CallExpression(call) = self.stack[up] {
if same(&call.callee, child) {
self.callee_calls.entry(symbol).or_default().push(call);
}
}
}

pub(super) fn safe_key_param(&self, key: &Expression<'a>) -> bool {
let Expression::Identifier(id) = key.without_parentheses() else {
return false;
};
let Some(symbol) = self.symbol(id) else {
return false;
};
let Some(slot) = self.param_slots.get(&symbol).copied() else {
return false;
};
let settled = !self.dynamic_scope
&& !self.opaque.contains(&symbol)
&& !self.opaque.contains(&slot.binding)
&& !self.shared_root(slot.binding)
&& !self.annex.may_write(slot.binding)
&& !crate::calls::agnostic::rebound(self.scoping, slot.binding)
&& self.scoping.symbol_redeclarations(slot.binding).is_empty()
&& self.scoping.symbol_redeclarations(symbol).is_empty()
&& slot
.function
.is_none_or(|function| !self.arguments_used.contains(&function));
settled && self.writes_numeric(symbol) && self.called_with_safe_keys(slot)
}

fn safe_key(&self, key: &Expression<'a>) -> bool {
match self.key_text(key, KIND_DEPTH) {
Some(text) => !CHAIN_KEYS.contains(&text.as_str()),
None => self.numeric_key(key, KIND_DEPTH) || self.unset_numeric(key),
}
}

pub(super) fn collect_unset(&mut self, declarator: &'a VariableDeclarator<'a>) {
let (BindingPattern::BindingIdentifier(id), None) = (&declarator.id, &declarator.init)
else {
return;
};
let looped = self.stack.len().checked_sub(3).is_some_and(|at| {
matches!(
self.stack[at],
AstKind::ForInStatement(_) | AstKind::ForOfStatement(_)
)
});
if let (false, Some(symbol)) = (looped, id.symbol_id.get()) {
self.unset.insert(symbol);
}
}

fn unset_numeric(&self, key: &Expression<'a>) -> bool {
let Expression::Identifier(id) = key.without_parentheses() else {
return false;
};
let Some(symbol) = self.symbol(id) else {
return false;
};
self.unset.contains(&symbol)
&& !self.dynamic_scope
&& !self.opaque.contains(&symbol)
&& !self.shared_root(symbol)
&& !self.annex.may_write(symbol)
&& self.scoping.symbol_redeclarations(symbol).is_empty()
&& self.writes_numeric(symbol)
}

fn called_with_safe_keys(&self, slot: ParamSlot) -> bool {
let references = self.scoping.get_resolved_reference_ids(slot.binding).len();
let Some(calls) = self.callee_calls.get(&slot.binding) else {
return references == 0;
};
calls.len() == references
&& calls.iter().all(|call| {
let spread = call
.arguments
.iter()
.take(slot.index + 1)
.any(Argument::is_spread);
let argument = call
.arguments
.get(slot.index)
.and_then(Argument::as_expression);
!spread && argument.is_some_and(|argument| self.safe_key(argument))
})
}
}
Loading