¿Ofuscar tu código de Java?[cerrado]

StackOverflow https://stackoverflow.com/questions/12088

  •  08-06-2019
  •  | 
  •  

Pregunta

Me pregunto si alguien utiliza comercial/java gratis obfuscators en su propio producto comercial.Sé que sólo alrededor de un proyecto que en realidad había una ofuscación de paso en el hormiguero el paso de generación de versiones.

¿Ofuscar?Y si es así, ¿por qué ocultar?

Es realmente una forma de proteger el código, o es sólo una sensación mejor para los desarrolladores y gerentes?

editar: Ok, yo para ser exactos acerca de mi punto:¿Ofuscar para proteger tu IP (la de los algoritmos, el trabajo que has puesto en tu producto)?No voy a ocultar por razones de seguridad, que no se siente bien.Así que sólo estoy hablando de la protección de su código de aplicaciones en contra de los competidores.

@staffan tiene un buen punto:

La razón para permanecer lejos de encadenamiento de flujo de código es que algunos de esos cambios hace que sea imposible para la JVM de manera eficiente optimizar el código.En efecto, lo que realmente le degradar el rendimiento de su aplicación.

¿Fue útil?

Solución

Si no ofuscar, manténgase alejado de obfuscators que modificar el código, cambiando el código de flujo y/o la adición de bloques de excepción y tal que hacen que sea difícil para desmontarlo.Para hacer que el código ilegible es generalmente suficiente con sólo cambiar todos los nombres de los métodos, campos y clases.

La razón para permanecer lejos de cambiar el código de flujo es que algunos de esos cambios hace que sea imposible para la JVM de manera eficiente optimizar el código.En efecto, lo que realmente le degradar el rendimiento de su aplicación.

Otros consejos

Creo que el viejo (clásica) de la ofuscación está perdiendo progresivamente su importancia.Porque en la mayoría de los casos, un clásico obfuscators romper un seguimiento de pila (no es bueno para apoyar a sus clientes)

Hoy en día el principal punto de no proteger a algunos de los algoritmos, pero para proteger datos sensibles:La API de inicios de sesión y contraseñas/claves, código responsable de la concesión de licencias (piratería todavía aquí, especialmente Europa Occidental, Rusia, Asia, en mi humilde opinión), anuncio Id de cuenta, etc.

Hecho interesante:tenemos todos estos datos sensibles en las Cadenas.Cadenas de caracteres en realidad es de alrededor de 50% a 80% de la lógica de nuestras aplicaciones.A mí me parece que el futuro de la ofuscación es "Cadena de herramientas de cifrado".

Pero ahora la Cadena de cifrado" característica sólo está disponible en comercial obfuscators, tales como: Allatori, Zelix KlassMaster, Cortina de humo, Stringer Java Kit De Herramientas De Ofuscación, DashO.

N. B.Soy CEO en Licel LLC.Desarrollador de Stringer Java Obfuscator.

Yo uso proguard para JavaME desarrollo.No sólo es muy muy bueno en lo que jar el tamaño de los archivos (Esencial para el móvil), pero es útil como una manera mejor de hacer de dispositivos específicos de código sin tener que recurrir a IDE-hostiles preprocesamiento de herramientas tales como el de la antena.

E. g.

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");
    }
}

Este se compila, ofuscado, y la clase de archivo que termina como si los hubiera escrito:

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

Así que usted puede tener variantes de código para evitar fabricante errores en la JVM/biblioteca implementaciones sin abultar el ejecutable final de la clase de archivos.

Creo que algunos comercial obfuscators también puede combinar archivos de clase juntos en ciertos casos.Esto es útil porque las clases más tenga, más grande es el tamaño de la sobrecarga que tienes en el zip (jar) de archivo.

Pasé algún momento de este año a probar Java obfuscators, y he encontrado uno para estar a millas por delante del resto: JBCO.Es, desafortunadamente, un poco engorroso de configurar, y no tiene interfaz de usuario, pero en términos del nivel de ofuscación que produce, es incomparable.Intenta de alimentación es un circuito simple, y si su decompiler no se cae tratando de carga, 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;
                }
            }

        }

    }

Usted no sabe de Java había goto es?Así, la JVM admite ellos =)

Yo uso ProGuard y lo recomiendo.Mientras ofuscación protege su código de casual atacantes, su principal beneficio es el de minimizar el efecto de quitar sin usar clases y métodos y el acortamiento de todos los identificadores para 1 o 2 caracteres.

Creo que la mayor parte de la ofuscación es inútil:incluso con el código fuente completo es generalmente bastante difícil de averiguar qué diablos intención era (asumiendo que no hay comentarios, y no nombres significativos para las variables locales, lo cual es el caso cuando la re-generación de fuentes de código de bytes).Ofuscación sólo decora el pastel.

Creo que los desarrolladores y sus directivos tienden a mucho exagerar el riesgo de ver a alguien y ver el código fuente.Mientras que la buena descompiladores puede producir agradable mirando el código fuente, no es trivial para trabajar con él, y los costos asociados (por no hablar de los riesgos legales) son lo suficientemente altas como para hacer que este enfoque rara vez útil.Sólo he descompilados para depurar problemas con el cierre de fuente de vendedores de productos (interbloqueos en la base de datos de la capa de abstracción, ugh).Bytecode era realmente confuso, creo, pero no obstante, nos encontró el problema de fondo, era un verdadero problema de diseño.

Supongo que se trata de ¿ el código Java se para, cómo se distribuye y que tus clientes están.Nosotros no borramos nada, ya que nunca hemos encontrado uno que era especialmente bueno y tiende a ser más problemas de lo que vale.Si alguien tiene acceso a nuestros archivos JAR y tiene el conocimiento para poder curiosear en el interior de ellos, entonces no hay mucho más preocupante cosas que pueden hacer que grabe fuera de nuestro código fuente.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top