Expose shared DEX inspection and bytecode decoding

This commit is contained in:
Dylan M. Taylor committed 2026-11-17 08:40:02 -05:00
1 parent 4039bc7695
commit 66f8c51048
9 files changed
+643 -13

No files matched your search

+4
View File
@@ -132,3 +132,7 @@ Sanitization, animation fitting and numeric output policy remain caller-owned.
## JSONC span-preserving editing
`crates/jsonc` is extracted from Craft Anything `crates/formats/src/jsonc.rs` at `e5c9c94106747ed44b9a3fb0decce867c2285f93` (MIT OR Apache-2.0). The original implementation and hardening by BFlat, newline preservation by NetterSilver, and subsequent RRFZ/Afloat correctness fixes retain separate primary-author port commits with immutable source revisions. Shared API wiring and optional input-byte admission are subsequent changes. Compatibility parsing and all existing formatting/editing tests are retained; application file I/O and policy are not imported.
## Dalvik DEX inspection
`crates/dex` extracts Craft Anything `crates/formats/src/dex.rs` and `dex_ops.rs` at `5979f9b13f16dcf1df3c7ae7f8e7735f452866f2` (MIT OR Apache-2.0). Five source-history ports preserve Brandon Thomas, BFlat and Afloat as primary authors. Five regression imports retain BFlat/Afloat authors and exact source revisions. The checked byte-reader/MUTF-8 subset and synthetic DEX fixture come from that app's `bytes.rs` and `testkit/src/android.rs`; deterministic noise/mutations come from its testkit. No application file I/O, APK logic or execution is imported. Shared neutral errors and workspace wiring are subsequent changes; existing per-file strings, member/handler and bytecode payload budgets are retained.
Generated
+8
View File
@@ -1722,6 +1722,14 @@ dependencies = [
"thiserror 2.0.21",
]
[[package]]
name = "craft-dex"
version = "0.1.0"
dependencies = [
"serde",
"thiserror 2.0.21",
]
[[package]]
name = "craft-dialogs"
version = "0.1.0"
+1
View File
@@ -11,6 +11,7 @@ rust-version = "1.95"
repository = "https://github.com/storytold/craft-libs"
[workspace.dependencies]
craft-dex = { path = "crates/dex" }
craft-jsonc = { path = "crates/jsonc" }
craft-palette = { path = "crates/palette" }
craft-score = { path = "crates/score" }
+13
View File
@@ -0,0 +1,13 @@
[package]
name="craft-dex"
description="Dalvik DEX reader and bytecode decoder with retained input bounds and partial-report semantics"
version.workspace=true
edition.workspace=true
license.workspace=true
rust-version.workspace=true
repository.workspace=true
[lints]
workspace=true
[dependencies]
serde={workspace=true}
thiserror={workspace=true}
+81
View File
@@ -0,0 +1,81 @@
//! Checked little/big-endian reads over untrusted bytes. Every read returns `None` when out of range.
#[derive(Debug, Clone, Copy)]
pub struct Reader<'a> {
data: &'a [u8],
}
impl<'a> Reader<'a> {
pub fn new(data: &'a [u8]) -> Self {
Reader { data }
}
pub fn len(&self) -> usize {
self.data.len()
}
pub fn data(&self) -> &'a [u8] {
self.data
}
pub fn slice(&self, off: usize, len: usize) -> Option<&'a [u8]> {
let end = off.checked_add(len)?;
self.data.get(off..end)
}
pub fn u8(&self, off: usize) -> Option<u8> {
self.data.get(off).copied()
}
fn arr<const N: usize>(&self, off: usize) -> Option<[u8; N]> {
self.slice(off, N)?.try_into().ok()
}
pub fn u16_le(&self, off: usize) -> Option<u16> {
self.arr(off).map(u16::from_le_bytes)
}
pub fn u32_le(&self, off: usize) -> Option<u32> {
self.arr(off).map(u32::from_le_bytes)
}
/// A NUL-terminated string starting at `off`, at most `max` bytes, lossily decoded.
pub fn cstr(&self, off: usize, max: usize) -> Option<String> {
let rest = self.data.get(off..)?;
let rest = rest.get(..max.min(rest.len()))?;
let end = rest.iter().position(|&b| b == 0).unwrap_or(rest.len());
Some(String::from_utf8_lossy(rest.get(..end)?).into_owned())
}
/// Unsigned LEB128 at `off`: (value, bytes consumed). At most 10 bytes.
pub fn uleb128(&self, off: usize) -> Option<(u64, usize)> {
let mut result = 0u64;
for i in 0..10usize {
let b = self.u8(off.checked_add(i)?)?;
let payload = u64::from(b & 0x7f);
let shift = 7 * i as u32;
if shift > 0 && payload.checked_shl(shift)? >> shift != payload {
return None;
}
result |= payload << shift;
if b & 0x80 == 0 {
return Some((result, i + 1));
}
}
None
}
}
/// Decode one modified UTF-8 code unit. Invalid bytes consume only themselves,
/// so a damaged sequence cannot hide valid text or borrow missing bytes.
pub(crate) fn mutf8_unit(bytes: &[u8]) -> (u16, usize) {
match bytes {
[a @ 0x00..=0x7f, ..] => (u16::from(*a), 1),
[0xc0, 0x80, ..] => (0, 2),
[a @ 0xc2..=0xdf, b @ 0x80..=0xbf, ..] => ((u16::from(*a & 0x1f) << 6) | u16::from(*b & 0x3f), 2),
[a @ 0xe0..=0xef, b @ 0x80..=0xbf, c @ 0x80..=0xbf, ..] if *a != 0xe0 || *b >= 0xa0 => {
((u16::from(*a & 0x0f) << 12) | (u16::from(*b & 0x3f) << 6) | u16::from(*c & 0x3f), 3)
}
_ => (0xfffd, 1),
}
}
+18 -10
View File
@@ -348,8 +348,11 @@ pub fn parse(data: &[u8]) -> Result<Dex<'_>, FormatError> {
ProtoId { shorty: r.u32_le(o).unwrap_or(0), ret: r.u32_le(o + 4).unwrap_or(NO_INDEX), params_off: r.u32_le(o + 8).unwrap_or(0) }
})
.collect();
let member =
|o: usize| MemberId { class_idx: r.u16_le(o).unwrap_or(0), type_or_proto: r.u16_le(o + 2).unwrap_or(0), name_idx: r.u32_le(o + 4).unwrap_or(NO_INDEX) };
let member = |o: usize| MemberId {
class_idx: r.u16_le(o).unwrap_or(0),
type_or_proto: r.u16_le(o + 2).unwrap_or(0),
name_idx: r.u32_le(o + 4).unwrap_or(NO_INDEX),
};
let fields = (0..nf).map(|i| member(fo + i * 8)).collect();
let methods = (0..nm).map(|i| member(mo + i * 8)).collect();
let classes = (0..nc)
@@ -423,7 +426,9 @@ impl<'a> Dex<'a> {
/// `Lcls;->name:Ltype;`
pub fn field_ref(&self, i: u32) -> String {
match self.fields.get(i as usize) {
Some(f) => format!("{}->{}:{}", self.type_desc(u32::from(f.class_idx)), self.string(f.name_idx), self.type_desc(u32::from(f.type_or_proto))),
Some(f) => {
format!("{}->{}:{}", self.type_desc(u32::from(f.class_idx)), self.string(f.name_idx), self.type_desc(u32::from(f.type_or_proto)))
}
None => format!("<field#{i}>"),
}
}
@@ -431,7 +436,9 @@ impl<'a> Dex<'a> {
/// `Lcls;->name(…)R`
pub fn method_ref(&self, i: u32) -> String {
match self.methods.get(i as usize) {
Some(m) => format!("{}->{}{}", self.type_desc(u32::from(m.class_idx)), self.string(m.name_idx), self.proto_desc(u32::from(m.type_or_proto))),
Some(m) => {
format!("{}->{}{}", self.type_desc(u32::from(m.class_idx)), self.string(m.name_idx), self.proto_desc(u32::from(m.type_or_proto)))
}
None => format!("<method#{i}>"),
}
}
@@ -683,9 +690,10 @@ pub fn references(dex: &Dex<'_>, desc: &str, method: Option<&str>, max: usize) -
let cls = dex.type_desc(u32::from(id.class_idx));
(cls == desc && method.is_none_or(|n| dex.string(id.name_idx) == n)).then(|| ("method", dex.method_ref(idx)))
}),
IndexKind::Field if method.is_none() => {
dex.fields.get(idx as usize).and_then(|id| (dex.type_desc(u32::from(id.class_idx)) == desc).then(|| ("field", dex.field_ref(idx))))
}
IndexKind::Field if method.is_none() => dex
.fields
.get(idx as usize)
.and_then(|id| (dex.type_desc(u32::from(id.class_idx)) == desc).then(|| ("field", dex.field_ref(idx)))),
IndexKind::Type if method.is_none() => {
let t = dex.type_desc(idx);
(t.trim_start_matches('[') == desc).then_some(("type", t))
@@ -707,7 +715,7 @@ pub fn references(dex: &Dex<'_>, desc: &str, method: Option<&str>, max: usize) -
#[cfg(test)]
mod tests {
use super::*;
use craft_anything_testkit::android as fx;
use crate::test_support::android as fx;
#[test]
fn parses_fixture() {
@@ -785,7 +793,7 @@ mod tests {
}
let _ = references(d, "Lcom/example/notes/Util;", None, 100);
};
for m in craft_anything_testkit::mutations(&data) {
for m in crate::test_support::mutations(&data) {
if let Ok(d) = parse(&m) {
walk(&d);
}
@@ -796,7 +804,7 @@ mod tests {
}
}
for seed in 0..64 {
let mut n = craft_anything_testkit::noise(seed, 2048);
let mut n = crate::test_support::noise(seed, 2048);
n[..8].copy_from_slice(b"dex\n035\0");
n[40..44].copy_from_slice(&0x1234_5678u32.to_le_bytes());
if let Ok(d) = parse(&n) {
+5 -3
View File
@@ -170,7 +170,8 @@ const BINOPS_2ADDR: [&str; 32] = [
"rem-double/2addr",
];
const LIT16: [&str; 8] = ["add-int/lit16", "rsub-int", "mul-int/lit16", "div-int/lit16", "rem-int/lit16", "and-int/lit16", "or-int/lit16", "xor-int/lit16"];
const LIT16: [&str; 8] =
["add-int/lit16", "rsub-int", "mul-int/lit16", "div-int/lit16", "rem-int/lit16", "and-int/lit16", "or-int/lit16", "xor-int/lit16"];
const LIT8: [&str; 11] = [
"add-int/lit8",
"rsub-int/lit8",
@@ -236,7 +237,8 @@ const SFIELD: [&str; 14] = [
"sput-short",
];
const INVOKE: [&str; 5] = ["invoke-virtual", "invoke-super", "invoke-direct", "invoke-static", "invoke-interface"];
const INVOKE_RANGE: [&str; 5] = ["invoke-virtual/range", "invoke-super/range", "invoke-direct/range", "invoke-static/range", "invoke-interface/range"];
const INVOKE_RANGE: [&str; 5] =
["invoke-virtual/range", "invoke-super/range", "invoke-direct/range", "invoke-static/range", "invoke-interface/range"];
fn pick(list: &[&'static str], i: u8, base: u8) -> &'static str {
list.get(usize::from(i.wrapping_sub(base))).copied().unwrap_or("unused")
@@ -683,7 +685,7 @@ mod tests {
#[test]
fn hostile() {
for seed in 0..200 {
let n = craft_anything_testkit::noise(seed, 256);
let n = crate::test_support::noise(seed, 256);
let code: Vec<u16> = n.as_chunks::<2>().0.iter().map(|c| u16::from_le_bytes(*c)).collect();
let _ = decode(&code, 1000);
}
+42
View File
@@ -0,0 +1,42 @@
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
#![forbid(unsafe_code)]
//! Dalvik DEX inspection and bytecode decoding. Never executes bytecode.
mod bytes;
/// Checked byte reader accepted by the signed-LEB compatibility helper.
pub use bytes::Reader;
pub mod dex;
pub mod dex_ops;
pub use dex::*;
#[cfg(test)]
mod test_support;
/// Parser admission failures; damaged substructures retain the original partial-report behavior.
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum DexError {
#[error("the file ends early ({0})")]
Truncated(String),
#[error("the file is malformed ({0})")]
Malformed(String),
#[error("not supported: {0}")]
Unsupported(String),
}
use DexError as FormatError;
#[cfg(test)]
#[path = "regressions/array_widths.rs"]
mod array_widths;
#[cfg(test)]
#[path = "regressions/capped_table_boundaries.rs"]
mod capped_table_boundaries;
#[cfg(test)]
#[path = "regressions/invoke_registers.rs"]
mod invoke_registers;
#[cfg(test)]
#[path = "regressions/payload_budgets.rs"]
mod payload_budgets;
#[cfg(test)]
#[path = "regressions/signed_leb128.rs"]
mod signed_leb128;
+471
View File
@@ -0,0 +1,471 @@
// Synthetic DEX fixture and deterministic mutations retained from Craft Anything.
/// Deterministic pseudo-random bytes (xorshift) for fuzz-like loops.
pub fn noise(seed: u64, len: usize) -> Vec<u8> {
let mut x = seed.wrapping_mul(0x9e37_79b9_7f4a_7c15) | 1;
(0..len)
.map(|_| {
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
x as u8
})
.collect()
}
/// Every way to damage a sample used by robustness tests: truncations at many lengths and
/// single-byte corruptions spread across the file.
pub fn mutations(sample: &[u8]) -> Vec<Vec<u8>> {
let mut out = Vec::new();
let n = sample.len();
let step = (n / 64).max(1);
let mut len = 0;
while len < n {
out.push(sample[..len].to_vec());
len += step;
}
for (i, seed) in (0..n).step_by(step).zip(1u64..) {
let mut m = sample.to_vec();
let noise = noise(seed, 8);
for (j, v) in noise.iter().enumerate() {
if let Some(b) = m.get_mut(i + j) {
*b = *v;
}
}
out.push(m);
let mut m = sample.to_vec();
if let Some(b) = m.get_mut(i) {
*b = 0xff;
}
out.push(m);
}
out
}
pub mod android {
pub const HELLO: &str = "Hello, Craft!";
fn u16le(v: &mut Vec<u8>, x: u16) {
v.extend_from_slice(&x.to_le_bytes());
}
fn u32le(v: &mut Vec<u8>, x: u32) {
v.extend_from_slice(&x.to_le_bytes());
}
fn uleb(v: &mut Vec<u8>, mut x: u32) {
loop {
let b = (x & 0x7f) as u8;
x >>= 7;
if x == 0 {
v.push(b);
break;
}
v.push(b | 0x80);
}
}
fn sleb(v: &mut Vec<u8>, mut x: i32) {
loop {
let b = (x & 0x7f) as u8;
x >>= 7;
let done = (x == 0 && b & 0x40 == 0) || (x == -1 && b & 0x40 != 0);
v.push(if done { b } else { b | 0x80 });
if done {
break;
}
}
}
fn align4(v: &mut Vec<u8>) {
while !v.len().is_multiple_of(4) {
v.push(0);
}
}
#[derive(Debug, Clone, Default)]
pub struct TrySpec {
pub start: u32,
pub count: u16,
/// (type idx, handler address)
pub handlers: Vec<(u32, u32)>,
pub catch_all: Option<u32>,
}
#[derive(Debug, Clone, Default)]
pub struct CodeSpec {
pub registers: u16,
pub ins: u16,
pub outs: u16,
pub insns: Vec<u16>,
pub tries: Vec<TrySpec>,
}
#[derive(Debug, Clone)]
pub struct MethodSpec {
pub method: u32,
pub access: u32,
pub code: Option<CodeSpec>,
}
#[derive(Debug, Clone, Default)]
pub struct ClassSpec {
pub class: u32,
pub access: u32,
pub superclass: u32,
pub interfaces: Vec<u32>,
pub source_file: u32,
pub annotations: Vec<u32>,
pub static_fields: Vec<(u32, u32)>,
pub instance_fields: Vec<(u32, u32)>,
pub direct: Vec<MethodSpec>,
pub virtuals: Vec<MethodSpec>,
}
#[derive(Debug, Clone, Default)]
pub struct DexBuilder {
strings: Vec<String>,
types: Vec<u32>,
protos: Vec<(u32, u32, Vec<u32>)>,
fields: Vec<(u32, u32, u32)>,
methods: Vec<(u32, u32, u32)>,
pub classes: Vec<ClassSpec>,
}
impl DexBuilder {
pub fn string(&mut self, s: &str) -> u32 {
if let Some(i) = self.strings.iter().position(|x| x == s) {
return i as u32;
}
self.strings.push(s.to_string());
(self.strings.len() - 1) as u32
}
pub fn ty(&mut self, desc: &str) -> u32 {
let s = self.string(desc);
if let Some(i) = self.types.iter().position(|&x| x == s) {
return i as u32;
}
self.types.push(s);
(self.types.len() - 1) as u32
}
pub fn proto(&mut self, ret: &str, params: &[&str]) -> u32 {
let short = |d: &str| if d.starts_with('L') || d.starts_with('[') { 'L' } else { d.chars().next().unwrap() };
let shorty: String = std::iter::once(short(ret)).chain(params.iter().map(|p| short(p))).collect();
let s = self.string(&shorty);
let r = self.ty(ret);
let ps: Vec<u32> = params.iter().map(|p| self.ty(p)).collect();
if let Some(i) = self.protos.iter().position(|p| p.1 == r && p.2 == ps) {
return i as u32;
}
self.protos.push((s, r, ps));
(self.protos.len() - 1) as u32
}
pub fn field(&mut self, cls: &str, ty: &str, name: &str) -> u32 {
let c = self.ty(cls);
let t = self.ty(ty);
let n = self.string(name);
if let Some(i) = self.fields.iter().position(|&f| f == (c, t, n)) {
return i as u32;
}
self.fields.push((c, t, n));
(self.fields.len() - 1) as u32
}
pub fn method(&mut self, cls: &str, name: &str, ret: &str, params: &[&str]) -> u32 {
let c = self.ty(cls);
let p = self.proto(ret, params);
let n = self.string(name);
if let Some(i) = self.methods.iter().position(|&m| m == (c, p, n)) {
return i as u32;
}
self.methods.push((c, p, n));
(self.methods.len() - 1) as u32
}
pub fn build(self) -> Vec<u8> {
let ns = self.strings.len();
let nt = self.types.len();
let np = self.protos.len();
let nf = self.fields.len();
let nm = self.methods.len();
let nc = self.classes.len();
let string_ids = 0x70;
let type_ids = string_ids + ns * 4;
let proto_ids = type_ids + nt * 4;
let field_ids = proto_ids + np * 12;
let method_ids = field_ids + nf * 8;
let class_defs = method_ids + nm * 8;
let mut data_start = class_defs + nc * 32;
data_start = (data_start + 3) & !3;
let mut d: Vec<u8> = Vec::new();
let at = |d: &Vec<u8>| (data_start + d.len()) as u32;
// type lists
let tl = |d: &mut Vec<u8>, list: &[u32]| -> u32 {
if list.is_empty() {
return 0;
}
align4(d);
let o = at(d);
u32le(d, list.len() as u32);
for &t in list {
u16le(d, t as u16);
}
o
};
let proto_params: Vec<u32> = self.protos.iter().map(|p| tl(&mut d, &p.2)).collect();
let class_ifaces: Vec<u32> = self.classes.iter().map(|c| tl(&mut d, &c.interfaces)).collect();
// string data
let mut string_offs = Vec::new();
for s in &self.strings {
string_offs.push(at(&d));
uleb(&mut d, s.encode_utf16().count() as u32);
for ch in s.chars() {
let c = ch as u32;
if c == 0 {
d.extend_from_slice(&[0xc0, 0x80]);
} else if c < 0x80 {
d.push(c as u8);
} else if c < 0x800 {
d.extend_from_slice(&[0xc0 | (c >> 6) as u8, 0x80 | (c & 0x3f) as u8]);
} else {
d.extend_from_slice(&[0xe0 | (c >> 12) as u8, 0x80 | ((c >> 6) & 0x3f) as u8, 0x80 | (c & 0x3f) as u8]);
}
}
d.push(0);
}
// code items, class data, annotations
let mut class_data_offs = Vec::new();
let mut annot_offs = Vec::new();
for c in &self.classes {
let code_off = |d: &mut Vec<u8>, m: &MethodSpec| -> u32 {
let Some(code) = &m.code else { return 0 };
align4(d);
let o = at(d);
u16le(d, code.registers);
u16le(d, code.ins);
u16le(d, code.outs);
u16le(d, code.tries.len() as u16);
u32le(d, 0);
u32le(d, code.insns.len() as u32);
for &i in &code.insns {
u16le(d, i);
}
if !code.tries.is_empty() {
if code.insns.len() % 2 == 1 {
u16le(d, 0);
}
let mut list = Vec::new();
uleb(&mut list, code.tries.len() as u32);
let mut offs = Vec::new();
for t in &code.tries {
offs.push(list.len() as u16);
let n = t.handlers.len() as i32;
sleb(&mut list, if t.catch_all.is_some() { -n } else { n });
for &(ty, addr) in &t.handlers {
uleb(&mut list, ty);
uleb(&mut list, addr);
}
if let Some(a) = t.catch_all {
uleb(&mut list, a);
}
}
for (t, off) in code.tries.iter().zip(offs) {
u32le(d, t.start);
u16le(d, t.count);
u16le(d, off);
}
d.extend_from_slice(&list);
}
o
};
let mut direct = c.direct.clone();
direct.sort_by_key(|m| m.method);
let mut virtuals = c.virtuals.clone();
virtuals.sort_by_key(|m| m.method);
let direct_offs: Vec<u32> = direct.iter().map(|m| code_off(&mut d, m)).collect();
let virtual_offs: Vec<u32> = virtuals.iter().map(|m| code_off(&mut d, m)).collect();
let cd = at(&d);
let mut sf = c.static_fields.clone();
sf.sort();
let mut inf = c.instance_fields.clone();
inf.sort();
uleb(&mut d, sf.len() as u32);
uleb(&mut d, inf.len() as u32);
uleb(&mut d, direct.len() as u32);
uleb(&mut d, virtuals.len() as u32);
for list in [&sf, &inf] {
let mut prev = 0;
for &(f, a) in list.iter() {
uleb(&mut d, f - prev);
uleb(&mut d, a);
prev = f;
}
}
for (list, offs) in [(&direct, &direct_offs), (&virtuals, &virtual_offs)] {
let mut prev = 0;
for (m, &o) in list.iter().zip(offs.iter()) {
uleb(&mut d, m.method - prev);
uleb(&mut d, m.access);
uleb(&mut d, o);
prev = m.method;
}
}
class_data_offs.push(cd);
if c.annotations.is_empty() {
annot_offs.push(0);
} else {
let mut items = Vec::new();
for &t in &c.annotations {
items.push(at(&d));
d.push(1); // runtime visibility
uleb(&mut d, t);
uleb(&mut d, 0);
}
align4(&mut d);
let set_off = at(&d);
u32le(&mut d, items.len() as u32);
for i in items {
u32le(&mut d, i);
}
let dir = at(&d);
u32le(&mut d, set_off);
u32le(&mut d, 0);
u32le(&mut d, 0);
u32le(&mut d, 0);
annot_offs.push(dir);
}
}
align4(&mut d);
let file_size = data_start + d.len();
let mut out = vec![0u8; data_start];
out[..8].copy_from_slice(b"dex\n035\0");
let put = |out: &mut Vec<u8>, off: usize, v: u32| out[off..off + 4].copy_from_slice(&v.to_le_bytes());
put(&mut out, 32, file_size as u32);
put(&mut out, 36, 0x70);
put(&mut out, 40, 0x1234_5678);
for (i, (n, o)) in
[(ns, string_ids), (nt, type_ids), (np, proto_ids), (nf, field_ids), (nm, method_ids), (nc, class_defs)].iter().enumerate()
{
put(&mut out, 56 + i * 8, *n as u32);
put(&mut out, 60 + i * 8, if *n == 0 { 0 } else { *o as u32 });
}
put(&mut out, 104, d.len() as u32);
put(&mut out, 108, data_start as u32);
for (i, o) in string_offs.iter().enumerate() {
put(&mut out, string_ids + i * 4, *o);
}
for (i, t) in self.types.iter().enumerate() {
put(&mut out, type_ids + i * 4, *t);
}
for (i, p) in self.protos.iter().enumerate() {
put(&mut out, proto_ids + i * 12, p.0);
put(&mut out, proto_ids + i * 12 + 4, p.1);
put(&mut out, proto_ids + i * 12 + 8, proto_params[i]);
}
for (i, (c, t, n)) in self.fields.iter().enumerate() {
out[field_ids + i * 8..field_ids + i * 8 + 2].copy_from_slice(&(*c as u16).to_le_bytes());
out[field_ids + i * 8 + 2..field_ids + i * 8 + 4].copy_from_slice(&(*t as u16).to_le_bytes());
put(&mut out, field_ids + i * 8 + 4, *n);
}
for (i, (c, p, n)) in self.methods.iter().enumerate() {
out[method_ids + i * 8..method_ids + i * 8 + 2].copy_from_slice(&(*c as u16).to_le_bytes());
out[method_ids + i * 8 + 2..method_ids + i * 8 + 4].copy_from_slice(&(*p as u16).to_le_bytes());
put(&mut out, method_ids + i * 8 + 4, *n);
}
for (i, c) in self.classes.iter().enumerate() {
let o = class_defs + i * 32;
for (k, v) in
[c.class, c.access, c.superclass, class_ifaces[i], c.source_file, annot_offs[i], class_data_offs[i], 0].iter().enumerate()
{
put(&mut out, o + k * 4, *v);
}
}
out.extend_from_slice(&d);
let sum = adler32(&out[12..]);
put(&mut out, 8, sum);
out
}
}
fn adler32(data: &[u8]) -> u32 {
let (mut a, mut b) = (1u32, 0u32);
for &x in data {
a = (a + u32::from(x)) % 65521;
b = (b + a) % 65521;
}
(b << 16) | a
}
const MAIN: &str = "Lcom/example/notes/MainActivity;";
const UTIL: &str = "Lcom/example/notes/Util;";
const STRING: &str = "Ljava/lang/String;";
/// `classes.dex` of the Notes app: `MainActivity` (constructor, `onCreate`, `run`, `pick` with a
/// packed switch inside a try/catch) and `Util` (two `log` overloads printing through
/// `System.out`).
pub fn notes_dex() -> Vec<u8> {
let mut b = DexBuilder::default();
let activity = b.ty("Landroid/app/Activity;");
let main = b.ty(MAIN);
let runnable = b.ty("Ljava/lang/Runnable;");
let deprecated = b.ty("Ljava/lang/Deprecated;");
let rte = b.ty("Ljava/lang/RuntimeException;");
let object = b.ty("Ljava/lang/Object;");
let util = b.ty(UTIL);
let tag = b.field(MAIN, STRING, "TAG");
let count = b.field(MAIN, "I", "count");
let out = b.field("Ljava/lang/System;", "Ljava/io/PrintStream;", "out");
let super_init = b.method("Landroid/app/Activity;", "<init>", "V", &[]);
let super_create = b.method("Landroid/app/Activity;", "onCreate", "V", &["Landroid/os/Bundle;"]);
let init = b.method(MAIN, "<init>", "V", &[]);
let on_create = b.method(MAIN, "onCreate", "V", &["Landroid/os/Bundle;"]);
let run = b.method(MAIN, "run", "V", &[]);
let pick = b.method(MAIN, "pick", "I", &["I"]);
let log_s = b.method(UTIL, "log", "V", &[STRING]);
let log_i = b.method(UTIL, "log", "V", &["I"]);
let println = b.method("Ljava/io/PrintStream;", "println", "V", &[STRING]);
let hello = b.string(HELLO);
let main_src = b.string("MainActivity.java");
let util_src = b.string("Util.java");
let code = |registers, ins, outs, insns: Vec<u16>| Some(CodeSpec { registers, ins, outs, insns, tries: vec![] });
b.classes.push(ClassSpec {
class: main,
access: 0x1,
superclass: activity,
interfaces: vec![runnable],
source_file: main_src,
annotations: vec![deprecated],
static_fields: vec![(tag, 0x1a)],
instance_fields: vec![(count, 0x2)],
direct: vec![MethodSpec { method: init, access: 0x10001, code: code(1, 1, 1, vec![0x1070, super_init as u16, 0x0000, 0x000e]) }],
virtuals: vec![
MethodSpec {
method: on_create,
access: 0x1,
code: code(3, 2, 2, vec![0x001a, hello as u16, 0x1071, log_s as u16, 0x0000, 0x206f, super_create as u16, 0x0021, 0x000e]),
},
MethodSpec { method: run, access: 0x1, code: code(1, 1, 1, vec![0x7012, 0x1071, log_i as u16, 0x0000, 0x000e]) },
MethodSpec {
method: pick,
access: 0x1,
code: Some(CodeSpec {
registers: 3,
ins: 2,
outs: 0,
insns: vec![0x022b, 10, 0, 0x0012, 0x000f, 0x1012, 0x000f, 0x2012, 0x000f, 0x0000, 0x0100, 2, 1, 0, 5, 0, 7, 0],
tries: vec![TrySpec { start: 0, count: 3, handlers: vec![(rte, 3)], catch_all: Some(3) }],
}),
},
],
});
b.classes.push(ClassSpec {
class: util,
access: 0x11,
superclass: object,
source_file: util_src,
direct: vec![
MethodSpec { method: log_s, access: 0x9, code: code(2, 1, 2, vec![0x0062, out as u16, 0x206e, println as u16, 0x0010, 0x000e]) },
MethodSpec { method: log_i, access: 0x9, code: code(1, 1, 0, vec![0x000e]) },
],
..ClassSpec::default()
});
b.build()
}
}