Obfussez-vous votre code Java commercial?

Question

Je me demande si quelqu'un utilise commercial/java gratuit obfuscators sur son propre produit commercial. Je sais que sur un projet qui avait effectivement un brouillage étape dans la fourmi étape de génération de rejets.

Avez-vous embrouiller? Et si oui, pourquoi avez-vous embrouiller?

Est-il vraiment un moyen de protéger le code ou est-ce juste une meilleure sensation pour les développeurs et gestionnaires?

edit: Ok, j'ai pour être exact au sujet de mon point de vue: Ne vous embrouiller pour protéger votre propriété intellectuelle (algorithmes, le travail que vous avez mis dans votre produit)? Je ne vais pas embrouiller pour des raisons de sécurité, qui ne se sent pas le droit. Donc je ne parle que de la protection de vos applications code contre les concurrents.

@staffan a un bon point:

La raison de rester loin de chaînage de flux de code, c'est que certains de ces changements, il est impossible pour la JVM pour optimiser le code. En effet, il se dégradera les performances de votre application.

Answer 1

Si vous ne obscurcir, rester à l'écart de obfuscators que de modifier le code en changeant le code de débit et/ou en ajoutant des blocs d'exception et de tel pour rendre plus difficile à démonter. Pour rendre le code illisible, il est généralement suffisant de simplement changer tous les noms de méthodes, les champs et les classes.

La raison de rester loin de l'évolution des flux de code, c'est que certains de ces changements, il est impossible pour la JVM pour optimiser le code. En effet, il se dégradera les performances de votre application.

Answer 2

Je pense que l'ancien (classique) de la dissimulation est en train de perdre de sa pertinence. Parce que dans la plupart des cas, un classique obfuscators casser une trace de la pile (il n'est pas bon pour l'accompagnement de vos clients)

Aujourd'hui, le principal point à ne pas protéger certains algorithmes, mais pour protéger les données sensibles: API logins/mots de passe/les clés, code responsable de l'octroi de licences (le piratage reste ici, en particulier en Europe Occidentale, en Russie, en Asie, à mon humble avis), annonce les Identifiants de comptes, etc.

Fait intéressant: nous avons toutes les données sensibles dans des Chaînes. En fait des Chaînes est d'environ 50 à 80% de la logique de nos applications. Il me semble que l'avenir de l'obfuscation est "String outils de chiffrement".

Mais maintenant, "le cryptage des chaînes" fonctionnalité est disponible uniquement dans commercial obfuscators, tels que: Allatori, Zelix KlassMaster, écran de fumée, Stringer Java de la Dissimulation de l'Toolkit, DashO.

N. B. Je suis chef de la direction à Licel LLC. Développeur de Stringer Java Obfuscator.

Answer 3

J'utilise proguard pour JavaME développement. Ce n'est pas seulement très très bon à faire de jar fichiers plus petits (Essentiel pour le mobile), mais il est utile comme une jolie manière de faire propre à l'appareil de code sans avoir recours à l'IDE de convivialité prétraitement des outils comme antenne.

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

Ce sera compilé, occulté, et le fichier de classe se termine comme si vous aviez écrit:

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

Vous pouvez donc avoir des variantes de code pour contourner fabricant de bugs dans la JVM/bibliothèque implémentations sans groupage l'exécutable final des fichiers de classe.

Je crois que certains commerciaux obfuscators pouvez également fusionner des fichiers de classe ensemble dans certains cas. Ceci est utile parce que les classes plus que vous avez, plus la taille de frais généraux que vous avez dans le zip jar fichier.

Answer 4

J'utilise ProGuard et le recommande vivement. Bien que l'obscurcissement protège votre code contre les attaquants occasionnels, son principal avantage est de minimiser l'effet de suppression des classes et méthodes inutilisées et de raccourcir tous les identificateurs à 1 ou 2 caractères.

Answer 5

J'ai passé un peu de temps cette année à essayer différents Java obfuscators, et j'en ai trouvé un à miles d'avance sur le reste: JBCO. C'est malheureusement un peu lourd à mettre en place, et n'a pas d'interface graphique, mais en termes de niveau de dissimulation qu'il produit, il est incomparable. Vous essayez de nourrir une simple boucle, et si votre decompiler ne crash pas essayer de le charger, vous verrez quelque chose comme ceci:

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

        }

    }

Vous ne saviez pas Java avait goto? Eh bien, la machine prend en charge eux =)