fix bytes: comments missing on inner class fields; add int[] support

Author: nklapste

CLAUDE.md

@@ -26,7 +26,7 @@ JadxStringDecoderPlugin.init()
   → registers B64DeobfuscateOptions
   → registers B64DeobfuscatePass  (method-body Base64 string detection)
   → registers B64FieldInitPass    (field initializer Base64 detection)
-  → registers ByteArrayStringPass (byte[] field string detection)
+  → registers ByteArrayStringPass (byte[]/int[] field string detection)
 ```
 
 All three passes are skipped when `enable` is false.
@@ -49,7 +49,7 @@ Comments are added via `field.addCodeComment()` which renders on a separate line
 
 **`ByteArrayStringPass`** — runs `.after("ExtractFieldInit")`
 
-Looks for `byte[]` fields initialised with a `FilledNewArrayNode` of all literal bytes. If the bytes decode as valid UTF-8 with sufficient printable characters, adds a `bytes: "..."` comment on the field.
+Looks for `byte[]` and `int[]` fields initialised with a `FilledNewArrayNode` of all literal values. For `int[]`, any element outside `[0, 255]` (e.g. a `-1` sentinel in a decode table) causes the whole array to be skipped. The elements are then treated as bytes, decoded as UTF-8, and if the result is sufficiently printable a `bytes: "..."` comment is added on the field. `visit(ClassNode)` returns `true` so `DepthTraversal` recurses into inner classes.
 
 ### Detection logic (`B64Detector`)
 

README.md

@@ -6,7 +6,7 @@ A JADX plugin that detects likely encoded string constants during decompilation
 
 **Base64 string detection** — scans string constants in method bodies, and field initializers. When a string looks to be Base64 encoded, a `// b64: <decoded>` comment is added next to it.
 
-**Byte array string detection** — scans `byte[]` fields initialised with literal byte arrays. When the bytes decode as valid UTF-8 with sufficient printable characters, a `// bytes: "<string>"` comment is added.
+**Byte array string detection** — scans `byte[]` and `int[]` fields initialised with literal arrays. The values are treated as bytes and decoded as UTF-8; if the result has enough printable characters, a `// bytes: "<string>"` comment is added.
 
 ### Installation
 
