diff --git a/crates/untwist-cli/tests/reports.rs b/crates/untwist-cli/tests/reports.rs index 7e8a796fe..318252fa0 100644 --- a/crates/untwist-cli/tests/reports.rs +++ b/crates/untwist-cli/tests/reports.rs @@ -114,7 +114,7 @@ fn the_deobfuscate_stage_times_prepare_then_every_round_in_order() { #[test] fn a_default_lane_alias_refusal_prints_the_unsafe_hint_on_stderr() { - let high = include_str!("../../../fixtures/reference/deobfuscate/obfuscator.io-high.js"); + let high = include_str!("../../../fixtures/obfuscator-io/preset-medium--greeting-1.js"); let hint = untwist::UNSAFE_LANE_DECODES; let out = stdin_output(high, &[]); assert!(out.status.success()); diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/bind.rs b/crates/untwist-deobfuscate/src/calls/agnostic/bind.rs index d0b551a1b..aed413a06 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/bind.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/bind.rs @@ -538,6 +538,11 @@ impl<'s, 'a> Bindings<'s, 'a> { } pub(super) fn never_reassigned(&self, symbol: SymbolId) -> bool { + let redeclared_param = self.params.contains_key(&symbol) + && !self.scoping.symbol_redeclarations(symbol).is_empty(); + if redeclared_param { + return false; + } match self.defs.get(symbol) { Some(defs) => !defs.mutated && defs.writes.is_empty(), None => !self.scoping.symbol_is_mutated(symbol), diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/judge.rs b/crates/untwist-deobfuscate/src/calls/agnostic/judge.rs index dcdd8619d..8a507dc08 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/judge.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/judge.rs @@ -415,7 +415,9 @@ impl<'s, 'a> Sites<'s, 'a> { fn into_saturated(mut self) -> (Agnostic<'a>, bool, bool) { self.creations_native(); self.out.saturated = true; + self.judge_refined(); self.out.pending_texts = self.pending_texts.take(); + self.out.judged_texts = self.judged_texts.take(); (self.out, true, true) } @@ -456,7 +458,9 @@ impl<'s, 'a> Sites<'s, 'a> { self.out.code_text.get_or_insert(span); } } + self.judge_refined(); self.out.pending_texts = self.pending_texts.take(); + self.out.judged_texts = self.judged_texts.take(); (self.out, chains, natives) } diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/keys.rs b/crates/untwist-deobfuscate/src/calls/agnostic/keys.rs index cfd5217d2..0971b1e4b 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/keys.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/keys.rs @@ -445,3 +445,24 @@ impl<'s, 'a> Sites<'s, 'a> { } } } + +impl<'a> Sites<'_, 'a> { + pub(super) fn refined(&self, hit: Option) -> bool { + if hit == Some(false) { + self.refined_away.set(true); + } + hit.unwrap_or(true) + } + + pub(super) fn note_refined(&mut self, base: &Expression<'a>) { + if self.refined_away.take() { + let base = self.alloc_expr(base); + self.refined_bases.push(base); + } + } + + pub(super) fn judge_refined(&mut self) { + let bases = std::mem::take(&mut self.refined_bases); + self.out.keyed_global |= bases.iter().any(|base| !self.proven_non_global(base)); + } +} diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/mod.rs b/crates/untwist-deobfuscate/src/calls/agnostic/mod.rs index 3c49a14c0..226214f70 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/mod.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/mod.rs @@ -113,10 +113,12 @@ pub struct Agnostic<'a> { pub(super) observe_keyed: Vec<(Span, Cow<'a, str>)>, pub(super) ambient: Vec<(Span, &'a str, bool)>, pub(super) saturated: bool, + pub(super) keyed_global: bool, pub(super) global_source: bool, pub(super) observe_stored: Option, pub(super) stores_global: bool, pub(super) pending_texts: Vec, + pub(super) judged_texts: Vec, pub bootstrap: Option<&'static str>, #[cfg(feature = "refusal-spans")] pub(super) trail: Vec, diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/blocks.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/blocks.rs index 243eb7226..2c96be4a1 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/blocks.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/blocks.rs @@ -120,6 +120,13 @@ impl<'s, 'a> Walker<'s, 'a> { } impl Loose { + pub(super) fn kept(&self, spans: Vec) -> Vec { + spans + .into_iter() + .filter(|span| !self.exempt(*span)) + .collect() + } + pub(in crate::calls::agnostic) fn exempt(&self, span: Span) -> bool { self.blocks .iter() 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 a15d9d832..da44b085b 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/flows.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/flows.rs @@ -2,9 +2,11 @@ use oxc_allocator::{Address, GetAddress}; use oxc_ast::ast::*; use oxc_ast::AstKind; use oxc_syntax::symbol::SymbolFlags; +use std::borrow::Cow; use super::{ - function_literal, member_key, same, transparent, Walker, GLOBAL_RECEIVER_READERS, NAMESPACE, + function_literal, member_address, member_key, same, transparent, unsafe_read, Walker, + GLOBAL_RECEIVER_READERS, KIND_DEPTH, NAMESPACE, VALUE, }; const FORWARDERS: [&str; 3] = ["call", "apply", "bind"]; @@ -89,4 +91,57 @@ impl<'s, 'a> Walker<'s, 'a> { }), } } + + pub(super) fn member_use(&self, at: usize, kind: u8) -> bool { + if kind & VALUE != 0 { + return false; + } + if kind & NAMESPACE == 0 { + return true; + } + let member = &self.stack[at]; + let address = member.address(); + let key = match member { + AstKind::StaticMemberExpression(m) => Some(Cow::Borrowed(m.property.name.as_str())), + AstKind::ComputedMemberExpression(m) => { + self.key_text(&m.expression, KIND_DEPTH).map(Cow::Owned) + } + _ => None, + }; + if self.called_or_written(at, address) { + return true; + } + if key.as_deref().is_some_and(|key| !unsafe_read(key)) { + return true; + } + self.allowed(at, VALUE) + } + + fn called_or_written(&self, at: usize, member: Address) -> bool { + let mut child = member; + let mut up = at; + while up > 0 { + up -= 1; + match &self.stack[up] { + kind if transparent(kind) => child = kind.address(), + AstKind::CallExpression(c) => return c.callee.address() == child, + AstKind::NewExpression(n) => return n.callee.address() == child, + AstKind::AssignmentExpression(a) => { + return a + .left + .as_member_expression() + .is_some_and(|m| member_address(m) == member) + } + AstKind::UpdateExpression(_) + | AstKind::ArrayAssignmentTarget(_) + | AstKind::AssignmentTargetWithDefault(_) + | AstKind::AssignmentTargetPropertyProperty(_) + | AstKind::AssignmentTargetRest(_) => return true, + AstKind::ForInStatement(f) => return !same(&f.right, child), + AstKind::ForOfStatement(f) => return !same(&f.right, child), + _ => return false, + } + } + false + } } diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holders.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holders.rs new file mode 100644 index 000000000..ad144714d --- /dev/null +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/holders.rs @@ -0,0 +1,184 @@ +use oxc_ast::ast::*; +use oxc_ast::AstKind; +use oxc_syntax::operator::LogicalOperator; +use oxc_syntax::symbol::{SymbolFlags, SymbolId}; +use std::borrow::Cow; + +use super::keys::KeyProof; +use super::{key_kind, str_const, Walker, GLOBAL, KIND_DEPTH, NAMESPACE}; +use crate::proof::GLOBAL_OBJECTS; + +const BUILTIN_CONSTRUCTORS: [&str; 16] = [ + "Object", "Function", "Array", "String", "Number", "Boolean", "Symbol", "BigInt", "RegExp", + "Date", "Error", "Map", "Set", "WeakMap", "WeakSet", "Promise", +]; + +impl<'s, 'a> Walker<'s, 'a> { + pub(super) fn computed_kind( + &self, + object: &Expression<'a>, + key: &Expression<'a>, + base: u8, + ) -> u8 { + let text = self.key_text(key, KIND_DEPTH); + let open = text.is_none(); + if open { + match self.key_proof(object, key) { + KeyProof::Open => {} + KeyProof::Symbol => return 0, + KeyProof::Enumerated => { + let global = base & GLOBAL != 0 || self.may_hold_global(object, KIND_DEPTH); + return if global { GLOBAL } else { 0 }; + } + } + } + let kind = key_kind(text.map(Cow::Owned), base); + if kind == 0 && open && self.may_hold_global(object, KIND_DEPTH) { + return NAMESPACE; + } + kind + } + + pub(super) fn key_text(&self, expr: &Expression<'a>, depth: u8) -> Option { + let next = depth.checked_sub(1)?; + let Expression::Identifier(id) = expr.without_parentheses() else { + return str_const(expr, self.resolve, depth); + }; + let symbol = self.symbol(id)?; + self.fixed_init(symbol) + .and_then(|init| self.key_text(init, next)) + } + + fn fixed_init(&self, symbol: SymbolId) -> Option<&'a Expression<'a>> { + let candidate = self.candidates.get(&symbol)?; + let fixed = !self.scoping.symbol_is_mutated(symbol) + && self.scoping.symbol_redeclarations(symbol).is_empty() + && candidate + .function + .is_none_or(|function| !self.arguments_used.contains(&function)); + fixed.then_some(candidate.init) + } + + 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::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::Identifier(id) => match self.symbol(id) { + None => GLOBAL_OBJECTS.contains(&id.name.as_str()), + 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::ConditionalExpression(c) => { + self.may_hold_global(&c.consequent, next) + || self.may_hold_global(&c.alternate, next) + } + Expression::LogicalExpression(l) if l.operator == LogicalOperator::And => { + self.may_hold_global(&l.right, next) + } + Expression::LogicalExpression(l) => { + self.may_hold_global(&l.left, next) || self.may_hold_global(&l.right, next) + } + Expression::SequenceExpression(s) => s + .expressions + .last() + .is_none_or(|last| self.may_hold_global(last, next)), + _ => true, + } + } + + 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; + } + self.fixed_init(symbol) + .is_none_or(|init| self.may_hold_global(init, depth)) + } + + fn this_open(&self) -> bool { + self.this_open.last().copied().unwrap_or(true) + } + + pub(super) fn collect_array_source(&mut self, kind: AstKind<'a>) { + match kind { + AstKind::Function(function) if function.is_declaration() => { + let Some(id) = function.id.as_ref() else { + return; + }; + let shaped = crate::string_array::is_string_array_function(function, &id.name); + if let (true, Some(symbol)) = (shaped, id.symbol_id.get()) { + self.array_functions.insert(symbol, function.span); + } + } + AstKind::AssignmentExpression(assign) => { + let AssignmentTarget::AssignmentTargetIdentifier(target) = &assign.left else { + return; + }; + if let Some(symbol) = self.symbol(target) { + self.assigned_at + .entry(symbol) + .or_default() + .push(assign.span); + } + } + _ => {} + } + } + + fn array_source(&self, call: &CallExpression<'a>) -> bool { + let Expression::Identifier(callee) = call.callee.without_parentheses() else { + return false; + }; + let Some(symbol) = self.symbol(callee) else { + return false; + }; + let Some(span) = self.array_functions.get(&symbol) else { + return false; + }; + let writes = self + .scoping + .get_resolved_reference_ids(symbol) + .iter() + .filter(|reference| self.scoping.get_reference(**reference).is_write()) + .count(); + let inside = self.assigned_at.get(&symbol).map_or(&[][..], Vec::as_slice); + call.arguments.is_empty() + && self.scoping.symbol_redeclarations(symbol).is_empty() + && inside.len() == writes + && inside + .iter() + .all(|write| span.start <= write.start && write.end <= span.end) + } + + fn builtin_prototype(&self, member: &StaticMemberExpression<'a>) -> bool { + let Expression::Identifier(owner) = member.object.without_parentheses() else { + return false; + }; + member.property.name == "prototype" + && self.symbol(owner).is_none() + && BUILTIN_CONSTRUCTORS.contains(&owner.name.as_str()) + } +} diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/keys.rs b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/keys.rs new file mode 100644 index 000000000..b29bef1bd --- /dev/null +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/keys.rs @@ -0,0 +1,274 @@ +use oxc_ast::ast::*; +use oxc_ast::AstKind; +use oxc_syntax::symbol::SymbolId; + +use super::Walker; + +const WELL_KNOWN_SYMBOLS: [&str; 15] = [ + "asyncDispose", + "asyncIterator", + "dispose", + "hasInstance", + "isConcatSpreadable", + "iterator", + "match", + "matchAll", + "replace", + "search", + "species", + "split", + "toPrimitive", + "toStringTag", + "unscopables", +]; + +const KEY_CALLBACKS: [&str; 5] = ["forEach", "map", "filter", "some", "every"]; + +#[derive(Clone, Copy, PartialEq, Eq)] +pub(super) enum Holder<'a> { + Bound(SymbolId), + Free(&'a str), +} + +pub(super) enum KeyProof { + Open, + Symbol, + Enumerated, +} + +impl<'s, 'a> Walker<'s, 'a> { + pub(super) fn key_proof(&self, object: &Expression<'a>, key: &Expression<'a>) -> KeyProof { + if self.well_known_symbol(key) { + self.symbol_proof_used.set(true); + return KeyProof::Symbol; + } + let Expression::Identifier(id) = key.without_parentheses() else { + return KeyProof::Open; + }; + let enumerated = self + .symbol(id) + .and_then(|symbol| self.enumerated_holder(symbol)) + .zip(self.holder_of(object)) + .is_some_and(|(from, read)| from == read); + if enumerated { + KeyProof::Enumerated + } else { + KeyProof::Open + } + } + + fn well_known_symbol(&self, key: &Expression<'a>) -> bool { + let Expression::StaticMemberExpression(member) = key.without_parentheses() else { + return false; + }; + let Expression::Identifier(owner) = member.object.without_parentheses() else { + return false; + }; + self.trust_symbol + && owner.name == "Symbol" + && self.symbol(owner).is_none() + && WELL_KNOWN_SYMBOLS.contains(&member.property.name.as_str()) + } + + fn holder_of(&self, expr: &Expression<'a>) -> Option> { + let Expression::Identifier(id) = expr.without_parentheses() else { + return None; + }; + self.holder_of_id(id) + } + + fn holder_of_id(&self, id: &IdentifierReference<'a>) -> Option> { + match self.symbol(id) { + Some(symbol) => self + .scoping + .symbol_redeclarations(symbol) + .is_empty() + .then_some(Holder::Bound(symbol)), + None => { + (!self.free_written(id.name.as_str())).then_some(Holder::Free(id.name.as_str())) + } + } + } + + fn settled(&self, symbol: SymbolId) -> bool { + !self.scoping.symbol_is_mutated(symbol) + && self.scoping.symbol_redeclarations(symbol).is_empty() + } + + fn free_written(&self, name: &str) -> bool { + self.scoping + .root_unresolved_references() + .get(name) + .is_some_and(|references| { + references + .iter() + .any(|reference| self.scoping.get_reference(*reference).is_write()) + }) + } + + fn enumerated_holder(&self, key: SymbolId) -> Option> { + let source = self.bound_keys.get(&key).copied().unwrap_or(key); + if source != key && !self.settled(key) { + return None; + } + let (holder, start) = *self.enumerations.get(&source)?; + let held = match holder { + Holder::Bound(symbol) => self.written_before(symbol, start), + Holder::Free(_) => true, + }; + (held && self.written_before(source, 0)).then_some(holder) + } + + fn written_before(&self, symbol: SymbolId, start: u32) -> bool { + let writes = self + .scoping + .get_resolved_reference_ids(symbol) + .iter() + .filter(|reference| self.scoping.get_reference(**reference).is_write()) + .count(); + let assigned = self.assigned_at.get(&symbol).map_or(&[][..], Vec::as_slice); + self.scoping.symbol_redeclarations(symbol).is_empty() + && writes == assigned.len() + && assigned.iter().all(|span| span.end <= start) + } + + pub(super) fn collect_enumeration(&mut self, kind: AstKind<'a>) { + match kind { + AstKind::ForInStatement(each) => { + let Some(holder) = self.holder_of(&each.right) else { + return; + }; + if let Some(key) = loop_key(&each.left, false) { + self.record_key(key, holder, each.span.start); + } + } + AstKind::ForOfStatement(each) => { + let Some((holder, pairs)) = self.listed_keys(&each.right) else { + return; + }; + if let Some(key) = loop_key(&each.left, pairs) { + self.record_key(key, holder, each.span.start); + } + } + AstKind::CallExpression(call) => self.collect_key_callback(call), + _ => {} + } + } + + fn record_key(&mut self, symbol: SymbolId, holder: Holder<'a>, start: u32) { + self.enumerations.insert(symbol, (holder, start)); + } + + fn listed_keys(&self, expr: &Expression<'a>) -> Option<(Holder<'a>, bool)> { + let Expression::CallExpression(call) = expr.without_parentheses() else { + return None; + }; + let Expression::StaticMemberExpression(member) = call.callee.without_parentheses() else { + return None; + }; + let Expression::Identifier(owner) = member.object.without_parentheses() else { + return None; + }; + let pairs = match member.property.name.as_str() { + "keys" => false, + "entries" => true, + _ => return None, + }; + let free_object = + owner.name == "Object" && self.symbol(owner).is_none() && !self.free_written("Object"); + let [Argument::Identifier(target)] = call.arguments.as_slice() else { + return None; + }; + if !free_object { + return None; + } + self.holder_of_id(target).map(|holder| (holder, pairs)) + } + + fn collect_key_callback(&mut self, call: &'a CallExpression<'a>) { + let Expression::StaticMemberExpression(member) = call.callee.without_parentheses() else { + return; + }; + if member.property.name == "bind" { + self.collect_bound_key(member, call); + return; + } + if !KEY_CALLBACKS.contains(&member.property.name.as_str()) { + return; + } + let Some((holder, pairs)) = self.listed_keys(&member.object) else { + return; + }; + let Some(params) = call + .arguments + .first() + .and_then(Argument::as_expression) + .and_then(callback_params) + else { + return; + }; + if let Some(entry) = params + .items + .first() + .and_then(|param| pattern_key(¶m.pattern, pairs)) + { + self.record_key(entry, holder, call.span.start); + } + } + + fn collect_bound_key( + &mut self, + member: &StaticMemberExpression<'a>, + call: &CallExpression<'a>, + ) { + let Expression::FunctionExpression(function) = member.object.without_parentheses() else { + return; + }; + let Some(Argument::Identifier(source)) = call.arguments.get(1) else { + return; + }; + let Some(source) = self.symbol(source) else { + return; + }; + let Some(BindingPattern::BindingIdentifier(param)) = + function.params.items.first().map(|param| ¶m.pattern) + else { + return; + }; + if let Some(param) = param.symbol_id.get() { + self.bound_keys.insert(param, source); + } + } +} + +fn callback_params<'k, 'a>(expr: &'k Expression<'a>) -> Option<&'k FormalParameters<'a>> { + match expr.without_parentheses() { + Expression::FunctionExpression(function) => Some(&function.params), + Expression::ArrowFunctionExpression(arrow) => Some(&arrow.params), + _ => None, + } +} + +fn pattern_key(pattern: &BindingPattern<'_>, pairs: bool) -> Option { + match (pattern, pairs) { + (BindingPattern::BindingIdentifier(id), false) => id.symbol_id.get(), + (BindingPattern::ArrayPattern(array), true) => match array.elements.first()? { + Some(BindingPattern::BindingIdentifier(id)) => id.symbol_id.get(), + _ => None, + }, + _ => None, + } +} + +fn loop_key(left: &ForStatementLeft<'_>, pairs: bool) -> Option { + match left { + ForStatementLeft::VariableDeclaration(declaration) => { + let [declarator] = declaration.declarations.as_slice() else { + return None; + }; + pattern_key(&declarator.id, pairs) + } + ForStatementLeft::AssignmentTargetIdentifier(_) => None, + _ => None, + } +} 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 53c31a6f9..d4de5379c 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/mod.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/namespace_uses/mod.rs @@ -1,5 +1,7 @@ mod blocks; mod flows; +mod holders; +mod keys; mod shapes; use std::borrow::Cow; @@ -86,9 +88,16 @@ struct Walker<'s, 'a> { phase: Phase, stack: Vec>, this_global: Vec, + this_open: Vec, functions: Vec
, arguments_used: FxHashSet
, candidates: FxHashMap>, + array_functions: FxHashMap, + enumerations: FxHashMap, u32)>, + bound_keys: FxHashMap, + trust_symbol: bool, + symbol_proof_used: std::cell::Cell, + assigned_at: FxHashMap>, aliases: FxHashMap, receivers: FxHashMap, protections: FxHashSet, @@ -100,12 +109,14 @@ struct Walker<'s, 'a> { pub(in crate::calls::agnostic) struct Loose { pub(in crate::calls::agnostic) spans: Vec, pub(in crate::calls::agnostic) blocks: Vec<(Span, &'static [&'static str])>, + pub(in crate::calls::agnostic) untrusted_symbol: Option>, } pub(super) fn loose_uses<'a>( program: &'a Program<'a>, scoping: &Scoping, resolve: Resolve<'_>, + trust_symbol: bool, ) -> Loose { let mut walker = Walker { scoping, @@ -114,9 +125,16 @@ pub(super) fn loose_uses<'a>( 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, + symbol_proof_used: std::cell::Cell::new(false), + assigned_at: FxHashMap::default(), aliases: FxHashMap::default(), receivers: FxHashMap::default(), protections: FxHashSet::default(), @@ -127,17 +145,23 @@ pub(super) fn loose_uses<'a>( walker.aliases = walker.qualified(); walker.phase = Phase::Check; walker.walk(program); + let trusted = std::mem::take(&mut walker.found); + let blocks = std::mem::take(&mut walker.blocks); + let untrusted = walker.symbol_proof_used.get().then(|| { + walker.trust_symbol = false; + walker.phase = Phase::Collect; + walker.aliases = walker.qualified(); + walker.phase = Phase::Check; + walker.walk(program); + std::mem::take(&mut walker.found) + }); let mut loose = Loose { - spans: walker.found, - blocks: walker.blocks, + spans: Vec::new(), + blocks, + untrusted_symbol: None, }; - let kept: Vec = loose - .spans - .iter() - .copied() - .filter(|span| !loose.exempt(*span)) - .collect(); - loose.spans = kept; + loose.spans = loose.kept(trusted); + loose.untrusted_symbol = untrusted.map(|spans| loose.kept(spans)); loose } @@ -232,8 +256,10 @@ 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); } @@ -308,7 +334,12 @@ impl<'s, 'a> Walker<'s, 'a> { } fn member_kind(&self, member: &MemberExpression<'a>, base: u8) -> u8 { - key_kind(member_key(member, self.resolve), base) + match member { + MemberExpression::ComputedMemberExpression(m) => { + self.computed_kind(&m.object, &m.expression, base) + } + other => key_kind(member_key(other, self.resolve), base), + } } fn kind_here(&self, expr: &Expression<'a>) -> u8 { @@ -445,10 +476,9 @@ impl<'s, 'a> Walker<'s, 'a> { Some(Cow::Borrowed(m.property.name.as_str())), self.kind_here(&m.object), ), - AstKind::ComputedMemberExpression(m) => key_kind( - str_const(&m.expression, self.resolve, KIND_DEPTH).map(Cow::Owned), - self.kind_here(&m.object), - ), + AstKind::ComputedMemberExpression(m) => { + self.computed_kind(&m.object, &m.expression, self.kind_here(&m.object)) + } _ => 0, } } @@ -677,59 +707,6 @@ impl<'s, 'a> Walker<'s, 'a> { } false } - - fn member_use(&self, at: usize, kind: u8) -> bool { - if kind & VALUE != 0 { - return false; - } - if kind & NAMESPACE == 0 { - return true; - } - let member = &self.stack[at]; - let address = member.address(); - let key = match member { - AstKind::StaticMemberExpression(m) => Some(Cow::Borrowed(m.property.name.as_str())), - AstKind::ComputedMemberExpression(m) => { - str_const(&m.expression, self.resolve, KIND_DEPTH).map(Cow::Owned) - } - _ => None, - }; - if self.called_or_written(at, address) { - return true; - } - if key.as_deref().is_some_and(|key| !unsafe_read(key)) { - return true; - } - self.allowed(at, VALUE) - } - - fn called_or_written(&self, at: usize, member: Address) -> bool { - let mut child = member; - let mut up = at; - while up > 0 { - up -= 1; - match &self.stack[up] { - kind if transparent(kind) => child = kind.address(), - AstKind::CallExpression(c) => return c.callee.address() == child, - AstKind::NewExpression(n) => return n.callee.address() == child, - AstKind::AssignmentExpression(a) => { - return a - .left - .as_member_expression() - .is_some_and(|m| member_address(m) == member) - } - AstKind::UpdateExpression(_) - | AstKind::ArrayAssignmentTarget(_) - | AstKind::AssignmentTargetWithDefault(_) - | AstKind::AssignmentTargetPropertyProperty(_) - | AstKind::AssignmentTargetRest(_) => return true, - AstKind::ForInStatement(f) => return !same(&f.right, child), - AstKind::ForOfStatement(f) => return !same(&f.right, child), - _ => return false, - } - } - false - } } fn member_address(member: &MemberExpression<'_>) -> Address { @@ -747,12 +724,18 @@ 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); } _ => {} } @@ -766,12 +749,14 @@ 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(); } _ => {} } @@ -785,6 +770,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_array_source(kind); + self.collect_enumeration(kind); match kind { AstKind::VariableDeclarator(declarator) => { self.collect_declarator(declarator); diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/reach.rs b/crates/untwist-deobfuscate/src/calls/agnostic/reach.rs index d112ccc3e..f3cb3b491 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/reach.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/reach.rs @@ -362,7 +362,19 @@ impl<'a> Sites<'_, 'a> { pub(super) fn key_hits(&self, expr: &Expression<'a>) -> bool { let keys = self.key_set(expr); - keys.iter().any(|key| self.may_hit(key)) && self.refined_hit(expr) + self.keys_hit(&keys, expr) + } + + fn keys_hit(&self, keys: &[AKey<'a>], expr: &Expression<'a>) -> bool { + let may = keys.iter().any(|key| self.may_hit(key)); + let open = keys + .iter() + .any(|key| matches!(key, AKey::Pending(_) | AKey::Filtered(_) | AKey::Unknown)); + if !may && !open { + return false; + } + let refined = self.refined_hit(expr); + may && refined } fn refined_hit(&self, expr: &Expression<'a>) -> bool { @@ -372,9 +384,9 @@ impl<'a> Sites<'_, 'a> { } match inner { Expression::Identifier(id) if self.substituted(id).is_none() => { - self.param_key_hits(id, VALUE_DEPTH).unwrap_or(true) + self.refined(self.param_key_hits(id, VALUE_DEPTH)) } - Expression::BinaryExpression(binary) => self.sum_key_hits(binary).unwrap_or(true), + Expression::BinaryExpression(binary) => self.refined(self.sum_key_hits(binary)), _ => true, } } @@ -441,11 +453,12 @@ impl<'a> Sites<'_, 'a> { } let candidate = match member { MemberExpression::StaticMemberExpression(m) => self.watched_name(&m.property.name), - MemberExpression::ComputedMemberExpression(m) => { - keys.iter().any(|key| self.may_hit(key)) && self.refined_hit(&m.expression) - } + MemberExpression::ComputedMemberExpression(m) => self.keys_hit(keys, &m.expression), MemberExpression::PrivateFieldExpression(_) => false, }; + if !self.in_machinery(member.span()) { + self.note_refined(member.object()); + } if candidate && !self.in_machinery(member.span()) { self.reach_base(member.object(), member.span()); } @@ -562,6 +575,7 @@ impl<'a> Sites<'_, 'a> { }; if let KeyedArgument::Given(key) = key { if self.paired_sites_safe(base, key) { + self.note_refined(base); return; } } @@ -570,6 +584,7 @@ impl<'a> Sites<'_, 'a> { KeyedArgument::Absent => self.watched_name("undefined"), KeyedArgument::Spread => dynamic_paths(), }; + self.note_refined(base); if hit { self.reach_base(base, span); } @@ -597,6 +612,9 @@ impl<'a> Sites<'_, 'a> { Some(None) => true, Some(Some(expr)) => self.site_key_hits(expr, VALUE_DEPTH), }; + if !key_hits && value(key_at).is_some() { + self.refined_away.set(true); + } !key_hits || match value(base_at) { None => true, @@ -618,7 +636,9 @@ impl<'a> Sites<'_, 'a> { return self.hit_dynamic(call.span); }; self.reach_enumerated(expr, call.span); - if self.source_may_hit(expr) { + let hit = self.source_may_hit(expr); + self.note_refined(target); + if hit { self.reach_base(target, call.span); } } @@ -668,6 +688,7 @@ impl<'a> Sites<'_, 'a> { .properties .iter() .any(|property| self.binding_property_hits(property)); + self.note_refined(base); if hit { self.reach_base(base, object.span); } @@ -721,6 +742,7 @@ impl<'a> Sites<'_, 'a> { .properties .iter() .any(|property| self.target_property_hits(property)); + self.note_refined(base); if hit { self.reach_base(base, target.span); } diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/reach_text.rs b/crates/untwist-deobfuscate/src/calls/agnostic/reach_text.rs index 84d4eb414..c54e04e80 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/reach_text.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/reach_text.rs @@ -171,6 +171,7 @@ impl<'a> Sites<'_, 'a> { } fn names_reach(&self, text: &str) -> bool { + self.judged_texts.borrow_mut().push(text.to_string()); let watched = (self.watch.names, self.watch.props); if !self.watch.defer { let judged = ( diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/reader_reach.rs b/crates/untwist-deobfuscate/src/calls/agnostic/reader_reach.rs index 376b826ed..35f7fb57a 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/reader_reach.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/reader_reach.rs @@ -168,7 +168,11 @@ impl<'a> Sites<'_, 'a> { pub(super) fn reach_loose(&mut self) { let bindings = self.fresh.bindings; - let loose = bindings.loose.spans.iter().copied(); + let spans = match (&bindings.loose.untrusted_symbol, self.symbol_safe) { + (Some(untrusted), false) => untrusted, + _ => &bindings.loose.spans, + }; + let loose = spans.iter().copied(); let effects = bindings .loose .blocks diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/settle.rs b/crates/untwist-deobfuscate/src/calls/agnostic/settle.rs index 19d4145c0..19630b207 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/settle.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/settle.rs @@ -193,11 +193,17 @@ 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.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 mut judged = Judged { source: bindings.global_source(), pristine: Pristine::of(&bindings), @@ -226,7 +232,12 @@ fn settle_ordered<'a>( if !next.pristine.filters { filters.open(); } - let rebound = rebound_globals(&out, &globals, &bindings, (next.source, &written)); + let rebound = rebound_globals( + &out, + (&globals, &lexicals), + &bindings, + (next.source, &written, &watch), + ); let broken = broken_tables(&out, &bindings.assembled, machinery); drop_tables(&mut bindings.assembled, &broken); if rebound.is_empty() && broken.is_empty() && next == judged { @@ -413,19 +424,60 @@ impl<'k> Written<'k> { fn rebound_globals( out: &Agnostic<'_>, - globals: &[SymbolId], + (globals, lexicals): (&[SymbolId], &[SymbolId]), bindings: &Bindings<'_, '_>, - (source, written): (bool, &Written<'_>), + (source, written, watch): (bool, &Written<'_>, &Watch<'_>), ) -> Vec { - if globals.is_empty() || out.saturated || out.code_text.is_some() { - return Vec::new(); + let texts = if out.code_text.is_some() { + lexicals + } else { + &[] + }; + if out.saturated || out.code_text.is_some() || out.keyed_global { + let watching = !watch.names.is_empty() && out.reach.or(out.reach_code).is_none(); + if !watching { + return Vec::new(); + } + if out.keyed_global { + return unwatched_roots(globals.iter().chain(texts), bindings, watch); + } + if out.code_text.is_none() { + return Vec::new(); + } } - globals + let unseen = |symbol: &&SymbolId| !bindings.is_opaque(**symbol); + 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) + }); + let renamed = texts .iter() + .filter(unseen) + .filter(|symbol| named_by_text(out, 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 unwatched_roots<'k>( + roots: impl Iterator, + bindings: &Bindings<'_, '_>, + watch: &Watch<'_>, +) -> Vec { + roots .filter(|symbol| { + let name = bindings.symbol_name(**symbol); !bindings.is_opaque(**symbol) - && (written.may_be(bindings.symbol_name(**symbol)) - || (source && bindings.state_written(**symbol, written))) + && !watch.has_name(name) + && !crate::stamp::is_machinery_name(name) }) .copied() .collect() diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/sites.rs b/crates/untwist-deobfuscate/src/calls/agnostic/sites.rs index 1267e21e3..b41d97792 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/sites.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/sites.rs @@ -146,6 +146,9 @@ pub(super) struct Sites<'s, 'a> { pub(super) noted_scripts: FxHashSet, pub(super) forward_calls: FxHashSet, pub(super) pending_texts: RefCell>, + pub(super) judged_texts: RefCell>, + pub(super) refined_away: Cell, + pub(super) refined_bases: Vec<&'a Expression<'a>>, pub(super) flow: &'s Flow<'s, 'a>, pub(super) holds: Holds<'s, 'a>, pub(super) known_rests: FxHashMap>>, @@ -217,6 +220,9 @@ impl<'s, 'a> Sites<'s, 'a> { noted_scripts: FxHashSet::default(), forward_calls: FxHashSet::default(), pending_texts: RefCell::default(), + judged_texts: RefCell::default(), + refined_away: Cell::new(false), + refined_bases: Vec::new(), flow, holds, known_rests: FxHashMap::default(), diff --git a/crates/untwist-deobfuscate/src/calls/agnostic/subst.rs b/crates/untwist-deobfuscate/src/calls/agnostic/subst.rs index 0d80e1e95..5ba82bed3 100644 --- a/crates/untwist-deobfuscate/src/calls/agnostic/subst.rs +++ b/crates/untwist-deobfuscate/src/calls/agnostic/subst.rs @@ -101,7 +101,11 @@ impl<'s, 'a> Sites<'s, 'a> { ) else { return false; }; - if aliased || self.fresh.scoping.symbol_is_mutated(symbol) { + let scoping = self.fresh.scoping; + if aliased + || scoping.symbol_is_mutated(symbol) + || !scoping.symbol_redeclarations(symbol).is_empty() + { continue; } let arg = self.alloc_expr(arg); diff --git a/crates/untwist-deobfuscate/tests/data/fused_scans.digest b/crates/untwist-deobfuscate/tests/data/fused_scans.digest index cd7e38317..a01eb3025 100644 --- a/crates/untwist-deobfuscate/tests/data/fused_scans.digest +++ b/crates/untwist-deobfuscate/tests/data/fused_scans.digest @@ -3,8 +3,8 @@ behaviour p 3490 e129d5f75b11509b behaviour u 3226 134fb50e2f0574ab behaviour up 3296 59158df058338562 corpora 2184 d0031681ed36039b -corpus-npm d 211 7153f0c650ecb42d -corpus-npm p 195 a39f455fcca386cd +corpus-npm d 220 1789d45dc0af86d9 +corpus-npm p 206 ee7bbeadc019de3a corpus-npm u 198 90bd67c032a5c4bd corpus-npm up 194 481dd0dd6c3b0410 deobfuscate d 303 03943da2569cfb93 diff --git a/crates/untwist-eval/tests/data/compile_records.sha256 b/crates/untwist-eval/tests/data/compile_records.sha256 index 3c47db75e..bf9845897 100644 --- a/crates/untwist-eval/tests/data/compile_records.sha256 +++ b/crates/untwist-eval/tests/data/compile_records.sha256 @@ -7199,7 +7199,8 @@ 69f8f84a309801ff 0 daca6f7fc22784879dba59b5f3ed83dd6ae28686999a3f8cfd03c96f6477c4d7 69f8f84a309801ff 1 daca6f7fc22784879dba59b5f3ed83dd6ae28686999a3f8cfd03c96f6477c4d7 69fe3e6f1d486c78 0 16269e7867574a83d714c04cdc451d9787a9192c17a93a0f76f00b82ef785836 -69fe3e6f1d486c78 1 7e2db7543c4f1cc0a5d6fea6a2a8511dcd9cabb9aa73a89622d516a511f9b36d +69fe3e6f1d486c78 1 16269e7867574a83d714c04cdc451d9787a9192c17a93a0f76f00b82ef785836 +69fe3e6f1d486c78 2 517f4b60396e7c15a1652fd2691c0216ed8246477cc4b7886dc15f8c19eb886f 6a11457981e98edc 0 1cfbbee0492dd80be0dd313f0d02a67235910763ad3cbc1f3e1ac4ca4677b8f2 6a15e21cf09e4fb2 0 ccb41f8ee39c042cf635ade86f73a1f4dea4b4736596cd94fedf8256d52a0027 6a19305b04ce31e4 0 2aa77c66ddf6b762586386b9bb3b5034f30489eacde1d87533b94b73be08209c @@ -7527,7 +7528,8 @@ 6f1ef2c8091cb2af 1 c79c5b7a5940563fb0c08bb985fb66eae912e59acd43b61c849699bc0b4af9aa 6f26444c3f410429 0 7da1fac40f697354afcacac6a30cf6d06832f513af350b5456e41c34f5c1500f 6f2fd4d5a1048649 0 16269e7867574a83d714c04cdc451d9787a9192c17a93a0f76f00b82ef785836 -6f2fd4d5a1048649 1 ebb42dd21c4aa4ec230aaeb1ca6fe6e5f21ca529ec5860db8837bf0a43bd31dd +6f2fd4d5a1048649 1 16269e7867574a83d714c04cdc451d9787a9192c17a93a0f76f00b82ef785836 +6f2fd4d5a1048649 2 92fef2d1dd3f8dc196c778b18747817f28a2407bdf157dbe0c2d16947bb03c81 6f33570ecf54f585 0 c841b215b57df8d673f2b659cf2c18e5f67b0a95a56dab32d506227d2b48380e 6f36fdce17efad8f 0 4c5139a6e0746bebbcb3f67e90bbab79d0aec5a948f0900fb27c6a3c11517c93 6f38907aed5441ad 0 946f869973257a216f7b15c48077f984c9f84566199cace0c3704c49872298be diff --git a/crates/untwist/tests/alias_form_rows.rs b/crates/untwist/tests/alias_form_rows.rs index 49fa53ad0..4ad72f7aa 100644 --- a/crates/untwist/tests/alias_form_rows.rs +++ b/crates/untwist/tests/alias_form_rows.rs @@ -4,7 +4,22 @@ use untwist_testing::node_rows::{self, node_or_skip, Mode}; const ROWS: &str = include_str!("data/alias_form_rows.txt"); -fn rows() -> Vec<(String, String)> { +type Row = (String, String); + +const READS_BY_UNPROVEN_KEY: &str = "the decoder reads the string array by an unproven key off a call result and returns it, which the namespace-by-key rule pins before the alias-form checks run"; + +const REFUSED_BY_THE_NAMESPACE_SCAN: &[(&str, &str)] = &[ + ("ref-object-deleted", READS_BY_UNPROVEN_KEY), + ("ref-comma-deleted", READS_BY_UNPROVEN_KEY), +]; + +fn refused_by_the_namespace_scan(label: &str) -> bool { + REFUSED_BY_THE_NAMESPACE_SCAN + .iter() + .any(|(refused, _)| *refused == label) +} + +fn rows() -> Vec { ROWS.lines() .filter(|line| !line.trim().is_empty()) .filter_map(|line| line.split_once('|')) @@ -84,10 +99,16 @@ fn the_sabotage_rows_diverge_from_node_under_the_alias_form_checks_mutant() { let Some(node) = node_or_skip() else { return; }; - let sabotage: Vec<(String, String)> = rows() + let (refused, sabotage): (Vec, Vec) = rows() .into_iter() .filter(|(label, _)| label.starts_with("ref-")) + .partition(|(label, _)| refused_by_the_namespace_scan(label)); + let refused_labels: Vec<&str> = refused.iter().map(|(label, _)| label.as_str()).collect(); + let former_sabotage: Vec<&str> = REFUSED_BY_THE_NAMESPACE_SCAN + .iter() + .map(|(label, _)| *label) .collect(); + assert_eq!(refused_labels, former_sabotage); let mutant = options(false, true); let run_mutant = |source: &str| transformed(&mutant, source); let modes: [Mode<'_>; 1] = [("mutant", &run_mutant)]; @@ -96,10 +117,13 @@ fn the_sabotage_rows_diverge_from_node_under_the_alias_form_checks_mutant() { .iter() .filter_map(|row| row.split(" (mutant):").next()) .collect(); - for (label, _) in &sabotage { - assert!( - names.contains(&label.as_str()), - "{label} did not diverge from node under the mutant" - ); - } + let kept: Vec<&str> = sabotage + .iter() + .map(|(label, _)| label.as_str()) + .filter(|label| !names.contains(label)) + .collect(); + assert!( + kept.is_empty(), + "did not diverge from node under the mutant: {kept:?}" + ); } diff --git a/crates/untwist/tests/data/opaque_branch_rows.txt b/crates/untwist/tests/data/opaque_branch_rows.txt index 4a137e402..0dececb51 100644 --- a/crates/untwist/tests/data/opaque_branch_rows.txt +++ b/crates/untwist/tests/data/opaque_branch_rows.txt @@ -1,2 +1,2 @@ -dec-opaque-lock|function aQ() { var h = ['Hello World!', 'console', 'deobfuscate', 'log']; aQ = function () { return h; }; return aQ(); } function bQ(c, d) { var e = aQ(); return (bQ = function (f, g) { f = f - 0; var i = e[f]; return i + '!'; }), bQ(c, d); } (function (c, d) { var e = c(); var tries = 0; while (!![]) { try { if (bQ(0) === 'log!') break; else e['push'](e['shift']()); } catch (h) { e['push'](e['shift']()); } if (tries++ > 1000) break; } })(aQ, 0); var host = { name: 'start', size: 3 }; var host = { name: 'start', size: 3 }; var seen; (function () { var that = Function('return this')(); var pred = function (s, n, codes) { if (bQ(0) !== bQ(1)) { if (s.length != n) return false; for (let i = 0; i < n; i++) { for (let j = 0; j < codes.length; j += 2) { if (i == codes[j] && s.charCodeAt(i | 0) != codes[j + 1]) return false; } } return true; } else { seen = s; return true; } }; var b; for (var k in that) { if (bQ(1) === bQ(1)) { if (pred(k, 4, [0, 104, 3, 116])) { if (bQ(0) === bQ(3)) { seen = k; } else { b = k; break; } } } else { seen = that[k]; } } if (!b || !that[b]) { console.log('no host'); return; } console.log('host ' + typeof that[b] + ' ' + (seen === undefined)); })(); console.log(bQ(0)); console.log(bQ(1)); console.log(bQ(3)); +dec-opaque-lock|function aQ() { var h = ['Hello World!', 'console', 'deobfuscate', 'log']; aQ = function () { return h; }; return aQ(); } function bQ(c, d) { var e = aQ(); return (bQ = function (f, g) { f = f - 0; var i = e[f]; return i + '!'; }), bQ(c, d); } (function (c, d) { var e = c(); var tries = 0; while (!![]) { try { if (bQ(0) === 'log!') break; else e['push'](e['shift']()); } catch (h) { e['push'](e['shift']()); } if (tries++ > 1000) break; } })(aQ, 0); var host = { name: 'start', size: 3 }; var host = { name: 'start', size: 3 }; var seen; (function () { var that = Function('return this')(); var pred = function (s, n, codes) { if (bQ(0) !== bQ(1)) { if (s.length != n) return false; for (let i = 0; i < n; i++) { for (let j = 0; j < codes.length; j += 2) { if (i == codes[j] && s.charCodeAt(i | 0) != codes[j + 1]) return false; } } return true; } else { seen = s; return true; } }; var b; for (var k in that) { if (bQ(1) === bQ(1)) { if (pred(k, 4, [0, 104, 3, 116])) { if (bQ(0) === bQ(3)) { seen = k; } else { b = k; break; } } } else { seen = typeof that[k]; } } if (!b || !that[b]) { console.log('no host'); return; } console.log('host ' + typeof that[b] + ' ' + (seen === undefined)); })(); console.log(bQ(0)); console.log(bQ(1)); console.log(bQ(3)); ref-opaque-live-predicate|function aQ() { var h = ['Hello World!', 'console', 'deobfuscate', 'log']; aQ = function () { return h; }; return aQ(); } function bQ(c, d) { var e = aQ(); return (bQ = function (f, g) { f = f - 0; var i = e[f]; return i + '!'; }), bQ(c, d); } (function (c, d) { var e = c(); var tries = 0; while (!![]) { try { if (bQ(0) === 'log!') break; else e['push'](e['shift']()); } catch (h) { e['push'](e['shift']()); } if (tries++ > 1000) break; } })(aQ, 0); var host = { name: 'start', size: 3 }; var host = { name: 'start', size: 3 }; var seen; (function () { var that = Function('return this')(); var pred = function (s, n, codes) { if (bQ(0) === bQ(1)) { if (s.length != n) return false; for (let i = 0; i < n; i++) { for (let j = 0; j < codes.length; j += 2) { if (i == codes[j] && s.charCodeAt(i | 0) != codes[j + 1]) return false; } } return true; } else { return s === 'b' + 'Q'; } }; var b; for (var k in that) { if (bQ(1) === bQ(1)) { if (pred(k, 4, [0, 104, 3, 116])) { if (bQ(0) === bQ(3)) { seen = k; } else { b = k; break; } } } else { seen = that[k]; } } if (!b || !that[b]) { console.log('no host'); return; } console.log('host ' + typeof that[b]); that[b] = function (i) { return 'EVIL' + i; }; })(); console.log(bQ(0)); console.log(bQ(1)); console.log(bQ(3)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/q-rx8-a-t10.js b/crates/untwist/tests/data/rename_a25rr/single/q-rx8-a-t10.js new file mode 100644 index 000000000..f05041160 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/q-rx8-a-t10.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var k = "x"; (function (n) { globalThis[n] = "f"; })("k"); globalThis[k] = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-d210.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-d210.js new file mode 100644 index 000000000..b7a588e09 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-d210.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; globalThis.eval("zz = 1"); globalThis.o = globalThis; o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-d211.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-d211.js new file mode 100644 index 000000000..827909a08 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-d211.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; setTimeout("zz = 1"); globalThis.o = globalThis; o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p3t33.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p3t33.js new file mode 100644 index 000000000..5e4ae17a3 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p3t33.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; (function (k) { this[k] = this; })("o"); o.f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p4t31.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p4t31.js new file mode 100644 index 000000000..1e192b704 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p4t31.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; (function (g, k) { Reflect.set(g, k, g); })(globalThis, "o"); o.f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p4t50.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p4t50.js new file mode 100644 index 000000000..93f7a214a --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p4t50.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; (function (k) { globalThis[k] = globalThis; })("o"); Object.assign(o, { f: function () { return 99; } }); +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p4t60.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p4t60.js new file mode 100644 index 000000000..045f4d806 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-p4t60.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; (function (k) { setTimeout(function () { globalThis[k] = globalThis; o.f = function () { return 99; }; }); })("o"); +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t1.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t1.js new file mode 100644 index 000000000..0505907ec --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t1.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; Function("o = globalThis")(); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t11.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t11.js new file mode 100644 index 000000000..6c4cb1a0f --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t11.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { var x = globalThis; return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t12.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t12.js new file mode 100644 index 000000000..3e36f18d3 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t12.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { for (var x of [globalThis]); return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t13.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t13.js new file mode 100644 index 000000000..708635118 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t13.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { try { throw globalThis; } catch (e) { var x = e; } return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t14.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t14.js new file mode 100644 index 000000000..454f6c159 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t14.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +(function (x) { var x = this; return x; })({}).f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t2.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t2.js new file mode 100644 index 000000000..5d9a952fe --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t2.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; Function("zz = 1")(); globalThis.o = globalThis; o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t3.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t3.js new file mode 100644 index 000000000..03ad17e5b --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t3.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; (function (g) { g.eval("o = g"); })(globalThis); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t4.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t4.js new file mode 100644 index 000000000..42cd1fc48 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t4.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A() { return {}; } Function("A = function () { return globalThis; }")(); A().f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t5.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t5.js new file mode 100644 index 000000000..dee5b2b4d --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t5.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +let o = {}; Function("o = globalThis")(); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t6.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t6.js new file mode 100644 index 000000000..d66a26298 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t6.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; (function (k) { globalThis[k] = globalThis; })("o"); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t7.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t7.js new file mode 100644 index 000000000..c59b5e009 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t7.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; (function (g, k) { g[k] = g; })(globalThis, "o"); o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t8.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t8.js new file mode 100644 index 000000000..edc6954be --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t8.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = {}; (function (k) { globalThis[k] = 1; })("zz"); globalThis.o = globalThis; o.f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t9.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t9.js new file mode 100644 index 000000000..a1a4668ee --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-a-t9.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A() { return {}; } (function (k) { globalThis[k] = function () { return globalThis; }; })("A"); A().f = function () { return 99; }; +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t43.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t43.js new file mode 100644 index 000000000..423209333 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t43.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { var x = globalThis; return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t44.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t44.js new file mode 100644 index 000000000..fb3c38605 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t44.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { { var x = globalThis; } return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t45.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t45.js new file mode 100644 index 000000000..990d00a78 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t45.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { for (var x = globalThis; ; ) return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t48.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t48.js new file mode 100644 index 000000000..d32a2f3fd --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t48.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { var { x } = { x: globalThis }; return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t49.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t49.js new file mode 100644 index 000000000..c7b3b5794 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t49.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { var [x] = [globalThis]; return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t50.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t50.js new file mode 100644 index 000000000..8c834bdaf --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t50.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { var x = this; return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t51.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t51.js new file mode 100644 index 000000000..293b5c50f --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t51.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { if (x) { var x = globalThis; } return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t57.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t57.js new file mode 100644 index 000000000..0fb909486 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t57.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { var x = globalThis; return B(x); } function B(y) { return y; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t62.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t62.js new file mode 100644 index 000000000..23a742d4f --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t62.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var A = function (x) { var x = globalThis; return x; }; A({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t64.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t64.js new file mode 100644 index 000000000..1e1f8b353 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t64.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +(function (x) { var x = globalThis; return x; })({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t74.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t74.js new file mode 100644 index 000000000..811374985 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t74.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { switch (1) { case 1: var x = globalThis; } return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t75.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t75.js new file mode 100644 index 000000000..9aaa15192 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-b-t75.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +function A(x) { l: var x = globalThis; return x; } A({}).f = function () { return 99; }; +console.log(f(1), f(2)); setTimeout(function () { console.log(f(1), f(2)); }, 5); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t19.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t19.js new file mode 100644 index 000000000..dbce2a2ff --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t19.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; 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/rx8-c-t20.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t20.js new file mode 100644 index 000000000..2f06a4c4f --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t20.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; (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/rx8-c-t21.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t21.js new file mode 100644 index 000000000..2260fb227 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t21.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; for (var { set: s } of [R]) s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t22.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t22.js new file mode 100644 index 000000000..34a0510e8 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t22.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; try { throw R; } catch ({ set: s }) { s(g, "f", function () { return 99; }); } +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t23.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t23.js new file mode 100644 index 000000000..ce8596509 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t23.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; var { r: { set: s } } = { r: R }; s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t24.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t24.js new file mode 100644 index 000000000..cd799f385 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t24.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; function w({ set: s } = R) { s(g, "f", function () { return 99; }); } w(); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t25.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t25.js new file mode 100644 index 000000000..c53bbe759 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t25.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; var s; [{ 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/rx8-c-t26.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t26.js new file mode 100644 index 000000000..e267716c7 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t26.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; var s; ({ r: { set: s } } = { r: R }); s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t28.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t28.js new file mode 100644 index 000000000..f638ce279 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t28.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; var [{ assign: s }] = [O]; s(g, { f: function () { return 99; } }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t29.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t29.js new file mode 100644 index 000000000..a2eaa1936 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t29.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; (function ({ defineProperty: s }) { s(g, "f", { value: function () { return 99; } }); })(O); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t35.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t35.js new file mode 100644 index 000000000..e3e2db5c6 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t35.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; var o = {}; O.setPrototypeOf(o, R); var s = Reflect.get(o, "set"); s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t40.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t40.js new file mode 100644 index 000000000..ac4e26511 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t40.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; var o = {}; R.setPrototypeOf(o, R); var s = Reflect.get(o, "set"); s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t42.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t42.js new file mode 100644 index 000000000..95beabe4f --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t42.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; function P() {} P.prototype = R; var o = new P(); var s = Reflect.get(o, "set"); s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t43.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t43.js new file mode 100644 index 000000000..9b24e2eca --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t43.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; function P() {} P.prototype = R; var s = Reflect.get(new P(), "set"); s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t44.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t44.js new file mode 100644 index 000000000..adb2463f6 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t44.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; function P() {} P["prototype"] = R; var s = Reflect.get(new P(), "set"); s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t45.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t45.js new file mode 100644 index 000000000..d3ad6ef3c --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t45.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; function P() {} Object.assign(P, { prototype: R }); var s = Reflect.get(new P(), "set"); s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t46.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t46.js new file mode 100644 index 000000000..b614ce15e --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t46.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; function P() {} Object.defineProperty(P, "prototype", { value: R }); var s = Reflect.get(new P(), "set"); s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t47.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t47.js new file mode 100644 index 000000000..6ef366af6 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-c-t47.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var n = "Reflect", m = "Object"; var R = g[n], O = g[m]; var P = function () {}; P.prototype = R; var s = Reflect.get(new P(), "set"); s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c1.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c1.js new file mode 100644 index 000000000..2ec6e8a55 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c1.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; Object.defineProperty(globalThis, "Reflect", { enumerable: true }); var s; for (var k in g) { if (k === "Reflect") s = g[k].set; } s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c2.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c2.js new file mode 100644 index 000000000..4b0d33aa7 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c2.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; Symbol.for = function () { return "Reflect"; }; var R = g[Symbol.for("x")]; R.set(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c3.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c3.js new file mode 100644 index 000000000..d904920ff --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c3.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; Symbol = { iterator: "Reflect" }; var R = g[Symbol.iterator]; R.set(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c4.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c4.js new file mode 100644 index 000000000..d2236aec9 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c4.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var s; Object.getOwnPropertyNames(g).forEach(function (k) { if (k === "Reflect") s = g[k].set; }); s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c5.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c5.js new file mode 100644 index 000000000..0fc0b52b2 --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-c5.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var g = [globalThis][0]; var s; Reflect.ownKeys(g).forEach(function (k) { if (k === "Reflect") s = g[k].set; }); s(g, "f", function () { return 99; }); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/data/rename_a25rr/single/rx8-k-p1.js b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-p1.js new file mode 100644 index 000000000..e467f571a --- /dev/null +++ b/crates/untwist/tests/data/rename_a25rr/single/rx8-k-p1.js @@ -0,0 +1,3 @@ +function f(a) { return a + 1; } +var o = { a: 1, b: 2 }; var t = 0; for (var k in o) t += o[k]; var q = []; for (var j in o) q.push(function (i) { return o[i]; }.bind(null, j)); Object.keys(o).forEach(function (m) { t += o[m]; }); console.log(t, q[0](), o[Symbol.iterator]); +console.log(f(1), f(2)); diff --git a/crates/untwist/tests/deobfuscate_retention.rs b/crates/untwist/tests/deobfuscate_retention.rs index a0f966275..9a528615d 100644 --- a/crates/untwist/tests/deobfuscate_retention.rs +++ b/crates/untwist/tests/deobfuscate_retention.rs @@ -75,10 +75,11 @@ fn assert_high_decodes_fully(label: &str, source: &str, observed: bool) { let output = Pipeline::new(options).run(source); let label_mode = format!("{label} ({mode})"); if mode == "default" { - let aliased = decode_notes(&output) - .iter() - .any(|note| note.starts_with(untwist_deobfuscate::notes::BUILTIN_ALIAS_PATCHED)); - assert!(aliased, "{label_mode}: {:?}", decode_notes(&output)); + let refused = decode_notes(&output).iter().any(|note| { + note.starts_with(untwist_deobfuscate::notes::BUILTIN_ALIAS_PATCHED) + || note.starts_with(untwist_deobfuscate::notes::STRING_ARRAY_GLOBAL_REACH) + }); + assert!(refused, "{label_mode}: {:?}", decode_notes(&output)); continue; } if observed { diff --git a/crates/untwist/tests/dynamic_reach_rows.rs b/crates/untwist/tests/dynamic_reach_rows.rs index 73258d7e6..f037f4389 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_inside_an_inlined_helper_no_longer_blocks_decoding() { +fn a_recursive_helper_handing_on_an_element_read_by_an_unproven_key_refuses_by_default() { let source = patched_after_rotator("true", RECURSIVE_HELPER); assert!( - decoded(&source, Lane::Safe), + !decoded(&source, Lane::Safe), "{}", run(&source, Lane::Safe).code() ); diff --git a/crates/untwist/tests/string_array_reach_rows.rs b/crates/untwist/tests/string_array_reach_rows.rs index 0d1369ed2..67ad764ba 100644 --- a/crates/untwist/tests/string_array_reach_rows.rs +++ b/crates/untwist/tests/string_array_reach_rows.rs @@ -18,7 +18,7 @@ fn rows(text: &str) -> Vec<(String, String)> { .collect() } -const DYNAMIC_PATH_WITNESSES: [&str; 17] = [ +const DYNAMIC_PATH_WITNESSES: [&str; 16] = [ "dr-d12", "dr-d15", "dr-d16", @@ -34,7 +34,6 @@ const DYNAMIC_PATH_WITNESSES: [&str; 17] = [ "dr-n-rest", "dr-n-spread", "s2-n-forin", - "s2-n-keys", "s2-n-stringify", ]; diff --git a/crates/untwist/tests/unsafe_lane_hint.rs b/crates/untwist/tests/unsafe_lane_hint.rs index 395650fc6..546677d73 100644 --- a/crates/untwist/tests/unsafe_lane_hint.rs +++ b/crates/untwist/tests/unsafe_lane_hint.rs @@ -1,6 +1,6 @@ use untwist::{NoteKind, Options, Output, Pipeline, UNSAFE_LANE_DECODES}; -const HIGH: &str = include_str!("../../../fixtures/reference/deobfuscate/obfuscator.io-high.js"); +const HIGH: &str = include_str!("../../../fixtures/obfuscator-io/preset-medium--greeting-1.js"); const PLAIN_ARRAY: &str = include_str!("../../../fixtures/reference/deobfuscate/obfuscator.io-multi-encoders.js"); diff --git a/fixtures/obfuscator-io/BASELINE b/fixtures/obfuscator-io/BASELINE index 2f21e0345..ba974e8b1 100644 --- a/fixtures/obfuscator-io/BASELINE +++ b/fixtures/obfuscator-io/BASELINE @@ -50,7 +50,7 @@ pair-calls+split 10 9/10 10/10 10/10 0 safe-global-names (1) pair-calls+unicode 10 9/10 10/10 10/10 0 safe-global-names (1) pair-cff+calls 10 9/10 10/10 10/10 0 safe-global-names (1) pair-cff+dead 10 9/10 10/10 10/10 0 safe-global-names (1) -pair-cff+debug 10 9/10 10/10 10/10 0 safe-global-names (1) +pair-cff+debug 10 0/10 10/10 10/10 0 namespace-by-key (9), safe-global-names (1) pair-cff+keys 10 8/10 9/10 10/10 1 object-keys-not-merged (2), safe-global-names (1) pair-cff+num 10 9/10 10/10 10/10 0 safe-global-names (1) pair-cff+rc4 10 9/10 10/10 10/10 0 builtin-replaced-decoded-key (1) @@ -132,3 +132,4 @@ object-keys-not-merged 13 13 23 13 transformObjectKeys' var o = {}; o[k] = v; x builtin-replaced-decoded-key 12 13 13 0 the global-object getter's code text (Function("return (function() " + ...)) is built through a proxy object whose keys are themselves decoder calls, so the text cannot be resolved before the decode and a stateful base64 or rc4 unit is refused as a possible built-in patch builtin-alias-patched 6 36 36 0 safe lane: a write through a variable, parameter, this or computed object that may hold a standard built-in (an alias of a prototype, constructor or the global object) could replace a built-in the decoders or rotator use, so the unit is left undecoded safe-global-key-reach 3 10 10 0 safe lane, premise 2: the program may hold the global object and reaches keys the check cannot resolve (an object spread or rest enumerates values, a Symbol-valued computed key), so the unit's call sites are left alone +namespace-by-key 1 9 9 0 safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) diff --git a/fixtures/obfuscator-io/EXPECT b/fixtures/obfuscator-io/EXPECT index a3e824a11..8577a67ef 100644 --- a/fixtures/obfuscator-io/EXPECT +++ b/fixtures/obfuscator-io/EXPECT @@ -175,3 +175,12 @@ wrappers-5--mixed-1.js safe machinery xfail safe-global-names: safe lane, premis wrappers-function--mixed-1.js safe machinery xfail safe-global-names: safe lane, premise 2: code may observe the global object's names (a non-strict this, require), so the decoded unit's string array, decoders and rotator are kept as written wrappers-function-params-5--mixed-1.js safe machinery xfail safe-global-names: safe lane, premise 2: code may observe the global object's names (a non-strict this, require), so the decoded unit's string array, decoders and rotator are kept as written wrappers-unchained--mixed-1.js safe machinery xfail safe-global-names: safe lane, premise 2: code may observe the global object's names (a non-strict this, require), so the decoded unit's string array, decoders and rotator are kept as written +pair-cff+debug--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +pair-cff+debug--greeting-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +pair-cff+debug--greeting-2.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +pair-cff+debug--greeting-3.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +pair-cff+debug--functions-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +pair-cff+debug--objects-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +pair-cff+debug--classes-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +pair-cff+debug--control-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +pair-cff+debug--strings-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) diff --git a/fixtures/obfuscator-versions/BASELINE b/fixtures/obfuscator-versions/BASELINE index 92d1ecdce..20b50a3ff 100644 --- a/fixtures/obfuscator-versions/BASELINE +++ b/fixtures/obfuscator-versions/BASELINE @@ -16,7 +16,7 @@ 0.10.2--plain-norot-t1--iife--uglify 1 1/1 1/1 - 0 - 0.10.2--plain-norot-t1-cff--wp4-module--terser 1 1/1 1/1 - 0 - 0.10.2--plain-norot-t1-self--top--none 1 1/1 1/1 - 0 - -0.10.2--plain-norot-t1-unicode--wp4-bundle--none 1 1/1 1/1 - 0 - +0.10.2--plain-norot-t1-unicode--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 0.10.2--plain-norot-t75--wp4-module--none 1 0/1 0/1 - 0 - 0.10.2--plain-norot-t75-self--iife--terser 1 1/1 1/1 - 0 - 0.10.2--plain-rot-t1-dead--wp4-module--uglify 1 1/1 1/1 - 0 - @@ -53,7 +53,7 @@ 0.16.0--plain-norot-t1-keys--wp4-module--uglify 1 1/1 1/1 - 0 - 0.16.0--plain-norot-t1-unicode--wp4-bundle--none 1 0/1 1/1 - 0 safe-global-names (1) 0.16.0--plain-norot-t75-keys--top--uglify 1 1/1 1/1 - 0 - -0.16.0--plain-norot-t75-keys--wp4-bundle--terser 1 1/1 1/1 - 0 - +0.16.0--plain-norot-t75-keys--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 0.16.0--plain-norot-t75-mangled--iife--uglify 1 1/1 1/1 - 0 - 0.16.0--plain-norot-t75-mangled--top--terser 1 1/1 1/1 - 0 - 0.16.0--plain-rot-t1-keys--iife--none 1 1/1 1/1 - 0 - @@ -85,8 +85,8 @@ 0.18.8--b64-rot-t1-unicode--wp4-bundle--none 1 0/1 1/1 - 0 legacy-array-reached (1) 0.18.8--b64-rot-t75--wp4-bundle--terser 1 0/1 1/1 - 0 legacy-array-reached (1) 0.18.8--b64-rot-t75-mangled--iife--none 1 0/1 1/1 - 0 builtin-alias-patched (1) -0.18.8--plain-norot-t1-unicode--wp4-bundle--none 1 1/1 1/1 - 0 - -0.18.8--plain-norot-t1-unicode--wp4-bundle--uglify 1 1/1 1/1 - 0 - +0.18.8--plain-norot-t1-unicode--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) +0.18.8--plain-norot-t1-unicode--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 0.18.8--plain-norot-t75--top--terser 1 1/1 1/1 - 0 - 0.18.8--plain-norot-t75--wp4-module--terser 1 1/1 1/1 - 0 - 0.18.8--plain-norot-t75-keys--top--none 1 0/1 0/1 - 0 legacy-array-reached (1) @@ -126,7 +126,7 @@ 0.20.4--plain-norot-t75-cff--wp4-bundle--uglify 1 0/1 1/1 - 0 legacy-array-reached (1) 0.20.4--plain-norot-t75-keys--iife--uglify 1 1/1 1/1 - 0 - 0.20.4--plain-norot-t75-split--wp4-module--none 1 1/1 1/1 - 0 - -0.20.4--plain-norot-t75-unicode--wp4-bundle--terser 1 1/1 1/1 - 0 - +0.20.4--plain-norot-t75-unicode--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 0.20.4--plain-rot-t1-mangled--wp4-module--uglify 1 1/1 1/1 - 0 - 0.20.4--plain-rot-t1-self--wp4-module--terser 1 0/1 1/1 - 0 self-defending-passed-through (1) 0.20.4--plain-rot-t1-split--top--terser 1 1/1 1/1 - 0 - @@ -158,11 +158,11 @@ 0.23.2--b64-rot-shuf-t1-dead--top--none 1 0/1 1/1 - 0 legacy-array-reached (1) 0.23.2--b64-rot-shuf-t75-keys--wp4-module--none 1 0/1 1/1 - 0 decoder-reads-outer-binding (1) 0.23.2--plain-norot-noshuf-t1-cff--top--none 1 1/1 1/1 - 0 - -0.23.2--plain-norot-noshuf-t1-split--wp4-bundle--none 1 1/1 1/1 - 0 - +0.23.2--plain-norot-noshuf-t1-split--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 0.23.2--plain-norot-shuf-t1-mangled--iife--none 1 1/1 1/1 - 0 - 0.23.2--plain-norot-shuf-t1-unicode--iife--terser 1 1/1 1/1 - 0 - 0.23.2--plain-rot-noshuf-t1-dead--wp4-module--uglify 1 1/1 1/1 - 0 - -0.23.2--plain-rot-noshuf-t1-keys--wp4-bundle--terser 1 0/1 1/1 - 0 safe-global-names (1) +0.23.2--plain-rot-noshuf-t1-keys--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1), safe-global-names (1) 0.23.2--plain-rot-noshuf-t75--top--terser 1 1/1 1/1 - 0 - 0.23.2--plain-rot-noshuf-t75-self--iife--uglify 1 0/1 1/1 - 0 builtin-alias-patched (1) 0.23.2--plain-rot-noshuf-t75-unicode--wp4-module--terser 1 1/1 1/1 - 0 - @@ -199,11 +199,11 @@ 0.28.5--plain-norot-shuf-t1-self--wp4-module--terser 1 0/1 1/1 - 0 builtin-alias-patched (1) 0.28.5--plain-norot-shuf-t75-unicode--top--terser 1 0/1 1/1 - 0 safe-global-names (1) 0.28.5--plain-rot-noshuf-t1-dead--iife--none 1 1/1 1/1 - 0 - -0.28.5--plain-rot-noshuf-t1-split--wp4-bundle--terser 1 1/1 1/1 - 0 - +0.28.5--plain-rot-noshuf-t1-split--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 0.28.5--plain-rot-noshuf-t75-keys--iife--uglify 1 1/1 1/1 - 0 - 0.28.5--plain-rot-noshuf-t75-self--top--uglify 1 1/1 1/1 - 0 - 0.28.5--plain-rot-shuf-t1--wp4-bundle--none 1 0/1 1/1 - 0 safe-global-names (1) -0.28.5--plain-rot-shuf-t1-split--wp4-bundle--uglify 1 1/1 1/1 - 0 - +0.28.5--plain-rot-shuf-t1-split--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 0.28.5--plain-rot-shuf-t75-split--wp4-module--uglify 1 1/1 1/1 - 0 - 0.28.5--rc4-norot-noshuf-t1--wp4-module--terser 1 0/1 1/1 - 0 decoder-reads-outer-binding (1) 0.28.5--rc4-norot-noshuf-t1-split--iife--none 1 0/1 1/1 - 0 decoder-reads-outer-binding (1) @@ -236,7 +236,7 @@ 1.12.1--plain-norot-shuf-t75-split--top--terser 1 1/1 1/1 - 0 - 1.12.1--plain-norot-shuf-t75-unicode--wp4-module--none 1 1/1 1/1 - 0 - 1.12.1--plain-rot-noshuf-t1-keys--iife--none 1 1/1 1/1 - 0 - -1.12.1--plain-rot-noshuf-t1-unicode--wp4-bundle--terser 1 1/1 1/1 - 0 - +1.12.1--plain-rot-noshuf-t1-unicode--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 1.12.1--plain-rot-noshuf-t75--iife--terser 1 1/1 1/1 - 0 - 1.12.1--plain-rot-noshuf-t75-dead--top--none 1 0/1 1/1 - 0 safe-global-names (1) 1.12.1--plain-rot-noshuf-t75-mangled--iife--uglify 1 1/1 1/1 - 0 - @@ -255,14 +255,14 @@ 1.12.1--rc4-rot-shuf-t75-mangled--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 1.4.0--b64-norot-noshuf-t1-keys--top--none 1 1/1 1/1 - 0 - 1.4.0--b64-norot-noshuf-t1-unicode--wp4-module--uglify 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) -1.4.0--b64-norot-noshuf-t75--wp4-bundle--uglify 1 1/1 1/1 - 0 - +1.4.0--b64-norot-noshuf-t75--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 1.4.0--b64-norot-noshuf-t75-self--wp4-module--none 1 0/1 1/1 - 0 builtin-alias-patched (1) 1.4.0--b64-norot-shuf-t75-keys--iife--uglify 1 0/1 0/1 - 0 builtin-replaced-decoded-key (1), object-keys-not-merged (1) 1.4.0--b64-norot-shuf-t75-mangled--iife--terser 1 1/1 1/1 - 0 - 1.4.0--b64-norot-shuf-t75-unicode--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) -1.4.0--b64-rot-noshuf-t1-mangled--wp4-bundle--none 1 1/1 1/1 - 0 - +1.4.0--b64-rot-noshuf-t1-mangled--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 1.4.0--b64-rot-noshuf-t75--iife--none 1 1/1 1/1 - 0 - -1.4.0--b64-rot-shuf-t1-split--wp4-bundle--terser 1 1/1 1/1 - 0 - +1.4.0--b64-rot-shuf-t1-split--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 1.4.0--b64-rot-shuf-t1-unicode--top--uglify 1 1/1 1/1 - 0 - 1.4.0--b64-rot-shuf-t75-cff--top--terser 1 1/1 1/1 - 0 - 1.4.0--plain-norot-noshuf-t1--iife--none 1 1/1 1/1 - 0 - @@ -271,7 +271,7 @@ 1.4.0--plain-norot-noshuf-t1-self--top--none 1 0/1 1/1 - 0 safe-global-names (1) 1.4.0--plain-norot-noshuf-t1-split--wp4-module--none 1 1/1 1/1 - 0 - 1.4.0--plain-norot-noshuf-t1-unicode--iife--uglify 1 1/1 1/1 - 0 - -1.4.0--plain-norot-shuf-t1-dead--wp4-bundle--terser 1 1/1 1/1 - 0 - +1.4.0--plain-norot-shuf-t1-dead--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 1.4.0--plain-rot-noshuf-t1-keys--wp4-module--uglify 1 1/1 1/1 - 0 - 1.4.0--plain-rot-shuf-t1-cff--iife--terser 1 1/1 1/1 - 0 - 1.4.0--plain-rot-shuf-t75-cff--wp4-bundle--none 1 0/1 1/1 - 0 legacy-array-reached (1) @@ -282,7 +282,7 @@ 1.4.0--rc4-norot-noshuf-t75-split--top--uglify 1 1/1 1/1 - 0 - 1.4.0--rc4-norot-shuf-t75-dead--iife--uglify 1 1/1 1/1 - 0 - 1.4.0--rc4-norot-shuf-t75-self--iife--terser 1 1/1 1/1 - 0 - -1.4.0--rc4-rot-noshuf-t1-split--wp4-bundle--terser 1 1/1 1/1 - 0 - +1.4.0--rc4-rot-noshuf-t1-split--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 1.4.0--rc4-rot-noshuf-t1-unicode--iife--none 1 0/1 1/1 - 0 builtin-alias-patched (1) 1.4.0--rc4-rot-shuf-t1-dead--wp4-module--none 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 1.4.0--rc4-rot-shuf-t1-dead--wp4-module--uglify 1 0/1 1/1 - 0 builtin-alias-patched (1) @@ -292,7 +292,7 @@ 1.6.0--b64-norot-noshuf-t75-numbers--wp4-module--none 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 1.6.0--b64-norot-noshuf-t75-unicode--wp4-bundle--terser 1 0/1 1/1 - 0 legacy-array-reached (1) 1.6.0--b64-norot-shuf-t1-mangled--wp4-module--uglify 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) -1.6.0--b64-norot-shuf-t1-unicode--wp4-bundle--uglify 1 1/1 1/1 - 0 - +1.6.0--b64-norot-shuf-t1-unicode--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 1.6.0--b64-norot-shuf-t75-mangled--top--uglify 1 1/1 1/1 - 0 - 1.6.0--b64-norot-shuf-t75-mangled--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 1.6.0--b64-norot-shuf-t75-self--wp4-bundle--none 1 0/1 1/1 - 0 legacy-array-reached (1) @@ -323,7 +323,7 @@ 1.6.0--rc4-rot-noshuf-t1-dead--wp4-module--uglify 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 1.6.0--rc4-rot-noshuf-t75-split--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 1.6.0--rc4-rot-shuf-t1-split--iife--uglify 1 1/1 1/1 - 0 - -1.6.0--rc4-rot-shuf-t75--wp4-bundle--uglify 1 1/1 1/1 - 0 - +1.6.0--rc4-rot-shuf-t75--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 1.6.0--rc4-rot-shuf-t75-keys--top--uglify 1 1/1 1/1 - 0 - 2.11.1--b64-norot-noshuf-noshift-inum-w3f-t1-mangled--top--uglify 1 1/1 1/1 - 0 - 2.11.1--b64-norot-noshuf-shift-istr-w2f5-t1-dead--iife--terser 1 1/1 1/1 - 0 - @@ -334,7 +334,7 @@ 2.11.1--b64-rot-noshuf-noshift-istr-w2f5-t1-self--iife--none 1 1/1 1/1 - 0 - 2.11.1--b64-rot-noshuf-shift-istr-w3f-t75-unicode--top--none 1 1/1 1/1 - 0 - 2.11.1--b64-rot-shuf-noshift-inum-w1-t75-self--wp4-module--terser 1 0/1 1/1 - 0 builtin-alias-patched (1) -2.11.1--b64-rot-shuf-noshift-inum-w2u-t1-mangled--wp4-bundle--none 1 1/1 1/1 - 0 - +2.11.1--b64-rot-shuf-noshift-inum-w2u-t1-mangled--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 2.11.1--b64-rot-shuf-shift-inum-w0-t75-self--wp4-module--uglify 1 0/1 1/1 - 0 builtin-alias-patched (1) 2.11.1--b64-rot-shuf-shift-istr-w3f-t75-self--wp4-bundle--uglify 1 0/1 1/1 - 0 legacy-array-reached (1) 2.11.1--plain-norot-noshuf-noshift-istr-w2u-t75-numbers--wp4-bundle--none 1 0/1 1/1 - 0 legacy-array-reached (1) @@ -343,7 +343,7 @@ 2.11.1--plain-norot-shuf-noshift-inum-w1-t1-dead--iife--uglify 1 0/1 0/1 - 0 decoder-used-as-value (2) 2.11.1--plain-norot-shuf-noshift-inum-w3f-t75-keys--wp4-module--uglify 1 1/1 1/1 - 0 - 2.11.1--plain-rot-noshuf-noshift-inum-w1-t1-mangled--wp4-bundle--uglify 1 0/1 1/1 - 0 safe-global-names (1) -2.11.1--plain-rot-noshuf-noshift-inum-w1-t75-mangled--wp4-bundle--terser 1 1/1 1/1 - 0 - +2.11.1--plain-rot-noshuf-noshift-inum-w1-t75-mangled--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 2.11.1--plain-rot-noshuf-shift-inum-w0-t1-unicode--iife--none 1 1/1 1/1 - 0 - 2.11.1--plain-rot-noshuf-shift-istr-w2u-t75-mangled--top--terser 1 1/1 1/1 - 0 - 2.11.1--plain-rot-shuf-noshift-inum-w1-t1-cff--wp4-module--none 1 1/1 1/1 - 0 - @@ -362,7 +362,7 @@ 2.11.1--rc4-rot-shuf-noshift-istr-w2f5-t1-mangled--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 2.11.1--rc4-rot-shuf-shift-inum-w1-t75-self--wp4-bundle--uglify 1 0/1 1/1 - 0 legacy-array-reached (1) 2.13.0--b64-norot-noshuf-noshift-istr-w0-t1--top--uglify 1 0/1 1/1 - 0 legacy-array-reached (1) -2.13.0--b64-norot-noshuf-shift-istr-w2f5-t1-mangled--wp4-bundle--terser 1 1/1 1/1 - 0 - +2.13.0--b64-norot-noshuf-shift-istr-w2f5-t1-mangled--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 2.13.0--b64-norot-shuf-noshift-inum-w2f5-t1-unicode--wp4-module--none 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 2.13.0--b64-norot-shuf-shift-inum-w3f-t1-split--iife--uglify 1 1/1 1/1 - 0 - 2.13.0--b64-norot-shuf-shift-istr-w1-t75-mangled--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) @@ -379,12 +379,12 @@ 2.13.0--plain-norot-noshuf-noshift-istr-w3f-t75-keys--top--terser 1 1/1 1/1 - 0 - 2.13.0--plain-norot-shuf-noshift-inum-w2u-t1-cff--wp4-module--uglify 1 0/1 0/1 - 0 wrapper-alias-read-early (2) 2.13.0--plain-rot-noshuf-noshift-istr-w1-t1--iife--none 1 1/1 1/1 - 0 - -2.13.0--plain-rot-noshuf-shift-inum-w3f-t75--wp4-bundle--none 1 1/1 1/1 - 0 - +2.13.0--plain-rot-noshuf-shift-inum-w3f-t75--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 2.13.0--plain-rot-noshuf-shift-istr-w2u-t1-self--iife--uglify 1 1/1 1/1 - 0 - 2.13.0--plain-rot-shuf-noshift-istr-w3f-t1-mangled--wp4-bundle--terser 1 0/1 1/1 - 0 legacy-array-reached (1) 2.13.0--plain-rot-shuf-shift-inum-w2f5-t1-mangled--wp4-module--terser 1 1/1 1/1 - 0 - 2.13.0--plain-rot-shuf-shift-istr-w0-t1-unicode--top--none 1 1/1 1/1 - 0 - -2.13.0--plain-rot-shuf-shift-istr-w0-t75-split--wp4-bundle--uglify 1 1/1 1/1 - 0 - +2.13.0--plain-rot-shuf-shift-istr-w0-t75-split--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 2.13.0--rc4-norot-noshuf-noshift-inum-w0-t1-split--wp4-module--none 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 2.13.0--rc4-norot-noshuf-shift-istr-w1-t1-numbers--iife--uglify 1 0/1 0/1 - 0 decoder-used-as-value (2) 2.13.0--rc4-norot-noshuf-shift-istr-w2u-t75-self--wp4-bundle--uglify 1 0/1 1/1 - 0 legacy-array-reached (1) @@ -404,14 +404,14 @@ 2.14.0--b64-norot-shuf-shift-inum-w0-t75-self--top--none 1 1/1 1/1 - 0 - 2.14.0--b64-norot-shuf-shift-inum-w2f5-t1-cff--wp4-bundle--uglify 1 0/1 1/1 - 0 legacy-array-reached (1) 2.14.0--b64-norot-shuf-shift-inum-w2u-t75-keys--top--uglify 1 0/1 1/1 - 0 legacy-array-reached (1) -2.14.0--b64-rot-noshuf-noshift-inum-w1-t75-unicode--wp4-bundle--none 1 1/1 1/1 - 0 - +2.14.0--b64-rot-noshuf-noshift-inum-w1-t75-unicode--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 2.14.0--b64-rot-noshuf-shift-inum-w2u-t1-split--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 2.14.0--b64-rot-noshuf-shift-istr-w0-t75--iife--uglify 1 1/1 1/1 - 0 - 2.14.0--b64-rot-noshuf-shift-istr-w2f5-t75-unicode--wp4-module--none 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) -2.14.0--b64-rot-noshuf-shift-istr-w2u-t1-dead--wp4-bundle--terser 1 1/1 1/1 - 0 - +2.14.0--b64-rot-noshuf-shift-istr-w2u-t1-dead--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 2.14.0--b64-rot-shuf-shift-inum-w3f-t75-numbers--wp4-module--uglify 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 2.14.0--plain-norot-noshuf-noshift-inum-w2f5-t1-self--top--uglify 1 0/1 1/1 - 0 legacy-array-reached (1) -2.14.0--plain-norot-noshuf-noshift-istr-w2f5-t1-split--wp4-bundle--uglify 1 1/1 1/1 - 0 - +2.14.0--plain-norot-noshuf-noshift-istr-w2f5-t1-split--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 2.14.0--plain-norot-noshuf-shift-inum-w3f-t75-cff--wp4-module--terser 1 1/1 1/1 - 0 - 2.14.0--plain-norot-shuf-noshift-inum-w1-t75-numbers--wp4-module--uglify 1 1/1 1/1 - 0 - 2.14.0--plain-norot-shuf-shift-inum-w2u-t1-numbers--wp4-bundle--none 1 0/1 1/1 - 0 legacy-array-reached (1) @@ -422,8 +422,8 @@ 2.14.0--plain-rot-shuf-noshift-istr-w2u-t75-cff--wp4-bundle--terser 1 0/1 1/1 - 0 legacy-array-reached (1) 2.14.0--plain-rot-shuf-shift-istr-w2u-t75-dead--top--none 1 1/1 1/1 - 0 - 2.14.0--plain-rot-shuf-shift-istr-w3f-t1-unicode--top--terser 1 1/1 1/1 - 0 - -2.14.0--rc4-norot-noshuf-noshift-inum-w1-t1-split--wp4-bundle--none 1 1/1 1/1 - 0 - -2.14.0--rc4-norot-noshuf-noshift-inum-w2f5-t1-numbers--wp4-bundle--uglify 1 1/1 1/1 - 0 - +2.14.0--rc4-norot-noshuf-noshift-inum-w1-t1-split--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) +2.14.0--rc4-norot-noshuf-noshift-inum-w2f5-t1-numbers--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 2.14.0--rc4-norot-noshuf-noshift-istr-w2f5-t1-mangled--iife--none 1 1/1 1/1 - 0 - 2.14.0--rc4-norot-noshuf-shift-istr-w3f-t75-self--top--terser 1 0/1 1/1 - 0 safe-global-names (1) 2.14.0--rc4-norot-shuf-shift-inum-w0-t1-split--iife--terser 1 1/1 1/1 - 0 - @@ -478,17 +478,17 @@ 2.18.1--b64-norot-shuf-noshift-inum-w3f-t1-numbers--iife--none 1 1/1 1/1 - 0 - 2.18.1--b64-rot-noshuf-noshift-inum-w2f5-t75-mangled--top--uglify 1 1/1 1/1 - 0 - 2.18.1--b64-rot-noshuf-noshift-inum-w3f-t1--top--terser 1 1/1 1/1 - 0 - -2.18.1--b64-rot-shuf-noshift-inum-w3f-t75-split--wp4-bundle--uglify 1 1/1 1/1 - 0 - +2.18.1--b64-rot-shuf-noshift-inum-w3f-t75-split--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 2.18.1--b64-rot-shuf-noshift-istr-w0-t75-unicode--iife--uglify 1 1/1 1/1 - 0 - 2.18.1--b64-rot-shuf-noshift-istr-w1-t1-numbers--wp4-bundle--none 1 0/1 1/1 - 0 legacy-array-reached (1) 2.18.1--b64-rot-shuf-noshift-istr-w2u-t1--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) -2.18.1--b64-rot-shuf-noshift-istr-w3f-t1-mangled--wp4-bundle--terser 1 1/1 1/1 - 0 - +2.18.1--b64-rot-shuf-noshift-istr-w3f-t1-mangled--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 2.18.1--plain-norot-noshuf-noshift-inum-w0-t1-unicode--wp4-module--uglify 1 1/1 1/1 - 0 - 2.18.1--plain-norot-noshuf-noshift-inum-w1-t1-dead--wp4-module--terser 1 1/1 1/1 - 0 - 2.18.1--plain-norot-noshuf-shift-istr-w3f-t75--top--terser 1 1/1 1/1 - 0 - 2.18.1--plain-norot-shuf-noshift-istr-w2u-t1-self--top--none 1 1/1 1/1 - 0 - 2.18.1--plain-norot-shuf-shift-inum-w3f-t1-mangled--wp4-bundle--uglify 1 0/1 1/1 - 0 legacy-array-reached (1) -2.18.1--plain-norot-shuf-shift-istr-w2f5-t1-unicode--wp4-bundle--none 1 1/1 1/1 - 0 - +2.18.1--plain-norot-shuf-shift-istr-w2f5-t1-unicode--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 2.18.1--plain-rot-noshuf-noshift-inum-w0-t1-cff--wp4-bundle--terser 1 0/1 1/1 - 0 legacy-array-reached (1) 2.18.1--plain-rot-noshuf-noshift-inum-w0-t1-keys--iife--none 1 1/1 1/1 - 0 - 2.18.1--plain-rot-noshuf-noshift-inum-w3f-t75-mangled--wp4-module--none 1 1/1 1/1 - 0 - @@ -503,7 +503,7 @@ 2.18.1--rc4-norot-shuf-shift-inum-w2u-t75-numbers--iife--none 1 1/1 1/1 - 0 - 2.18.1--rc4-norot-shuf-shift-inum-w3f-t75-cff--wp4-bundle--uglify 1 0/1 0/1 - 0 legacy-array-reached (1), stateful-decoder-escape (1) 2.18.1--rc4-rot-noshuf-noshift-inum-w3f-t75-numbers--top--terser 1 1/1 1/1 - 0 - -2.18.1--rc4-rot-noshuf-noshift-istr-w2f5-t75-split--wp4-bundle--none 1 1/1 1/1 - 0 - +2.18.1--rc4-rot-noshuf-noshift-istr-w2f5-t75-split--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 2.18.1--rc4-rot-noshuf-shift-inum-w2u-t1-cff--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 2.18.1--rc4-rot-shuf-noshift-inum-w0-t75-split--wp4-module--none 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 2.18.1--rc4-rot-shuf-noshift-istr-w1-t1-self--wp4-module--uglify 1 0/1 1/1 - 0 builtin-alias-patched (1) @@ -519,12 +519,12 @@ 2.19.1--b64-rot-shuf-noshift-istr-w2u-t1-numbers--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 2.19.1--b64-rot-shuf-shift-inum-w2f5-t1-self--wp4-bundle--none 1 0/1 1/1 - 0 builtin-alias-patched (1) 2.19.1--b64-rot-shuf-shift-inum-w3f-t75-keys--wp4-module--uglify 1 0/1 0/1 - 0 array-reached-outside (2) -2.19.1--plain-norot-noshuf-noshift-inum-w1-t1-split--wp4-bundle--terser 1 1/1 1/1 - 0 - +2.19.1--plain-norot-noshuf-noshift-inum-w1-t1-split--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 2.19.1--plain-norot-noshuf-noshift-istr-w2f5-t1-numbers--wp4-module--terser 1 1/1 1/1 - 0 - 2.19.1--plain-norot-noshuf-shift-istr-w0-t75-cff--wp4-module--none 1 1/1 1/1 - 0 - 2.19.1--plain-norot-shuf-noshift-inum-w3f-t75-keys--iife--uglify 1 1/1 1/1 - 0 - 2.19.1--plain-norot-shuf-shift-istr-w1-t1--top--none 1 0/1 1/1 - 0 safe-global-names (1) -2.19.1--plain-norot-shuf-shift-istr-w2u-t1--wp4-bundle--none 1 1/1 1/1 - 0 - +2.19.1--plain-norot-shuf-shift-istr-w2u-t1--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 2.19.1--plain-rot-noshuf-noshift-inum-w2f5-t75-dead--top--uglify 1 0/1 0/1 - 0 rotator-reads-outside (2) 2.19.1--plain-rot-noshuf-shift-inum-w1-t75-split--iife--terser 1 1/1 1/1 - 0 - 2.19.1--plain-rot-noshuf-shift-istr-w0-t75-self--top--terser 1 0/1 0/1 - 0 rotator-reads-outside (2) @@ -540,13 +540,13 @@ 2.19.1--rc4-rot-noshuf-noshift-istr-w0-t1-unicode--top--none 1 1/1 1/1 - 0 - 2.19.1--rc4-rot-noshuf-shift-istr-w3f-t75-split--wp4-bundle--none 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 2.19.1--rc4-rot-shuf-noshift-inum-w1-t75-self--wp4-module--uglify 1 0/1 0/1 - 0 array-reached-outside (2) -2.19.1--rc4-rot-shuf-noshift-inum-w2u-t75-numbers--wp4-bundle--uglify 1 1/1 1/1 - 0 - +2.19.1--rc4-rot-shuf-noshift-inum-w2u-t75-numbers--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 2.19.1--rc4-rot-shuf-shift-istr-w2f5-t1-cff--wp4-module--terser 1 0/1 1/1 - 0 builtin-alias-patched (1) 2.19.1--rc4-rot-shuf-shift-istr-w2u-t75-cff--iife--uglify 1 0/1 0/1 - 0 array-reached-outside (2) 2.4.3--b64-norot-noshuf-w0-t1-split--top--uglify 1 1/1 1/1 - 0 - 2.4.3--b64-norot-noshuf-w3f-t1-keys--wp4-bundle--uglify 1 0/1 0/1 - 0 legacy-array-reached (1), object-keys-not-merged (1) 2.4.3--b64-norot-noshuf-w3f-t1-mangled--wp4-module--uglify 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) -2.4.3--b64-norot-shuf-w0-t75-keys--wp4-bundle--terser 1 1/1 1/1 - 0 - +2.4.3--b64-norot-shuf-w0-t75-keys--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 2.4.3--b64-norot-shuf-w1-t75-split--top--terser 1 1/1 1/1 - 0 - 2.4.3--b64-norot-shuf-w2u-t1-self--top--none 1 0/1 1/1 - 0 safe-global-names (1) 2.4.3--b64-rot-noshuf-w1-t1-dead--wp4-bundle--none 1 0/1 1/1 - 0 legacy-array-reached (1) @@ -564,7 +564,7 @@ 2.4.3--plain-rot-noshuf-w1-t1-keys--iife--uglify 1 1/1 1/1 - 0 - 2.4.3--plain-rot-noshuf-w2u-t1-split--wp4-module--uglify 1 0/1 1/1 - 0 builtin-alias-patched (1) 2.4.3--plain-rot-shuf-w0-t75-dead--wp4-bundle--none 1 0/1 1/1 - 0 safe-global-names (1) -2.4.3--plain-rot-shuf-w2u-t1-keys--wp4-bundle--terser 1 1/1 1/1 - 0 - +2.4.3--plain-rot-shuf-w2u-t1-keys--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 2.4.3--plain-rot-shuf-w3f-t75--wp4-bundle--uglify 1 0/1 1/1 - 0 safe-global-names (1) 2.4.3--plain-rot-shuf-w3f-t75-dead--top--terser 1 0/1 1/1 - 0 safe-global-names (1) 2.4.3--rc4-norot-noshuf-w2u-t75-cff--wp4-bundle--none 1 0/1 1/1 - 0 legacy-array-reached (1) @@ -576,7 +576,7 @@ 2.4.3--rc4-rot-noshuf-w0-t75-self--wp4-module--none 1 0/1 1/1 - 0 builtin-alias-patched (1) 2.4.3--rc4-rot-noshuf-w1-t1-self--iife--none 1 0/1 1/1 - 0 builtin-alias-patched (1) 2.4.3--rc4-rot-noshuf-w1-t1-unicode--wp4-bundle--terser 1 0/1 1/1 - 0 legacy-array-reached (1) -2.4.3--rc4-rot-noshuf-w3f-t1-split--wp4-bundle--uglify 1 1/1 1/1 - 0 - +2.4.3--rc4-rot-noshuf-w3f-t1-split--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 2.4.3--rc4-rot-shuf-w2u-t1-keys--wp4-module--uglify 1 0/1 0/1 - 0 builtin-alias-patched (1), wrapper-alias-redeclared (1) 2.4.3--rc4-rot-shuf-w3f-t75-numbers--top--none 1 1/1 1/1 - 0 - 2.9.6--b64-norot-noshuf-noshift-istr-w2f5-t75-keys--iife--terser 1 1/1 1/1 - 0 - @@ -584,15 +584,15 @@ 2.9.6--b64-norot-noshuf-shift-istr-w2f5-t1-mangled--wp4-module--none 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 2.9.6--b64-norot-shuf-noshift-inum-w3f-t1-self--top--uglify 1 0/1 1/1 - 0 legacy-array-reached (1) 2.9.6--b64-norot-shuf-noshift-istr-w1-t1-dead--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) -2.9.6--b64-norot-shuf-shift-inum-w0-t1-mangled--wp4-bundle--uglify 1 1/1 1/1 - 0 - +2.9.6--b64-norot-shuf-shift-inum-w0-t1-mangled--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 2.9.6--b64-norot-shuf-shift-istr-w2u-t1-cff--iife--none 1 1/1 1/1 - 0 - 2.9.6--b64-rot-noshuf-noshift-inum-w2u-t1-dead--wp4-bundle--none 1 0/1 1/1 - 0 safe-global-names (1) 2.9.6--b64-rot-noshuf-shift-istr-w3f-t75-self--wp4-module--uglify 1 0/1 1/1 - 0 builtin-alias-patched (1) -2.9.6--b64-rot-shuf-noshift-inum-w0-t1--wp4-bundle--terser 1 1/1 1/1 - 0 - +2.9.6--b64-rot-shuf-noshift-inum-w0-t1--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) 2.9.6--b64-rot-shuf-shift-inum-w1-t1--iife--uglify 1 1/1 1/1 - 0 - 2.9.6--b64-rot-shuf-shift-istr-w2f5-t1-split--top--none 1 1/1 1/1 - 0 - -2.9.6--plain-norot-noshuf-shift-inum-w0-t1-keys--wp4-bundle--terser 1 1/1 1/1 - 0 - -2.9.6--plain-norot-noshuf-shift-istr-w3f-t75-dead--wp4-bundle--uglify 1 1/1 1/1 - 0 - +2.9.6--plain-norot-noshuf-shift-inum-w0-t1-keys--wp4-bundle--terser 1 0/1 1/1 - 0 namespace-by-key (1) +2.9.6--plain-norot-noshuf-shift-istr-w3f-t75-dead--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 2.9.6--plain-norot-shuf-noshift-inum-w1-t75-numbers--iife--terser 1 1/1 1/1 - 0 - 2.9.6--plain-norot-shuf-noshift-inum-w2f5-t75-numbers--wp4-bundle--none 1 0/1 1/1 - 0 legacy-array-reached (1) 2.9.6--plain-norot-shuf-noshift-inum-w2u-t75-split--wp4-module--terser 1 1/1 1/1 - 0 - @@ -639,29 +639,29 @@ 3.2.7--plain-rot-shuf-shift-istr-w0-calls-t75-unicode--top--none 1 1/1 1/1 - 0 - 3.2.7--plain-rot-shuf-shift-istr-w2u-calls-t1-split--wp4-bundle--uglify 1 0/1 0/1 - 0 wrapper-alias-redeclared (2) 3.2.7--plain-rot-shuf-shift-istr-w2u-nocalls-t75-split--iife--terser 1 1/1 1/1 - 0 - -3.2.7--plain-rot-shuf-shift-istr-w3f-nocalls-t75-unicode--wp4-bundle--none 1 1/1 1/1 - 0 - +3.2.7--plain-rot-shuf-shift-istr-w3f-nocalls-t75-unicode--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 3.2.7--rc4-norot-noshuf-noshift-inum-w0-calls-t75-mangled--iife--none 1 1/1 1/1 - 0 - 3.2.7--rc4-norot-noshuf-noshift-istr-w2u-calls-t1-cff--top--uglify 1 1/1 1/1 - 0 - 3.2.7--rc4-norot-noshuf-shift-inum-w3f-calls-t1-cff--wp4-module--terser 1 0/1 1/1 - 0 builtin-alias-patched (1) 3.2.7--rc4-norot-shuf-noshift-istr-w1-calls-t1-self--iife--uglify 1 0/1 0/1 - 0 stateful-decoder-state (2) 3.2.7--rc4-norot-shuf-shift-inum-w2f5-calls-t75-numbers--wp4-module--uglify 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) -3.2.7--rc4-rot-noshuf-noshift-inum-w0-nocalls-t75-mangled--wp4-bundle--none 1 1/1 1/1 - 0 - +3.2.7--rc4-rot-noshuf-noshift-inum-w0-nocalls-t75-mangled--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 3.2.7--rc4-rot-noshuf-noshift-istr-w2u-calls-t75--wp4-module--none 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 3.2.7--rc4-rot-noshuf-shift-inum-w1-nocalls-t1-split--top--none 1 1/1 1/1 - 0 - 3.2.7--rc4-rot-noshuf-shift-inum-w2f5-calls-t75-cff--iife--terser 1 0/1 1/1 - 0 builtin-alias-patched (1) 3.2.7--rc4-rot-noshuf-shift-inum-w3f-nocalls-t75-dead--top--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) -3.2.7--rc4-rot-shuf-noshift-inum-w3f-nocalls-t1-numbers--wp4-bundle--uglify 1 1/1 1/1 - 0 - +3.2.7--rc4-rot-shuf-noshift-inum-w3f-nocalls-t1-numbers--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 3.2.7--rc4-rot-shuf-shift-istr-w3f-calls-t1-numbers--wp4-bundle--terser 1 0/1 1/1 - 0 builtin-alias-patched (1) 4.2.2--b64-norot-noshuf-noshift-inum-w2f5-calls-t1-dead--wp4-bundle--terser 1 0/1 1/1 - 0 safe-global-key-reach (1) 4.2.2--b64-norot-noshuf-noshift-istr-w3f-calls-t75-self--iife--none 1 1/1 1/1 - 0 - -4.2.2--b64-norot-noshuf-shift-inum-w2u-nocalls-t1--wp4-bundle--none 1 1/1 1/1 - 0 - +4.2.2--b64-norot-noshuf-shift-inum-w2u-nocalls-t1--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 4.2.2--b64-norot-shuf-noshift-istr-w0-calls-t1-split--wp4-module--none 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 4.2.2--b64-norot-shuf-noshift-istr-w1-calls-t1--top--none 1 1/1 1/1 - 0 - 4.2.2--b64-norot-shuf-noshift-istr-w2f5-nocalls-t75-keys--iife--terser 1 1/1 1/1 - 0 - 4.2.2--b64-rot-shuf-noshift-istr-w1-calls-t1-dead--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 4.2.2--b64-rot-shuf-noshift-istr-w2f5-calls-t1-cff--top--uglify 1 1/1 1/1 - 0 - 4.2.2--b64-rot-shuf-shift-istr-w0-calls-t75-self--top--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) -4.2.2--b64-rot-shuf-shift-istr-w1-nocalls-t1-unicode--wp4-bundle--uglify 1 1/1 1/1 - 0 - +4.2.2--b64-rot-shuf-shift-istr-w1-nocalls-t1-unicode--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 4.2.2--b64-rot-shuf-shift-istr-w2u-calls-t1-keys--wp4-module--uglify 1 0/1 0/1 - 0 array-reached-outside (2) 4.2.2--b64-rot-shuf-shift-istr-w3f-calls-t75-dead--iife--uglify 1 1/1 1/1 - 0 - 4.2.2--plain-norot-noshuf-noshift-inum-w3f-calls-t1-mangled--top--none 1 1/1 1/1 - 0 - @@ -671,12 +671,12 @@ 4.2.2--plain-norot-shuf-noshift-istr-w2f5-nocalls-t1-dead--wp4-bundle--terser 1 0/1 1/1 - 0 safe-global-key-reach (1) 4.2.2--plain-norot-shuf-shift-istr-w1-nocalls-t1-self--wp4-bundle--none 1 0/1 1/1 - 0 builtin-alias-patched (1) 4.2.2--plain-rot-noshuf-noshift-inum-w1-calls-t1-unicode--iife--none 1 1/1 1/1 - 0 - -4.2.2--plain-rot-noshuf-noshift-inum-w1-nocalls-t1-mangled--wp4-bundle--uglify 1 1/1 1/1 - 0 - +4.2.2--plain-rot-noshuf-noshift-inum-w1-nocalls-t1-mangled--wp4-bundle--uglify 1 0/1 1/1 - 0 namespace-by-key (1) 4.2.2--plain-rot-noshuf-noshift-istr-w2f5-calls-t1-self--iife--terser 1 0/1 1/1 - 0 builtin-alias-patched (1) 4.2.2--plain-rot-noshuf-shift-istr-w3f-calls-t75--wp4-module--uglify 1 0/1 0/1 - 0 array-reached-outside (2) 4.2.2--plain-rot-shuf-noshift-inum-w2u-nocalls-t1-split--iife--uglify 1 0/1 0/1 - 0 wrapper-alias-redeclared (2) 4.2.2--plain-rot-shuf-shift-istr-w0-nocalls-t75-numbers--top--terser 1 1/1 1/1 - 0 - -4.2.2--rc4-norot-noshuf-shift-istr-w0-calls-t75-keys--wp4-bundle--none 1 1/1 1/1 - 0 - +4.2.2--rc4-norot-noshuf-shift-istr-w0-calls-t75-keys--wp4-bundle--none 1 0/1 1/1 - 0 namespace-by-key (1) 4.2.2--rc4-norot-shuf-noshift-inum-w1-calls-t75-cff--top--uglify 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 4.2.2--rc4-norot-shuf-noshift-inum-w2f5-calls-t1-cff--wp4-module--terser 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) 4.2.2--rc4-norot-shuf-noshift-istr-w3f-calls-t75-mangled--wp4-module--uglify 1 0/1 1/1 - 0 builtin-replaced-decoded-key (1) @@ -729,6 +729,7 @@ legacy-array-reached 128 128 128 0 safe lane: code may reach the plain string ar builtin-replaced-decoded-key 74 74 74 0 a call or write on a built-in whose key is itself a decoder call is judged as a possible built-in patch, so a stateful base64 or rc4 unit is refused builtin-alias-patched 65 65 65 0 safe lane: a write through a variable, parameter, this or computed object that may hold a standard built-in (an alias of a prototype, constructor or the global object) could replace a built-in the decoders or rotator use, so the unit is left undecoded decoder-reads-outer-binding 58 58 59 0 a decoder reads a binding outside itself that is not a standard global (the old atob polyfill's window fallback), so the unit's calls are left alone +namespace-by-key 48 48 48 0 safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) safe-global-names 26 26 26 0 safe lane, premise 2: code may observe the global object's names (a non-strict this, require), so the decoded unit's string array, decoders and rotator are kept as written array-reached-outside 12 12 24 0 the string array is reachable from code outside its declaration, decoders and a recognised rotator, so the unit's calls are left alone self-defending-passed-through 9 9 11 0 a self-defending check reads the source text of a function the output would print across lines (a minified or older template untwist cannot keep on one line), so the input is passed through unchanged diff --git a/fixtures/obfuscator-versions/EXPECT b/fixtures/obfuscator-versions/EXPECT index 36b704f42..021901024 100644 --- a/fixtures/obfuscator-versions/EXPECT +++ b/fixtures/obfuscator-versions/EXPECT @@ -440,3 +440,55 @@ 5.9.1--rc4-rot-noshuf-noshift-istr-w2u-calls-t1-self--wp4-bundle--uglify--* * machinery xfail decoder-used-as-value: a decoder of the unit is used other than as the callee of a call, so it may run from where no call site was collected, and the unit's calls are left alone 5.9.1--rc4-rot-shuf-shift-inum-w0-calls-t75-cff--iife--uglify--* * machinery xfail array-reached-outside: the string array is reachable from code outside its declaration, decoders and a recognised rotator, so the unit's calls are left alone 5.9.1--rc4-rot-shuf-shift-istr-w2u-nocalls-t1-keys--top--none--* safe machinery xfail builtin-replaced-decoded-key: a call or write on a built-in whose key is itself a decoder call is judged as a possible built-in patch, so a stateful base64 or rc4 unit is refused +0.10.2--plain-norot-t1-unicode--wp4-bundle--none--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +0.16.0--plain-norot-t75-keys--wp4-bundle--terser--functions-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +0.18.8--plain-norot-t1-unicode--wp4-bundle--none--greeting-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +0.18.8--plain-norot-t1-unicode--wp4-bundle--uglify--strings-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +0.20.4--plain-norot-t75-unicode--wp4-bundle--terser--control-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +0.23.2--plain-norot-noshuf-t1-split--wp4-bundle--none--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +0.23.2--plain-rot-noshuf-t1-keys--wp4-bundle--terser--strings-1.js safe simplified xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +0.28.5--plain-rot-shuf-t1-split--wp4-bundle--uglify--greeting-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +0.28.5--plain-rot-noshuf-t1-split--wp4-bundle--terser--strings-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +1.4.0--plain-norot-shuf-t1-dead--wp4-bundle--terser--strings-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +1.4.0--b64-rot-noshuf-t1-mangled--wp4-bundle--none--greeting-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +1.4.0--b64-norot-noshuf-t75--wp4-bundle--uglify--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +1.4.0--b64-rot-shuf-t1-split--wp4-bundle--terser--functions-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +1.4.0--rc4-rot-noshuf-t1-split--wp4-bundle--terser--control-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +1.6.0--b64-norot-shuf-t1-unicode--wp4-bundle--uglify--greeting-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +1.6.0--rc4-rot-shuf-t75--wp4-bundle--uglify--greeting-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +1.12.1--plain-rot-noshuf-t1-unicode--wp4-bundle--terser--strings-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.4.3--plain-rot-shuf-w2u-t1-keys--wp4-bundle--terser--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.4.3--plain-rot-shuf-w2u-t1-keys--wp4-bundle--terser--empty-log-1.js safe simplified xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.4.3--b64-norot-shuf-w0-t75-keys--wp4-bundle--terser--greeting-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.4.3--b64-norot-shuf-w0-t75-keys--wp4-bundle--terser--greeting-1.js safe simplified xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.4.3--rc4-rot-noshuf-w3f-t1-split--wp4-bundle--uglify--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.9.6--plain-norot-noshuf-shift-istr-w3f-t75-dead--wp4-bundle--uglify--control-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.9.6--plain-norot-noshuf-shift-inum-w0-t1-keys--wp4-bundle--terser--strings-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.9.6--plain-norot-noshuf-shift-inum-w0-t1-keys--wp4-bundle--terser--strings-1.js safe simplified xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.9.6--b64-norot-shuf-shift-inum-w0-t1-mangled--wp4-bundle--uglify--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.9.6--b64-rot-shuf-noshift-inum-w0-t1--wp4-bundle--terser--functions-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.11.1--plain-rot-noshuf-noshift-inum-w1-t75-mangled--wp4-bundle--terser--control-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.11.1--b64-rot-shuf-noshift-inum-w2u-t1-mangled--wp4-bundle--none--functions-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.13.0--plain-rot-noshuf-shift-inum-w3f-t75--wp4-bundle--none--strings-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.13.0--plain-rot-shuf-shift-istr-w0-t75-split--wp4-bundle--uglify--greeting-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.13.0--b64-norot-noshuf-shift-istr-w2f5-t1-mangled--wp4-bundle--terser--control-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.14.0--plain-norot-noshuf-noshift-istr-w2f5-t1-split--wp4-bundle--uglify--functions-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.14.0--b64-rot-noshuf-noshift-inum-w1-t75-unicode--wp4-bundle--none--greeting-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.14.0--b64-rot-noshuf-shift-istr-w2u-t1-dead--wp4-bundle--terser--control-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.14.0--rc4-norot-noshuf-noshift-inum-w1-t1-split--wp4-bundle--none--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.14.0--rc4-norot-noshuf-noshift-inum-w2f5-t1-numbers--wp4-bundle--uglify--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.18.1--plain-norot-shuf-shift-istr-w2f5-t1-unicode--wp4-bundle--none--greeting-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.18.1--b64-rot-shuf-noshift-inum-w3f-t75-split--wp4-bundle--uglify--functions-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.18.1--b64-rot-shuf-noshift-istr-w3f-t1-mangled--wp4-bundle--terser--control-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.18.1--rc4-rot-noshuf-noshift-istr-w2f5-t75-split--wp4-bundle--none--strings-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.19.1--plain-norot-shuf-shift-istr-w2u-t1--wp4-bundle--none--control-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.19.1--plain-norot-noshuf-noshift-inum-w1-t1-split--wp4-bundle--terser--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +2.19.1--rc4-rot-shuf-noshift-inum-w2u-t75-numbers--wp4-bundle--uglify--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +3.2.7--plain-rot-shuf-shift-istr-w3f-nocalls-t75-unicode--wp4-bundle--none--functions-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +3.2.7--rc4-rot-noshuf-noshift-inum-w0-nocalls-t75-mangled--wp4-bundle--none--control-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +3.2.7--rc4-rot-shuf-noshift-inum-w3f-nocalls-t1-numbers--wp4-bundle--uglify--functions-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +4.2.2--plain-rot-noshuf-noshift-inum-w1-nocalls-t1-mangled--wp4-bundle--uglify--strings-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +4.2.2--b64-norot-noshuf-shift-inum-w2u-nocalls-t1--wp4-bundle--none--functions-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +4.2.2--b64-rot-shuf-shift-istr-w1-nocalls-t1-unicode--wp4-bundle--uglify--greeting-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +4.2.2--rc4-norot-noshuf-shift-istr-w0-calls-t75-keys--wp4-bundle--none--empty-log-1.js safe machinery xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) +4.2.2--rc4-norot-noshuf-shift-istr-w0-calls-t75-keys--wp4-bundle--none--empty-log-1.js safe simplified xfail namespace-by-key: safe lane: namespace read by unproven key; a read keyed by a decoder call, which the check cannot resolve before decoding, off a holder not proven to be something other than the global object is pinned like a spelled Reflect or Object (R51-RX8) diff --git a/web/scripts/size.ts b/web/scripts/size.ts index 0de925bf5..0a516a24f 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_365_000; +const WASM_BASELINE_BYTES = 14_375_000; const WASM_GROWTH = 0.1; const gzip = (bytes: Buffer): number => gzipSync(bytes, { level: 9 }).length;