¿Ofuscas tu código comercial Java? [cerrado]

Creo que la antigua (clásica) forma de ofuscación está perdiendo gradualmente su relevancia. Porque en la mayoría de los casos un ofuscadores clásicos romper un rastro de pila (no es bueno para apoyar a sus clientes)

Hoy en día el punto principal para no proteger algunos algoritmos, sino para proteger un datos sensibles: API inicios de sesión/contraseñas/claves, código que responsable de la concesión de licencias (piratería todavía aquí, especialmente Europa Occidental, Rusia, Asia, IMHO), ID de cuenta de publicidad, etc.

Interesante hecho: tenemos todos estos datos confidenciales en cadenas. En realidad, las cadenas son alrededor del 50-80% de la lógica de nuestras aplicaciones. Me parece que el futuro de la ofuscación son las "herramientas de cifrado de cadenas".

Pero ahora la función "Cifrado de cadenas" solo está disponible en ofuscadores comerciales, como: Allatori, Zelix KlassMaster, Cortina de humo, Kit de Herramientas de Ofuscación de Stringer Java, DashO .

N.b. Soy CEO de Licel LLC. Desarrollador de Stringer Java Ofuscador.

Uso proguard para el desarrollo de JavaME. No solo es muy bueno para hacer archivos jar más pequeños (Esencial para móviles), sino que es útil como una forma más agradable de hacer código específico del dispositivo sin recurrir a herramientas de preprocesamiento IDE-hostiles como antenna.

Por ejemplo

public void doSomething()
{
    /* Generated config class containing static finals: */
    if (Configuration.ISMOTOROLA)
    {
        System.out.println("This is a motorola phone");
    }
    else
    {
        System.out.println("This is not a motorola phone");
    }
}

Esto se compila, se ofusca, y el archivo de clase termina como si hubiera escrito:

public void doSomething()
{
    System.out.println("This is a motorola phone");
}

Así que puede tener variantes de código para evitar errores del fabricante en implementaciones de JVM / bibliotecas sin abultar los archivos de clase ejecutables finales.

Creo que algunos ofuscadores comerciales también pueden combinar archivos de clase juntos en ciertos casos. Esto es útil porque cuantas más clases tenga, mayor será el tamaño de sobrecarga que tenga en el archivo zip (jar).

Pasé algún tiempo este año probando varios ofuscadores Java, y encontré uno que está millas por delante del resto: JBCO. Desafortunadamente, es un poco engorroso de configurar y no tiene GUI, pero en términos del nivel de ofuscación que produce, no tiene paralelo. Intenta alimentarlo con un bucle simple, y si tu descompilador no falla al intentar cargarlo, verás algo como esto:

    if(i < ll1) goto _L6; else goto _L5
_L5:
    char ac[] = run(stop(lI1l));
    l7 = (long)ac.length << 32 & 0xffffffff00000000L ^ l7 & 0xffffffffL;
    if((int)((l7 & 0xffffffff00000000L) >> 32) != $5$)
    {
        l = (long)III << 50 & 0x4000000000000L ^ l & 0xfffbffffffffffffL;
    } else
    {
        for(l3 = (long)III & 0xffffffffL ^ l3 & 0xffffffff00000000L; (int)(l3 & 0xffffffffL) < ll1; l3 = (long)(S$$ + (int)(l3 & 0xffffffffL)) ^ l3 & 0xffffffff00000000L)
        {
            for(int j = III; j < ll1; j++)
            {
                l2 = (long)actionevent[j][(int)(l3 & 0xffffffffL)] & 65535L ^ l2 & 0xffffffffffff0000L;
                l6 = (long)(j << -351) & 0xffffffffL ^ l6 & 0xffffffff00000000L;
                l1 = (long)((int)(l6 & 0xffffffffL) + j) & 0xffffffffL ^ l1 & 0xffffffff00000000L;
                l = (long)((int)(l1 & 0xffffffffL) + (int)(l3 & 0xffffffffL)) << 16 & 0xffffffff0000L ^ l & 0xffff00000000ffffL;
                l = (long)ac[(int)((l & 0xffffffff0000L) >> 16)] & 65535L ^ l & 0xffffffffffff0000L;
                if((char)(int)(l2 & 65535L) != (char)(int)(l & 65535L))
                {
                    l = (long)III << 50 & 0x4000000000000L ^ l & 0xfffbffffffffffffL;
                }
            }

        }

    }

¿No sabías que Java tenía goto? Bueno, la JVM los soporta=)

Uso ProGuard y lo recomiendo encarecidamente. Si bien la ofuscación protege su código de atacantes ocasionales, su principal beneficio es el efecto de minimizar la eliminación de clases y métodos no utilizados y acortar todos los identificadores a 1 o 2 caracteres.

Creo que la mayor parte de la ofuscación no tiene sentido: incluso con el código fuente completo, generalmente es bastante difícil averiguar cuál era la intención (suponiendo que no haya comentarios ni nombres significativos para las variables locales which que es el caso cuando se vuelven a generar fuentes a partir de código de bytes). La ofuscación solo decora el pastel.

Creo que los desarrolladores y especialmente sus gerentes tienden a exagerar mucho el riesgo de que alguien vea el código fuente. Mientras que los buenos descompiladores pueden producir código fuente de aspecto agradable, no es trivial trabajar con él, y los costos asociados (por no mencionar los riesgos legales) son lo suficientemente altos como para que este enfoque rara vez sea útil. Solo he descompilado para depurar problemas con productos de proveedores de código cerrado (bloqueos en la capa de abstracción de BD, ugh). El Bytecode estaba en realidad ofuscado, creo, pero sin embargo encontramos el problema subyacente was era un problema de diseño real.

Supongo que realmente se reduce a para qué sirve su código Java, cómo se distribuye y quiénes son sus clientes. No ofuscamos nada, ya que nunca hemos encontrado uno que fuera particularmente bueno y tiende a ser más problemático de lo que vale. Si alguien tiene acceso a nuestros archivos JAR y tiene el conocimiento para poder husmear dentro de ellos, entonces hay cosas mucho más preocupantes que pueden hacer que robar nuestro código fuente.