Como esconder cordas em um exe ou dll?
https://stackoverflow.com/questions/926172
-
06-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu descobri que é possível extrair as strings na mão de um binário.
Por exemplo, as propriedades ver de displays Process Explorer toda a corda com mais de 3 caracteres.
Aqui está o código de um executável simples que eu escrevi simplesmente testá-lo:
#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;
}
As cordas podem claramente ser extraído do correspondente executável:
Eu acho que é um pouco mais fácil de encontrar as strings.
As minhas perguntas são:
- Como simples hide hiddenString1 ou hiddenString2 na executável?
- Existe um mundo mais seguro forma de utilização "código da fraude" do que com alguma entrada escondida obscura?
Solução
Bem-vindo ao mundo mais amplo de programação defensiva.
Há um par de opções, mas acredito que todos eles dependem de alguma forma de ofuscamento; que, embora não seja perfeito, é pelo menos alguma coisa.
-
Em vez de um valor de cadeia reta você pode armazenar o texto de alguma outra forma binária (hex?).
-
Você pode criptografar as cordas que são armazenados em seu aplicativo, em seguida, descriptografar-los em tempo de execução.
-
Você pode dividi-los em vários pontos no seu código, e reconstituir mais tarde.
Ou alguma combinação destes.
Tenha em mente que alguns ataques ir mais longe do que olhar para o binário real. Às vezes eles vão investigar o espaço de endereçamento de memória do programa enquanto ele está funcionando. MS surgiu com algo chamado SecureString na Net 2.0 . O objectivo é o de manter as cordas criptografados enquanto o aplicativo está sendo executado.
A quarta ideia é a de não armazenar a cadeia no aplicativo em si, mas sim contar com um código de validação para ser submetido a um servidor que você controla. No servidor, você pode verificar se é um "código da fraude" legítimo ou não.
Outras dicas
Existem muitas maneiras de obscuros dados em um arquivo executável. Outros aqui postaram boas soluções - alguns mais fortes do que outros. Não vou acrescentar a essa lista.
Apenas estar ciente: é tudo um jogo de gato-e-rato:. É impossível para garantia que ninguém vai descobrir o seu "segredo"
Não importa o quanto de criptografia ou outros truques que você usa; Não importa como muito esforço ou dinheiro que você colocar nele. Não importa quantos tipos "NASA / MIT / CIA / NSA" estão envolvidos em escondê-lo.
Tudo se resume à física simples:
Se fosse impossível para qualquer user para retirar o seu segredo do executável e "unhide", então o computador não seria capaz de mostrá-lo, quer, e seu programa não seria capaz de uso isto. Qualquer desenvolvedor moderadamente hábil com incentivo suficiente vai encontrar o caminho para reexibir o segredo.
No momento em que você entregou o seu executável para um usuário, eles têm tudo o que precisam para descobrir o segredo.
O melhor que você pode esperar é para torná-lo tão difícil para descobrir o segredo que quaisquer benefícios que você pode obter de saber o segredo tornar-se não vale a pena.
Então, é OK para tentar obscurecer os dados se é simplesmente "não-bom" para que ela seja pública, ou se as consequências de se tornar pública seria apenas "inconveniente". Mas não pense mesmo de se esconder em seu programa "a senha para seu banco de dados mestre de cliente", uma chave privada, ou algum outro segredo crítico. Você simplesmente não pode.
Se você tem informação verdadeiramente crítica segredo que seu programa irá de alguma forma precisa, mas nunca deve se tornar a informação pública (como uma chave privada), então você vai precisar de ter o seu programa de talk para um servidor remoto sob seu controle, aplicar autenticação adequado e controles de autorização ( que é, certifique-se apenas as pessoas ou computadores aprovados são capazes de fazer o pedido para o servidor ), e ter esse servidor manter o segredo e usá-lo.
A maneira mais simples é criptografar-los com algo trivial como xor ou podridão-13, e, em seguida, descriptografar-los na mosca quando eles são usados. Isso vai eliminar a visualização ocasional deles, mas não vai parar qualquer pessoa com muita experiência em marcha-atrás.
Além desses métodos Chris menciona você também pode usar um algoritmo de hash. Se tudo que você quer fazer é verificar se o ID correto foi especificado na verdade você não precisa armazenar toda a ID em seu programa.
- Criar um hash (MD5, SHA, etc) da string / senha / id você quiser comparar contra, talvez adicionar um valor de 'sal' para ele. Guarde isto em seu programa
- Quando o programa é executado, faça o mesmo algoritmo na cadeia de entrada / senha / id e comparar os dois hashes para ver se eles combinam.
Desta forma, o texto real nunca é armazenado em seu programa e não podem engenharia reversa seu programa para descobrir o que o texto original foi porque algoritmos de hash são one-way somente.
Existem URLs para solicitações HTTP que eu gostaria de esconder também.
Se seu aplicativo está fazendo a solicitação, não há nenhum ponto escondendo isso. Executando um aplicativo como violinista, http analisador, ou uma das dezenas de outros métodos gratuitos e prontamente disponíveis irá mostrar todo o tráfego seu aplicativo está criando.
Será que todos os seus códigos secretos ser GUIDs ou foi apenas um exemplo?
Talvez guardar o seu segredo como um guid binário:
const GUID SecretGuid =
{ 0x4537774B, 0xCC80, 0x4eda, { 0x7A, 0x9E, 0xE7, 0x79, 0x91, 0xF5 } };
Em seguida, converter o seu guid fornecidos a partir de corda para o formato binário e compara os dois guids binários.
Se há uma seqüência específica que você não quer que as pessoas sejam capazes de ver, então criptografá-lo e descriptografar em tempo de execução.
Se você não quer que as pessoas vejam o seu GUID, então construí-la a partir de bytes, em vez de construída a partir de uma string:
const GUID SecretGuid =
{ 0x4537774B, 0xCC80, 0x4eda, { 0x7A, 0x9E, 0xE7, 0x79, 0x91, 0xF5 } };
O melhor que você pode fazer é codificar sua senha ou outra cadeia de caracteres que você deseja ocultar como matriz de char. Por exemplo:
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.
Aqui está o método de uso I para esta finalidade. Em primeiro lugar, eu uso o do href="https://docs.microsoft.com/en-us/sysinternals/downloads/strings" rel="nofollow noreferrer"> ferramenta por Sysinternals para exibir as cordas em um EXE ou DLL. Eu, então, usar o seguinte pequena ferramenta (veja artigo ) para substituir estas cordas com uma matriz mexidos de caracteres armazenados como uma expressão aritmética: para exemplo: em vez da string: "Este é um teste" Vou colocar o seguinte código: (qual é gerado automaticamente pelo esta ferramenta )
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;
Existem muitas soluções para este problema e nenhum deles (incluindo o meu) é perfeito, no entanto, existem maneiras para embaralhar, disfarce e esconder as cordas sensíveis. Pode, claro, criptografá-las e descriptografar durante a execução (ver este artigo), mas eu acho mais importante para fazer estes corda desaparecer entre os bits e bytes do arquivo executável e ele funciona. Depois de executar a minha ferramenta, você não vai encontrar "este é um teste" no arquivo executável.
