Cifrado de cadenas

Por qué importa

Java compilado conserva cada literal en claro dentro del pool de constantes. Un mensaje de licencia, un endpoint, un permiso o un error están a un solo strings comando de distancia, y cada uno señala el código que lo rodea. Cifrarlos no solo oculta el texto: elimina el mapa que utiliza un atacante para orientarse.

Se activa con un único campo en techniques:

{ "techniques": { "stringEncryption": "POOL" } }

Todos los ejemplos siguientes son salida real del motor — un método pequeño cifrado con cada modo y después descompilado de nuevo a Java con una herramienta estándar, para que veas exactamente lo que se distribuye. Este es el original:

public String tier(int n) {
    if (n >= 500) {
        return "gold";
    }
    return "standard";
}

Los cuatro modos

stringEncryption admite cuatro valores. Se diferencian por el lugar donde donde residen los datos cifrados y la rutina de descifrado; eso determina lo difícil que resulta interceptarlos o extraerlos:

Los tres modos cifrados comparten una propiedad: la clave deriva de la runtime caller (see callerBinding); por eso, copiar una cadena cifrada y su llamada a otra clase produce basura al descifrarla. No existe una única rutina que permita «descifrarlo todo».

PER_METHOD

El literal desaparece y lo sustituye una llamada a un método de descifrado generado (Sample.a aquí) que recibe el texto cifrado y parámetros propios de cada cadena. El texto legible desaparece del pool de constantes; queda una carga opaca de caracteres mostrada como \uXXXX escapes. Usa el show characters selector del bloque para alternar entre los escapes y los glifos sin procesar:

public String tier(int n) {
    if (n >= 500) {
        return "gold";
    }
    return "standard";
}

public String tier(int n) {
    if (n >= 500) {
        return Sample.a("_", "\u23e4\u23e5\u23fd\u23fc", 9, 2, 6);
    }
    return Sample.a("_", "\u2300\u230d\u2306\u2303\u233f\u2320\u233d\u2351", 10, 6, 29);
}

INLINE

No existe ningún método auxiliar: el descifrado —una secuencia XOR propia de cada cadena— se escribe directamente en el método. No hay una rutina compartida que interceptar y cada punto de uso es diferente. Las cadenas en claro "gold" and "standard" are nowhere to be found:

public String tier(int n) {
    if (n >= 500) {
        return "gold";
    }
    return "standard";
}

public String tier(int n) {
    if (n >= 500) {
        char[] cArray = "\u2787\u2785\u2799\u279b".toCharArray();
        int n2 = cArray.length * 29;
        for (int i = 0; i < cArray.length; ++i) {
            int n3 = i;
            cArray[n3] = (char)(cArray[n3] ^ (18208 + 1653 ^ 0x6A01 ^ i * 10 ^ i >> 1 ^ n2));
        }
        return new String(cArray);
    }
    char[] cArray = "\u2ba8\u2ba7\u2baa\u2bad\u2b9f\u2b92\u2b99\u2b87".toCharArray();
    int n4 = cArray.length * 26;
    for (int i = 0; i < cArray.length; ++i) {
        int n5 = i;
        cArray[n5] = (char)(cArray[n5] ^ (12523 + 9927 ^ 0x7CB9 ^ i * 8 ^ i >> 6 ^ n4));
    }
    return new String(cArray);
}

POOL

La opción más fuerte en tamaño y separación: los literales salen por completo de la clase y pasan a un pool compartido (ab aquí), desde donde se recuperan por índice. El método no conserva datos de texto, solo una llamada de acceso:

public String tier(int n) {
    if (n >= 500) {
        return "gold";
    }
    return "standard";
}

public String tier(int n) {
    if (n >= 500) {
        return ab.ba("x", 0);
    }
    return ab.aa("x", 0);
}

También funciona con concatenaciones. Aquí, un saludo formado por dos literales y una variable: los literales se convierten en dos consultas al pool y solo permanece la variable recibida:

public String welcome(String string) {
    String string2 = string;
    return (String)((Object)ab.aa("x", 2)) + string2 + (String)((Object)ab.ab("x", 2));
}

Opciones

Los valores predeterminados sirven para casi todos los casos; estas opciones ajustan el comportamiento del descifrador:

Excluir clases del cifrado de cadenas

El cifrado de cadenas se aplica a todas las clases. Para conservar algunos literales legibles —una versión que busca otra herramienta o textos que un framework compara por valor— añade esas clases a stringEncryptionExclude. Esas clases siguen renombrándose y ofuscando su flujo; solo se desactiva su cifrado de cadenas.

La lista admite clases y paquetes combinados libremente, sin límite práctico. Cada entrada es un internal name: a bare name (com/you/Version) coincide con esa clase y sus clases internas; una barra final (com/you/messages/) coincide con todo el árbol del paquete. Puedes combinar varios paquetes y clases individuales:

{
  "techniques": {
    "stringEncryption": "POOL",
    "rename": true,
    "stringEncryptionExclude": [
      "com/you/Version",
      "com/you/messages/",
      "com/you/templates/"
    ]
  }
}