download de obfus.h - obfus.h download de código fonte

obfus.h

Código-fonte C#

2024-11-24

Baixar

obfus.h

O OBFUS.H é uma biblioteca somente macro para aplicações C offuscating de tempo de compilação, projetadas especificamente para o minúsculo C (TCC) . É adaptado para plataformas Windows X86 e X64 e suporta quase todas as versões do compilador. Armadura muito confiável para seus programas C!

Que recursos ele tem? ...

? Função Chamada OBFUSCAÇÃO : Confuso Chamadas de função para tornar seu código menos legível aos olhos não autorizados.
? Aste Técnicas de anti-fuga : mecanismos internos para impedir a análise de código durante o tempo de execução.
Controle Código de fluxo Mutação : transforma o código em espaguete, dificultando a análise de condições e loops.
Técnicas de anti-decompilação : torna inútil muitos decompilers populares quebrando visualmente sua produção.
? Assinaturas falsas adicionando : pode adicionar assinaturas falsas de vários Packers e protetores para confundir engenheiros reversos.
? Virtualização : torna as operações matemáticas muito difíceis de entender usando comandos de máquina virtual.

? Uso

A integração do Obfus.H em seu projeto é um processo simples. Basta incluir a linha a seguir em seu código:

 #include "obfus.h"

Isso ofuscará automaticamente seu código durante a compilação, garantindo proteção e confidencialidade de sua propriedade intelectual.

Opções disponíveis para configuração de proteção:

 // Advanced code protection (see the "Virtualization" part of the documentation!)
#define VIRT           1  // Allows you to use the functions of a math VM

// Additional options
#define CFLOW_V2       1  // More powerful Control Flow obfuscation (slowly!)
#define ANTIDEBUG_V2   1  // Use better dynamic anti-debugging protection
#define FAKE_SIGNS     1  // Adds fake signatures of various protectors or packers

// Disabling default features
#define NO_CFLOW       1  // Don't use Control-Flow obfuscation
#define NO_ANTIDEBUG   1  // Don't build in debugging protection

ou use -o com o compilador args:

 tcc "app.c" -w  -D NO_CFLOW  -D ANTIDEBUG_V2  -D FAKE_SIGNS  -D VIRT

Aviso

Ao compilar um aplicativo com ofuscação, use o argumento -w para suprimir os avisos. Caso contrário, o console exibirá inúmeros logs intimidadores que não têm impacto no resultado final. Não há necessidade de ficar alarmado com eles.

? A proteção de depuração é acionada por chamadas para muitas funções básicas do MSVCRT. Em locais críticos no código, você pode usar o ANTI_DEBUG; construir. Por exemplo:

 ANTI_DEBUG ;
if (! licenseExpired ()) {
    // ...
}

? Virtualização

Esta é uma técnica de proteção na qual certos cálculos são realizados através de uma máquina virtual incorporada após comando. Torna muito difícil a análise de operações matemáticas! Funcionará com a opção VIRT ativada (e somente!). Caso contrário, todos os comandos da máquina virtual serão substituídos por operadores matemáticos comuns.

Aviso

A virtualização em locais críticos pode afetar a otimização. Use com cautela apenas em áreas onde é realmente necessário

