From 14a5b07686067e9ca33d5e2f2055e1a045ec1702 Mon Sep 17 00:00:00 2001 From: sorte1 Date: Thu, 19 Nov 2026 04:46:53 +0100 Subject: [PATCH 1/4] fix: prove namespace holders by allow-list, judge texts by parse, distrust Symbol after code text, treat shared roots as opaque --- .../src/calls/agnostic/assembled.rs | 5 +- .../src/calls/agnostic/bind.rs | 6 +- .../src/calls/agnostic/bootstrap.rs | 8 +- .../src/calls/agnostic/bootstrap/getter.rs | 4 +- .../src/calls/agnostic/bootstrap/record.rs | 6 +- .../src/calls/agnostic/bound_this.rs | 10 +- .../src/calls/agnostic/chain_text.rs | 171 ++++++++++++++++++ .../src/calls/agnostic/holds.rs | 2 +- .../src/calls/agnostic/judge.rs | 42 +++-- .../src/calls/agnostic/mod.rs | 12 +- .../calls/agnostic/namespace_uses/chains.rs | 162 +++++++++++++++++ .../calls/agnostic/namespace_uses/flows.rs | 2 +- .../agnostic/namespace_uses/holder_uses.rs | 150 +++++++++++++++ .../calls/agnostic/namespace_uses/holders.rs | 109 ++++++++--- .../src/calls/agnostic/namespace_uses/keys.rs | 4 +- .../src/calls/agnostic/namespace_uses/mod.rs | 55 ++++-- .../calls/agnostic/namespace_uses/numeric.rs | 130 +++++++++++++ .../calls/agnostic/namespace_uses/shapes.rs | 2 +- .../src/calls/agnostic/settle.rs | 142 +++++++++++++-- .../src/calls/agnostic/sites.rs | 9 + .../src/calls/agnostic/subst.rs | 3 +- .../src/calls/agnostic/text.rs | 31 ++++ .../tests/data/rename_a25rr/multi/rx9-m1/a.js | 1 + .../tests/data/rename_a25rr/multi/rx9-m1/b.js | 3 + .../data/rename_a25rr/multi/rx9-m10/a.js | 1 + .../data/rename_a25rr/multi/rx9-m10/b.js | 3 + .../data/rename_a25rr/multi/rx9-m11/a.js | 1 + .../data/rename_a25rr/multi/rx9-m11/b.js | 3 + .../data/rename_a25rr/multi/rx9-m12/a.js | 1 + .../data/rename_a25rr/multi/rx9-m12/b.js | 3 + .../data/rename_a25rr/multi/rx9-m13/a.js | 1 + .../data/rename_a25rr/multi/rx9-m13/b.js | 3 + .../data/rename_a25rr/multi/rx9-m14/a.js | 1 + .../data/rename_a25rr/multi/rx9-m14/b.js | 3 + .../data/rename_a25rr/multi/rx9-m15/a.js | 1 + .../data/rename_a25rr/multi/rx9-m15/b.js | 3 + .../data/rename_a25rr/multi/rx9-m16/a.js | 1 + .../data/rename_a25rr/multi/rx9-m16/b.js | 3 + .../data/rename_a25rr/multi/rx9-m17/a.js | 1 + .../data/rename_a25rr/multi/rx9-m17/b.js | 3 + .../data/rename_a25rr/multi/rx9-m18/a.js | 1 + .../data/rename_a25rr/multi/rx9-m18/b.js | 3 + .../data/rename_a25rr/multi/rx9-m19/a.js | 1 + .../data/rename_a25rr/multi/rx9-m19/b.js | 3 + .../tests/data/rename_a25rr/multi/rx9-m2/a.js | 1 + .../tests/data/rename_a25rr/multi/rx9-m2/b.js | 3 + .../data/rename_a25rr/multi/rx9-m20/a.js | 1 + .../data/rename_a25rr/multi/rx9-m20/b.js | 3 + .../data/rename_a25rr/multi/rx9-m21/a.js | 1 + .../data/rename_a25rr/multi/rx9-m21/b.js | 2 + .../data/rename_a25rr/multi/rx9-m22/a.js | 1 + .../data/rename_a25rr/multi/rx9-m22/b.js | 2 + .../data/rename_a25rr/multi/rx9-m23/a.js | 1 + .../data/rename_a25rr/multi/rx9-m23/b.js | 2 + .../data/rename_a25rr/multi/rx9-m24/a.js | 1 + .../data/rename_a25rr/multi/rx9-m24/b.js | 2 + .../data/rename_a25rr/multi/rx9-m25/a.js | 1 + .../data/rename_a25rr/multi/rx9-m25/b.js | 2 + .../data/rename_a25rr/multi/rx9-m26/a.js | 1 + .../data/rename_a25rr/multi/rx9-m26/b.js | 2 + .../data/rename_a25rr/multi/rx9-m27/a.js | 2 + .../data/rename_a25rr/multi/rx9-m27/b.js | 1 + .../data/rename_a25rr/multi/rx9-m28/a.js | 1 + .../data/rename_a25rr/multi/rx9-m28/b.js | 2 + .../data/rename_a25rr/multi/rx9-m29/a.js | 1 + .../data/rename_a25rr/multi/rx9-m29/b.js | 2 + .../tests/data/rename_a25rr/multi/rx9-m3/a.js | 1 + .../tests/data/rename_a25rr/multi/rx9-m3/b.js | 3 + .../data/rename_a25rr/multi/rx9-m30/a.js | 1 + .../data/rename_a25rr/multi/rx9-m30/b.js | 2 + .../data/rename_a25rr/multi/rx9-m31/a.js | 1 + .../data/rename_a25rr/multi/rx9-m31/b.js | 2 + .../data/rename_a25rr/multi/rx9-m32/a.js | 1 + .../data/rename_a25rr/multi/rx9-m32/b.js | 2 + .../data/rename_a25rr/multi/rx9-m33/a.js | 1 + .../data/rename_a25rr/multi/rx9-m33/b.js | 2 + .../data/rename_a25rr/multi/rx9-m34/a.js | 1 + .../data/rename_a25rr/multi/rx9-m34/b.js | 2 + .../data/rename_a25rr/multi/rx9-m35/a.js | 1 + .../data/rename_a25rr/multi/rx9-m35/b.js | 2 + .../data/rename_a25rr/multi/rx9-m36/a.js | 1 + .../data/rename_a25rr/multi/rx9-m36/b.js | 2 + .../data/rename_a25rr/multi/rx9-m37/a.js | 1 + .../data/rename_a25rr/multi/rx9-m37/b.js | 2 + .../data/rename_a25rr/multi/rx9-m38/a.js | 1 + .../data/rename_a25rr/multi/rx9-m38/b.js | 2 + .../data/rename_a25rr/multi/rx9-m39/a.js | 1 + .../data/rename_a25rr/multi/rx9-m39/b.js | 2 + .../tests/data/rename_a25rr/multi/rx9-m4/a.js | 1 + .../tests/data/rename_a25rr/multi/rx9-m4/b.js | 3 + .../data/rename_a25rr/multi/rx9-m40/a.js | 1 + .../data/rename_a25rr/multi/rx9-m40/b.js | 2 + .../data/rename_a25rr/multi/rx9-m41/a.js | 1 + .../data/rename_a25rr/multi/rx9-m41/b.js | 2 + .../data/rename_a25rr/multi/rx9-m42/a.js | 1 + .../data/rename_a25rr/multi/rx9-m42/b.js | 2 + .../tests/data/rename_a25rr/multi/rx9-m6/a.js | 1 + .../tests/data/rename_a25rr/multi/rx9-m6/b.js | 3 + .../tests/data/rename_a25rr/multi/rx9-m7/a.js | 1 + .../tests/data/rename_a25rr/multi/rx9-m7/b.js | 3 + .../tests/data/rename_a25rr/multi/rx9-m8/a.js | 1 + .../tests/data/rename_a25rr/multi/rx9-m8/b.js | 3 + .../tests/data/rename_a25rr/multi/rx9-m9/a.js | 1 + .../tests/data/rename_a25rr/multi/rx9-m9/b.js | 3 + .../data/rename_a25rr/single/q-rx9-a15.js | 3 + .../tests/data/rename_a25rr/single/rx9-a1.js | 3 + .../tests/data/rename_a25rr/single/rx9-a10.js | 3 + .../tests/data/rename_a25rr/single/rx9-a11.js | 3 + .../tests/data/rename_a25rr/single/rx9-a12.js | 3 + .../tests/data/rename_a25rr/single/rx9-a13.js | 3 + .../tests/data/rename_a25rr/single/rx9-a14.js | 3 + .../tests/data/rename_a25rr/single/rx9-a16.js | 3 + .../tests/data/rename_a25rr/single/rx9-a17.js | 3 + .../tests/data/rename_a25rr/single/rx9-a18.js | 3 + .../tests/data/rename_a25rr/single/rx9-a19.js | 3 + .../tests/data/rename_a25rr/single/rx9-a2.js | 3 + .../tests/data/rename_a25rr/single/rx9-a20.js | 3 + .../tests/data/rename_a25rr/single/rx9-a21.js | 3 + .../tests/data/rename_a25rr/single/rx9-a22.js | 3 + .../tests/data/rename_a25rr/single/rx9-a23.js | 3 + .../tests/data/rename_a25rr/single/rx9-a24.js | 3 + .../tests/data/rename_a25rr/single/rx9-a25.js | 3 + .../tests/data/rename_a25rr/single/rx9-a26.js | 3 + .../tests/data/rename_a25rr/single/rx9-a3.js | 3 + .../tests/data/rename_a25rr/single/rx9-a4.js | 3 + .../tests/data/rename_a25rr/single/rx9-a5.js | 3 + .../tests/data/rename_a25rr/single/rx9-a6.js | 3 + .../tests/data/rename_a25rr/single/rx9-a7.js | 3 + .../tests/data/rename_a25rr/single/rx9-a8.js | 3 + .../tests/data/rename_a25rr/single/rx9-a9.js | 3 + 130 files changed, 1184 insertions(+), 101 deletions(-) create mode 100644 crates/untwist-deobfuscate/src/calls/agnostic/chain_text.rs create mode 100644 crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/chains.rs create mode 100644 crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holder_uses.rs create mode 100644 crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/numeric.rs create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m1/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m1/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m10/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m10/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m11/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m11/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m12/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m12/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m13/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m13/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m14/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m14/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m15/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m15/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m16/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m16/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m17/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m17/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m18/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m18/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m19/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m19/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m2/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m2/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m20/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m20/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m21/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m21/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m22/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m22/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m23/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m23/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m24/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m24/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m25/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m25/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m26/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m26/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m27/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m27/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m28/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m28/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m29/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m29/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m3/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m3/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m30/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m30/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m31/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m31/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m32/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m32/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m33/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m33/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m34/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m34/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m35/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m35/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m36/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m36/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m37/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m37/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m38/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m38/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m39/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m39/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m4/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m4/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m40/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m40/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m41/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m41/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m42/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m42/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m6/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m6/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m7/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m7/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m8/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m8/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m9/a.js create mode 100644 crates/untwist/tests/data/rename_a25rr/multi/rx9-m9/b.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/q-rx9-a15.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a1.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a10.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a11.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a12.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a13.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a14.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a16.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a17.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a18.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a19.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a2.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a20.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a21.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a22.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a23.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a24.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a25.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a26.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a3.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a4.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a5.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a6.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a7.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a8.js create mode 100644 crates/untwist/tests/data/rename_a25rr/single/rx9-a9.js diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/assembled.rs b/crates/untwist-deobfuscate/src/calls/agnostic/assembled.rs index 30a58ee36..877d084a2 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/assembled.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/assembled.rs @@ -159,7 +159,10 @@ impl<'a> Scan<'_, '_, 'a> { let alias = self.alias_of(statements.get(next)?, table)?; let references = self.scoping.get_resolved_reference_ids(table).len(); let unchecked = flow_rule_disabled(BUILT_LITERAL); - if !unchecked && (references != writes.len() + 1 || self.scoping.symbol_is_mutated(table)) { + if !unchecked + && (references != writes.len() + 1 + || crate::calls::agnostic::rebound(self.scoping, table)) + { return None; } Some((alias, Assembled { fields, writes })) diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/bind.rs b/crates/untwist-deobfuscate/src/calls/agnostic/bind.rs index aed413a06..d14b6d24d 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/bind.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/bind.rs @@ -195,7 +195,7 @@ fn inlinable_of(defs: &DefTable<'_>, scoping: &Scoping) -> FxHashSet { for (_, found) in defs.present() { if let Some(func) = inlinable_func(&found) { if plain_param_syms(func).iter().all(|sym| { - !scoping.symbol_is_mutated(*sym) + !crate::calls::agnostic::rebound(scoping, *sym) && defs.get(*sym).is_none_or(|d| d.writes.is_empty()) }) { inlinable.insert(func.span.start); @@ -322,7 +322,7 @@ impl<'s, 'a> Bindings<'s, 'a> { bindings.unsealed_maps = std::mem::take(&mut bindings.map_uses).unsealed(resolve); let annex = std::mem::take(&mut bindings.annex); bindings.defs.each_present_mut(|symbol, def| { - def.set_to(MUTATED, scoping.symbol_is_mutated(symbol)); + def.set_to(MUTATED, crate::calls::agnostic::rebound(scoping, symbol)); if annex.contains(scoping.symbol_name(symbol)) { def.set(OPAQUE); } @@ -545,7 +545,7 @@ impl<'s, 'a> Bindings<'s, 'a> { } match self.defs.get(symbol) { Some(defs) => !defs.mutated && defs.writes.is_empty(), - None => !self.scoping.symbol_is_mutated(symbol), + None => !crate::calls::agnostic::rebound(self.scoping, symbol), } } diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap.rs b/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap.rs index bd1df73d6..94723fefb 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap.rs @@ -324,7 +324,7 @@ fn shape<'a>( .id .as_ref() .and_then(|id| id.symbol_id.get()) - .filter(|symbol| !scoping.symbol_is_mutated(*symbol)) + .filter(|symbol| !crate::calls::agnostic::rebound(scoping, *symbol)) .ok_or(DISPATCH_SHAPE)?; if dispatch.optional { return Err(DISPATCH_SHAPE); @@ -452,7 +452,7 @@ impl<'a> Uses<'_, 'a> { let escapes = self.helper_reads.iter().any(|read| read == name); !escapes && (dead - || (!self.scoping.symbol_is_mutated(*symbol) + || (!crate::calls::agnostic::rebound(self.scoping, *symbol) && calls().all(|(_, call)| { call.arguments .get(at) @@ -711,14 +711,14 @@ pub(super) fn prove<'a>( let (outer, shape) = found?; let table_symbol = outer.table; let table = table_of(scoping, outer.elements).ok_or(TABLE_NOT_LITERAL)?; - if scoping.symbol_is_mutated(table_symbol) || !outer.plain { + if crate::calls::agnostic::rebound(scoping, table_symbol) || !outer.plain { return Err(TABLE_ESCAPES); } let mut aliases = FxHashSet::default(); for params in &table.functions { for index in &shape.aliases { if let Some(symbol) = params.items.get(*index).and_then(binding_symbol) { - if scoping.symbol_is_mutated(symbol) { + if crate::calls::agnostic::rebound(scoping, symbol) { return Err(REQUIRE_ESCAPES); } aliases.insert(symbol); diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap/getter.rs b/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap/getter.rs index 49efc0f80..dde97b578 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap/getter.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap/getter.rs @@ -59,7 +59,7 @@ fn for_in_pair<'a>( }; let key = id.symbol_id.get()?; let plain = declarator.init.is_none() - && !scoping.symbol_is_mutated(key) + && !crate::calls::agnostic::rebound(scoping, key) && names(scoping, &each.right, definition); plain.then_some((key, &**each)) } @@ -126,7 +126,7 @@ pub(super) fn getter_read( return None; } let definition = params.items.get(1).and_then(binding_symbol)?; - if scoping.symbol_is_mutated(definition) + if crate::calls::agnostic::rebound(scoping, definition) || calls .iter() .any(|call| !call.arguments.get(1).is_some_and(function_literal)) diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap/record.rs b/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap/record.rs index fa091f6d2..12b3a5be1 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap/record.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/bootstrap/record.rs @@ -104,7 +104,7 @@ fn caches_confined( escapes: false, }; uses.visit_program(program); - !uses.escapes && !scoping.symbol_is_mutated(symbol) + !uses.escapes && !crate::calls::agnostic::rebound(scoping, symbol) }) } @@ -229,7 +229,7 @@ pub(super) fn module_record<'a>(scoping: &Scoping, shape: &Shape<'a>) -> Option< return None; }; let symbol = id.symbol_id.get()?; - if scoping.symbol_is_mutated(symbol) { + if crate::calls::agnostic::rebound(scoping, symbol) { return None; } let mut caches = Vec::new(); @@ -300,7 +300,7 @@ pub(super) fn dispatched_objects( continue; } if let Some(symbol) = binding_symbol(param) { - if !scoping.symbol_is_mutated(symbol) { + if !crate::calls::agnostic::rebound(scoping, symbol) { objects.push(symbol); } } diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/bound_this.rs b/crates/untwist-deobfuscate/src/calls/agnostic/bound_this.rs index 508632949..dc7f14cf9 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/bound_this.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/bound_this.rs @@ -85,7 +85,7 @@ impl Literals<'_> { let Some((symbol, object)) = object_declarator(declarator) else { return; }; - if self.tables.contains(&symbol) || self.scoping.symbol_is_mutated(symbol) { + if self.tables.contains(&symbol) || crate::calls::agnostic::rebound(self.scoping, symbol) { return; } if let Some(literal) = literal_of(object) { @@ -125,8 +125,12 @@ impl Literals<'_> { let alias = self.alias_of(statements.get(next)?, table)?; let references = self.scoping.get_resolved_reference_ids(table).len(); let unchecked = flow_rule_disabled(BUILT_LITERAL); - let sole = references == writes + 1 && !self.scoping.symbol_is_mutated(table); - if writes == 0 || !(unchecked || sole) || self.scoping.symbol_is_mutated(alias) { + let sole = + references == writes + 1 && !crate::calls::agnostic::rebound(self.scoping, table); + if writes == 0 + || !(unchecked || sole) + || crate::calls::agnostic::rebound(self.scoping, alias) + { return None; } self.tables.insert(table); diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/chain_text.rs b/crates/untwist-deobfuscate/src/calls/agnostic/chain_text.rs new file mode 100644 index 000000000..604222e41 --- /dev/null +++ b/crates/untwist-deobfuscate/src/calls/agnostic/chain_text.rs @@ -0,0 +1,171 @@ +use oxc_ast::ast::*; +use oxc_ast_visit::{walk_js, VisitJs}; +use untwist_core::ast_util::js_text::js_text; + +const CHAIN_NAMES: [&str; 8] = [ + "__proto__", + "prototype", + "setPrototypeOf", + "getPrototypeOf", + "getOwnPropertyDescriptor", + "getOwnPropertyDescriptors", + "__lookupSetter__", + "__defineSetter__", +]; + +const RUNNER_NAMES: [&str; 8] = [ + "eval", + "Function", + "constructor", + "execScript", + "setTimeout", + "setInterval", + "setImmediate", + "importScripts", +]; + +const FUNCTION_FORM: (&str, &str) = ("(function () {\n", "\n});"); + +pub(super) fn text_spares_chains(text: &str, depth: u8) -> bool { + let Some(next) = depth.checked_sub(1) else { + return false; + }; + let wrapped = format!("{}{text}{}", FUNCTION_FORM.0, FUNCTION_FORM.1); + [text, wrapped.as_str()].iter().any(|form| { + crate::proof::with_parsed_text(form, |program| { + let mut scan = ChainText::default(); + scan.visit_program(program); + (!scan.open).then_some(scan.nested) + }) + .flatten() + .flatten() + .is_some_and(|nested| nested.iter().all(|inner| text_spares_chains(inner, next))) + }) +} + +#[derive(Default)] +struct ChainText { + open: bool, + nested: Vec, +} + +impl ChainText { + fn name(&mut self, name: &str) { + self.open |= CHAIN_NAMES.contains(&name); + } + + fn runner_callee(callee: &Expression<'_>) -> bool { + match callee.without_parentheses() { + Expression::Identifier(id) => RUNNER_NAMES.contains(&id.name.as_str()), + Expression::StaticMemberExpression(member) => { + RUNNER_NAMES.contains(&member.property.name.as_str()) + } + _ => false, + } + } + + fn texts(&mut self, arguments: &[Argument<'_>]) { + for argument in arguments { + match argument { + Argument::StringLiteral(text) => self.nested.push(js_text(text.value).into_owned()), + Argument::TemplateLiteral(template) if template.expressions.is_empty() => { + match template.quasis.first().and_then(|quasi| quasi.value.cooked) { + Some(cooked) => self.nested.push(js_text(cooked).into_owned()), + None => self.open = true, + } + } + Argument::NumericLiteral(_) + | Argument::FunctionExpression(_) + | Argument::ArrowFunctionExpression(_) => {} + _ => self.open = true, + } + } + } +} + +impl<'a> VisitJs<'a> for ChainText { + fn visit_identifier_reference(&mut self, it: &IdentifierReference<'a>) { + self.name(&it.name); + self.open |= RUNNER_NAMES.contains(&it.name.as_str()); + } + + fn visit_binding_identifier(&mut self, it: &BindingIdentifier<'a>) { + self.name(&it.name); + } + + fn visit_identifier_name(&mut self, it: &IdentifierName<'a>) { + self.name(&it.name); + self.open |= RUNNER_NAMES.contains(&it.name.as_str()); + } + + fn visit_string_literal(&mut self, it: &StringLiteral<'a>) { + self.name(&js_text(it.value)); + } + + fn visit_template_element(&mut self, it: &TemplateElement<'a>) { + match it.value.cooked { + Some(cooked) => self.name(&js_text(cooked)), + None => self.open = true, + } + } + + fn visit_computed_member_expression(&mut self, it: &ComputedMemberExpression<'a>) { + let literal = matches!( + it.expression.without_parentheses(), + Expression::StringLiteral(_) | Expression::NumericLiteral(_) + ); + self.open |= !literal; + walk_js::walk_computed_member_expression(self, it); + } + + fn visit_with_statement(&mut self, it: &WithStatement<'a>) { + self.open = true; + walk_js::walk_with_statement(self, it); + } + + fn visit_tagged_template_expression(&mut self, it: &TaggedTemplateExpression<'a>) { + self.open = true; + walk_js::walk_tagged_template_expression(self, it); + } + + fn visit_import_expression(&mut self, it: &ImportExpression<'a>) { + self.open = true; + walk_js::walk_import_expression(self, it); + } + + fn visit_call_expression(&mut self, it: &CallExpression<'a>) { + if Self::runner_callee(&it.callee) { + self.texts(&it.arguments); + for argument in &it.arguments { + if let Some(expr) = argument.as_expression() { + if matches!( + expr, + Expression::FunctionExpression(_) | Expression::ArrowFunctionExpression(_) + ) { + self.visit_expression(expr); + } + } + } + self.visit_runner_callee(&it.callee); + return; + } + walk_js::walk_call_expression(self, it); + } + + fn visit_new_expression(&mut self, it: &NewExpression<'a>) { + if Self::runner_callee(&it.callee) { + self.texts(&it.arguments); + self.visit_runner_callee(&it.callee); + return; + } + walk_js::walk_new_expression(self, it); + } +} + +impl ChainText { + fn visit_runner_callee(&mut self, callee: &Expression<'_>) { + if let Expression::StaticMemberExpression(member) = callee.without_parentheses() { + self.visit_expression(&member.object); + } + } +} diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/holds.rs b/crates/untwist-deobfuscate/src/calls/agnostic/holds.rs index c12302a65..12db17e2c 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/holds.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/holds.rs @@ -56,7 +56,7 @@ impl<'a> VisitJs<'a> for MemberTarget { } } -fn writes_a_member(target: &AssignmentTarget<'_>) -> bool { +pub(in crate::calls::agnostic) fn writes_a_member(target: &AssignmentTarget<'_>) -> bool { let mut scan = MemberTarget::default(); scan.visit_assignment_target(target); scan.found diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/judge.rs b/crates/untwist-deobfuscate/src/calls/agnostic/judge.rs index 8a507dc08..600976477 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/judge.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/judge.rs @@ -424,11 +424,13 @@ impl<'s, 'a> Sites<'s, 'a> { pub(super) fn judge_collected(mut self) -> (Agnostic<'a>, bool, bool) { self.judge_script_sinks(); if !self.walks_on() { + self.out.text_unknown = true; return self.into_saturated(); } let calls = std::mem::take(&mut self.calls); for call in calls { if !self.walks_on() { + self.out.text_unknown = true; return self.into_saturated(); } self.judge_call(call); @@ -447,7 +449,11 @@ impl<'s, 'a> Sites<'s, 'a> { self.check_template(template.span, &template.quasi, self.unbounded_text()); } } - if saturated_while_watching || !self.element_bounds_hold() { + if !self.element_bounds_hold() { + self.out.text_unknown |= !self.element_bounds_hold_beside_blocks(); + return self.into_saturated(); + } + if saturated_while_watching { return self.into_saturated(); } let (chains, natives) = self.assumptions_hold(); @@ -465,18 +471,32 @@ impl<'s, 'a> Sites<'s, 'a> { } fn element_bounds_hold(&self) -> bool { + self.element_bounds_hold_without(|_| false) + } + + fn element_bounds_hold_beside_blocks(&self) -> bool { + let blocks = &self.fresh.bindings.loose; + self.element_bounds_hold_without(|span| blocks.exempt(span) || self.in_machinery(span)) + } + + fn element_bounds_hold_without(&self, exempt: impl Fn(Span) -> bool) -> bool { !self.bounds_used.get() - || !self.out.sites.iter().any(|site| { - matches!( - site.root, - ProtoRoot::Array | ProtoRoot::Object | ProtoRoot::Either - ) && match &site.key { - AKey::Named(name) => { - !name.is_empty() && name.bytes().all(|byte| byte.is_ascii_digit()) + || !self + .out + .sites + .iter() + .filter(|site| !exempt(site.span)) + .any(|site| { + matches!( + site.root, + ProtoRoot::Array | ProtoRoot::Object | ProtoRoot::Either + ) && match &site.key { + AKey::Named(name) => { + !name.is_empty() && name.bytes().all(|byte| byte.is_ascii_digit()) + } + AKey::Index | AKey::Pending(_) | AKey::Filtered(_) | AKey::Unknown => true, } - AKey::Index | AKey::Pending(_) | AKey::Filtered(_) | AKey::Unknown => true, - } - }) + }) } pub(super) fn assumptions_hold(&self) -> (bool, bool) { diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/mod.rs b/crates/untwist-deobfuscate/src/calls/agnostic/mod.rs index 5a2bfdb26..b424197e4 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/mod.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/mod.rs @@ -4,6 +4,7 @@ mod bind; mod bootstrap; mod bound_once; mod bound_this; +mod chain_text; mod consume; mod defs; mod filtered; @@ -119,6 +120,9 @@ pub struct Agnostic<'a> { pub(super) stores_global: bool, pub(super) pending_texts: Vec, pub(super) judged_texts: Vec, + pub(super) symbol_text: bool, + pub(super) chain_text: bool, + pub(super) text_unknown: bool, pub bootstrap: Option<&'static str>, #[cfg(feature = "refusal-spans")] pub(super) trail: Vec, @@ -406,7 +410,7 @@ fn text_reach<'a>( defer: true, printers_quiet: false, runner_texts, - texts_in_every_lane: false, + texts_in_every_lane: true, sources_outside: false, }; let found = settle(program, scoping, (None, &[], watch)).0; @@ -592,3 +596,9 @@ pub fn fold_record(program: &Program<'_>, scoping: &Scoping) -> FoldRecord { code_text: found.code_text.is_some() || found.saturated, } } + +pub(crate) fn rebound(scoping: &Scoping, symbol: SymbolId) -> bool { + scoping.symbol_is_mutated(symbol) + || (scoping.symbol_scope_id(symbol) == scoping.root_scope_id() + && untwist_core::semantic::is_shared_global(scoping.symbol_name(symbol))) +} diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/chains.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/chains.rs new file mode 100644 index 000000000..01d5b74d1 --- /dev/null +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/chains.rs @@ -0,0 +1,162 @@ +use oxc_ast::ast::*; +use oxc_ast::AstKind; +use oxc_syntax::operator::BinaryOperator; +use oxc_syntax::symbol::SymbolFlags; +use std::borrow::Cow; +use untwist_core::ast_util::js_text::js_text; +use untwist_core::semantic::{observers, Observers}; + +use super::{member_address, same, str_const, Walker, KIND_DEPTH}; + +const PROTOTYPE_READERS: [&str; 5] = [ + "__proto__", + "getPrototypeOf", + "getOwnPropertyDescriptor", + "getOwnPropertyDescriptors", + "__lookupSetter__", +]; + +const CONSTRUCTORS: [&str; 18] = [ + "Object", "Function", "Array", "String", "Number", "Boolean", "Symbol", "BigInt", "RegExp", + "Date", "Error", "Map", "Set", "WeakMap", "WeakSet", "Promise", "Reflect", "Iterator", +]; + +impl<'s, 'a> Walker<'s, 'a> { + pub(super) fn collect_chain(&mut self, kind: AstKind<'a>) { + if self.chains_open { + return; + } + let obtained = match kind { + AstKind::StaticMemberExpression(member) => { + self.member_obtains(member.property.name.as_str(), &member.object) + } + 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), + } + } + AstKind::StringLiteral(text) => { + !self.member_key_position() + && !self.decoded_array_text(text.span) + && PROTOTYPE_READERS.contains(&js_text(text.value).as_ref()) + } + AstKind::TemplateElement(element) => element + .value + .cooked + .is_some_and(|cooked| PROTOTYPE_READERS.contains(&js_text(cooked).as_ref())), + AstKind::IdentifierReference(id) => self.reference_obtains(id), + AstKind::IdentifierName(name) => PROTOTYPE_READERS[1..].contains(&name.name.as_str()), + AstKind::WithStatement(_) => true, + _ => false, + }; + self.chains_open |= obtained; + } + + fn member_obtains(&self, key: &str, object: &Expression<'a>) -> bool { + match key { + "__proto__" => !self.member_written(), + "prototype" => !self.user_constructor(object) && self.value_position(), + _ => false, + } + } + + fn decoded_array_text(&self, span: oxc_span::Span) -> bool { + self.resolve.is_some() + && self + .array_functions + .values() + .any(|function| function.start <= span.start && span.end <= function.end) + } + + fn member_key_position(&self) -> bool { + let at = self.stack.len() - 1; + let Some((up, child)) = self.parent(at) else { + return false; + }; + matches!(self.stack[up], AstKind::ComputedMemberExpression(member) if same(&member.expression, child)) + } + + fn member_written(&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.left.as_member_expression().is_some_and(|target| member_address(target) == child)) + } + + fn value_position(&self) -> bool { + let at = self.stack.len() - 1; + let Some((up, child)) = self.parent(at) else { + return true; + }; + let key: Cow<'_, str> = match self.stack[up] { + AstKind::StaticMemberExpression(outer) if same(&outer.object, child) => { + Cow::Borrowed(outer.property.name.as_str()) + } + AstKind::ComputedMemberExpression(outer) if same(&outer.object, child) => { + match str_const(&outer.expression, self.resolve, KIND_DEPTH) { + Some(key) => Cow::Owned(key), + None => return true, + } + } + AstKind::AssignmentExpression(assign) => { + return !assign + .left + .as_member_expression() + .is_some_and(|target| member_address(target) == child) + } + _ => return true, + }; + key == "__proto__" + } + + fn user_constructor(&self, object: &Expression<'a>) -> bool { + match object.without_parentheses() { + Expression::FunctionExpression(_) | Expression::ClassExpression(_) => true, + Expression::Identifier(id) => self.symbol(id).is_some_and(|symbol| { + self.scoping + .symbol_flags(symbol) + .intersects(SymbolFlags::Function | SymbolFlags::Class) + && !crate::calls::agnostic::rebound(self.scoping, symbol) + && !self.opaque.contains(&symbol) + }), + _ => false, + } + } + + fn constructor_name(&self, object: &Expression<'a>) -> bool { + match object.without_parentheses() { + Expression::Identifier(id) => { + self.symbol(id).is_none() && CONSTRUCTORS.contains(&id.name.as_str()) + } + _ => false, + } + } + + fn reference_obtains(&self, id: &IdentifierReference<'a>) -> bool { + if self.symbol(id).is_some() || !CONSTRUCTORS.contains(&id.name.as_str()) { + return false; + } + let at = self.stack.len() - 1; + let Some((up, child)) = self.parent(at) else { + return true; + }; + match self.stack[up] { + AstKind::StaticMemberExpression(m) => !same(&m.object, child), + AstKind::ComputedMemberExpression(m) => !same(&m.object, child), + AstKind::CallExpression(call) => !same(&call.callee, child), + AstKind::NewExpression(new) => !same(&new.callee, child), + AstKind::BinaryExpression(binary) => { + !(binary.operator == BinaryOperator::Instanceof && same(&binary.right, child)) + } + AstKind::UnaryExpression(_) => false, + _ => true, + } + } + + pub(super) fn settle_chains(&mut self, texts_run: bool) { + self.builtins_trusted = observers() == Observers::None || !(self.chains_open || texts_run); + } +} diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/flows.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/flows.rs index da44b085b..6beed5ee0 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/flows.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/flows.rs @@ -83,7 +83,7 @@ impl<'s, 'a> Walker<'s, 'a> { .candidates .get(&symbol) .is_some_and(|candidate| function_literal(candidate.init)); - declared && !self.scoping.symbol_is_mutated(symbol) + declared && !crate::calls::agnostic::rebound(self.scoping, symbol) }), other => other.as_member_expression().is_some_and(|reader| { member_key(reader, self.resolve) 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 new file mode 100644 index 000000000..da019c1d4 --- /dev/null +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holder_uses.rs @@ -0,0 +1,150 @@ +use oxc_ast::ast::*; +use oxc_ast::AstKind; +use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, UnaryOperator}; +use std::borrow::Cow; + +use super::{member_address, same, str_const, Walker, KIND_DEPTH}; + +const PROTO_KEYS: [&str; 6] = [ + "__proto__", + "__defineGetter__", + "__defineSetter__", + "__lookupGetter__", + "__lookupSetter__", + "constructor", +]; + +#[derive(Default)] +pub(super) struct HolderUses<'a> { + pub(super) escaped: bool, + pub(super) protos: Vec>>, + pub(super) written: Vec>, + pub(super) called: Vec>, +} + +enum Use<'a> { + Plain, + Escape, + Proto(Option<&'a Expression<'a>>), + Written(Cow<'a, str>), + Called(Cow<'a, str>), +} + +fn proto_key(key: &str) -> bool { + PROTO_KEYS.contains(&key) +} + +fn harmless_binary(operator: BinaryOperator, right: bool) -> bool { + matches!( + operator, + BinaryOperator::StrictEquality | BinaryOperator::StrictInequality + ) || (operator == BinaryOperator::Instanceof && !right) + || (operator == BinaryOperator::In && right) +} + +impl<'s, 'a> Walker<'s, 'a> { + pub(super) fn collect_holder_use(&mut self, id: &IdentifierReference<'a>) { + let Some(symbol) = self.symbol(id) else { + return; + }; + let read = id + .reference_id + .get() + .is_some_and(|reference| self.scoping.get_reference(reference).is_read()); + if !read { + return; + } + let found = self.holder_use(self.stack.len() - 1); + let uses = self.holder_uses.entry(symbol).or_default(); + match found { + Use::Plain => {} + Use::Escape => uses.escaped = true, + Use::Proto(value) => uses.protos.push(value), + Use::Written(key) => uses.written.push(key), + Use::Called(key) => uses.called.push(key), + } + } + + fn holder_use(&self, at: usize) -> Use<'a> { + let Some((up, child)) = self.parent(at) else { + return Use::Escape; + }; + match self.stack[up] { + AstKind::StaticMemberExpression(m) if same(&m.object, child) => { + self.member_use_of(up, Some(Cow::Borrowed(m.property.name.as_str()))) + } + AstKind::ComputedMemberExpression(m) if same(&m.object, child) => { + let key = str_const(&m.expression, self.resolve, KIND_DEPTH).map(Cow::Owned); + self.member_use_of(up, key) + } + AstKind::UnaryExpression(u) + if matches!( + u.operator, + UnaryOperator::Typeof | UnaryOperator::Void | UnaryOperator::LogicalNot + ) => + { + Use::Plain + } + AstKind::BinaryExpression(b) if harmless_binary(b.operator, same(&b.right, child)) => { + Use::Plain + } + AstKind::ExpressionStatement(_) => Use::Plain, + AstKind::IfStatement(s) if same(&s.test, child) => Use::Plain, + AstKind::ConditionalExpression(c) if same(&c.test, child) => Use::Plain, + AstKind::WhileStatement(s) if same(&s.test, child) => Use::Plain, + AstKind::DoWhileStatement(s) if same(&s.test, child) => Use::Plain, + AstKind::ForInStatement(f) if same(&f.right, child) => Use::Plain, + _ => Use::Escape, + } + } + + fn member_use_of(&self, member_at: usize, key: Option>) -> Use<'a> { + let Some((up, child)) = self.parent(member_at) else { + return Use::Plain; + }; + let proto = key.as_deref().is_none_or(proto_key); + match self.stack[up] { + AstKind::CallExpression(call) if same(&call.callee, child) => match key { + Some(key) if !proto => Use::Called(key), + _ => Use::Escape, + }, + AstKind::TaggedTemplateExpression(tagged) if same(&tagged.tag, child) => Use::Escape, + AstKind::AssignmentExpression(assign) if self.targets(&assign.left, child) => match key + { + Some(key) if !proto => Use::Written(key), + _ if numeric_assignment(assign.operator) => Use::Plain, + _ => Use::Proto(Some(&assign.right)), + }, + AstKind::UpdateExpression(_) => Use::Plain, + AstKind::ForInStatement(f) if !same(&f.right, child) => self.target_use(key), + AstKind::ForOfStatement(f) if !same(&f.right, child) => self.target_use(key), + AstKind::AssignmentTargetWithDefault(_) + | AstKind::ArrayAssignmentTarget(_) + | AstKind::AssignmentTargetPropertyProperty(_) + | AstKind::AssignmentTargetRest(_) => self.target_use(key), + _ => Use::Plain, + } + } + + fn targets(&self, left: &AssignmentTarget<'a>, child: oxc_allocator::Address) -> bool { + left.as_member_expression() + .is_some_and(|member| member_address(member) == child) + } + + fn target_use(&self, key: Option>) -> Use<'a> { + match key { + Some(key) if !proto_key(&key) => Use::Written(key), + _ => Use::Proto(None), + } + } +} + +fn numeric_assignment(operator: AssignmentOperator) -> bool { + !matches!( + operator, + AssignmentOperator::Assign + | AssignmentOperator::LogicalAnd + | AssignmentOperator::LogicalOr + | AssignmentOperator::LogicalNullish + ) +} diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holders.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holders.rs index ad144714d..1efa0ac03 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holders.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holders.rs @@ -1,12 +1,12 @@ use oxc_ast::ast::*; use oxc_ast::AstKind; use oxc_syntax::operator::LogicalOperator; -use oxc_syntax::symbol::{SymbolFlags, SymbolId}; +use oxc_syntax::symbol::SymbolId; use std::borrow::Cow; +use untwist_core::semantic::is_shared_global; use super::keys::KeyProof; -use super::{key_kind, str_const, Walker, GLOBAL, KIND_DEPTH, NAMESPACE}; -use crate::proof::GLOBAL_OBJECTS; +use super::{key_kind, property_name, str_const, Resolve, Walker, GLOBAL, KIND_DEPTH, NAMESPACE}; const BUILTIN_CONSTRUCTORS: [&str; 16] = [ "Object", "Function", "Array", "String", "Number", "Boolean", "Symbol", "BigInt", "RegExp", @@ -22,6 +22,10 @@ impl<'s, 'a> Walker<'s, 'a> { ) -> u8 { let text = self.key_text(key, KIND_DEPTH); let open = text.is_none(); + if open && self.numeric_key(key, KIND_DEPTH) { + let global = base & GLOBAL != 0 || self.may_hold_global(object, KIND_DEPTH); + return if global { GLOBAL } else { 0 }; + } if open { match self.key_proof(object, key) { KeyProof::Open => {} @@ -51,7 +55,7 @@ impl<'s, 'a> Walker<'s, 'a> { fn fixed_init(&self, symbol: SymbolId) -> Option<&'a Expression<'a>> { let candidate = self.candidates.get(&symbol)?; - let fixed = !self.scoping.symbol_is_mutated(symbol) + let fixed = !crate::calls::agnostic::rebound(self.scoping, symbol) && self.scoping.symbol_redeclarations(symbol).is_empty() && candidate .function @@ -59,33 +63,39 @@ impl<'s, 'a> Walker<'s, 'a> { fixed.then_some(candidate.init) } - fn may_hold_global(&self, expr: &Expression<'a>, depth: u8) -> bool { + pub(super) fn may_hold_global(&self, expr: &Expression<'a>, depth: u8) -> bool { let Some(next) = depth.checked_sub(1) else { return true; }; match expr.without_parentheses() { + Expression::NullLiteral(_) => false, Expression::StringLiteral(_) | Expression::NumericLiteral(_) | Expression::BigIntLiteral(_) | Expression::BooleanLiteral(_) - | Expression::NullLiteral(_) | Expression::RegExpLiteral(_) | Expression::TemplateLiteral(_) - | Expression::ObjectExpression(_) - | Expression::ArrayExpression(_) - | Expression::FunctionExpression(_) - | Expression::ArrowFunctionExpression(_) - | Expression::ClassExpression(_) | Expression::UnaryExpression(_) | Expression::BinaryExpression(_) - | Expression::UpdateExpression(_) => false, + | Expression::UpdateExpression(_) + | Expression::ArrayExpression(_) + | Expression::FunctionExpression(_) + | Expression::ArrowFunctionExpression(_) => !self.builtins_trusted, + Expression::ClassExpression(class) => { + class.heritage.is_some() || !self.builtins_trusted + } + Expression::ObjectExpression(object) => { + !self.builtins_trusted || sets_own_chain(object, self.resolve) + } Expression::Identifier(id) => match self.symbol(id) { - None => GLOBAL_OBJECTS.contains(&id.name.as_str()), + None => true, Some(symbol) => self.symbol_may_hold_global(symbol, next), }, - Expression::ThisExpression(_) => self.this_open(), - Expression::CallExpression(call) => !self.array_source(call), - Expression::StaticMemberExpression(member) => !self.builtin_prototype(member), + Expression::ThisExpression(_) => true, + Expression::CallExpression(call) => !self.array_source(call) || !self.builtins_trusted, + Expression::StaticMemberExpression(member) => { + !self.builtin_prototype(member) || !self.builtins_trusted + } Expression::ConditionalExpression(c) => { self.may_hold_global(&c.consequent, next) || self.may_hold_global(&c.alternate, next) @@ -105,21 +115,34 @@ impl<'s, 'a> Walker<'s, 'a> { } fn symbol_may_hold_global(&self, symbol: SymbolId, depth: u8) -> bool { - let fixed_callable = self - .scoping - .symbol_flags(symbol) - .intersects(SymbolFlags::Function | SymbolFlags::Class) - && !self.scoping.symbol_is_mutated(symbol) - && self.scoping.symbol_redeclarations(symbol).is_empty(); - if fixed_callable { - return false; + if self.opaque.contains(&symbol) || self.shared_root(symbol) { + return true; } - self.fixed_init(symbol) - .is_none_or(|init| self.may_hold_global(init, depth)) + let Some(init) = self.fixed_init(symbol) else { + return true; + }; + let Some(uses) = self.holder_uses.get(&symbol) else { + return self.may_hold_global(init, depth); + }; + if uses.escaped + || uses + .protos + .iter() + .any(|value| value.is_none_or(|value| self.may_hold_global(value, depth))) + { + return true; + } + let own_method = uses + .called + .iter() + .any(|key| uses.written.contains(key) || init_defines(init, key, self.resolve)); + own_method || self.may_hold_global(init, depth) } - fn this_open(&self) -> bool { - self.this_open.last().copied().unwrap_or(true) + pub(super) fn shared_root(&self, symbol: SymbolId) -> bool { + self.script + && self.scoping.symbol_scope_id(symbol) == self.scoping.root_scope_id() + && is_shared_global(self.scoping.symbol_name(symbol)) } pub(super) fn collect_array_source(&mut self, kind: AstKind<'a>) { @@ -180,5 +203,35 @@ impl<'s, 'a> Walker<'s, 'a> { member.property.name == "prototype" && self.symbol(owner).is_none() && BUILTIN_CONSTRUCTORS.contains(&owner.name.as_str()) + && !self.free_written(owner.name.as_str()) } } + +fn sets_own_chain(object: &ObjectExpression<'_>, resolve: Resolve<'_>) -> bool { + object.properties.iter().any(|property| match property { + ObjectPropertyKind::ObjectProperty(p) => { + p.kind != PropertyKind::Init + || (!p.computed + && !p.shorthand + && !p.method + && property_name(&p.key, resolve).as_deref() == Some("__proto__")) + } + ObjectPropertyKind::SpreadProperty(_) => false, + }) +} + +fn init_defines(init: &Expression<'_>, key: &str, resolve: Resolve<'_>) -> bool { + let object = match init.without_parentheses() { + Expression::ObjectExpression(object) => object, + Expression::ArrayExpression(_) => { + return key == "length" || key.bytes().all(|byte| byte.is_ascii_digit()) + } + _ => return false, + }; + object.properties.iter().any(|property| match property { + ObjectPropertyKind::ObjectProperty(p) => { + property_name(&p.key, resolve).is_none_or(|name| name == key) + } + ObjectPropertyKind::SpreadProperty(_) => true, + }) +} diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/keys.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/keys.rs index b29bef1bd..e6e114d0f 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/keys.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/keys.rs @@ -91,11 +91,11 @@ impl<'s, 'a> Walker<'s, 'a> { } fn settled(&self, symbol: SymbolId) -> bool { - !self.scoping.symbol_is_mutated(symbol) + !crate::calls::agnostic::rebound(self.scoping, symbol) && self.scoping.symbol_redeclarations(symbol).is_empty() } - fn free_written(&self, name: &str) -> bool { + pub(super) fn free_written(&self, name: &str) -> bool { self.scoping .root_unresolved_references() .get(name) 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 d4de5379c..8ff0d969a 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/mod.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/mod.rs @@ -1,7 +1,10 @@ mod blocks; +mod chains; mod flows; +mod holder_uses; mod holders; mod keys; +mod numeric; mod shapes; use std::borrow::Cow; @@ -88,7 +91,6 @@ struct Walker<'s, 'a> { phase: Phase, stack: Vec>, this_global: Vec, - this_open: Vec, functions: Vec
, arguments_used: FxHashSet
, candidates: FxHashMap>, @@ -103,6 +105,12 @@ struct Walker<'s, 'a> { protections: FxHashSet, blocks: Vec<(Span, &'static [&'static str])>, found: Vec, + holder_uses: FxHashMap>, + opaque: &'s FxHashSet, + builtins_trusted: bool, + chains_open: bool, + numeric_writes: FxHashMap>>, + dynamic_scope: bool, } #[derive(Default)] @@ -112,27 +120,33 @@ pub(in crate::calls::agnostic) struct Loose { pub(in crate::calls::agnostic) untrusted_symbol: Option>, } +pub(in crate::calls::agnostic) struct Judged<'k> { + pub(in crate::calls::agnostic) trust_symbol: bool, + pub(in crate::calls::agnostic) opaque: &'k FxHashSet, + pub(in crate::calls::agnostic) texts_run: bool, +} + pub(super) fn loose_uses<'a>( program: &'a Program<'a>, scoping: &Scoping, resolve: Resolve<'_>, - trust_symbol: bool, + judged: Judged<'_>, ) -> Loose { + let script = !untwist_core::semantic::has_module_syntax(program); let mut walker = Walker { scoping, resolve, - script: !untwist_core::semantic::has_module_syntax(program), + script, phase: Phase::Collect, stack: Vec::new(), this_global: Vec::new(), - this_open: Vec::new(), functions: Vec::new(), arguments_used: FxHashSet::default(), candidates: FxHashMap::default(), array_functions: FxHashMap::default(), enumerations: FxHashMap::default(), bound_keys: FxHashMap::default(), - trust_symbol, + trust_symbol: judged.trust_symbol, symbol_proof_used: std::cell::Cell::new(false), assigned_at: FxHashMap::default(), aliases: FxHashMap::default(), @@ -140,8 +154,15 @@ pub(super) fn loose_uses<'a>( protections: FxHashSet::default(), blocks: Vec::new(), found: Vec::new(), + holder_uses: FxHashMap::default(), + opaque: judged.opaque, + builtins_trusted: true, + chains_open: false, + numeric_writes: FxHashMap::default(), + dynamic_scope: false, }; walker.walk(program); + walker.settle_chains(judged.texts_run); walker.aliases = walker.qualified(); walker.phase = Phase::Check; walker.walk(program); @@ -256,10 +277,8 @@ impl<'s, 'a> Walker<'s, 'a> { fn walk(&mut self, program: &'a Program<'a>) { self.stack.clear(); self.this_global.clear(); - self.this_open.clear(); self.functions.clear(); self.this_global.push(self.script); - self.this_open.push(self.script); self.visit_program(program); } @@ -351,7 +370,7 @@ impl<'s, 'a> Walker<'s, 'a> { self.candidates .iter() .filter(|(symbol, candidate)| { - !self.scoping.symbol_is_mutated(**symbol) + !crate::calls::agnostic::rebound(self.scoping, **symbol) && self.scoping.symbol_redeclarations(**symbol).is_empty() && candidate .function @@ -388,7 +407,8 @@ impl<'s, 'a> Walker<'s, 'a> { symbol: SymbolId, init: &'a Expression<'a>, ) -> Option<&'a Function<'a>> { - shapes::returned_function(init).filter(|_| !self.scoping.symbol_is_mutated(symbol)) + shapes::returned_function(init) + .filter(|_| !crate::calls::agnostic::rebound(self.scoping, symbol)) } fn collect_params(&mut self, call: &'a CallExpression<'a>) { @@ -594,7 +614,7 @@ impl<'s, 'a> Walker<'s, 'a> { self.scoping .symbol_flags(symbol) .intersects(SymbolFlags::Function | SymbolFlags::Class) - && !self.scoping.symbol_is_mutated(symbol) + && !crate::calls::agnostic::rebound(self.scoping, symbol) } }, Expression::LogicalExpression(l) if l.operator == LogicalOperator::And => { @@ -724,18 +744,12 @@ impl<'s, 'a> VisitJs<'a> for Walker<'s, 'a> { AstKind::Function(function) => { let global = self.global_receiver_function(); self.this_global.push(global); - let strict = function - .scope_id - .get() - .is_some_and(|scope| self.scoping.scope_flags(scope).is_strict_mode()); - self.this_open.push(!strict); self.functions.push(function.unstable_address()); } AstKind::StaticBlock(_) | AstKind::PropertyDefinition(_) | AstKind::AccessorProperty(_) => { self.this_global.push(false); - self.this_open.push(false); } _ => {} } @@ -749,14 +763,12 @@ impl<'s, 'a> VisitJs<'a> for Walker<'s, 'a> { match kind { AstKind::Function(_) => { self.this_global.pop(); - self.this_open.pop(); self.functions.pop(); } AstKind::StaticBlock(_) | AstKind::PropertyDefinition(_) | AstKind::AccessorProperty(_) => { self.this_global.pop(); - self.this_open.pop(); } _ => {} } @@ -770,6 +782,8 @@ impl<'s, 'a> VisitJs<'a> for Walker<'s, 'a> { impl<'s, 'a> Walker<'s, 'a> { fn collect(&mut self, kind: AstKind<'a>) { + self.collect_chain(kind); + self.collect_numeric(kind); self.collect_array_source(kind); self.collect_enumeration(kind); match kind { @@ -784,7 +798,10 @@ impl<'s, 'a> Walker<'s, 'a> { self.arguments_used.insert(*function); } } - AstKind::IdentifierReference(id) => self.collect_reference(id), + AstKind::IdentifierReference(id) => { + self.collect_reference(id); + self.collect_holder_use(id); + } _ => {} } } diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/numeric.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/numeric.rs new file mode 100644 index 000000000..095eb44b7 --- /dev/null +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/numeric.rs @@ -0,0 +1,130 @@ +use oxc_ast::ast::*; +use oxc_ast::AstKind; +use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, UnaryOperator}; +use oxc_syntax::symbol::SymbolId; + +use super::Walker; + +#[derive(Clone, Copy)] +pub(super) enum NumericWrite<'a> { + Numeric, + Value(&'a Expression<'a>), + Unknown, +} + +impl<'s, 'a> Walker<'s, 'a> { + pub(super) fn collect_numeric(&mut self, kind: AstKind<'a>) { + match kind { + AstKind::WithStatement(_) => self.dynamic_scope = true, + AstKind::CallExpression(call) if call.callee.is_specific_id("eval") => { + self.dynamic_scope = true; + } + AstKind::IdentifierReference(id) => self.collect_numeric_write(id), + _ => {} + } + } + + fn collect_numeric_write(&mut self, id: &IdentifierReference<'a>) { + let Some(symbol) = self.symbol(id) else { + return; + }; + let written = id + .reference_id + .get() + .is_some_and(|reference| self.scoping.get_reference(reference).is_write()); + if !written { + return; + } + let write = self.numeric_write(self.stack.len() - 1); + self.numeric_writes.entry(symbol).or_default().push(write); + } + + fn numeric_write(&self, at: usize) -> NumericWrite<'a> { + let Some((up, _)) = self.parent(at) else { + return NumericWrite::Unknown; + }; + match self.stack[up] { + AstKind::UpdateExpression(_) => NumericWrite::Numeric, + AstKind::AssignmentExpression(assign) => match assign.operator { + AssignmentOperator::Assign + | AssignmentOperator::Addition + | AssignmentOperator::LogicalAnd + | AssignmentOperator::LogicalOr + | AssignmentOperator::LogicalNullish => NumericWrite::Value(&assign.right), + _ => NumericWrite::Numeric, + }, + _ => NumericWrite::Unknown, + } + } + + pub(super) fn numeric_key(&self, expr: &Expression<'a>, depth: u8) -> bool { + let Some(next) = depth.checked_sub(1) else { + return false; + }; + match expr.without_parentheses() { + Expression::NumericLiteral(_) | Expression::UpdateExpression(_) => true, + Expression::UnaryExpression(unary) => matches!( + unary.operator, + UnaryOperator::UnaryNegation | UnaryOperator::UnaryPlus | UnaryOperator::BitwiseNot + ), + Expression::BinaryExpression(binary) => match binary.operator { + BinaryOperator::Addition => { + self.numeric_key(&binary.left, next) && self.numeric_key(&binary.right, next) + } + operator => operator.is_arithmetic() || operator.is_bitwise(), + }, + Expression::ConditionalExpression(c) => { + self.numeric_key(&c.consequent, next) && self.numeric_key(&c.alternate, next) + } + Expression::SequenceExpression(s) => s + .expressions + .last() + .is_some_and(|last| self.numeric_key(last, next)), + Expression::Identifier(id) => self + .symbol(id) + .is_some_and(|symbol| self.numeric_symbol(symbol, next)), + Expression::CallExpression(call) => self.fresh_symbol(call), + _ => false, + } + } + + fn fresh_symbol(&self, call: &CallExpression<'a>) -> bool { + let Expression::Identifier(callee) = call.callee.without_parentheses() else { + return false; + }; + let fresh = self.trust_symbol + && callee.name == "Symbol" + && self.symbol(callee).is_none() + && !self.free_written("Symbol"); + if fresh { + self.symbol_proof_used.set(true); + } + fresh + } + + fn numeric_symbol(&self, symbol: SymbolId, depth: u8) -> bool { + if self.dynamic_scope + || self.opaque.contains(&symbol) + || self.shared_root(symbol) + || !self.scoping.symbol_redeclarations(symbol).is_empty() + { + return false; + } + let Some(candidate) = self.candidates.get(&symbol) else { + return false; + }; + let arguments = candidate + .function + .is_some_and(|function| self.arguments_used.contains(&function)); + if arguments || !self.numeric_key(candidate.init, depth) { + return false; + } + self.numeric_writes.get(&symbol).is_none_or(|writes| { + writes.iter().all(|write| match write { + NumericWrite::Numeric => true, + NumericWrite::Value(value) => self.numeric_key(value, depth), + NumericWrite::Unknown => false, + }) + }) + } +} diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/shapes.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/shapes.rs index 3250d6e8b..2e8b52de8 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/shapes.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/shapes.rs @@ -44,7 +44,7 @@ impl<'s, 'a> Walker<'s, 'a> { } } - fn parent(&self, at: usize) -> Option<(usize, Address)> { + pub(super) fn parent(&self, at: usize) -> Option<(usize, Address)> { let mut child = self.stack[at].address(); let mut up = at; while up > 0 { diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/settle.rs b/crates/untwist-deobfuscate/src/calls/agnostic/settle.rs index 19630b207..1e580f94a 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/settle.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/settle.rs @@ -3,9 +3,10 @@ use oxc_ast_visit::VisitJs; use oxc_semantic::Scoping; use oxc_span::Span; use oxc_syntax::symbol::{SymbolFlags, SymbolId}; -use rustc_hash::FxHashMap; +use rustc_hash::{FxHashMap, FxHashSet}; use std::borrow::Cow; use std::cell::RefCell; +use untwist_core::semantic::is_shared_global; use super::assembled::{broken_tables, drop_tables}; use super::bind::Bindings; @@ -14,6 +15,7 @@ use super::flow::Flow; use super::fresh::Fresh; use super::instance::Unwritten; use super::native_map; +use super::reach_text::names_reach_text; use super::sites::*; use super::{AKey, ASite, Agnostic}; use crate::proof::ProtoRoot; @@ -145,9 +147,9 @@ impl Pristine { } } - fn after(self, written: &Written<'_>) -> Self { + fn after(self, written: &Written<'_>, symbol_text: bool) -> Self { Self { - symbol: self.symbol && !written.may_be("Symbol"), + symbol: self.symbol && !written.may_be("Symbol") && !symbol_text, map: self.map && !native_map::may_be_patched(written), unwritten: self.unwritten.after(written), filters: self.filters && !STRING_METHODS.iter().any(|name| written.may_be(name)), @@ -192,20 +194,32 @@ fn settle_ordered<'a>( }; let mut bindings = Bindings::collect(program, scoping, (!watch.names.is_empty(), exempt), resolve); - if !watch.names.is_empty() { - bindings.loose = - super::namespace_uses::loose_uses(program, scoping, resolve, bindings.symbol_safe()); - } - let flow = Flow::new(program, scoping, resolve); - let filters = std::rc::Rc::clone(&bindings.filters); let globals = script_globals(program, scoping); let lexicals = if watch.names.is_empty() { Vec::new() } else { script_lexicals(program, scoping) }; + let shared = shared_roots(program, scoping); + bindings.make_opaque(&shared); + let shared_source = !shared.is_empty(); + let mut opaque: FxHashSet = shared.into_iter().collect(); + let mut texts_run = false; + let scan_loose = |bindings: &Bindings<'_, 'a>, opaque: &FxHashSet, texts_run| { + let judged = super::namespace_uses::Judged { + trust_symbol: bindings.symbol_safe(), + opaque, + texts_run, + }; + super::namespace_uses::loose_uses(program, scoping, resolve, judged) + }; + if !watch.names.is_empty() { + bindings.loose = scan_loose(&bindings, &opaque, texts_run); + } + let flow = Flow::new(program, scoping, resolve); + let filters = std::rc::Rc::clone(&bindings.filters); let mut judged = Judged { - source: bindings.global_source(), + source: bindings.global_source() || shared_source, pristine: Pristine::of(&bindings), }; if judged.source { @@ -224,7 +238,7 @@ fn settle_ordered<'a>( let written = Written::of(&out.sites, machinery, (&filters, scoping)); let next = Judged { source: judged.source || out.global_source, - pristine: judged.pristine.after(&written), + pristine: judged.pristine.after(&written, out.symbol_text), }; if next.source && !judged.source { bindings.hide_calls(&globals); @@ -240,7 +254,26 @@ fn settle_ordered<'a>( ); let broken = broken_tables(&out, &bindings.assembled, machinery); drop_tables(&mut bindings.assembled, &broken); - if rebound.is_empty() && broken.is_empty() && next == judged { + let rescanned = !watch.names.is_empty() && { + let blocks: Vec = machinery + .iter() + .copied() + .chain(bindings.loose.blocks.iter().map(|(span, _)| *span)) + .collect(); + let unblocked = Written::of(&out.sites, &blocks, (&filters, scoping)); + let roots = (globals.as_slice(), lexicals.as_slice()); + let exposed = walker_rebound(&out, &unblocked, roots, (&bindings, next.source)); + let before = opaque.len(); + opaque.extend(exposed); + let ran = !texts_run && out.chain_text; + texts_run |= ran; + let grown = opaque.len() != before || ran; + if grown { + bindings.loose = scan_loose(&bindings, &opaque, texts_run); + } + grown + }; + if rebound.is_empty() && broken.is_empty() && next == judged && !rescanned { let (reach, observed) = rebound_ambient(&out, scoping, &written); out.realm_rebound |= roots_rebound(scoping, &out.sites, machinery, &filters); out.global_source = judged.source; @@ -311,6 +344,18 @@ pub(super) fn script_lexicals(program: &Program<'_>, scoping: &Scoping) -> Vec, scoping: &Scoping) -> Vec { + if untwist_core::semantic::has_module_syntax(program) { + return Vec::new(); + } + scoping + .get_bindings(scoping.root_scope_id()) + .iter() + .filter(|(name, _)| is_shared_global(name.as_str())) + .map(|(_, symbol)| *symbol) + .collect() +} + fn root_bindings(program: &Program<'_>, scoping: &Scoping, lexical: bool) -> Vec { if untwist_core::semantic::has_module_syntax(program) { return Vec::new(); @@ -446,25 +491,82 @@ fn rebound_globals( } } let unseen = |symbol: &&SymbolId| !bindings.is_opaque(**symbol); + let candidates: Vec<&str> = globals + .iter() + .chain(texts) + .filter(unseen) + .map(|symbol| bindings.symbol_name(*symbol)) + .collect(); + let named = names_by_text(out, &candidates); let rewritten = globals.iter().filter(unseen).filter(|symbol| { let name = bindings.symbol_name(**symbol); written.may_be(name) || (source && bindings.state_written(**symbol, written)) - || named_by_text(out, name) + || named.contains(&name) }); let renamed = texts .iter() .filter(unseen) - .filter(|symbol| named_by_text(out, bindings.symbol_name(**symbol))); + .filter(|symbol| named.contains(&bindings.symbol_name(**symbol))); rewritten.chain(renamed).copied().collect() } -fn named_by_text(out: &Agnostic<'_>, name: &str) -> bool { - out.code_text.is_some() - && out - .judged_texts - .iter() - .any(|text| crate::proof::names_a_token(text, &[name])) +fn walker_rebound( + out: &Agnostic<'_>, + written: &Written<'_>, + (globals, lexicals): (&[SymbolId], &[SymbolId]), + (bindings, source): (&Bindings<'_, '_>, bool), +) -> Vec { + let texts: &[SymbolId] = if out.code_text.is_some() { + lexicals + } else { + &[] + }; + if out.text_unknown || out.keyed_global || written.any { + return globals.iter().chain(texts).copied().collect(); + } + let candidates: Vec<&str> = globals + .iter() + .chain(texts) + .map(|symbol| bindings.symbol_name(*symbol)) + .collect(); + let named = names_by_text(out, &candidates); + let rewritten = globals.iter().filter(|symbol| { + let name = bindings.symbol_name(**symbol); + written.may_be(name) + || (source && bindings.state_written(**symbol, written)) + || named.contains(&name) + }); + let renamed = texts + .iter() + .filter(|symbol| named.contains(&bindings.symbol_name(**symbol))); + rewritten.chain(renamed).copied().collect() +} + +fn names_by_text<'k>(out: &Agnostic<'_>, names: &[&'k str]) -> Vec<&'k str> { + if out.code_text.is_none() || names.is_empty() || out.judged_texts.is_empty() { + return Vec::new(); + } + let mut sorted = names.to_vec(); + sorted.sort_unstable(); + sorted.dedup(); + let mut texts: Vec<&str> = out.judged_texts.iter().map(String::as_str).collect(); + texts.sort_unstable(); + texts.dedup(); + let judged = (super::reach_text::TEXT_DEPTH, true); + let mut named = Vec::new(); + for text in texts { + if !names_reach_text(text, (&sorted, &sorted), judged) { + continue; + } + for name in &sorted { + let one = [*name]; + if !named.contains(name) && names_reach_text(text, (&one, &one), judged) { + named.push(*name); + } + } + } + named } fn unwatched_roots<'k>( diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/sites.rs b/crates/untwist-deobfuscate/src/calls/agnostic/sites.rs index b41d97792..9092dec32 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/sites.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/sites.rs @@ -153,6 +153,9 @@ pub(super) struct Sites<'s, 'a> { pub(super) holds: Holds<'s, 'a>, pub(super) known_rests: FxHashMap>>, pub(super) assigned_globals: std::cell::OnceCell>, + pub(super) symbol_spared: Cell, + pub(super) chain_spared: Cell, + pub(super) literal_spared: Cell, } impl<'s, 'a> Sites<'s, 'a> { @@ -227,6 +230,9 @@ impl<'s, 'a> Sites<'s, 'a> { holds, known_rests: FxHashMap::default(), assigned_globals: std::cell::OnceCell::new(), + symbol_spared: Cell::new(false), + chain_spared: Cell::new(false), + literal_spared: Cell::new(false), } } @@ -383,6 +389,9 @@ impl<'s, 'a> Sites<'s, 'a> { if self.out.code_text.is_none() { self.out.code_text = Some(span); } + self.out.symbol_text |= !self.symbol_spared.get(); + self.out.chain_text |= !self.chain_spared.get(); + self.out.text_unknown |= !self.literal_spared.get(); if !self.text_judged { self.out.reach_code.get_or_insert(span); } diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/subst.rs b/crates/untwist-deobfuscate/src/calls/agnostic/subst.rs index 5ba82bed3..cf5565721 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/subst.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/subst.rs @@ -103,7 +103,7 @@ impl<'s, 'a> Sites<'s, 'a> { }; let scoping = self.fresh.scoping; if aliased - || scoping.symbol_is_mutated(symbol) + || crate::calls::agnostic::rebound(scoping, symbol) || !scoping.symbol_redeclarations(symbol).is_empty() { continue; @@ -175,6 +175,7 @@ impl<'s, 'a> Sites<'s, 'a> { pub(super) fn inline_exhausted(&mut self, span: Span) { self.out.code_text.get_or_insert(span); + self.out.text_unknown = true; if !self.text_judged { self.out.reach_code.get_or_insert(span); } diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/text.rs b/crates/untwist-deobfuscate/src/calls/agnostic/text.rs index 61e669b35..a15d192d9 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/text.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/text.rs @@ -79,7 +79,24 @@ impl<'s, 'a> Sites<'s, 'a> { let plain = kind .plain() .is_some_and(|plain| self.text_unsafe(arguments, plain)); + let texts: Vec>> = + arguments.iter().map(Argument::as_expression).collect(); + let literal: Option> = texts + .iter() + .map(|text| text.and_then(|expr| self.text_value(expr, KEY_DEPTH))) + .collect(); + self.spare_texts(literal.as_deref()); self.mark_judged(call_span, kind, plain); + self.spare_texts(None); + } + + fn spare_texts(&self, texts: Option<&[String]>) { + let spared = |judge: fn(&str) -> bool| { + texts.is_some_and(|texts| texts.iter().all(|text| judge(text))) + }; + self.symbol_spared.set(spared(text_spares_symbol)); + self.chain_spared.set(spared(text_spares_chains)); + self.literal_spared.set(texts.is_some()); } fn mark_judged(&mut self, span: Span, kind: Text, plain: bool) { @@ -119,7 +136,10 @@ impl<'s, 'a> Sites<'s, 'a> { }; if writes(kind) { let plain = kind.plain().is_some_and(writes); + let texts = text.as_ref().map(|text| vec![text.to_string()]); + self.spare_texts(texts.as_deref()); self.mark_judged(span, kind, plain); + self.spare_texts(None); } } @@ -421,3 +441,14 @@ impl<'s, 'a> Sites<'s, 'a> { } } } + +const SYMBOL: [&str; 1] = ["Symbol"]; + +fn text_spares_chains(text: &str) -> bool { + super::chain_text::text_spares_chains(text, super::reach_text::TEXT_DEPTH) +} + +fn text_spares_symbol(text: &str) -> bool { + let judged = (super::reach_text::TEXT_DEPTH, true); + !super::reach_text::names_reach_text(text, (&SYMBOL, &SYMBOL), judged) +} diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m1/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m1/a.js new file mode 100644 index 000000000..7f9987378 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m1/a.js @@ -0,0 +1 @@ +var Symbol = { iterator: "eval" }; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m1/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m1/b.js new file mode 100644 index 000000000..05f4658dd --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m1/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +globalThis[Symbol.iterator]("f = function () { return 99; }"); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m10/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m10/a.js new file mode 100644 index 000000000..e3466759f --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m10/a.js @@ -0,0 +1 @@ +var c = globalThis; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m10/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m10/b.js new file mode 100644 index 000000000..727b99eac --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m10/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m11/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m11/a.js new file mode 100644 index 000000000..fbbfd0031 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m11/a.js @@ -0,0 +1 @@ +var o = {}; var o = globalThis; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m11/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m11/b.js new file mode 100644 index 000000000..3adc35bc3 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m11/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m12/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m12/a.js new file mode 100644 index 000000000..9b2894f55 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m12/a.js @@ -0,0 +1 @@ +o = globalThis; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m12/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m12/b.js new file mode 100644 index 000000000..ee338d19a --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m12/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; var d = 1; o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m13/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m13/a.js new file mode 100644 index 000000000..e73c7c325 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m13/a.js @@ -0,0 +1 @@ +function later() { o = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m13/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m13/b.js new file mode 100644 index 000000000..16d3e8055 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m13/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; later(); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m14/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m14/a.js new file mode 100644 index 000000000..a55bb8150 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m14/a.js @@ -0,0 +1 @@ +function later() { globalThis.o = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m14/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m14/b.js new file mode 100644 index 000000000..16d3e8055 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m14/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; later(); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m15/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m15/a.js new file mode 100644 index 000000000..506e3bef8 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m15/a.js @@ -0,0 +1 @@ +function later(k) { globalThis[k] = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m15/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m15/b.js new file mode 100644 index 000000000..b0d603b13 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m15/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; later("o"); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m16/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m16/a.js new file mode 100644 index 000000000..370d41d54 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m16/a.js @@ -0,0 +1 @@ +function later() { Function("o = globalThis")(); } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m16/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m16/b.js new file mode 100644 index 000000000..16d3e8055 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m16/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; later(); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m17/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m17/a.js new file mode 100644 index 000000000..79a57ce14 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m17/a.js @@ -0,0 +1 @@ +var later = { get x() { o = globalThis; } }; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m17/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m17/b.js new file mode 100644 index 000000000..0cf263423 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m17/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; later.x; o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m18/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m18/a.js new file mode 100644 index 000000000..1a2f00602 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m18/a.js @@ -0,0 +1 @@ +Object.defineProperty(globalThis, "zz", { get() { o = globalThis; } }); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m18/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m18/b.js new file mode 100644 index 000000000..91bdbaaea --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m18/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; zz; o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m19/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m19/a.js new file mode 100644 index 000000000..8e4ffe609 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m19/a.js @@ -0,0 +1 @@ +Object.prototype.valueOf = function () { o = globalThis; return 1; }; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m19/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m19/b.js new file mode 100644 index 000000000..34c3c748f --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m19/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; var t = {} + 1; o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m2/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m2/a.js new file mode 100644 index 000000000..b8a788007 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m2/a.js @@ -0,0 +1 @@ +Symbol = { iterator: "eval" }; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m2/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m2/b.js new file mode 100644 index 000000000..05f4658dd --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m2/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +globalThis[Symbol.iterator]("f = function () { return 99; }"); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m20/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m20/a.js new file mode 100644 index 000000000..1e3d22192 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m20/a.js @@ -0,0 +1 @@ +var p = { toString() { o = globalThis; return ""; } }; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m20/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m20/b.js new file mode 100644 index 000000000..8fd3da79f --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m20/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; var t = "" + p; o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m21/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m21/a.js new file mode 100644 index 000000000..02efde3ee --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m21/a.js @@ -0,0 +1 @@ +function later() { k = "f"; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m21/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m21/b.js new file mode 100644 index 000000000..22327057c --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m21/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var k = "x"; later(); globalThis[k] = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m22/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m22/a.js new file mode 100644 index 000000000..6485f5b82 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m22/a.js @@ -0,0 +1 @@ +function later() { k = 2; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m22/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m22/b.js new file mode 100644 index 000000000..f236bd350 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m22/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var k = 1; later(); console.log(k); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m23/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m23/a.js new file mode 100644 index 000000000..d071a1479 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m23/a.js @@ -0,0 +1 @@ +function later() { A = function () { return globalThis; }; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m23/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m23/b.js new file mode 100644 index 000000000..3f1525938 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m23/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +function A() { return {}; } later(); A().f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m24/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m24/a.js new file mode 100644 index 000000000..250eb39ee --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m24/a.js @@ -0,0 +1 @@ +function later() { f = function () { return 99; }; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m24/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m24/b.js new file mode 100644 index 000000000..7bec42aba --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m24/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +later(); console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m25/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m25/a.js new file mode 100644 index 000000000..2a6b4ec1f --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m25/a.js @@ -0,0 +1 @@ +function later() { c = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m25/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m25/b.js new file mode 100644 index 000000000..d23b9be0a --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m25/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var c = {}; later(); var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m26/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m26/a.js new file mode 100644 index 000000000..e73c7c325 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m26/a.js @@ -0,0 +1 @@ +function later() { o = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m26/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m26/b.js new file mode 100644 index 000000000..f0c8ab222 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m26/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +let o = {}; later(); o.f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m27/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m27/a.js new file mode 100644 index 000000000..16946923c --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m27/a.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; function go() { o.f = function () { return 99; }; console.log(f(1), f(2)); } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m27/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m27/b.js new file mode 100644 index 000000000..12bbccbc5 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m27/b.js @@ -0,0 +1 @@ +o = globalThis; go(); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m28/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m28/a.js new file mode 100644 index 000000000..e73c7c325 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m28/a.js @@ -0,0 +1 @@ +function later() { o = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m28/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m28/b.js new file mode 100644 index 000000000..01701d9c1 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m28/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; later(); Object.assign(o, { f: function () { return 99; } }); console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m29/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m29/a.js new file mode 100644 index 000000000..e73c7c325 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m29/a.js @@ -0,0 +1 @@ +function later() { o = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m29/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m29/b.js new file mode 100644 index 000000000..e99615040 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m29/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; later(); (function (q) { q.f = function () { return 99; }; })(o); console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m3/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m3/a.js new file mode 100644 index 000000000..715516fc8 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m3/a.js @@ -0,0 +1 @@ +globalThis.Symbol = { iterator: "eval" }; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m3/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m3/b.js new file mode 100644 index 000000000..42439f596 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m3/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; g[Symbol.iterator]("f = function () { return 99; }"); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m30/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m30/a.js new file mode 100644 index 000000000..e73c7c325 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m30/a.js @@ -0,0 +1 @@ +function later() { o = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m30/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m30/b.js new file mode 100644 index 000000000..4ea4ab49a --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m30/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; later(); o["f"] = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m31/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m31/a.js new file mode 100644 index 000000000..0dc663c9c --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m31/a.js @@ -0,0 +1 @@ +var later = function () { o = globalThis; }; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m31/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m31/b.js new file mode 100644 index 000000000..61f0714ee --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m31/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; later(); o.f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m32/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m32/a.js new file mode 100644 index 000000000..b3478acb2 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m32/a.js @@ -0,0 +1 @@ +function later() { var o2 = "o"; globalThis[o2] = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m32/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m32/b.js new file mode 100644 index 000000000..61f0714ee --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m32/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; later(); o.f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m33/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m33/a.js new file mode 100644 index 000000000..6835887fb --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m33/a.js @@ -0,0 +1 @@ +function later() { this.o = this; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m33/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m33/b.js new file mode 100644 index 000000000..61f0714ee --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m33/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; later(); o.f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m34/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m34/a.js new file mode 100644 index 000000000..e73c7c325 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m34/a.js @@ -0,0 +1 @@ +function later() { o = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m34/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m34/b.js new file mode 100644 index 000000000..8f104a633 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m34/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +function o() {} later(); o.f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m35/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m35/a.js new file mode 100644 index 000000000..e73c7c325 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m35/a.js @@ -0,0 +1 @@ +function later() { o = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m35/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m35/b.js new file mode 100644 index 000000000..29457c93b --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m35/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = []; later(); o.f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m36/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m36/a.js new file mode 100644 index 000000000..e73c7c325 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m36/a.js @@ -0,0 +1 @@ +function later() { o = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m36/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m36/b.js new file mode 100644 index 000000000..dd84afe41 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m36/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +(function () { later(); })(); var o = {}; [1].forEach(later); o.f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m37/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m37/a.js new file mode 100644 index 000000000..e73c7c325 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m37/a.js @@ -0,0 +1 @@ +function later() { o = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m37/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m37/b.js new file mode 100644 index 000000000..6f63325d6 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m37/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; later(); var q = o; q.f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m38/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m38/a.js new file mode 100644 index 000000000..05ef177d0 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m38/a.js @@ -0,0 +1 @@ +function later() { p = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m38/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m38/b.js new file mode 100644 index 000000000..9945dc6a1 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m38/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; var p = o; later(); p.f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m39/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m39/a.js new file mode 100644 index 000000000..c5e3bfb66 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m39/a.js @@ -0,0 +1 @@ +var o; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m39/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m39/b.js new file mode 100644 index 000000000..9a75638ca --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m39/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; later(); o.f = function () { return 99; }; console.log(f(1), f(2)); function later() {} diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m4/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m4/a.js new file mode 100644 index 000000000..4e0f527e7 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m4/a.js @@ -0,0 +1 @@ +function Symbol() {} Symbol.iterator = "eval"; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m4/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m4/b.js new file mode 100644 index 000000000..42439f596 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m4/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; g[Symbol.iterator]("f = function () { return 99; }"); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m40/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m40/a.js new file mode 100644 index 000000000..b125bffda --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m40/a.js @@ -0,0 +1 @@ +function later() { o = globalThis; } var o; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m40/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m40/b.js new file mode 100644 index 000000000..61f0714ee --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m40/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; later(); o.f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m41/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m41/a.js new file mode 100644 index 000000000..658cdcc24 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m41/a.js @@ -0,0 +1 @@ +function later() { ({ o } = { o: globalThis }); } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m41/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m41/b.js new file mode 100644 index 000000000..61f0714ee --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m41/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; later(); o.f = function () { return 99; }; console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m42/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m42/a.js new file mode 100644 index 000000000..e73c7c325 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m42/a.js @@ -0,0 +1 @@ +function later() { o = globalThis; } diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m42/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m42/b.js new file mode 100644 index 000000000..6cb8c7612 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m42/b.js @@ -0,0 +1,2 @@ +function f(a) { return a + 1; } +var o = {}; later(); Reflect.set(o, "f", function () { return 99; }); console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m6/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m6/a.js new file mode 100644 index 000000000..92af9afc7 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m6/a.js @@ -0,0 +1 @@ +(function (k) { globalThis[k] = { iterator: "eval" }; })("Symbol"); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m6/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m6/b.js new file mode 100644 index 000000000..42439f596 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m6/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; g[Symbol.iterator]("f = function () { return 99; }"); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m7/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m7/a.js new file mode 100644 index 000000000..4f7da8cf2 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m7/a.js @@ -0,0 +1 @@ +globalThis.eval("var Symbol = { iterator: \"eval\" }"); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m7/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m7/b.js new file mode 100644 index 000000000..42439f596 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m7/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; g[Symbol.iterator]("f = function () { return 99; }"); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m8/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m8/a.js new file mode 100644 index 000000000..9af548247 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m8/a.js @@ -0,0 +1 @@ +var c = {}; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m8/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m8/b.js new file mode 100644 index 000000000..2de80c004 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m8/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; globalThis.c = globalThis; var n = ["Reflect"][0]; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m9/a.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m9/a.js new file mode 100644 index 000000000..dbc088ff1 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m9/a.js @@ -0,0 +1 @@ +globalThis.c = globalThis; diff --git a/crates/untwist/tests/data/rename_a25rr/multi/rx9-m9/b.js b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m9/b.js new file mode 100644 index 000000000..727b99eac --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/multi/rx9-m9/b.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/q-rx9-a15.js b/crates/untwist/tests/data/rename_a25rr/single/q-rx9-a15.js new file mode 100644 index 000000000..00a5ac870 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/q-rx9-a15.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var X = { prototype: g }; Object.setPrototypeOf(Array.prototype, X.prototype); var R = [][n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a1.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a1.js new file mode 100644 index 000000000..e7b1a08c9 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a1.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var c = {}; globalThis.c = globalThis; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a10.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a10.js new file mode 100644 index 000000000..007e874e3 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a10.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; function P() {} P.prototype = g; var c = { __proto__: P.prototype }; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a11.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a11.js new file mode 100644 index 000000000..153639dbc --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a11.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; function P() {} globalThis.P = globalThis; var c = { __proto__: P }; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a12.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a12.js new file mode 100644 index 000000000..11adf1d03 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a12.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var c = {}; Object.prototype.__lookupSetter__("__proto__").call(c, g); var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a13.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a13.js new file mode 100644 index 000000000..be7f45215 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a13.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var p = ["__proto__"][0]; var c = {}; c[p] = g; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a14.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a14.js new file mode 100644 index 000000000..488dc1020 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a14.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var c = {}; Reflect.set(c, "__proto__", g); var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a16.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a16.js new file mode 100644 index 000000000..362dbd4c8 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a16.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; (function () { var X = { prototype: g }; var c = { __proto__: X.prototype }; var R = c[n]; (function ({ set }) { set(g, "f", function () { return 99; }); })(R); })(); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a17.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a17.js new file mode 100644 index 000000000..f81de730b --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a17.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; Function("\\u006f = globalThis")(); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a18.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a18.js new file mode 100644 index 000000000..1d6c94628 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a18.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; globalThis.eval("this['\\x6f'] = this"); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a19.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a19.js new file mode 100644 index 000000000..614431065 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a19.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; eval("globalThis['\\u006f'] = globalThis"); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a2.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a2.js new file mode 100644 index 000000000..dfe94bc34 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a2.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; function c() {} globalThis.c = globalThis; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a20.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a20.js new file mode 100644 index 000000000..be1bbe568 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a20.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +let o = {}; Function("\\u006f = globalThis")(); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a21.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a21.js new file mode 100644 index 000000000..23f046bc4 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a21.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A() { return {}; } Function("\\u0041 = function () { return globalThis; }")(); A().f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a22.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a22.js new file mode 100644 index 000000000..36341b9e5 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a22.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; globalThis.eval("Function('\\x6f = globalThis')()"); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a23.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a23.js new file mode 100644 index 000000000..902a0e957 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a23.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +globalThis.eval("var Symbol = { iterator: 'eval' }"); globalThis[Symbol.iterator]("f = function () { return 99; }"); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a24.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a24.js new file mode 100644 index 000000000..9c50aff71 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a24.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +globalThis.eval("Symbol = { iterator: 'Function' }"); var g = [globalThis][0]; g[Symbol.iterator]("f = function () { return 99; }")(); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a25.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a25.js new file mode 100644 index 000000000..565565a26 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a25.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +(function (g) { g.eval("var Symbol = { iterator: 'eval' }"); })(globalThis); this[Symbol.iterator]("f = function () { return 99; }"); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a26.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a26.js new file mode 100644 index 000000000..6256dc7ad --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a26.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +eval("globalThis.Symbol = { iterator: 'eval' }"); globalThis[Symbol.iterator]("f = function () { return 99; }"); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a3.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a3.js new file mode 100644 index 000000000..af64dcc58 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a3.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; globalThis.c = globalThis; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a4.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a4.js new file mode 100644 index 000000000..7478601b0 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a4.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; c = [globalThis][0]; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a5.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a5.js new file mode 100644 index 000000000..cf6b963f6 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a5.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var c = {}; Object.assign(globalThis, { c: globalThis }); var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a6.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a6.js new file mode 100644 index 000000000..5c02b70e1 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a6.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var X = { prototype: g }; var c = { __proto__: X.prototype }; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a7.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a7.js new file mode 100644 index 000000000..2731be4f1 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a7.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var X = { prototype: g }; var c = {}; Object.setPrototypeOf(c, X.prototype); var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a8.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a8.js new file mode 100644 index 000000000..6c8762d33 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a8.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var X = { prototype: g }; var c = {}; c.__proto__ = X.prototype; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx9-a9.js b/crates/untwist/tests/data/rename_a25rr/single/rx9-a9.js new file mode 100644 index 000000000..e05267ce6 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx9-a9.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = ["Reflect"][0]; var w = { bind: function () { return g; } }; var c = { __proto__: w.bind() }; var R = c[n]; var [{ set: s }] = [R]; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); From adf8759b7dcea11c1d34d45418e0e28900eb3e2d Mon Sep 17 00:00:00 2001 From: sorte1 Date: Thu, 19 Nov 2026 07:31:37 +0100 Subject: [PATCH 2/4] test: a recursive helper handing on an element read by a numeric key is decoded again --- crates/untwist/tests/dynamic_reach_rows.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/untwist/tests/dynamic_reach_rows.rs b/crates/untwist/tests/dynamic_reach_rows.rs index f037f4389..3f46382e5 100644 --- a/crates/untwist/tests/dynamic_reach_rows.rs +++ b/crates/untwist/tests/dynamic_reach_rows.rs @@ -58,10 +58,10 @@ const MACHINERY_NAME_WITNESSES: [&str; 1] = ["an unknown-key defineProperty on a maybe-global parameter"]; #[test] -fn a_recursive_helper_handing_on_an_element_read_by_an_unproven_key_refuses_by_default() { +fn a_recursive_helper_handing_on_an_element_read_by_a_numeric_key_is_decoded() { let source = patched_after_rotator("true", RECURSIVE_HELPER); assert!( - !decoded(&source, Lane::Safe), + decoded(&source, Lane::Safe), "{}", run(&source, Lane::Safe).code() ); From f07dc08558591c5dcc6dce1b3fff3fc2998c20c0 Mon Sep 17 00:00:00 2001 From: sorte1 Date: Thu, 19 Nov 2026 07:55:31 +0100 Subject: [PATCH 3/4] test: the other-input key rebinding row is under the unsafe keyed-rebind premise --- crates/untwist/tests/rename_a25rr_rows.rs | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/crates/untwist/tests/rename_a25rr_rows.rs b/crates/untwist/tests/rename_a25rr_rows.rs index 12abcf115..73631108e 100644 --- a/crates/untwist/tests/rename_a25rr_rows.rs +++ b/crates/untwist/tests/rename_a25rr_rows.rs @@ -27,8 +27,15 @@ const PN_UNSAFE_NAMES: &[&str] = &[ "rx5-rd-t18.js", ]; -const UNSAFE_PREMISE_MULTI: &[(&str, RenameMode)] = - &[("u2", RenameMode::Unique), ("rx3-n3", RenameMode::Simple)]; +const UNSAFE_PREMISE_MULTI: &[(&str, RenameMode)] = &[ + ("u2", RenameMode::Unique), + ("rx3-n3", RenameMode::Simple), + ("rx9-m21", RenameMode::None), + ("rx9-m21", RenameMode::Mangle), + ("rx9-m21", RenameMode::Simple), + ("rx9-m21", RenameMode::Unique), + ("rx9-m21", RenameMode::Smart), +]; const OBSERVED_INPUT: &str = "a.js"; From 49b93c00277982516e735d00cfccc4a84d9c5067 Mon Sep 17 00:00:00 2001 From: sorte1 Date: Thu, 19 Nov 2026 10:16:53 +0100 Subject: [PATCH 4/4] ci(web): wasm baseline 14,720,000 (cap 16,192,000) for the namespace holder proofs on top of main --- web/scripts/size.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/web/scripts/size.ts b/web/scripts/size.ts index 1b7205e72..f2c551911 100644 --- a/web/scripts/size.ts +++ b/web/scripts/size.ts @@ -12,7 +12,7 @@ const INITIAL_JS_GZIP = 190_000; const CSS_GZIP = 15_000; const FONT_BYTES = 120_000; const SW_GZIP = 4_000; -const WASM_BASELINE_BYTES = 14_680_000; +const WASM_BASELINE_BYTES = 14_720_000; const WASM_GROWTH = 0.1; const gzip = (bytes: Buffer): number => gzipSync(bytes, { level: 9 }).length;