diff --git a/.gitignore b/.gitignore index 083ba40..3626605 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,9 @@ /target **/*.rs.bk +# План работ — локальный, не публикуется в истории +/todo.md + # Локальный cargo-config (может содержать секреты репозитория) /.cargo/config.toml /config.toml diff --git a/crates/noxis-classfile/src/format/write/code/frames.rs b/crates/noxis-classfile/src/format/write/code/frames.rs index 9f23677..20f5c7a 100644 --- a/crates/noxis-classfile/src/format/write/code/frames.rs +++ b/crates/noxis-classfile/src/format/write/code/frames.rs @@ -1,7 +1,9 @@ -//! Кадры `StackMapTable` при записи: вариант в вариант, дельты как есть. +//! Кадры `StackMapTable` при записи: вариант в вариант, дельты по инструкциям. //! -//! Наш IR хранит кадры в номерах инструкций (как backend после чтения) — -//! backend сам пересчитает их в байты при `to_bytes`. +//! Наш IR хранит `offset_delta` в номерах инструкций; backend при `to_bytes` +//! сам пересчитает их в байты. Компактный формат (`Same`/`SameLocals`) годен +//! только когда **байтовая** дельта ≤ 63 — иначе нужен расширенный вариант. +//! Выбор делаем по байтовой дельте: байты считаются от layout текущего метода. use ristretto_classfile::attributes::{StackFrame as RtFrame, VerificationType as RtType}; @@ -9,37 +11,70 @@ use super::super::pool::Pool; use crate::error::ClassfileError; use crate::format::{StackMapFrame, VerificationType}; +/// Байтовое смещение начала инструкции (для расчёта дельт кадров). +type ByteOf<'a> = &'a (dyn Fn(u32) -> Result + 'a); + /// Кадры IR → кадры backend'а (индексные дельты — как есть). pub(super) fn convert_frames( frames: &[StackMapFrame], pool: &mut Pool, + byte_of: ByteOf<'_>, ) -> Result, ClassfileError> { - frames - .iter() - .map(|frame| build_frame(frame, pool)) - .collect() + let mut out = Vec::with_capacity(frames.len()); + let mut first = true; + let mut last_instruction: u32 = 0; + let mut last_byte: u16 = 0; + for frame in frames { + let delta = frame_delta(frame); + let instruction = if first { + delta + } else { + last_instruction + delta + 1 + }; + let byte = byte_of(instruction)?; + // Байтовая дельта относительно конца предыдущего кадра. + let byte_delta = if first { + byte + } else { + byte.checked_sub(last_byte) + .and_then(|d| d.checked_sub(1)) + .ok_or_else(|| ClassfileError::Write("кадры не по порядку".into()))? + }; + out.push(build_frame(frame, pool, byte_delta)?); + last_instruction = instruction; + last_byte = byte; + first = false; + } + Ok(out) } -fn build_frame(frame: &StackMapFrame, pool: &mut Pool) -> Result { +/// `byte_delta` — истинная байтовая дельта; компактный вид годен лишь при ≤ 63. +fn build_frame( + frame: &StackMapFrame, + pool: &mut Pool, + byte_delta: u16, +) -> Result { let delta = frame_delta(frame); - let offset = u16::try_from(delta) + let extended = u16::try_from(delta) .map_err(|_| ClassfileError::Write(format!("дельта кадра {delta} вне u16")))?; Ok(match frame { StackMapFrame::Same { .. } => { - if delta <= 63 { + if byte_delta <= 63 { + // Backend при verify()/to_bytes читает frame_type как дельту по + // ИНСТРУКЦИЯМ и сам пересчитает её в байты (≤ 63 — влезает). RtFrame::SameFrame { frame_type: delta as u8, } } else { RtFrame::SameFrameExtended { frame_type: 251, - offset_delta: offset, + offset_delta: extended, } } } StackMapFrame::SameLocals { local, .. } => { let stack = vec![vtype(local, pool)?]; - if delta <= 63 { + if byte_delta <= 63 { RtFrame::SameLocals1StackItemFrame { frame_type: 64 + delta as u8, stack, @@ -47,14 +82,14 @@ fn build_frame(frame: &StackMapFrame, pool: &mut Pool) -> Result RtFrame::ChopFrame { frame_type: 251u8.wrapping_sub(*count), - offset_delta: offset, + offset_delta: extended, }, StackMapFrame::Append { locals, .. } => { let count = u8::try_from(locals.len()).map_err(|_| { @@ -67,13 +102,13 @@ fn build_frame(frame: &StackMapFrame, pool: &mut Pool) -> Result RtFrame::FullFrame { frame_type: 255, - offset_delta: offset, + offset_delta: extended, locals: types(locals, pool)?, stack: types(stack, pool)?, }, diff --git a/crates/noxis-classfile/src/format/write/code/mod.rs b/crates/noxis-classfile/src/format/write/code/mod.rs index 0ecd58b..d621396 100644 --- a/crates/noxis-classfile/src/format/write/code/mod.rs +++ b/crates/noxis-classfile/src/format/write/code/mod.rs @@ -55,7 +55,7 @@ pub(super) fn convert_code(code: &Code, pool: &mut Pool) -> Result, -} - -impl Pool { - pub(crate) fn new() -> Self { - Pool { - pool: ConstantPool::default(), - } - } - - pub(super) fn utf8(&mut self, value: &str) -> Result { - self.pool.add_utf8(value).map_err(write_err) - } - - pub(super) fn name_and_type( - &mut self, - name: &str, - descriptor: &str, - ) -> Result { - self.pool - .add_name_and_type(name, descriptor) - .map_err(write_err) - } - - pub(super) fn class(&mut self, name: &str) -> Result { - self.pool.add_class(name).map_err(write_err) - } - - pub(super) fn field_ref( - &mut self, - owner: &str, - name: &str, - descriptor: &str, - ) -> Result { - let owner = self.class(owner)?; - self.pool - .add_field_ref(owner, name, descriptor) - .map_err(write_err) - } - - pub(super) fn method_ref( - &mut self, - owner: &str, - name: &str, - descriptor: &str, - kind: InvokeKind, - ) -> Result { - let owner = self.class(owner)?; - match kind { - InvokeKind::Interface => self - .pool - .add_interface_method_ref(owner, name, descriptor) - .map_err(write_err), - _ => self - .pool - .add_method_ref(owner, name, descriptor) - .map_err(write_err), - } - } - - /// Константа для `ldc`/`ldc2_w`; `dynamic` запрещён (только через bootstrap). - pub(super) fn constant(&mut self, value: &Const) -> Result { - match value { - Const::Int(v) => self.pool.add_integer(*v).map_err(write_err), - Const::Float(v) => self.pool.add_float(*v).map_err(write_err), - Const::Long(v) => self.pool.add_long(*v).map_err(write_err), - Const::Double(v) => self.pool.add_double(*v).map_err(write_err), - Const::String(v) => self.pool.add_string(v).map_err(write_err), - Const::Class(v) => self.class(v), - Const::MethodType(v) => self.pool.add_method_type(v).map_err(write_err), - Const::MethodHandle { - kind, - owner, - name, - descriptor, - itf, - } => self.method_handle(*kind, owner, name, descriptor, *itf), - Const::Dynamic { .. } => Err(ClassfileError::Write( - "CONSTANT_Dynamic пишется только через BootstrapMethods".into(), - )), - } - } - - pub(super) fn method_handle( - &mut self, - kind: u8, - owner: &str, - name: &str, - descriptor: &str, - itf: bool, - ) -> Result { - let reference_kind = ReferenceKind::try_from(kind).map_err(|e| { - ClassfileError::Write(format!("некорректный reference_kind {kind}: {e}")) - })?; - let reference = if itf { - self.method_ref(owner, name, descriptor, InvokeKind::Interface)? - } else if matches!( - reference_kind, - ReferenceKind::GetField - | ReferenceKind::GetStatic - | ReferenceKind::PutField - | ReferenceKind::PutStatic - ) { - self.field_ref(owner, name, descriptor)? - } else { - self.method_ref(owner, name, descriptor, InvokeKind::Static)? - }; - self.pool - .add_method_handle(reference_kind, reference) - .map_err(write_err) - } - - pub(super) fn invoke_dynamic( - &mut self, - bootstrap: u16, - name: &str, - descriptor: &str, - ) -> Result { - self.pool - .add_invoke_dynamic(bootstrap, name, descriptor) - .map_err(write_err) - } - - pub(super) fn dynamic( - &mut self, - bootstrap: u16, - name: &str, - descriptor: &str, - ) -> Result { - self.pool - .add_dynamic(bootstrap, name, descriptor) - .map_err(write_err) - } - - pub(super) fn finish(self) -> ConstantPool<'static> { - self.pool - } -} - -fn write_err(error: ristretto_classfile::Error) -> ClassfileError { - ClassfileError::Write(error.to_string()) -} diff --git a/crates/noxis-classfile/src/format/write/pool/mod.rs b/crates/noxis-classfile/src/format/write/pool/mod.rs new file mode 100644 index 0000000..27cccc1 --- /dev/null +++ b/crates/noxis-classfile/src/format/write/pool/mod.rs @@ -0,0 +1,155 @@ +//! Сборка constant pool при записи: строки нашего IR → индексы backend'а. +//! +//! Пул строится с нуля детерминированным обходом (классы, поля, методы, +//! атрибуты, код), поэтому одинаковый IR даёт одинаковые байты. Индексы +//! `Raw`-атрибутов при этом не переносятся — см. `super::attrs`. +//! +//! Backend не дедуплицирует: `add_*` всегда толкает новый элемент. Кэшируем +//! семантические ключи сами — иначе `LocalVariableTable` и +//! `LocalVariableTypeTable` получат разные `name_index` для одного имени, и +//! HotSpot отвергнет класс (`LVTT entry ... does not match any LVT entry`). +//! Порядок обхода детерминирован, поэтому кэш меняет только компактность пула. +//! Референсы (поле/метод/хендл/динамик) — в [`refs`]. + +use std::collections::HashMap; + +use ristretto_classfile::{Constant, ConstantPool}; + +use crate::error::ClassfileError; +use crate::insn::Const; + +mod refs; + +/// Строитель пула; живёт только внутри одного `write`. +pub(crate) struct Pool { + pub(super) pool: ConstantPool<'static>, + pub(super) utf8s: HashMap, + pub(super) classes: HashMap, + pub(super) name_types: HashMap<(String, String), u16>, + pub(super) strings: HashMap, + pub(super) method_types: HashMap, + pub(super) field_refs: HashMap<(String, String, String), u16>, + pub(super) method_refs: HashMap<(String, String, String, bool), u16>, + pub(super) handles: HashMap<(u8, String, String, String, bool), u16>, + pub(super) dynamics: HashMap<(u16, String, String, bool), u16>, +} + +impl Pool { + pub(crate) fn new() -> Self { + Pool { + pool: ConstantPool::default(), + utf8s: HashMap::new(), + classes: HashMap::new(), + name_types: HashMap::new(), + strings: HashMap::new(), + method_types: HashMap::new(), + field_refs: HashMap::new(), + method_refs: HashMap::new(), + handles: HashMap::new(), + dynamics: HashMap::new(), + } + } + + pub(super) fn utf8(&mut self, value: &str) -> Result { + if let Some(&index) = self.utf8s.get(value) { + return Ok(index); + } + let index = self.pool.add_utf8(value).map_err(write_err)?; + self.utf8s.insert(value.to_string(), index); + Ok(index) + } + + pub(super) fn name_and_type( + &mut self, + name: &str, + descriptor: &str, + ) -> Result { + let key = (name.to_string(), descriptor.to_string()); + if let Some(&index) = self.name_types.get(&key) { + return Ok(index); + } + // Собираем из примитивов, а не `add_name_and_type`: последний толкает + // собственные `Utf8`-строки мимо нашего кэша (дубли в пуле). + let name_index = self.utf8(name)?; + let descriptor_index = self.utf8(descriptor)?; + let index = self + .pool + .add(Constant::NameAndType { + name_index, + descriptor_index, + }) + .map_err(write_err)?; + self.name_types.insert(key, index); + Ok(index) + } + + pub(super) fn class(&mut self, name: &str) -> Result { + if let Some(&index) = self.classes.get(name) { + return Ok(index); + } + let name_index = self.utf8(name)?; + let index = self + .pool + .add(Constant::Class(name_index)) + .map_err(write_err)?; + self.classes.insert(name.to_string(), index); + Ok(index) + } + + /// Константа для `ldc`/`ldc2_w`; `dynamic` запрещён (только через bootstrap). + pub(super) fn constant(&mut self, value: &Const) -> Result { + match value { + Const::Int(v) => self.pool.add_integer(*v).map_err(write_err), + Const::Float(v) => self.pool.add_float(*v).map_err(write_err), + Const::Long(v) => self.pool.add_long(*v).map_err(write_err), + Const::Double(v) => self.pool.add_double(*v).map_err(write_err), + Const::String(v) => self.string(v), + Const::Class(v) => self.class(v), + Const::MethodType(v) => self.method_type(v), + Const::MethodHandle { + kind, + owner, + name, + descriptor, + itf, + } => self.method_handle(*kind, owner, name, descriptor, *itf), + Const::Dynamic { .. } => Err(ClassfileError::Write( + "CONSTANT_Dynamic пишется только через BootstrapMethods".into(), + )), + } + } + + fn string(&mut self, value: &str) -> Result { + if let Some(&index) = self.strings.get(value) { + return Ok(index); + } + let string_index = self.utf8(value)?; + let index = self + .pool + .add(Constant::String(string_index)) + .map_err(write_err)?; + self.strings.insert(value.to_string(), index); + Ok(index) + } + + fn method_type(&mut self, descriptor: &str) -> Result { + if let Some(&index) = self.method_types.get(descriptor) { + return Ok(index); + } + let descriptor_index = self.utf8(descriptor)?; + let index = self + .pool + .add(Constant::MethodType(descriptor_index)) + .map_err(write_err)?; + self.method_types.insert(descriptor.to_string(), index); + Ok(index) + } + + pub(super) fn finish(self) -> ConstantPool<'static> { + self.pool + } +} + +fn write_err(error: ristretto_classfile::Error) -> ClassfileError { + ClassfileError::Write(error.to_string()) +} diff --git a/crates/noxis-classfile/src/format/write/pool/refs.rs b/crates/noxis-classfile/src/format/write/pool/refs.rs new file mode 100644 index 0000000..67e6e02 --- /dev/null +++ b/crates/noxis-classfile/src/format/write/pool/refs.rs @@ -0,0 +1,162 @@ +//! Референсы constant pool: `Fieldref`/`Methodref`/`MethodHandle`/`Dynamic`. +//! +//! Это `impl Pool` из [`super`]; вынесено отдельно, чтобы материнский файл +//! держался в лимите структуры. Каждый билдер мемоизирован по семантическому +//! ключу (owner/name/descriptor/…) — одинаковая ссылка всегда получает один +//! индекс, а пул не раздувается дублями (раздувание иначе расширяет `ldc` +//! в `ldc_w` и меняет длину кода при переносе). + +use ristretto_classfile::{Constant, ReferenceKind}; + +use crate::error::ClassfileError; +use crate::insn::InvokeKind; + +use super::{Pool, write_err}; + +impl Pool { + pub(crate) fn field_ref( + &mut self, + owner: &str, + name: &str, + descriptor: &str, + ) -> Result { + let key = (owner.to_string(), name.to_string(), descriptor.to_string()); + if let Some(&index) = self.field_refs.get(&key) { + return Ok(index); + } + let class_index = self.class(owner)?; + let name_and_type_index = self.name_and_type(name, descriptor)?; + let index = self + .pool + .add(Constant::FieldRef { + class_index, + name_and_type_index, + }) + .map_err(write_err)?; + self.field_refs.insert(key, index); + Ok(index) + } + + pub(crate) fn method_ref( + &mut self, + owner: &str, + name: &str, + descriptor: &str, + kind: InvokeKind, + ) -> Result { + let itf = matches!(kind, InvokeKind::Interface); + let key = ( + owner.to_string(), + name.to_string(), + descriptor.to_string(), + itf, + ); + if let Some(&index) = self.method_refs.get(&key) { + return Ok(index); + } + let class_index = self.class(owner)?; + let name_and_type_index = self.name_and_type(name, descriptor)?; + let constant = if itf { + Constant::InterfaceMethodRef { + class_index, + name_and_type_index, + } + } else { + Constant::MethodRef { + class_index, + name_and_type_index, + } + }; + let index = self.pool.add(constant).map_err(write_err)?; + self.method_refs.insert(key, index); + Ok(index) + } + + pub(crate) fn method_handle( + &mut self, + kind: u8, + owner: &str, + name: &str, + descriptor: &str, + itf: bool, + ) -> Result { + let key = ( + kind, + owner.to_string(), + name.to_string(), + descriptor.to_string(), + itf, + ); + if let Some(&index) = self.handles.get(&key) { + return Ok(index); + } + let reference_kind = ReferenceKind::try_from(kind).map_err(|e| { + ClassfileError::Write(format!("некорректный reference_kind {kind}: {e}")) + })?; + let reference = if itf { + self.method_ref(owner, name, descriptor, InvokeKind::Interface)? + } else if matches!( + reference_kind, + ReferenceKind::GetField + | ReferenceKind::GetStatic + | ReferenceKind::PutField + | ReferenceKind::PutStatic + ) { + self.field_ref(owner, name, descriptor)? + } else { + self.method_ref(owner, name, descriptor, InvokeKind::Static)? + }; + let index = self + .pool + .add_method_handle(reference_kind, reference) + .map_err(write_err)?; + self.handles.insert(key, index); + Ok(index) + } + + pub(crate) fn invoke_dynamic( + &mut self, + bootstrap: u16, + name: &str, + descriptor: &str, + ) -> Result { + self.dynamic_like(bootstrap, name, descriptor, true) + } + + pub(crate) fn dynamic( + &mut self, + bootstrap: u16, + name: &str, + descriptor: &str, + ) -> Result { + self.dynamic_like(bootstrap, name, descriptor, false) + } + + fn dynamic_like( + &mut self, + bootstrap: u16, + name: &str, + descriptor: &str, + invoke: bool, + ) -> Result { + let key = (bootstrap, name.to_string(), descriptor.to_string(), invoke); + if let Some(&index) = self.dynamics.get(&key) { + return Ok(index); + } + let name_and_type_index = self.name_and_type(name, descriptor)?; + let constant = if invoke { + Constant::InvokeDynamic { + bootstrap_method_attr_index: bootstrap, + name_and_type_index, + } + } else { + Constant::Dynamic { + bootstrap_method_attr_index: bootstrap, + name_and_type_index, + } + }; + let index = self.pool.add(constant).map_err(write_err)?; + self.dynamics.insert(key, index); + Ok(index) + } +} diff --git a/crates/noxis-classfile/tests/pool/main.rs b/crates/noxis-classfile/tests/pool/main.rs new file mode 100644 index 0000000..aef55f1 --- /dev/null +++ b/crates/noxis-classfile/tests/pool/main.rs @@ -0,0 +1,47 @@ +//! Инвариант писателя: записанный пул не содержит дублей `CONSTANT_Utf8`. +//! +//! Backend не дедуплицирует (`add_*` всегда толкает новый элемент), а HotSpot +//! сопоставляет запись `LocalVariableTypeTable` с `LocalVariableTable` по +//! сырому `name_index`. Дублирующий `Utf8` для одного имени даёт разные индексы +//! и рушит класс: `ClassFormatError: LVTT entry ... does not match any LVT +//! entry`. Писатель обязан интернировать строки — поэтому в записанном пуле +//! каждый `CONSTANT_Utf8` уникален. + +#![allow(clippy::expect_used, clippy::unwrap_used)] + +use std::collections::HashSet; +use std::path::PathBuf; + +use noxis_classfile::format; +use ristretto_classfile::{ClassFile as RtClass, Constant}; + +#[test] +fn written_pool_has_no_duplicate_utf8() { + let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/data"); + let mut names: Vec = std::fs::read_dir(&dir) + .expect("tests/data") + .filter_map(|entry| entry.ok().map(|entry| entry.path())) + .filter(|path| path.extension().is_some_and(|ext| ext == "class")) + .collect(); + names.sort(); + assert!(!names.is_empty(), "нет фикстур в tests/data"); + + for path in &names { + let parsed = format::parse(&std::fs::read(path).expect("read")).expect("parse"); + let written = format::write(&parsed).expect("write"); + let raw = RtClass::from_bytes(&written).expect("written parses"); + raw.verify().expect("written verifies"); + let mut seen = HashSet::new(); + for index in 1..=raw.constant_pool.len() { + if let Some(Constant::Utf8(value)) = raw.constant_pool.get(index as u16) { + let bytes = value.as_bytes().to_vec(); + assert!( + seen.insert(bytes), + "дубль CONSTANT_Utf8 {:?} в {}", + String::from_utf8_lossy(value.as_bytes()), + parsed.this_class + ); + } + } + } +} diff --git a/crates/noxis-core/src/config/sections.rs b/crates/noxis-core/src/config/sections.rs index a35141e..54f56f2 100644 --- a/crates/noxis-core/src/config/sections.rs +++ b/crates/noxis-core/src/config/sections.rs @@ -17,6 +17,9 @@ pub enum NameStyle { MixedLatin, /// Псевдосмысленные слова из другого проекта (дезориентация). DecoyWords, + /// Правдоподобные имена: `TextureCache`, `resolveToken` — вместо + /// явного мусора маскируется под обычный прикладной код. + Plausible, } /// Настройки переименования. diff --git a/crates/noxis-core/src/pipeline/mod.rs b/crates/noxis-core/src/pipeline/mod.rs index b8be11e..abc027b 100644 --- a/crates/noxis-core/src/pipeline/mod.rs +++ b/crates/noxis-core/src/pipeline/mod.rs @@ -87,6 +87,10 @@ impl Pipeline { for pass in &self.passes { let id = pass.id(); + if !ctx.config.is_enabled(id) { + tracing::info!(target: "noxis", pass = %id, "пасс выключен — пропущен"); + continue; + } tracing::info!(target: "noxis", pass = %id, "пасс запущен"); let result = pass.apply(ctx, program)?; tracing::info!( diff --git a/crates/noxis-passes/src/namegen/alphabet.rs b/crates/noxis-passes/src/namegen/alphabet.rs index 609ec8a..cf4c524 100644 --- a/crates/noxis-passes/src/namegen/alphabet.rs +++ b/crates/noxis-passes/src/namegen/alphabet.rs @@ -117,3 +117,40 @@ pub(super) const DECOY_RIGHT: &[&str] = &[ "mirror", "lantern", "harbor", "ember", "shadow", "quarry", "meadow", "cipher", "anchor", "ripple", ]; + +/// Стиль `Plausible`: домен-нейтральные существительные для классов/полей — +/// похожи на обычный прикладной код, не привязаны к конкретному проекту. +pub(super) const PLAUSIBLE_NOUN: &[&str] = &[ + "Texture", "Event", "State", "Render", "Asset", "Config", "Session", "Cache", "Buffer", + "Socket", "Stream", "Widget", "Layout", "Theme", "Profile", "Metric", "Token", "Handle", + "Context", "Registry", "Request", "Response", "Payload", "Resource", "Snapshot", "Pipeline", + "Queue", "Slot", "Frame", "Entry", +]; +/// Суффиксы ролей для классов (`NounSuffix`, напр. `TextureCache`). +pub(super) const PLAUSIBLE_SUFFIX: &[&str] = &[ + "Manager", + "Handler", + "Service", + "Provider", + "Factory", + "Builder", + "Cache", + "Store", + "Loader", + "Parser", + "Worker", + "Controller", + "Adapter", + "Wrapper", + "Registry", + "Resolver", + "Validator", + "Processor", + "Context", + "Listener", +]; +/// Глаголы для методов/полей (`verbNoun`, напр. `resolveToken`). +pub(super) const PLAUSIBLE_VERB: &[&str] = &[ + "get", "set", "update", "process", "handle", "compute", "resolve", "load", "build", "parse", + "fetch", "apply", "validate", "clear", "reset", "sync", "flush", "bind", "attach", "detach", +]; diff --git a/crates/noxis-passes/src/namegen/mod.rs b/crates/noxis-passes/src/namegen/mod.rs index 6d09b1d..2efdf64 100644 --- a/crates/noxis-passes/src/namegen/mod.rs +++ b/crates/noxis-passes/src/namegen/mod.rs @@ -1,6 +1,8 @@ //! Генерация имён: стили, анти-ключевые слова, уникальность в scope. pub mod alphabet; +#[cfg(test)] +mod tests; use std::collections::HashSet; @@ -8,7 +10,7 @@ use noxis_core::{NameStyle, Rng}; use self::alphabet::{ AVOID_CLASS, AVOID_MEMBER, CONFUSABLE, DECOY_LEFT, DECOY_RIGHT, KEYWORDS, LATIN_LOWER, - LATIN_UPPER, UNICODE_LETTERS, + LATIN_UPPER, PLAUSIBLE_NOUN, PLAUSIBLE_SUFFIX, PLAUSIBLE_VERB, UNICODE_LETTERS, }; /// Генератор имён с гарантированной уникальностью в пределах одного scope. @@ -68,7 +70,7 @@ impl NameGenerator { match self.style { NameStyle::ShortLatin | NameStyle::IlO0 | NameStyle::MixedLatin => "z", NameStyle::Unicode => "\u{043e}", - NameStyle::DecoyWords => "tmp", + NameStyle::DecoyWords | NameStyle::Plausible => "tmp", } } @@ -121,6 +123,20 @@ impl NameGenerator { } name } + // Маскируется под обычный прикладной код, а не под мусор: + // классы — `NounSuffix` (`TextureCache`), члены — `verbNoun` + // (`resolveToken`) camelCase. + NameStyle::Plausible => { + let noun = PLAUSIBLE_NOUN[self.rng.below(PLAUSIBLE_NOUN.len() as u64) as usize]; + if self.avoid_class { + let suffix = + PLAUSIBLE_SUFFIX[self.rng.below(PLAUSIBLE_SUFFIX.len() as u64) as usize]; + format!("{noun}{suffix}") + } else { + let verb = PLAUSIBLE_VERB[self.rng.below(PLAUSIBLE_VERB.len() as u64) as usize]; + format!("{verb}{noun}") + } + } } } @@ -164,52 +180,3 @@ fn capitalize(s: &str) -> String { None => String::new(), } } - -#[cfg(test)] -mod tests { - #![allow(clippy::expect_used, clippy::unwrap_used)] - use super::alphabet::{AVOID_MEMBER, KEYWORDS}; - use super::*; - - #[test] - fn names_are_unique_and_valid() { - let mut names = NameGenerator::new(Rng::from_seed(1), NameStyle::ShortLatin); - let mut seen = HashSet::new(); - for _ in 0..500 { - let name = names.next_name(); - assert!(seen.insert(name.clone()), "повтор имени {name}"); - assert!(!KEYWORDS.contains(&name.as_str())); - assert!(name.starts_with(|c: char| c.is_ascii_alphabetic())); - } - } - - #[test] - fn avoids_reserved_member_names() { - let mut names = NameGenerator::new(Rng::from_seed(2), NameStyle::DecoyWords); - for _ in 0..500 { - let name = names.next_name(); - assert!(!AVOID_MEMBER.contains(&name.as_str())); - } - } - - #[test] - fn unicode_style_produces_identifier_valid_names() { - let mut names = NameGenerator::new(Rng::from_seed(3), NameStyle::Unicode); - for _ in 0..100 { - let name = names.next_name(); - assert!( - name.chars() - .all(|c| c.is_alphanumeric() || c == '_' || c == '$') - ); - } - } - - #[test] - fn reserved_names_never_reissued() { - let mut names = NameGenerator::new(Rng::from_seed(4), NameStyle::ShortLatin); - names.reserve("abc"); - for _ in 0..300 { - assert_ne!(names.next_name(), "abc"); - } - } -} diff --git a/crates/noxis-passes/src/namegen/tests.rs b/crates/noxis-passes/src/namegen/tests.rs new file mode 100644 index 0000000..3fa0cb6 --- /dev/null +++ b/crates/noxis-passes/src/namegen/tests.rs @@ -0,0 +1,76 @@ +//! Тесты генератора имён: уникальность, валидность, форма по стилю. + +#![allow(clippy::expect_used, clippy::unwrap_used)] + +use std::collections::HashSet; + +use noxis_core::{NameStyle, Rng}; + +use super::NameGenerator; +use super::alphabet::{AVOID_MEMBER, KEYWORDS}; + +#[test] +fn names_are_unique_and_valid() { + let mut names = NameGenerator::new(Rng::from_seed(1), NameStyle::ShortLatin); + let mut seen = HashSet::new(); + for _ in 0..500 { + let name = names.next_name(); + assert!(seen.insert(name.clone()), "повтор имени {name}"); + assert!(!KEYWORDS.contains(&name.as_str())); + assert!(name.starts_with(|c: char| c.is_ascii_alphabetic())); + } +} + +#[test] +fn avoids_reserved_member_names() { + let mut names = NameGenerator::new(Rng::from_seed(2), NameStyle::DecoyWords); + for _ in 0..500 { + let name = names.next_name(); + assert!(!AVOID_MEMBER.contains(&name.as_str())); + } +} + +#[test] +fn unicode_style_produces_identifier_valid_names() { + let mut names = NameGenerator::new(Rng::from_seed(3), NameStyle::Unicode); + for _ in 0..100 { + let name = names.next_name(); + assert!( + name.chars() + .all(|c| c.is_alphanumeric() || c == '_' || c == '$') + ); + } +} + +#[test] +fn reserved_names_never_reissued() { + let mut names = NameGenerator::new(Rng::from_seed(4), NameStyle::ShortLatin); + names.reserve("abc"); + for _ in 0..300 { + assert_ne!(names.next_name(), "abc"); + } +} + +#[test] +fn plausible_class_names_look_like_noun_suffix() { + let mut names = NameGenerator::new(Rng::from_seed(5), NameStyle::Plausible).for_classes(); + for _ in 0..50 { + let name = names.next_name(); + assert!(name.starts_with(|c: char| c.is_ascii_uppercase()), "{name}"); + // Два слова подряд слиплись в CamelCase без разделителей. + assert!( + name.chars().filter(|c| c.is_ascii_uppercase()).count() >= 2, + "{name}" + ); + } +} + +#[test] +fn plausible_member_names_look_like_verb_noun() { + let mut names = NameGenerator::new(Rng::from_seed(6), NameStyle::Plausible); + for _ in 0..50 { + let name = names.next_name(); + assert!(name.starts_with(|c: char| c.is_ascii_lowercase()), "{name}"); + assert!(!KEYWORDS.contains(&name.as_str())); + } +} diff --git a/crates/noxis-passes/src/rename/assign.rs b/crates/noxis-passes/src/rename/assign.rs index 3d68353..2838b38 100644 --- a/crates/noxis-passes/src/rename/assign.rs +++ b/crates/noxis-passes/src/rename/assign.rs @@ -180,6 +180,7 @@ pub(super) fn generate_packages(cfg: &Config, rng: &mut Rng) -> Vec { let style = match cfg.rename.class_style { NameStyle::Unicode => NameStyle::Unicode, NameStyle::IlO0 => NameStyle::IlO0, + NameStyle::Plausible => NameStyle::Plausible, _ => NameStyle::MixedLatin, }; let mut names = NameGenerator::new(rng.clone(), style).for_classes(); diff --git a/docs/techniques.md b/docs/techniques.md index dfde703..ac1f2f6 100644 --- a/docs/techniques.md +++ b/docs/techniques.md @@ -27,9 +27,19 @@ `ClassNotFoundException` в рантайме. - Рефлексия через строки мы ловим автоматически (анализ `Class.forName`, `getMethod`/`getField` и т.п.), но динамическую конкатенацию — нет. +- JSON-(де)сериализация по именам полей (Gson/Jackson/`Codec`) не ловится: + биндинг идёт через `X.class`-литерал, не строку — см. `todo.md` §2. - Для библиотек `rename_public_members = false` по умолчанию: менять публичный API библиотеки — сломать всех потребителей. +Шесть стилей имён (`ShortLatin`, `IlO0`, `Unicode`, `MixedLatin`, +`DecoyWords`, `Plausible`) — компромисс по-разному: `IlO0`/`Unicode` явно +сигнализируют «это обфускация», `Plausible` маскируется под обычный +прикладной код (`TextureCache`, `resolveToken`), ценой того, что при +ручном чтении он менее заметно отличается от настоящей логики, чем +намеренный мусор — скрыть обфускацию и скрыть её цену ценой чуть большей +путаницы для собственной команды при отладке маппингов. + **Статус: готово.** ## 2. Шифрование строк (`Strings`) diff --git a/todo.md b/todo.md deleted file mode 100644 index cf81788..0000000 --- a/todo.md +++ /dev/null @@ -1,299 +0,0 @@ -# todo.md — план работ noxis - -Обновляется по мере выполнения. Текущее состояние кодовой базы — в -[`docs/architecture.md`](docs/architecture.md) (раздел «Статус»). - -Обозначения: `[x]` готово и проверено, `[~]` частично, `[ ]` не начато, -`[!]` заблокировано другим пунктом. - ---- - -## 0. Каркас и правила — **готово** - -- [x] Workspace: `Cargo.toml`, lints (`deny(unsafe_code)`), release-профиль -- [x] Крейты: `noxis-classfile`, `noxis-core`, `noxis-analysis`, - `noxis-passes`, `noxis-runtime`, `noxis-jar`, `noxis-structure-check` -- [x] `noxis-structure-check`: 250 строк / 4 `.rs`-файла, вызывается из - `build.rs` каждого крейта, сканирует только `src/`/`tests`/`benches` - этого крейта; `docs/` и остальная документация вне гейта -- [x] `cargo:rerun-if-changed` на проверяемые деревья (гейт не реагирует на - правки вне `src`/`tests`/`benches`) -- [x] `scripts/check.sh` — `check → fmt --check → clippy -D warnings → test` -- [x] Документация: `docs/README`, `architecture`, `techniques`, `stack`, - `learnings/{lessons,reference,priorities}` -- [x] Гейт проверяет и `crates/*/tests`, `crates/*/benches` (правило нельзя - обойти выносом кода в тесты) -- [x] Лицензия: `LICENSE` (MIT), `Cargo.toml` → `license = "MIT"`, - `NOTICE.md` — third-party (`ristretto_classfile`) - -## 1. Данные и модель — **готово** - -- [x] IR: `Program → ClassFile → Code → Insn`, метки вместо смещений -- [x] `Attribute::Raw` — round-trip непонятных атрибутов -- [x] Builder + writer (без frames), `frames::compute_frames` — заглушка P1 -- [x] Конфиг: `Profile`, `RenameConfig`, `StringsConfig`, `DebugConfig`, - `NoiseConfig`, `FlowConfig`; загрузка из TOML -- [x] Детерминированный PRNG: `xoshiro256++` + `splitmix64` + - доменное разделение по FNV-1a -- [x] Маппинги классов/полей/методов + JSON-отчёт `Report`/`PassReport` -- [x] Контракт `Pass` + `Context::rng(domain)` - -## 2. Анализ — **готово** - -- [x] `hierarchy`: слои наследования, `check::virtual_safe` -- [x] `entrypoints`: `main`, ``, ServiceLoader, `jar:file` из manifest -- [x] `keep`: reflection по строкам (`Class.forName`, `getMethod`, …), - fixed-члены (`serialVersionUID`, `access_widened`, JNI/native), - поддержка `format::compute_frames` (`stackmap`), сериализация, - `@Override` + `getMethod` для стабов, `record`-аксессоры, - `enum`-константы (`values`/`valueOf`/`$VALUES`) -- [x] Детект класса из дескриптора (`Lpkg/C;` + dotted + slash) - -## 3. Пассы - -### 3.1 Переименование — **готово** - -- [x] `namegen`: алфавиты, `builtin`/`english`/`cyrillic`-стили, - счётчики, запрет одинаковых имён в scope, `$` только если включено -- [x] `rename::assign`: классы в пакеты, private/static/final → Safe, - virtual → семейства, widening по `keep::widen` + policy -- [x] `rename::rewrite`: дескрипторы, `LDC`-классы, вызовы, поля, - exception table, `Signature`/`Exceptions`/`InnerClasses`/`MethodParameters` -- [x] `standard_pipeline()` — каркас конвейера -- [x] Тесты: round-trip классов, `constant_value` не тронут, - `ACC_BRIDGE`, `package-info`, `module-info` - -### 3.2 Строки — **готово** - -- [x] `noxis-runtime::scheme`: `XorSplitmix` + `XteaCtr`, salt→ключ, - nonce→stream, FNV-1a MAC, roundtrip/tamper-тесты -- [x] `noxis-runtime::decoder`: ABI `d(Ljava/lang/String;I)Ljava/lang/String;` -- [x] пасс `strings` (`passes/strings/{mod,crypt,tests}`): замена - `Const::String` → `cipher+salt+invokestatic`, ротация схем по `salt % n` - (salt всегда неотрицателен), split на 1–3 чанка + `String.concat` -- [x] генератор класса-декодера (`runtime/decoder/{mod,kdf,xor,xtea}`): - v49 без `StackMapTable`, KDF через FNV+`ByteBuffer`, мастер как `k1^k2`, - обе схемы побайтово зеркалят Rust -- [x] вывод мастер-секрета в рантайме (B2): части в `ldc2_w`, сборка в декодере -- [x] приёмка: `runtime/tests/exec.rs` — шифруем в Rust, расшифровываем - настоящим `java` (6 строк × 2 схемы, побайтовое сравнение stdout) - -### 3.3 Константы — **готово (int/long)** - -- [x] пасс `constants` (`passes/constants/{mod,forms,tests}`): `x^k`, `a+b`, - сдвиг; `ConstantsConfig{schemes, max_predicates, skip}` (секция TOML) -- [x] opaque-предикаты: `(C*C+C)&1 == 0` + мёртвая ветвь из `nop` - (константные — честно слабее против свёртки, см. ограничения) -- [x] отдельные схемы для `int`/`long`; `float`/`double` — не тронуты - -### 3.4 Контрольный поток — **кадры готовы, схемы не начаты** - -- [x] spike `ristretto_classfile 0.34` — backend выбран и подтверждён - (`tests/spike_ristretto.rs`: сборка/`verify`/round-trip/запись кадров) -- [x] spike по генерации кадров (`tests/spike_frames.rs`): inference работает, - **но кадры наружу не отдаются** — `inference`/`diagnostics`/`frame` - объявлены `pub(crate)`, строгий режим возвращает `Err(VerifyError)` -- [x] **решение: кадры считаем сами на своём IR**; вендор `inference` - отвергнут (14 `crate::`-ссылок, весь `verifiers/bytecode/` ≈ 9 700 - строк, весь крейт 61 193 строки) — обоснование в `docs/stack.md` §3 -- [x] реализация `format::parse` / `format::write` поверх ристретто - (`parse/{class,attrs}`, `write/{mod,pool,attrs,code/{mod,insns,ops,frames}}`; - пул строится заново детерминированным обходом; `tests/roundtrip.rs`: - минимальный класс, ветвления+handler+кадры, bootstrap — все green) -- [x] `SlotKind` в `Insn::Load/Store` (тип слота терялся при parse — - writer не мог восстановить `aload` vs `iload`); найдены пропущенные - `laload`/`lastore` (падали с «неизвестная инструкция») -- [x] `Attribute::{BootstrapMethods, EnclosingMethod, MethodParameters, - ConstantValue}` — ссылки пула переживают пересборку; `keep` лочит - BSM-методы от переименования; `debug` режет новые варианты -- [x] `compute_frames` вместо заглушки (границы блоков, worklist, merge/LUB - через `Hierarchy`-трейт, эмиссия `StackMapFrame`) - (`format/frames/{mod,flow,emit,tests,xfer/{mod,stack,calls},merge/{mod,descs}}`) -- [x] приёмка: `java -Xverify:all` на фикстурах (`tests/data` 4 класса + - `tests/frames.rs`: снести кадры → посчитать → round-trip → `java` - для JDK-классов; `verify_class(Strict)` для приёмки НЕ годится — - backend хранит кадры в индексах, а его верификатор ждёт байты) -- [x] закрыты дыры: `I2d`/`I2D`, `Record` + `LocalVariableTypeTable` как явные - варианты (`Raw` со старыми индексами ломал чтение); кадры `Append` — - на гранулярности переменных (`[Top, Long]` отвергает JVM) -- [ ] 4 схемы: `state-spread`, `computed-switch`, `butterfly`, `exception-goto` -- [ ] ротация схем между методами + мешанина внутри метода -- [ ] только после: включение в `standard_pipeline` - -### 3.5 Шум — **готово (без аннотаций)** - -- [x] junk-классы + `weave_reachable` (`passes/noise/{mod,weave}`): - `shadow/decoyN` с `run()V`, вызов вшит перед терминалом живого метода -- [x] бюджет раздувания (`junk_ratio` × классы; по умолчанию 0 — выключено) -- [ ] junk-аннотации: пропущены сознательно (сырые атрибуты не несут свежие - индексы пула — нужно моделирование аннотаций) - -### 3.6 Отладочная информация — **готово** - -- [x] `DebugInfoPass`: strip `LineNumberTable`, `LocalVariableTable`, - `Signature`, `InnerClasses`, `EnclosingMethod`, `MethodParameters` -- [x] `spoof_source_file` — ложное, но правдоподобное имя (B4) -- [x] детерминированность подмены от мастер-сида -- [ ] `fake_line_numbers` — ложные номера строк (не только `SourceFile`) -- [ ] `strip_source_file` — полное удаление вместо подмены - -### 3.7 Ресурсы — **частично** - -- [x] крейт `noxis-jar`: чтение/запись ZIP (порядок, deflate, дубликаты) -- [x] `strip_signatures` — `*.SF/*.RSA/*.DSA/*.EC`, `META-INF/SIG-*` -- [x] `load`/`save` — архив ↔ `Program` (классы через парсер, остальное ресурсы) -- [x] пасс `resources`: патч текстовых ресурсов по маппингу (boundary-замена), - `META-INF/services/*`, 9 тестов, в `standard_pipeline` -- [ ] `fabric.mod.json`, `*.mixins.json`, refmap, access widener - -## 4. Верификация — **готово (без декомпилята и ristretto_vm)** - -- [x] крейт `noxis-verify`: красный список паттернов `RED_PATTERNS` - (`leaks.rs`, хранится в репо, тест `red_patterns_all_compile`) -- [x] утечки имён: `collect_names`/`find_leaks` — сверка идентификаторов - программы с учётом keep-списка -- [x] `scan_secrets` — те же red-паттерны прогоняются по строкам - обфусцированного `Program` (CLI-команда `patterns --input`) -- [x] `java -Xverify:all` subprocess (`java.rs`: `verify_class_bytes`, - `verify_jar`; `Verified`/`Failed`/`Skipped`, когда `java` недоступна) -- [x] метрики (`metrics.rs`): `program_stats` — классы/методы/поля/ - инструкции/строки/ресурсы -- [x] бюджет размера: `inflation_ratio` + `check_inflation(max_ratio)` -- [x] стабильность между сборками: `mappings_changed` (маппинги обязаны - отличаться между прогонами с разным seed) -- [ ] доля распознанных структур в декомпиляте (JADX/CFR) — не начато -- [ ] бюджет времени исполнения (только размер реализован) -- [ ] противник-скрипт (свёртка констант, regex) как тест — см. §6 -- [ ] P3: опция `ristretto_vm` (встраиваемый JVM) вместо системного `java` - -## 5. CLI — **готово (без пасса flow)** - -- [x] крейт `noxis`: `obfuscate`, `analyze`, `patterns` - (`cmd/{obfuscate,analyze,patterns}.rs`) -- [x] флаги конфига (`--config`) + `--seed` (детерминированность по - умолчанию, без флага — seed из конфига) -- [x] честные off-ключи: `--no-rename`, `--no-resources`, `--no-strings`, - `--no-constants`, `--no-noise`, `--no-debug-info`; `--no-flow` - падает с понятной ошибкой («пасс ещё не реализован»), а не молчит -- [x] JSON-отчёт (`out.report.json`) + текстовые маппинги (`out.mapping.txt`) - рядом с выходным jar или по `--report` -- [x] `analyze`: классы, ресурсы, locked-классы, entrypoint'ы, keep-правила -- [x] `patterns`: список red-паттернов (`--list`) или прогон по jar - (`--input`, через `scan_secrets`) -- [x] end-to-end тест (`obfuscate_end_to_end`): jar → обфускация → файлы - выхода существуют - -## 6. Тесты и данные - -- [ ] regression-кейсы из референса: `smoke-safe`, `smoke-inheritance`, - `smoke-flow`, `smoke-fields`, `smoke-aes` -- [ ] встроить `.class`-фикстуры в `noxis-classfile/tests/data/` -- [ ] противник-скрипт (свёртка констант, regex) как тест в `noxis-verify` - -### 6.1 Fixtures — jar из `/storage/project/jvm/` (найдены, не подключены) - -| jar | классов | major | `StackMapTable` | тип | -|---|---|---|---|---| -| `LoReport/build/libs/lorep-1.1.0.jar` | 17 | 65 | 15 | Spigot-плагин, **быстрый smoke** | -| `hillsphere/neoforge/build/libs/hillsphere-neoforge-1.21.1-0.1.0.jar` | 40 | 65 | 22 | NeoForge-мод, Java 21 | -| `LoParkour/build/libs/LoParkour-1.4.0.jar` | 274 | 65 | 204 | Spigot-плагин, средний | -| `LoChat/build/libs/LoChat-1.5.5-1.20.1.jar` | 1 080 | 51/52/65 | 591 | **микс версий** — стресс | -| `oc2r/build/libs/oc2r-1.21.1-neoforge-0.1.1+78704d26.jar` | 1 278 | 65 | 659 | NeoForge, 28 MB (shaded) | -| `LoVisual/mod/build/libs/lovisual-0.1.1.jar` | 4 082 | 47–69 | 2 251 | Fabric, **включает major 47/49 без кадров** | - -- [ ] скопировать в fixtures-каталог репозитория (licenses permitting) -- [ ] прогон `load → pipeline → save → verify` на `lorep` и `hillsphere` -- [ ] `java -Xverify:all` на каждом; для Fabric/NeoForge — только `verify_class` - (запуск требует лаунчеров) - -## 7. Устойчивость к ИИ-анализу — **исследование, не блокер** - -Разбор источников (Acoda, ICSE 2026; Elastic Security Labs, апрель 2026) — -[`docs/learnings/ai-resistance.md`](docs/learnings/ai-resistance.md). Рычаг -один: цена агента на разбор должна расти быстрее, чем цена нашей сборки. -Эффект меряется прогоном конкретного агента, а не верой в методичку — -критерий тот же, что и для остальных техник (§4). - -- [ ] **Вложенные слои шифрования строк** (аналог Matryoshka Wall из - Elastic): `StringsConfig` получает глубину N, декодер разворачивает - N слоёв вместо одного; цена агента растёт почти линейно с N, цена - сборки — нет -- [ ] **Больше decoy-точек сборки ключа** (аналог Dispatch Maze): сейчас - `master = k1^k2` собирается в одном месте декодера (`stack.md` §4); - поднять число частей и раскидать их сборку по случайным junk-методам - из `Noise` -- [ ] **MBA вместо простых тождеств в `Constants`**: по данным Elastic, - `Flatten + MBA` на Tigress бьёт по модели сильнее, чем один `Flatten` - — укладывается в текущий пасс без архитектурных изменений -- [ ] **P4, после схем `flow` (§3.4):** виртуализация байткода (table - interpretation) — самая мощная техника по академическому обзору, но - ломает допущение `noxis-verify` (`java -Xverify:all` проверяет - обычный байткод с `StackMapTable`, не тело интерпретатора) -- [!] **Сознательно не делаем:** имитацию вредоносных паттернов, prompt - injection в строках, EOS-токены (методы Acoda, завязанные на - natural-language канал и чат-интерфейс LLM, а не на байткод) — риск - ложного срабатывания антивируса/EDR на легитимном продукте, - противоречит `README.md` → «Ответственное использование» - ---- - -## Порядок (что делать следующим) - -0. ~~Ремонт структуры + тулчейн~~ — готов (08.10.2026, оценка **55/100**). - Гейт падал на `parse/code.rs`/`insns.rs` — разбиты; 8 латентных багов - orphan-кода исправлены; `stable` 1.97→**1.99**, edition→**2024**, - `toml`→**1.1.7**; MSRV 1.97. `./check.sh` — OK. -1. ~~`noxis-jar`~~ — готов. -2. ~~Пасс `debug`~~ — готов (P0/A2/B4). -3. ~~Пасс `resources`~~ — готов (P0/A4). -4. ~~Spike `ristretto_classfile`~~ — backend выбран, ограничение найдено. -5. ~~**`format::parse`/`format::write`** (P1)~~ — готов (08.10.2026): - классовый уровень поверх ристретто, пул с нуля, `StackMapTable` туда-обратно - (байтовые дельты ↔ индексные), `verify()` backend'а на выходе writer'а, - `tests/roundtrip.rs` (3 теста). Снимает блокер writer'а и генератора - декодера, то есть и `strings`, и `flow`. - Известные ограничения (P2): `rename` не переписывает ссылки внутри - `BootstrapMethods` (имена лочатся в `keep`, классы с BSM переименовывать - методы не будут — безопасно, но менее мутно); `Raw`-атрибуты со ссылками - пула (аннотации, ...) несут старые индексы — моделировать явно - (`Record` + `LocalVariableTypeTable` уже смоделированы 08.10.2026) - или переходить на пул-сохраняющий writer. -6. ~~**Кадры `StackMapTable`** (P1)~~ — готов (08.10.2026): свой dataflow - (`format/frames/{mod,flow,emit,tests,xfer/{mod,stack,calls},merge/{mod,descs}}`, - `Hierarchy`-трейт для LUB); приёмка — `java -Xverify:all` на фикстурах - (`tests/data` 4 класса, `tests/frames.rs`): снести → посчитать → - round-trip → `java` зелёный для JDK-классов. -7. ~~**Пассы `strings`, `constants`, `noise`**~~ — готовы (08.10.2026): - строки с декодером v49 (сквозной тест исполнением), константы int/long - + opaque, шум с вплетанием; все в `standard_pipeline`. - Ограничения: opaque константные (бьются свёрткой); `float`/`double` - не шифруются; junk-аннотации пропущены; `rename` не правит ссылки в BSM. -8. ~~**`noxis-verify`**~~ — готов: красные паттерны (`leaks.rs`), - `java -Xverify:all` (`java.rs`), метрики/бюджет размера/стабильность - маппингов (`metrics.rs`). Не хватает: доли распознанных структур в - декомпиляте, бюджета времени, `ristretto_vm` (P3). -9. ~~**`noxis` (CLI)**~~ — готов: `obfuscate`/`analyze`/`patterns`, - конфиг + seed, честные off-флаги, JSON-отчёт + маппинги, - end-to-end тест. Единственный честный блокер — `--no-flow` - падает с ошибкой, потому что пасса ещё нет. -10. **Схемы `flow`** (§3.4) — единственная крупная техника без реализации: - `state-spread`, `computed-switch`, `butterfly`, `exception-goto` + - ротация между методами. Кадры для них уже считаются (п.6). -11. **Fixtures и regression** (§6) — подключить jar из - `/storage/project/jvm/`, прогнать `load → pipeline → save → verify`, - противник-скрипт как тест в `noxis-verify`. - -После каждого пункта — `./scripts/check.sh`. - ---- - -## Долг структуры (на грани лимита, разбить превентивно) - -Гейт — только про `.rs` (см. `docs/README.md`), `docs/stack.md` из списка -убран: лимит строк на markdown больше не действует. - -- `noxis-passes/src/debug.rs` — 249/250 -- `noxis-analysis/src/entrypoints.rs` — 244/250 -- `noxis-passes/src/rename/{mod,assign}` — 232–237/250 -- `noxis-passes/src/namegen/mod.rs` — 215/250 -- `noxis-runtime/src/decoder/{xor,xtea}.rs` — 243–245/250