Função	Tipo	Op	Descrição	Exemplo
`VM_ADD`	longo	`+`	Adiciona dois números	`VM_ADD(5, 3)` = `8`
`VM_SUB`	longo	`-`	Subtrai dois números	`VM_SUB(5, 3)` = `2`
`VM_MUL`	longo	`*`	Multiplica dois números	`VM_MUL(5, 3)` = `15`
`VM_DIV`	longo	`/`	Divide dois números	`VM_DIV(6, 3)` = `2`
`VM_MOD`	longo	`%`	Calcula o módulo de dois números	`VM_MOD(5, 3)` = `2`
`VM_EQU`	Bool	`==`	Verifica se dois números são iguais	`VM_EQU(5, 5)` = `true`
`VM_NEQ`	Bool	`!=`	Verifica se dois números não são iguais	`VM_NEQ(5, 3)` = `true`
`VM_LSS`	Bool	`<`	Verifica se o primeiro número é menor que o segundo número	`VM_LSS(3, 5)` = `true`
`VM_GTR`	Bool	`>`	Verifica se o primeiro número é maior que o segundo número	`VM_GTR(5, 3)` = `true`
`VM_LEQ`	Bool	`<=`	Verifica se o primeiro número é menor ou igual ao segundo número	`VM_LEQ(3, 5)` = `true`
`VM_GEQ`	Bool	`>=`	Verifica se o primeiro número é maior ou igual ao segundo número	`VM_GEQ(5, 3)` = `true`
`VM_ADD_DBL`	Longo duplo	`+`	Adiciona dois números duplos	`VM_ADD_DBL(5.5, 3.2)` = `≈8.7`
`VM_SUB_DBL`	Longo duplo	`-`	Subtrai dois números duplos	`VM_SUB_DBL(5.5, 3.2)` = `≈2.3`
`VM_MUL_DBL`	Longo duplo	`*`	Multiplica dois números duplos	`VM_MUL_DBL(5.5, 3.2)` = `≈17.6`
`VM_DIV_DBL`	Longo duplo	`/`	Divide dois números duplos	`VM_DIV_DBL(6.0, 3.0)` = `≈2.0`
`VM_LSS_DBL`	Bool	`<`	Verifica se o primeiro número duplo é menor que o segundo número duplo	`VM_LSS_DBL(3.5, 5.2)` = `true`
`VM_GTR_DBL`	Bool	`>`	Verifica se o primeiro número duplo é maior que o segundo número duplo	`VM_GTR_DBL(5.5, 3.2)` = `true`

A máquina virtual não suporta algumas operações básicas de comparação double .

Você pode usar operadores lógicos que usam chamadas de máquinas virtuais para complicar ainda mais a compreensão do seu código.

Operador	Descrição
`VM_IF`	Use em vez de `if`
`VM_ELSE_IF`	Use em vez de `else if`
`VM_ELSE`	Use em vez de `else`

Um exemplo simples de usar a virtualização:

 // ...
#define VIRT 1
// ...

// if ((2 + 2) == 4) { ... }
VM_IF ( VM_EQU ( VM_ADD ( 2 , 2 ), 4 )) {
    printf ( "2 + 2 == 4!" );
}

// if (condition1) { ... }
// else if (condition2) { ... }
// else { ... }
VM_IF ( condition1 ) {
    // if
} VM_ELSE_IF ( condition2 ) {
    // else if
} VM_ELSE {
    // else
}

Você pode encontrar exemplos de usar todas as funções de uma máquina virtual nos testes de arquivo/virtualmachine.c

❓ Exemplo de usar

Se você precisar de proteção avançada contra reversores qualificados, use as opções CFLOW_V2 e ANTIDEBUG_V2 .

 // Let's obfuscate your code!

#include <stdio.h>

#define VIRT         1 // [+] Use math virtual machine

#define CFLOW_V2     1 // [+] ControlFlow v2
#define FAKE_SIGNS   1 // [+] Fake signatures
#define ANTIDEBUG_V2 1 // [+] AntiDebug v2

#define NO_CFLOW     0 // [-] Disable ControlFlow
#define NO_ANTIDEBUG 0 // [-] Disable AntiDebug


#include "obfus.h"

void main () {
    char * out = malloc ( 256 );

    strcpy ( out , "Hello, world!n" );

    if ( out ) {
        printf ( out );
    } else {
        printf ( "Error!n" );
    }

    free ( out );

    int result = VM_ADD ( 5 , 7 ); // 5 + 7

    VM_IF ( VM_EQU ( result , 12 )) { // (5 + 7) == 12
        printf ( "5 + 7 == 12" );
    }
}

? Como funciona?

? Compilador (importante)

A versão mais recente do Tiny C ( 0.9.27 ) é recomendada para uso. Infelizmente, algumas versões do compilador não suportam a funcionalidade necessária para ofuscar completamente. Visual C , GCC e CLANG não são suportados e é improvável que seja suportado.

obfus.h Updater

Você pode usar o script especial para o Windows para obter as versões mais recentes do obfus.h baixando o pacote do repositório oficial. Isso é útil se você precisar automatizar as atualizações de segurança sem usar git .

Por exemplo, você pode usá -lo antes de criar seu projeto:
 + C:...> call obfh-update
  C:...> tcc app.c -w
O script atualizará o conteúdo do arquivo obfus.h no diretório atual (de acordo com a configuração especificada)

Resumir

O código de um programa (e sua lógica original original) protegida usando obfus.h é quase impossível de recuperar (Deobfuscate) . No entanto, o uso desse ofusco não garante proteção completa contra todos os tipos de ameaças. É importante desenvolver e manter sistemas internos de segurança do programa.