为什么混淆器不混淆方法体？

Question

我正在使用 ProGuard 混淆我的 .jar 程序。一切正常，除了 ProGuard 不会混淆方法主体中的局部变量。这是一个例子：

原始：

混淆：

以黄色突出显示的变量名应该被混淆，但实际上没有。我怎样才能混淆它们（使它们重命名为 a、b、c 等 ？）

这是我的 ProGuard 配置：http://pastebin.com/sb3DMRcC（上述方法并非来自排除的类之一）。

Answer 1

Why proguard does not obfuscate method body?

因为不能。
编译时根本不存储方法参数和局部变量的名称。
您看到的名称是由您的反编译器生成的。

对于编译后的代码，有两种方法可以将数据存储在本地（即在一个方法中）：

在操作数栈上
在局部变量中

操作数栈实际上只是一个栈。
请参阅堆栈运算符的 Java VM 规范中的 Table 7.2。
您可以弹出值 (pop)、复制顶部值 (dup)、交换顶部两个值 (swap) 以及稍作改变的行为 (pop2, dup_x1、dup_x2、dup2、dup2_x1、dup2_x2).
大多数（如果不是全部）产生 return 值的指令会将所述值放入堆栈。

这个问题的重点是如何引用堆栈中的内容，这与任何其他堆栈一样：
相对于顶部位置，并基于使用的指令。
没有分配的号码或名称，它只是当前存在的任何内容。

现在，对于所谓的"local variables"：

将它们视为 ArrayList 而不是 Java 中的变量。
因为这正是您访问它们的方式：按索引。
对于变量 0 到 3，有特殊指令（即单字节），因为它们经常使用，所有其他变量只能通过双字节指令访问，其中第二个字节是索引。
再看Table 7.2，"Loads"和"Stores"。
两个表中的前五个条目是每种数据类型的宽（双字节）store/load 指令（请注意，对于单个值，boolean、char、byte和short都转换为int，只留下int、float和Object作为单槽值，long和double作为双槽），后面20条指令是直接访问寄存器0到3的指令，最后8条指令是访问数组索引（注意数组里面，boolean，byte、char和short是不转为int，为了不浪费space，所以多了三个指令（不是四个，因为 byte 和 char 具有相同的大小）。

最大堆栈大小和局部变量的数量都是有限制的，必须在每个方法的Code属性的头部给出，定义在Section 4.7.3(max_stack 和 max_locals).

不过，关于局部变量的有趣之处在于它们兼作方法参数，这意味着局部变量的数量永远不会低于方法参数的数量。
请注意，在计算 Java VM 的值时，long 和 double 类型的变量被视为两个值，因此需要两个 "slots"。
另请注意，对于非静态方法，参数 0 将是 this，它本身需要另一个 "slot"。

话虽如此，让我们看一些代码！

示例：

class Test
{
    public static void main(String[] myArgs) throws NumberFormatException
    {
        String myString = "42";
        int myInt = Integer.parseInt(myString);
        double myDouble = (double)myInt * 42.0d;
        System.out.println(myDouble);
    }
}

这里我们有三个局部变量myString、myInt和myDouble，加上一个参数myArgs.
另外，我们还有两个常量"42"和42.0d，还有很多外部引用：

java.lang.String[] - class
java.lang.NumberFormatException - class
java.lang.String - class
java.lang.Integer.parseInt - 方法
java.lang.System.out - 字段
java.io.PrintStream.println - 方法

还有一些导出：Test 和 main，加上编译器将为我们生成的默认构造函数。

所有常量、引用和导出都将导出到 Constant Pool - 局部变量和参数名称不会。

编译和反汇编 class（使用 javap -c Test）产生：

Compiled from "Test.java"
class Test {
  Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]) throws java.lang.NumberFormatException;
    Code:
       0: ldc           #2                  // String 42
       2: astore_1
       3: aload_1
       4: invokestatic  #3                  // Method java/lang/Integer.parseInt:(Ljava/lang/String;)I
       7: istore_2
       8: iload_2
       9: i2d
      10: ldc2_w        #4                  // double 42.0d
      13: dmul
      14: dstore_3
      15: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
      18: dload_3
      19: invokevirtual #7                  // Method java/io/PrintStream.println:(D)V
      22: return
}

除了默认的构造函数，我们可以看到我们的main方法，一步一步。
请注意如何使用 astore_1 和 aload_1 访问 myString，如何使用 istore_2 和 iload_2 访问 myInt，以及如何使用 [=70] 访问 myDouble =] 和 dload_3.
myArgs 未在任何地方访问，因此也没有字节码处理它，但在方法的开头，对 String 数组的引用将位于局部变量 1 中，它很快就会被对 [ 的引用覆盖=51=].

如果您将

javap 传递给 -v 标志，

javap 也会向您显示常量池，但它并没有真正为输出添加任何值，因为所有相关信息都来自常量池无论如何都会显示在评论中。

但是现在，让我们看看反编译器产生了什么！

JD-GUI 0.3.5 (JD-Core 0.6.2):

import java.io.PrintStream;

class Test
{
  public static void main(String[] paramArrayOfString)
    throws NumberFormatException
  {
    String str = "42";
    int i = Integer.parseInt(str);
    double d = i * 42.0D;
    System.out.println(d);
  }
}

南河三 0.5.28:

class Test
{
    public static void main(final String[] array) throws NumberFormatException {
        System.out.println(Integer.parseInt("42") * 42.0);
    }
}

请注意导出到常量池的所有内容如何保留，而 JD-GUI 只是为局部变量选择一些名称，而 Procyon 将它们完全优化掉。
参数的名称 - paramArrayOfString vs array（与原始 myArgs 相比） - 是一个完美的例子，表明不再有 "correct" 名称，并且反编译器只需要依赖于选择名称的某种模式。

我不知道你的反编译代码中的 "true" 名称是从哪里来的，但我很确定它们不包含在 jar 文件中。
也许是您的 IDE 特征？

为什么混淆器不混淆方法体？

Why proguard does not obfuscate method body?

java

variables

obfuscation

jvm

proguard