C ++ binary offuscamento: come aggirare i controlli delle licenze come semplici rami if / then?

Question

C ++ binary offuscamento: come aggirare i controlli delle licenze come semplici rami if / then?

#1 da (-1 voti)

2

Sto esaminando l'offuscamento binario per un binario eseguibile scritto in C ++. Mi rendo conto che prevenire le crepe è impossibile, ma renderlo leggermente più difficile sarebbe bello.

Non importa quanto sia complesso l'attuale schema di licenza, non riesco a pensare a un modo per convalidarlo che alla fine non si riduce a:

if (doVeryComplexLicenseValidationCheck())
{
    //execute code
}

... che sarebbe banalmente facile aggirare da qualsiasi cracker competente. Ma ovviamente ci sono molti sistemi di protezione da copia che sono stati molto difficili da decifrare ... quindi cosa stanno facendo che mi manca? C'è un modo per offuscare un ramo semplice come quello, che è molto più difficile da bypassare?

c++ obfuscation license-enforcement

posta Tyson 24.09.2018 - 20:11

fonte

1 risposta

Leggi altre domande sui tag c++ obfuscation license-enforcement

Database compromesso (SQL-injection): come gestire la situazione, dopo il fatto? Come ispezionare un allegato e-mail senza scaricarlo?

score -1 · Answer 1

Ecco alcuni suggerimenti che possono aiutarti, ma ricorda che chiunque abbia una buona conoscenza dell'assembler lo troverà.

Immagina che il tuo programma sia come descrivi:

int main() {

    if (myCheck()) {
            std::cout << "License pass\n";
    }
    ....

Ed ecco il disassemblatore del codice.

00000000004006d3 <main>:
4006d3:       55                      push   %rbp
4006d4:       48 89 e5                mov    %rsp,%rbp
4006d7:       e8 da ff ff ff          callq  4006b6 <_Z7myCheckv>
4006dc:       84 c0                   test   %al,%al
4006de:       74 0f                   je     4006ef <main+0x1c>
4006e0:       be d1 07 40 00          mov    $0x4007d1,%esi
4006e5:       bf 40 10 60 00          mov    $0x601040,%edi
4006ea:       e8 b1 fe ff ff          callq  4005a0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
4006ef:       b8 00 00 00 00          mov    $0x0,%eax
4006f4:       5d                      pop    %rbp
4006f5:       c3                      retq

Quindi, aggiungendo le istruzioni asm nel codice, puoi renderlo più difficile.

#define OPS1 "xor \%rbx,\%rbx\n"
int main() {
    __asm__ volatile (
            "push %rax\n"
            "xor %rax,%rax\n"
            "pop %rax\n"
    );

    if (myCheck()) {
            std::cout << "License pass\n";
    }
    __asm__ volatile (OPS1);

Ed ecco l'output

4006d3:       55                      push   %rbp
4006d4:       48 89 e5                mov    %rsp,%rbp
4006d7:       50                      push   %rax
4006d8:       48 31 c0                xor    %rax,%rax
4006db:       58                      pop    %rax
4006dc:       e8 d5 ff ff ff          callq  4006b6 <_Z7myCheckv>
4006e1:       84 c0                   test   %al,%al
4006e3:       74 0f                   je     4006f4 <main+0x21>
4006e5:       be e1 07 40 00          mov    $0x4007e1,%esi
4006ea:       bf 40 10 60 00          mov    $0x601040,%edi
4006ef:       e8 ac fe ff ff          callq  4005a0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
4006f4:       48 31 db                xor    %rbx,%rbx
4006f7:       b8 00 00 00 00          mov    $0x0,%eax
4006fc:       5d                      pop    %rbp
4006fd:       c3                      retq

Questo caso è davvero molto semplice, ma se hai una buona conoscenza dei template, assembler complichi un po 'il codice generato.