diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/chains.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/chains.rs
index 8d354698..54b1c11f 100644
--- a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/chains.rs
+++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/chains.rs
@@ -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",
@@ -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)
@@ -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(),
@@ -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();
diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/discarded.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/discarded.rs
new file mode 100644
index 00000000..6c5ccf4a
--- /dev/null
+++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/discarded.rs
@@ -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,
+ }
+ }
+}
diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holder_uses.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holder_uses.rs
index 65a20ac7..a9e02d68 100644
--- a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holder_uses.rs
+++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holder_uses.rs
@@ -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
diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/key_params.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/key_params.rs
new file mode 100644
index 00000000..7ca0444f
--- /dev/null
+++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/key_params.rs
@@ -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
,
+}
+
+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) =
+ (¶m.pattern, ¶m.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 {
+ 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))
+ })
+ }
+}
diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/mod.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/mod.rs
index b7147826..f0a0659e 100644
--- a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/mod.rs
+++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/mod.rs
@@ -1,11 +1,14 @@
mod blocks;
mod chains;
+mod discarded;
mod flows;
mod holder_uses;
mod holders;
+mod key_params;
mod keys;
mod numeric;
mod proto_stores;
+mod rewritten;
mod shapes;
use std::borrow::Cow;
@@ -118,6 +121,10 @@ struct Walker<'s, 'a> {
annex: AnnexBWrites,
proto_stores: Vec