Julgamento De Osiris

Como configurar o julgamento de Osiris para ofuscação de código Java

O julgamento de osiris é uma ferramenta open-source que compila e ofusca código Java, originalmente criada pela equipe do projeto Minecraft Anarchy. Ela transforma variáveis, métodos e classes em identificadores ilegíveis e introduz lógica de proteção contra engenharia reversa básica. Se você está desenvolvendo software onde quer dificultar a leitura do bytecode, essa ferramenta ainda tem seus usos, apesar da idade.

O que exatamente o julgamento de osiris faz no final das contas

Ele pega um JAR compilado e aplicava transformações no bytecode usando a biblioteca ASM. O processo inclui renomeação de nomes de campos e métodos, remoção de atributos de debug, e a injeção de armadilhas como classes falsas, strings codificadas, e instruções mortas que travam decompiladores comuns. A versão mais recente que rodou de forma estável foi a 3.0, lançada em 2015, mas ainda circula por aí em repositórios mirrors. O mecanismo principal funciona assim: você entrega um JAR de entrada, define um conjunto de regras em um arquivo de configuração YAML, e ele sai com um JAR ofuscado. Não é mágica, é apenas manipulação direta de bytecode com uma camada de confusão adicional.

Na prática, isso significa que se alguém abrir seu JAR no CFR ou FernFlower, vai ver nomes como a, b, c1, d2f3 em vez dos nomes originais que você deu às suas classes e métodos. E se você configurou as regras de confusão corretamente, vai encontrar loops infinitos simulados, branches mortos, e Strings que só são decodificadas em tempo de execução. Eu uso isso principalmente para proteger utilities que distribuo em servidores privados. Não é uma solução perfeita, mas para a maioria dos jogadores que tentam mexer com o código, é mais do que suficiente. Descompiladores gratuitos levam de 20 minutos a uma hora para chegar em algo remotamente legível, dependendo da complexidade das ofuscações aplicadas.

Como baixar e instalar

O código-fonte original estava no GitHub sob o repositório de SkyAxe, mas o repositório principal foi arquivado. Você encontra builds funcionais no repositório do GitHub como "JuryOfOsiris" ou em mirrors como o osiris-hack.github.io. Para compilar do zero, você precisa de Java 8+ e Maven. Roda o comando:

mvn clean package

Isso gera um JAR executável na pasta target. Use a flag -jar passando o input e output. Um comando típico seria:

java -jar JuryOfOsiris.jar --input meu-projeto.jar --output meu-projeto-ofuscado.jar

Se estiver no Windows, há a versão .exe pré-compilada que também funciona sem preocupações com classpath. O download direto pode ser feito procurando por "JuryOfOsiris latest release" no GitHub ou no site do projeto original.

Configuração do arquivo YAML

O coração do julgamento de osiris está no arquivo de configuração. Por padrão, você começa com um arquivo config.yml vazio e ele aplica ofuscação básica automaticamente. Mas o que realmente diferencia um trabalho ruim de um trabalho decente é a configuração manual. Aqui estão as opções mais importantes:

classes: lista de pacotes para ofuscar. Use expressões regulares. Por exemplo, "com\.meu\.projeto\..*" vai pegar tudo dentro desse pacote. fields: controla se campos são renomeados. Defina como true para forçar.

methods: mesmo princípio para métodos. obfStrings: habilita a ofuscação de strings com Base64 e lógica de decodificação inline.

fakeClasses: injeta classes vazias que confundem descompiladores. Use com moderação porque aumenta o tamanho do JAR. deadBranches: adiciona blocos de código que nunca são executados mas aparentam ser parte da lógica real.

Um arquivo de configuração mínimo que eu uso rotineiramente parece com isto:

target: target/classes
output: output.jar
obfStrings: true
fakeClasses: true
deadBranches: true
packages:
  - com\.minha\.app\..*

Problemas comuns e como resolver

O julgamento de osiris não é perfeito e tem limitações sérias que aparecem na prática. O primeiro problema que encontrei foi com bibliotecas de third-party. Quando seu JAR depende de outras bibliotecas e você tenta ofuscar tudo junto, o descompilador do descompilador quebra a assinatura dos métodos das dependências, gerando erros de runtime. A solução é excluir pacotes de bibliotecas conhecidas do processo de ofuscação usando a seção exclude no config.yml.

exclude:
  - org\.apache\..*
  - com\.google\..*
  - lombok\..*

O segundo problema que tive foi com reflection. Meu sistema de plugin usava reflection para carregar módulos dinamicamente, e após a ofuscação, todos os nomes de classes mudavam e o reflection parava de funcionar. A workaround que funcionou foi manter uma lista de nomes inalteráveis no config:

keepNames:
  - MyPluginLoader
  - ModuleInterface

Isso preserva esses nomes específicos enquanto o restante é ofuscado normalmente. Não é elegante, mas resolve o problema sem precisar remover a ofuscação completamente. Outro ponto importante: o julgamento de osiris não ofusca nomes de exceções personalizadas de forma consistente em todas as versões do ASM. Se você usa try-catch com exceptions customizadas, verifique se o JAR resultante compila e roda antes de distribuir. Testei com javap e o nome da exception aparecia como String codificada em vez de uma referência de classe válida em certas combinações de bytecode.

Performance e tempo de processamento

Para projetos pequenos, com até 50 classes, o processo leva cerca de 30 segundos a 1 minuto. Para projetos médios com 200-300 classes, algo entre 2 e 4 minutos. Projetos grandes de 1000+ classes podem levar 10 minutos ou mais, especialmente se você habilitar fakeClasses e deadBranches em massa. O gargalo principal é a geração de código morto e a análise de fluxograma. Cada branch morto adicionado exige que a ferramenta reanalise o bytecode inteiro para garantir que a lógica original permanece funcional. É por isso que aplicar deadBranches em JARs enormes pode travar a ferramenta temporariamente ou consumir bastante memória. Recomendo aumentar o heap para pelo menos 512MB se o JAR de entrada for maior que 5MB.

java -Xmx512m -jar JuryOfOsiris.jar ...

Limitações que ninguém menciona

O julgamento de osiris é efetivo contra ferramentas gratuitas de descompilação. Mas contra ferramentas pagas como JD-GUI premium, Procyon, ou decompiladores comerciais como o da JetBrains, o nível de proteção cai significativamente. Essas ferramentas lidam melhor com strings codificadas e branches mortos, reduzindo o tempo de análise de horas para minutos. Além disso, a ofuscação baseada em bytecode tem um teto. Ela torna a leitura humana difícil, mas não impossibilita a engenharia reversa. Alguém com experiência em ASM e bytecode Java pode desmontar o JAR ofuscado em questão de horas se tiver motivação suficiente. Se você precisa de proteção real contra reverse engineering, considere combinar o julgamento de osiris com ferramentas como ProGuard ou o encriptador de strings da yguard antes de passar pelo Osiris.

O julgamento de osiris ainda funciona, ainda que seja uma ferramenta antiga. Use com consciência das limitações, configure corretamente as exclusões, e teste sempre o JAR de saída antes de considerar o trabalho terminado.