@@ -37,4 +37,7 @@ void example() {
 
 // bytes: "Hello, World!"
 private static final byte[] MSG = {72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33};
+
+// bytes: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+private static final int[] BASE64_ENCODE_TABLE = {65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, ...};
 ```

build.gradle.kts

@@ -42,6 +42,10 @@ java {
     targetCompatibility = JavaVersion.VERSION_11
 }
 
+tasks.withType<JavaCompile> {
+    options.encoding = "UTF-8"
+}
+
 version = System.getenv("VERSION") ?: "dev"
 
 tasks {

src/main/java/jadx/plugins/stringdecoder/B64FieldInitPass.java

@@ -50,7 +50,7 @@ public boolean visit(ClassNode cls) {
 		for (FieldNode field : cls.getFields()) {
 			processField(field);
 		}
-		return false;
+		return true;
 	}
 
 	private void processField(FieldNode field) {

src/main/java/jadx/plugins/stringdecoder/ByteArrayStringPass.java

@@ -46,7 +46,7 @@ public boolean visit(ClassNode cls) {
 		for (FieldNode field : cls.getFields()) {
 			processField(field);
 		}
-		return false;
+		return true;
 	}
 
 	private void processField(FieldNode field) {
@@ -59,10 +59,15 @@ private void processField(FieldNode field) {
 			return;
 		}
 		FilledNewArrayNode filledArr = (FilledNewArrayNode) insn;
-		if (!ArgType.BYTE.equals(filledArr.getElemType())) {
+		ArgType elemType = filledArr.getElemType();
+		byte[] bytes;
+		if (ArgType.BYTE.equals(elemType)) {
+			bytes = extractLiteralBytes(filledArr);
+		} else if (ArgType.INT.equals(elemType)) {
+			bytes = extractIntAsAsciiBytes(filledArr);
+		} else {
 			return;
 		}
-		byte[] bytes = extractLiteralBytes(filledArr);
 		if (bytes == null || bytes.length == 0) {
 			return;
 		}
@@ -78,14 +83,30 @@ private static byte[] extractLiteralBytes(FilledNewArrayNode insn) {
 		for (int i = 0; i < count; i++) {
 			InsnArg arg = insn.getArg(i);
 			if (!(arg instanceof LiteralArg)) {
-				// Non-literal arg (e.g. SGET to a named constant) — skip this array
 				return null;
 			}
 			bytes[i] = (byte) ((LiteralArg) arg).getLiteral();
 		}
 		return bytes;
 	}
 
+	private static byte[] extractIntAsAsciiBytes(FilledNewArrayNode insn) {
+		int count = insn.getArgsCount();
+		byte[] bytes = new byte[count];
+		for (int i = 0; i < count; i++) {
+			InsnArg arg = insn.getArg(i);
+			if (!(arg instanceof LiteralArg)) {
+				return null;
+			}
+			long val = ((LiteralArg) arg).getLiteral();
+			if (val < 0 || val > 255) {
+				return null;
+			}
+			bytes[i] = (byte) val;
+		}
+		return bytes;
+	}
+
 	private String tryDecodeAsString(byte[] bytes) {
 		try {
 			CharsetDecoder utf8 = StandardCharsets.UTF_8.newDecoder()

src/test/java/jadx/plugins/stringdecoder/JadxStringDecoderPluginTest.java

@@ -201,6 +201,41 @@ public void byteArrayStringTest() throws Exception {
 		assertThat(code).contains("bytes: \"Hello, World!\"");
 	}
 
+	@Test
+	public void intArrayUtf8Test() throws Exception {
+		// int[] storing "café" as unsigned UTF-8 bytes {99, 97, 102, 195, 169}.
+		// Values 195 and 169 exceed signed byte range; byte[] would need negative literals, int[] avoids that.
+		String code = decompileSmali("bytes/int_array_utf8.smali");
+		System.out.println(code);
+		assertThat(code).contains("bytes: \"café\"");
+	}
+
+	@Test
+	public void twoByteArraysInClinitTest() throws Exception {
+		// Two byte[] fields initialised sequentially in <clinit> via new-array + fill-array-data.
+		// Mirrors the real-world Base64$Encoder pattern — both fields should get bytes: comments.
+		String code = decompileSmali("bytes/two_byte_arrays.smali");
+		System.out.println(code);
+		assertThat(code).contains("bytes: \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"");
+		assertThat(code).contains("bytes: \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\"");
+	}
+
+	@Test
+	public void byteArrayB64AlphabetTest() throws Exception {
+		// byte[] alphabet field — standard Base64 (+/)
+		String code = decompileSmali("bytes/b64_alphabet_byte_array.smali");
+		System.out.println(code);
+		assertThat(code).contains("bytes: \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"");
+	}
+
+	@Test
+	public void intArrayB64AlphabetTest() throws Exception {
+		// int[] alphabet field — URL-safe Base64 (-_); verifies int[] is treated identically to byte[]
+		String code = decompileSmali("bytes/b64_alphabet_byte_array.smali");
+		System.out.println(code);
+		assertThat(code).contains("bytes: \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\"");
+	}
+
 	@Test
 	public void multilineFieldB64Test() throws Exception {
 		// PEM-style line-wrapped Base64 string passed to Base64.decode — MIME decoder required
@@ -373,6 +408,16 @@ public void multiB64InvokeChainTest() throws Exception {
 		assertThat(code).contains("b64[1]: getPackageManager");
 	}
 
+	@Test
+	public void base64EncoderInnerClassTest() throws Exception {
+		// Synthetic inner class with two byte[] fields (standard and URL-safe Base64 alphabets)
+		// initialised sequentially in <clinit>. Verifies ByteArrayStringPass recurses into inner classes.
+		String code = decompileSmali("bytes/base64_encoder_inner_class.smali");
+		System.out.println(code);
+		assertThat(code).contains("bytes: \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\"");
+		assertThat(code).contains("bytes: \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\"");
+	}
+
 	@Test
 	public void byteArrayStringPassDisabledTest() throws Exception {
 		// with enableByteArrayStringPass=false the bytes: comment must not appear

src/test/resources/samples/bytes/b64_alphabet_byte_array.smali

@@ -0,0 +1,42 @@
+.class public Lbytes/B64Alphabets;
+.super Ljava/lang/Object;
+
+# Standard Base64 encode alphabet as byte[] — ABCDE...+/
+.field public static final alphabet:[B
+
+# URL-safe Base64 encode alphabet as int[] — ABCDE...-_
+# int[] is a common real-world pattern to avoid signed-byte confusion with high values.
+.field public static final alphabetUrlSafe:[I
+
+.method static constructor <clinit>()V
+    .registers 2
+
+    const/16 v0, 0x40
+    new-array v0, v0, [B
+    fill-array-data v0, :array_standard_bytes
+    sput-object v0, Lbytes/B64Alphabets;->alphabet:[B
+
+    const/16 v0, 0x40
+    new-array v0, v0, [I
+    fill-array-data v0, :array_urlsafe_ints
+    sput-object v0, Lbytes/B64Alphabets;->alphabetUrlSafe:[I
+
+    return-void
+
+    :array_standard_bytes
+    .array-data 1
+        65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
+        81 82 83 84 85 86 87 88 89 90 97 98 99 100 101 102
+        103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
+        119 120 121 122 48 49 50 51 52 53 54 55 56 57 43 47
+    .end array-data
+
+    :array_urlsafe_ints
+    .array-data 4
+        65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
+        81 82 83 84 85 86 87 88 89 90 97 98 99 100 101 102
+        103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
+        119 120 121 122 48 49 50 51 52 53 54 55 56 57 45 95
+    .end array-data
+
+.end method

src/test/resources/samples/bytes/base64_encoder_inner_class.smali

@@ -0,0 +1,90 @@
+# Synthetic test fixture — NOT taken from any APK.
+# Reproduces the inner-class byte[] field pattern:
+#   - static class inside an outer class (EnclosingClass + InnerClass annotations)
+#   - two byte[] fields (standard and URL-safe Base64 alphabets) initialised in <clinit>
+#   - a virtual method whose body is irrelevant to the test
+# Tests that ByteArrayStringPass recurses into inner classes (visit() returns true).
+.class Ltestdata/b64impl/Base64Impl$Encoder;
+.super Ltestdata/b64impl/Base64Impl$Coder;
+.source "Base64Impl.java"
+
+# annotations
+.annotation system Ldalvik/annotation/EnclosingClass;
+    value = Ltestdata/b64impl/Base64Impl;
+.end annotation
+
+.annotation system Ldalvik/annotation/InnerClass;
+    accessFlags = 0x8
+    name = "Encoder"
+.end annotation
+
+
+# static fields
+.field private static final k:[B
+
+.field private static final l:[B
+
+
+# instance fields
+.field public final useUrlSafe:Z
+
+
+# direct methods
+.method static constructor <clinit>()V
+    .registers 2
+
+    const/16 v0, 0x40
+
+    new-array v1, v0, [B
+    fill-array-data v1, :array_standard
+    sput-object v1, Ltestdata/b64impl/Base64Impl$Encoder;->k:[B
+
+    new-array v0, v0, [B
+    fill-array-data v0, :array_urlsafe
+    sput-object v0, Ltestdata/b64impl/Base64Impl$Encoder;->l:[B
+
+    return-void
+
+    nop
+
+    :array_standard
+    .array-data 1
+        0x41t 0x42t 0x43t 0x44t 0x45t 0x46t 0x47t 0x48t
+        0x49t 0x4at 0x4bt 0x4ct 0x4dt 0x4et 0x4ft 0x50t
+        0x51t 0x52t 0x53t 0x54t 0x55t 0x56t 0x57t 0x58t
+        0x59t 0x5at 0x61t 0x62t 0x63t 0x64t 0x65t 0x66t
+        0x67t 0x68t 0x69t 0x6at 0x6bt 0x6ct 0x6dt 0x6et
+        0x6ft 0x70t 0x71t 0x72t 0x73t 0x74t 0x75t 0x76t
+        0x77t 0x78t 0x79t 0x7at 0x30t 0x31t 0x32t 0x33t
+        0x34t 0x35t 0x36t 0x37t 0x38t 0x39t 0x2bt 0x2ft
+    .end array-data
+
+    :array_urlsafe
+    .array-data 1
+        0x41t 0x42t 0x43t 0x44t 0x45t 0x46t 0x47t 0x48t
+        0x49t 0x4at 0x4bt 0x4ct 0x4dt 0x4et 0x4ft 0x50t
+        0x51t 0x52t 0x53t 0x54t 0x55t 0x56t 0x57t 0x58t
+        0x59t 0x5at 0x61t 0x62t 0x63t 0x64t 0x65t 0x66t
+        0x67t 0x68t 0x69t 0x6at 0x6bt 0x6ct 0x6dt 0x6et
+        0x6ft 0x70t 0x71t 0x72t 0x73t 0x74t 0x75t 0x76t
+        0x77t 0x78t 0x79t 0x7at 0x30t 0x31t 0x32t 0x33t
+        0x34t 0x35t 0x36t 0x37t 0x38t 0x39t 0x2dt 0x5ft
+    .end array-data
+.end method
+
+.method public constructor <init>(Z)V
+    .registers 2
+
+    invoke-direct {p0}, Ltestdata/b64impl/Base64Impl$Coder;-><init>()V
+    iput-boolean p1, p0, Ltestdata/b64impl/Base64Impl$Encoder;->useUrlSafe:Z
+    return-void
+.end method
+
+
+# virtual methods
+.method public encode([B)[B
+    .registers 2
+
+    const/4 v0, 0x0
+    return-object v0
+.end method

src/test/resources/samples/bytes/int_array_utf8.smali

@@ -0,0 +1,21 @@
+.class public Lbytes/IntArrayUtf8;
+.super Ljava/lang/Object;
+
+# int[] storing "café" as unsigned UTF-8 bytes — values 195 and 169 exceed signed byte range
+.field public static final MSG:[I
+
+.method static constructor <clinit>()V
+    .registers 2
+
+    const/4 v0, 0x5
+    new-array v0, v0, [I
+    fill-array-data v0, :array_cafe
+    sput-object v0, Lbytes/IntArrayUtf8;->MSG:[I
+    return-void
+
+    :array_cafe
+    .array-data 4
+        99 97 102 195 169
+    .end array-data
+
+.end method

src/test/resources/samples/bytes/two_byte_arrays.smali

@@ -0,0 +1,48 @@
+.class public Lbytes/TwoByteArrays;
+.super Ljava/lang/Object;
+
+# Two byte[] encode-table fields initialized sequentially in <clinit>.
+# Mirrors the real-world pattern in Base64$Encoder (k and l fields).
+.field private static final k:[B
+
+.field private static final l:[B
+
+.method static constructor <clinit>()V
+    .registers 2
+
+    const/16 v0, 0x40
+    new-array v1, v0, [B
+    fill-array-data v1, :array_standard
+    sput-object v1, Lbytes/TwoByteArrays;->k:[B
+
+    new-array v0, v0, [B
+    fill-array-data v0, :array_urlsafe
+    sput-object v0, Lbytes/TwoByteArrays;->l:[B
+
+    return-void
+
+    :array_standard
+    .array-data 1
+        0x41t 0x42t 0x43t 0x44t 0x45t 0x46t 0x47t 0x48t
+        0x49t 0x4at 0x4bt 0x4ct 0x4dt 0x4et 0x4ft 0x50t
+        0x51t 0x52t 0x53t 0x54t 0x55t 0x56t 0x57t 0x58t
+        0x59t 0x5at 0x61t 0x62t 0x63t 0x64t 0x65t 0x66t
+        0x67t 0x68t 0x69t 0x6at 0x6bt 0x6ct 0x6dt 0x6et
+        0x6ft 0x70t 0x71t 0x72t 0x73t 0x74t 0x75t 0x76t
+        0x77t 0x78t 0x79t 0x7at 0x30t 0x31t 0x32t 0x33t
+        0x34t 0x35t 0x36t 0x37t 0x38t 0x39t 0x2bt 0x2ft
+    .end array-data
+
+    :array_urlsafe
+    .array-data 1
+        0x41t 0x42t 0x43t 0x44t 0x45t 0x46t 0x47t 0x48t
+        0x49t 0x4at 0x4bt 0x4ct 0x4dt 0x4et 0x4ft 0x50t
+        0x51t 0x52t 0x53t 0x54t 0x55t 0x56t 0x57t 0x58t
+        0x59t 0x5at 0x61t 0x62t 0x63t 0x64t 0x65t 0x66t
+        0x67t 0x68t 0x69t 0x6at 0x6bt 0x6ct 0x6dt 0x6et
+        0x6ft 0x70t 0x71t 0x72t 0x73t 0x74t 0x75t 0x76t
+        0x77t 0x78t 0x79t 0x7at 0x30t 0x31t 0x32t 0x33t
+        0x34t 0x35t 0x36t 0x37t 0x38t 0x39t 0x2dt 0x5ft
+    .end array-data
+
+.end method