Come nascondere le stringhe in un EXE o una DLL?

Question

ho scoperto che è possibile estrarre le stringhe hard-coded da un binario.
Ad esempio le proprietà di vista Process mostra tutta la stringa con più di 3 caratteri.

Ecco il codice di un semplice eseguibile che ho scritto per testare semplicemente:

#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif
#include <stdio.h>
#include <tchar.h>
#include <Windows.h>

int _tmain(int argc, _TCHAR* argv[])
{
    _TCHAR* hiddenString1 =_T("4537774B-CC80-4eda-B3E4-7A9EE77991F5");
    _TCHAR* hiddenString2 =_T("hidden_password_or_whatever");
    for (int i= 0; i<argc; i++) {
        if (0 == _tcscmp(argv[i],hiddenString1)) {
            _tprintf (_T("The guid argument is correct.\n")); }
        else if (0 == _tcscmp(argv[i],hiddenString2)) {
            _tprintf (_T("Do something here.\n")); }
    }

    _tprintf (_T("This is a visible string.\n"));
    //Keep Running
    Sleep(60000);
    return 0;
}

Le stringhe possono chiaramente essere estratti dal corrispondente eseguibile:

Credo che sia un po 'troppo facile trovare le stringhe.

Le mie domande sono:

1. Come semplicemente nascondere hiddenString1 o hiddenString2 nella eseguibile?
2. È più sicuro modo di usare "cheat code" che con alcuni input nascosto oscura?

Answer 1

Benvenuti nel più ampio mondo della programmazione difensiva.

Ci sono un paio di opzioni, ma credo che tutti loro dipendono da una qualche forma di offuscamento; che, anche se non perfetto, è almeno qualcosa.

1. Al posto di un valore stringa dritto è possibile memorizzare il testo in qualche altra forma binaria (hex?).

2. È possibile crittografare le stringhe che vengono memorizzati nella vostra app, poi decifrare in fase di esecuzione.

3. Si possono dividere in vari punti nel codice, e ricostituire in seguito.

O qualche combinazione di questi.

Si tenga presente che alcuni attacchi vanno oltre a guardare il binario vero e proprio. A volte si indagare lo spazio di indirizzamento di memoria del programma mentre è in esecuzione. MS si avvicinò con qualcosa chiamato un SecureString in .Net 2.0 . Lo scopo è quello di mantenere le stringhe criptate mentre l'applicazione è in esecuzione.

Una quarta idea è quella di non memorizzare la stringa nella stessa applicazione, ma piuttosto fare affidamento su un codice di convalida da sottoporre a un server che controlli. Sul server è possibile verificare se si tratta di un "cheat" legittimo o meno.

Answer 2

Ci sono molti modi per / dati oscuri in un file eseguibile. Altri qui hanno inviato buone soluzioni - alcuni più forti di altri. Non voglio aggiungere a quella lista.

Basta essere consapevoli: è tutto un gioco del gatto col topo:. È impossibile a garanzia che nessuno scoprirà il vostro "segreto"

Non importa quanto cifratura o altri trucchi si usa; non importa come molto sforzo o denaro che mettete in esso. Non importa quanti tipi "NASA / MIT / CIA / NSA" sono coinvolti in nasconderlo.

Tutto si riduce alla semplice fisica:
Se fosse impossibile per qualsiasi all'utente di tirare fuori il segreto l'eseguibile e "Scopri", allora il computer non sarebbe in grado di mostrare che sia, e il programma non sarebbe in grado di utilizzare esso. Ogni sviluppatore moderatamente abile con un incentivo sufficiente troverà il modo per visualizzarla il segreto.

Nel momento in cui avete consegnato il vostro eseguibile a un utente, hanno tutto il necessario per scoprire il segreto.

Il meglio che puoi sperare è di rendere così difficile per scoprire il segreto che tutti i benefici che si possono ottenere dal conoscere il segreto diventare non vale la fatica.

Quindi, va bene per cercare di oscurare i dati se è semplicemente "non-bello" per essere pubblico o pubblico, se le conseguenze di esso diventando sarebbe solo "scomodo". Ma non pensate nemmeno di nascondere nel programma "la password per il tuo padrone database client", una chiave privata, o qualche altro segreto critica. Non ci si può.

Se si dispone di informazioni veramente critico è un segreto che il programma verrà in qualche modo bisogno ma MAI dovrebbe diventare l'informazione del pubblico (come una chiave privata), allora si avrà bisogno di avere il vostro parlare programma a un server remoto sotto il vostro controllo, applicare l'autenticazione appropriata e controlli di autorizzazione ( che è, assicurarsi che solo le persone o computer approvati sono in grado di fare la richiesta al server ), e che hanno server di mantenere il segreto e usarlo.

