Compare commits

...

No commits in common. "87b7663873522e6359a94f2b678068d56ea15b7f" and "ec28ec82e3aec36f28d48c7bb96485944996002a" have entirely different histories.

15 changed files with 568 additions and 522 deletions

3
.gitignore vendored
View file

@ -2,6 +2,9 @@
/target
**/*.rs.bk
# План работ — локальный, не публикуется в истории
/todo.md
# Локальный cargo-config (может содержать секреты репозитория)
/.cargo/config.toml
/config.toml

View file

@ -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<u16, ClassfileError> + 'a);
/// Кадры IR → кадры backend'а (индексные дельты — как есть).
pub(super) fn convert_frames(
frames: &[StackMapFrame],
pool: &mut Pool,
byte_of: ByteOf<'_>,
) -> Result<Vec<RtFrame>, 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<RtFrame, ClassfileError> {
/// `byte_delta` — истинная байтовая дельта; компактный вид годен лишь при ≤ 63.
fn build_frame(
frame: &StackMapFrame,
pool: &mut Pool,
byte_delta: u16,
) -> Result<RtFrame, ClassfileError> {
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, Classf
} else {
RtFrame::SameLocals1StackItemFrameExtended {
frame_type: 247,
offset_delta: offset,
offset_delta: extended,
stack,
}
}
}
StackMapFrame::Chop { count, .. } => 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, Classf
}
RtFrame::AppendFrame {
frame_type: 251 + count,
offset_delta: offset,
offset_delta: extended,
locals: types(locals, pool)?,
}
}
StackMapFrame::Full { locals, stack, .. } => RtFrame::FullFrame {
frame_type: 255,
offset_delta: offset,
offset_delta: extended,
locals: types(locals, pool)?,
stack: types(stack, pool)?,
},

View file

@ -55,7 +55,7 @@ pub(super) fn convert_code(code: &Code, pool: &mut Pool) -> Result<RtAttr, Class
resolve: &resolve,
byte_of: &byte_of,
};
let frames = convert_frames(&code.frames, pool)?;
let frames = convert_frames(&code.frames, pool, &byte_of)?;
let mut attributes = Vec::with_capacity(code.attributes.len() + 1);
for attr in &code.attributes {
attributes.push(match attr {

View file

@ -1,155 +0,0 @@
//! Сборка constant pool при записи: строки нашего IR → индексы backend'а.
//!
//! Пул строится с нуля детерминированным обходом (классы, поля, методы,
//! атрибуты, код), поэтому одинаковый IR даёт одинаковые байты. Индексы
//! `Raw`-атрибутов при этом не переносятся — см. `super::attrs`.
use ristretto_classfile::{ConstantPool, ReferenceKind};
use crate::error::ClassfileError;
use crate::insn::{Const, InvokeKind};
/// Строитель пула; живёт только внутри одного `write`.
pub(crate) struct Pool {
pool: ConstantPool<'static>,
}
impl Pool {
pub(crate) fn new() -> Self {
Pool {
pool: ConstantPool::default(),
}
}
pub(super) fn utf8(&mut self, value: &str) -> Result<u16, ClassfileError> {
self.pool.add_utf8(value).map_err(write_err)
}
pub(super) fn name_and_type(
&mut self,
name: &str,
descriptor: &str,
) -> Result<u16, ClassfileError> {
self.pool
.add_name_and_type(name, descriptor)
.map_err(write_err)
}
pub(super) fn class(&mut self, name: &str) -> Result<u16, ClassfileError> {
self.pool.add_class(name).map_err(write_err)
}
pub(super) fn field_ref(
&mut self,
owner: &str,
name: &str,
descriptor: &str,
) -> Result<u16, ClassfileError> {
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<u16, ClassfileError> {
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<u16, ClassfileError> {
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<u16, ClassfileError> {
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<u16, ClassfileError> {
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<u16, ClassfileError> {
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())
}

View file

@ -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<String, u16>,
pub(super) classes: HashMap<String, u16>,
pub(super) name_types: HashMap<(String, String), u16>,
pub(super) strings: HashMap<String, u16>,
pub(super) method_types: HashMap<String, u16>,
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<u16, ClassfileError> {
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<u16, ClassfileError> {
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<u16, ClassfileError> {
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<u16, ClassfileError> {
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<u16, ClassfileError> {
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<u16, ClassfileError> {
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())
}

View file

@ -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<u16, ClassfileError> {
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<u16, ClassfileError> {
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<u16, ClassfileError> {
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<u16, ClassfileError> {
self.dynamic_like(bootstrap, name, descriptor, true)
}
pub(crate) fn dynamic(
&mut self,
bootstrap: u16,
name: &str,
descriptor: &str,
) -> Result<u16, ClassfileError> {
self.dynamic_like(bootstrap, name, descriptor, false)
}
fn dynamic_like(
&mut self,
bootstrap: u16,
name: &str,
descriptor: &str,
invoke: bool,
) -> Result<u16, ClassfileError> {
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)
}
}

View file

@ -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<PathBuf> = 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
);
}
}
}
}

View file

@ -17,6 +17,9 @@ pub enum NameStyle {
MixedLatin,
/// Псевдосмысленные слова из другого проекта (дезориентация).
DecoyWords,
/// Правдоподобные имена: `TextureCache`, `resolveToken` — вместо
/// явного мусора маскируется под обычный прикладной код.
Plausible,
}
/// Настройки переименования.

View file

@ -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!(

View file

@ -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",
];

View file

@ -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");
}
}
}

View file

@ -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()));
}
}

View file

@ -180,6 +180,7 @@ pub(super) fn generate_packages(cfg: &Config, rng: &mut Rng) -> Vec<String> {
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();

View file

@ -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`)

299
todo.md
View file

@ -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`, `<clinit>`, 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