Обфусцируете ли вы свой коммерческий Java-код?

Если вы делаете обфускацию, держитесь подальше от обфускаторов, которые модифицируют код, изменяя поток кода и/или добавляя блоки исключений и тому подобное, чтобы затруднить его разборку. Чтобы сделать код нечитаемым, обычно достаточно просто изменить все имена методов, полей и классов.

Причина, по которой следует воздерживаться от изменения потока кода, заключается в том, что некоторые из этих изменений делают невозможной эффективную оптимизацию кода для JVM. По сути, это приведет к снижению производительности вашего приложения.

Я думаю, что старый (классический) способ путаницы постепенно теряет свою уместность. Поскольку в большинстве случаев классический obfuscators ломка трассировки стека (это не хорошо для поддержки Ваши клиенты),

В наше время основной момент, чтобы не защитить некоторые алгоритмы, но защитить конфиденциальные данные: логины/пароли/ключи API, кодекс, который ответственный за лицензирование (пиратство все еще здесь, особенно Западная Европа, Россия, Азия, по моему скромному мнению), ID счета рекламы, и т.д.

Интересный факт: у нас есть все эти конфиденциальные данные в Последовательностях. На самом деле Последовательности составляют приблизительно 50-80% логики наших заявлений. Мне кажется, что будущее путаницы - " шифрование Последовательности tools".

Но теперь " Последовательность encryption" особенность доступна только в коммерческом obfuscators, такова как: < href =" http://www.allatori.com/" > Allatori < href =" http://www.zelix.com/klassmaster/index.html" > Zelix KlassMaster < href =" http://www.leesw.com/smokescreen/" > Smokescreen < href =" https://jfxstore.com/stringer" > Стрингер Явская Путаница Toolkit < href =" http://www.preemptive.com/" > DashO.

N.B. I' m генеральный директор в Licel LLC. Разработчик Стрингера Ява Obfuscator.

Я использую proguard для разработки JavaME. Он не только очень хорош в уменьшении размера jar-файлов (что очень важно для мобильных устройств), но и полезен как более приятный способ выполнения кода, специфичного для конкретного устройства, не прибегая к недружественным для IDE инструментам предварительной обработки, таким как antenna.

Например.

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

Это будет скомпилировано, обфусцировано, и файл класса будет выглядеть так, как будто его написали вы:

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

Таким образом, вы можете иметь варианты кода для работы над ошибками производителей в реализациях JVM/библиотек без увеличения объема конечных исполняемых файлов классов.

Я полагаю, что некоторые коммерческие обфускаторы также могут объединять файлы классов вместе в определенных случаях. Это полезно, потому что чем больше классов, тем больше накладные расходы на размер zip (jar) файла.

Я провел некоторое время в этом году, испытывая различную Яву obfuscators, и я нашел, что был милями перед остальными: JBCO. It' s, к сожалению, немного тяжелый, чтобы настроить, и не имеет никакого графический интерфейса пользователя, но с точки зрения уровня путаницы это производит, это беспрецедентно. Вы пытаетесь кормить его простой петлей, и если Ваш детранслятор doesn' t катастрофа, пытающаяся загрузить это, Вы будете видеть что-то вроде этого:

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

        }

    }

Вы didn' t знают, что у Явы было goto' s? Ну, JVM поддерживает их =),

Я использую Проохрана и настоятельно рекомендую его. В то время как путаница действительно защищает Ваш кодекс от случайных нападавших, it' s главная выгода эффект уменьшения удаления неиспользованных классов и методов и сокращения всех идентификаторов 1 или 2 знакам.

Я думаю, что по большей части путаница бессмысленна: даже с полным исходным кодом it' s достаточно вообще трудно, чтобы выяснить, какого черта намерение было (принимающий нет никаких комментариев и никаких значащих названий местных переменных - который имеет место, восстанавливая источники из кодекса байта). Путаница просто украшает пирог.

Я думаю разработчики, и особенно их менеджеры склонны значительно сверхпреувеличивать риск кого-то видящего исходный код. В то время как хорошие детрансляторы могут создать хорошо выглядящий исходный код, it' s, не тривиальные, чтобы работать с ним, и связанные затраты (не говоря уже о юридических рисках), достаточно высоки, чтобы редко делать этот подход полезным. Я только декомпилировал, чтобы отладить проблемы с закрытым источником vendors' продукты (заходит в тупик в слое абстракции DB, тьфу). Bytecode на самом деле запутывался, я думаю, но мы, тем не менее, нашли основную проблему - это была фактическая проблема проектирования.

Думаю, все зависит от того, для чего предназначен ваш Java-код, как он распространяется и кто ваши клиенты. Мы ничего не обфусцируем, так как мы никогда не находили ничего особенно хорошего, и это, как правило, доставляет больше проблем, чем того стоит. Если кто-то имеет доступ к нашим JAR-файлам и обладает знаниями, позволяющими разнюхивать внутри них, то он может сделать гораздо более опасные вещи, чем вырвать наш исходный код.