Answer 3

Il modo più semplice è quello di crittografare loro con qualcosa di banale come XOR o marcire-13, e poi decifrare al volo quando sono utilizzati. Che eliminerà la visualizzazione casuale di loro, ma non si fermerà chiunque con molta esperienza in retromarcia.

Answer 4

In aggiunta a questi metodi Chris menziona si potrebbe anche usare un algoritmo di hashing. Se tutto quello che vogliamo fare è controllare se è stato specificato l'ID corretto in realtà non c'è bisogno di memorizzare l'intero ID nel programma.

• Crea un hash (MD5, SHA, ecc) della stringa / password / id che si desidera confrontare con, magari aggiungere un valore 'sale' ad esso. Memorizzare questo nel vostro programma
• Quando il programma viene eseguito, fare lo stesso algoritmo sulla stringa di input / password / id e confrontare i due hash per vedere se corrispondono.

In questo modo il testo effettivo non è mai memorizzato nel vostro programma e non possono decodificare il programma per scoprire ciò che il testo originale è stato perché gli algoritmi di hash sono a senso unico.

Answer 5

  

Non ci sono URL per le richieste HTTP che vorrei nascondere troppo.

Se la vostra applicazione sta facendo la richiesta, non esiste un punto nascondere questo. Esecuzione di un app come violinista, analizzatore http, o una delle decine di altri metodi gratuiti e facilmente reperibili mostrerà tutto il traffico la vostra applicazione è la creazione.

Answer 6

saranno tutti i tuoi codici segreti essere GUID o è che solo un esempio?

Forse conservare il segreto come un guid binario:

const GUID SecretGuid =
    { 0x4537774B, 0xCC80, 0x4eda, { 0x7A, 0x9E, 0xE7, 0x79, 0x91, 0xF5 } };

Poi convertire i vostri forniti GUID da stringa in formato binario e confrontare i due GUID binari.

Answer 7

Se c'è una stringa specifica non si vuole che la gente di essere in grado di vedere, poi cifrare e decifrare in fase di esecuzione.

Se non si desidera la gente a vedere il tuo GUID, poi costruirlo da byte, piuttosto che costruita da una stringa:

const GUID SecretGuid = 
      { 0x4537774B, 0xCC80, 0x4eda, { 0x7A, 0x9E, 0xE7, 0x79, 0x91, 0xF5 } };

Answer 8

Il meglio che puoi fare è codificare la password o altre stringa che si desidera nascondere array come char. Ad esempio:

std::string s1 = "Hello";   // This will show up in exe in hex editor
char* s2 = "World";   // this will show up in exe in hex editor
char s3[] = {'G', 'O', 'D'}; // this will not show up in exe in hex editor.

Answer 9

Ecco il metodo che uso per questo scopo. In primo luogo, io uso il Strings strumento da Sysinternals per visualizzare le stringhe in un file EXE o DLL. Ho quindi utilizzare il seguente piccolo strumento (vedi articolo ) per sostituire le stringhe con una matrice codificato di caratteri memorizzati come espressione aritmetica: per esempio: invece della stringa: "Questo è un test" Porrò il seguente codice: (che viene generato automaticamente da questo strumento )

WCHAR T1[28];
 T1[22] = 69;
 T1[15] = 121 - 17;
 T1[9] = L':' + -26;
 T1[12] = L't' - 1;
 T1[6] = 116 - 1;
 T1[17] = 117 - 12;
 T1[3] = 116 - 1;
 T1[14] = L'' - 3;
 T1[13] = L'w' - 3;
 T1[23] = 69;
 T1[26] = L'Y' + 3;
 T1[19] = 111 + 0;
 T1[21] = L'k' - 34;
 T1[27] = L'\\' - 8;
 T1[20] = L'B' + 32;
 T1[4] = 42 + -10;
 T1[25] = L'm' - 17;
 T1[16] = L'H' + 18;
 T1[18] = L'A' + 56;
 T1[24] = 68;
 T1[1] = 105 - 1;
 T1[11] = L'k' - 6;
 T1[10] = 66 + 50;
 T1[2] = 105;
 T1[0] = 117 - 1;
 T1[5] = L'k' - 2;
 T1[8] = 89 + 8;
 T1[7] = 32;

Ci sono molte soluzioni a questo problema e nessuno di loro (compreso il mio) è perfetto, ma ci sono modi per rimescolare, travestimento, e nascondere le corde sensibili. Ovviamente si può crittografare e decrittografare loro durante l'esecuzione (vedi questo articolo), ma trovo più importante per rendere questi stringa di sparire tra i bit e byte del file eseguibile e funziona. Dopo aver eseguito il mio strumento, non troverete "questa è una prova" nel file eseguibile.