Código polimórfico

Da Wikipédia, a enciclopédia livre
Ir para a navegação Saltar para pesquisar

Na computação, o código polimórfico é um código que usa um mecanismo polimórfico para sofrer mutação enquanto mantém o algoritmo original intacto - ou seja, o código muda a si mesmo toda vez que é executado, mas a função do código (sua semântica ) não muda nada. Por exemplo, as equações matemáticas simples 3+1 e 6-2 atingem o mesmo resultado, mas são executadas com código de máquina diferente em uma CPU . Essa técnica às vezes é usada por vírus de computador , shellcodes e worms de computador para ocultar sua presença. [1]

A criptografia é o método mais comum para ocultar o código. Com a criptografia, o corpo principal do código (também chamado de payload ) é criptografado e parecerá sem sentido. Para que o código funcione como antes, uma função de descriptografia é adicionada ao código. Quando o código é executado , essa função lê a carga útil e a descriptografa antes de executá-la.

A criptografia por si só não é polimorfismo. Para ganhar comportamento polimórfico, o par criptografador/descriptografador é modificado a cada cópia do código. Isso permite diferentes versões de algum código que funcionam da mesma forma. [2]

Código malicioso

A maioria dos softwares antivírus e dos sistemas de detecção de intrusão (IDS) tentam localizar códigos maliciosos pesquisando arquivos de computador e pacotes de dados enviados por uma rede de computadores . Se o software de segurança encontrar padrões que correspondam a vírus ou worms de computador conhecidos, ele tomará as medidas apropriadas para neutralizar a ameaça. Algoritmos polimórficos tornam difícil para esse software reconhecer o código incorreto porque ele sofre mutações constantemente.

Programadores maliciosos têm procurado proteger seu código criptografado dessa estratégia de varredura de vírus reescrevendo o mecanismo de descriptografia não criptografado (e a carga útil criptografada resultante) toda vez que o vírus ou worm é propagado. O software antivírus usa uma análise sofisticada de padrões para encontrar padrões subjacentes nas diferentes mutações do mecanismo de descriptografia, na esperança de detectar esse malware de maneira confiável .

A emulação pode ser usada para derrotar a ofuscação polimórfica, permitindo que o malware se desfaça em um ambiente virtual antes de utilizar outros métodos, como a verificação de assinatura tradicional. Esse ambiente virtual às vezes é chamado de sandbox . O polimorfismo não protege o vírus contra tal emulação se a carga descriptografada permanecer a mesma, independentemente da variação no algoritmo de descriptografia. Técnicas de código metamórfico podem ser usadas para complicar ainda mais a detecção, pois o vírus pode ser executado sem nunca ter blocos de código identificáveis ​​na memória que permaneçam constantes de infecção para infecção.

O primeiro vírus polimórfico conhecido foi escrito por Mark Washburn. O vírus, chamado 1260 , foi escrito em 1990. Um vírus polimórfico mais conhecido foi criado em 1992 pelo hacker Dark Avenger como forma de evitar o reconhecimento de padrões do software antivírus. Um vírus polimórfico comum e muito virulento é o vírus infectador de arquivos Virut .

Exemplo

Este exemplo não é realmente um código polimórfico, mas servirá como uma introdução ao mundo da criptografia por meio do operador XOR . Por exemplo, em um algoritmo usando as variáveis ​​A e B, mas não a variável C, pode haver uma grande quantidade de código que altera C, e isso não afetaria o próprio algoritmo, permitindo que ele fosse alterado indefinidamente e sem atenção. sobre qual será o produto final.

Começar:
	GOTO Decryption_Code

Criptografado:
	...muito código criptografado...

Decryption_Code:
	C = C + 1
	A = Criptografado
Ciclo:
	B = *A
	C = 3214 * A
	B = B XOR CryptoKey
	*A = B
	C = 1
	C = A + B
	A = A + 1
	GOTO Loop IF NOT A = Decryption_Code
	C = C^2
	GOTO Criptografado
Chave Criptográfica:
	some_random_number

O código criptografado é a carga útil. Para fazer diferentes versões do código, em cada cópia as linhas de lixo que manipulam C serão alteradas. O código dentro de "Encrypted" ("muitos códigos criptografados") pode pesquisar o código entre Decryption_Code e CryptoKey e cada algoritmo para um novo código que faça a mesma coisa. Normalmente, o codificador utiliza uma chave zero (por exemplo; A xor 0 = A) para a primeira geração do vírus, facilitando para o codificador, pois com essa chave o código não é criptografado. O codificador então implementa um algoritmo de chave incremental ou aleatório.

Criptografia polimórfica

O código polimórfico também pode ser usado para gerar algoritmo de criptografia. Este código foi gerado pelo serviço online StringEncrypt. [3] Ele pega a string ou o conteúdo de um arquivo e o criptografa com comandos de criptografia aleatórios e gera código de descriptografia polimórfica em uma das muitas linguagens de programação suportadas:

// criptografado com https://www.stringencrypt.com (v1.1.0) [C/C++] 
// szLabel = "Wikipedia" 
wchar_t szLabel [ 10 ] = { 0xB1A8 , 0xB12E , 0xB0B4 , 0xB03C , 0x33B9 , 0xB30C , 0x3295 , 0xB260 , 0xB5E5 , 0x35A2 };              
 
for ( não assinado tUTuj = 0 , KRspk = 0 ; tUTuj < 10 ; tUTuj ++ ) {            
    KRspk = szLabel [ tUTuj ];  
    KRspk ^= 0x2622 ;  
    KRspk = ~ KRspk ;  
    KRspk -- ; 
    KRspk += tUTuj ;  
    KRspk = ((( KRspk & 0xFFFF ) >> 3 ) | ( KRspk << 13 )) & 0xFFFF ;            
    KRspk += tUTuj ;  
    KRspk -- ; 
    KRspk = (( KRspk << 8 ) | ( ( KRspk & 0xFFFF ) >> 8 )) & 0xFFFF ;             
    KRspk ^= 0xE702 ;  
    KRspk = (( KRspk << 4 ) | ( ( KRspk & 0xFFFF ) >> 12 )) & 0xFFFF ;             
    KRspk ^= tUTuj ;  
    KRspk ++ ; 
    KRspk = ((( KRspk & 0xFFFF ) >> 8 ) | ( KRspk << 8 )) & 0xFFFF ;            
    KRspk = ~ KRspk ;  
    szLabel [ tUTuj ] = KRspk ;  
}
 
wprintf ( szLabel );

Como você pode ver neste exemplo C++, a string foi criptografada e cada caractere foi armazenado em formato criptografado usando o formato UNICODE widechar. Diferentes comandos de criptografia foram usados ​​como bit a bit XOR , NOT , adição, subtração, rotações de bits. Tudo é aleatório, chaves de criptografia, contadores de rotação de bits e ordens de comandos de criptografia também. O código de saída pode ser gerado em C/C++ , C# , Java , JavaScript , Python , Ruby , Haskell , MASM , FASM e AutoIt. Graças à randomização, o algoritmo gerado é sempre diferente. Não é possível escrever ferramentas de descriptografia genéricas e o código compilado com código de criptografia polimórfica deve ser analisado cada vez que for criptografado novamente.

Veja também

Referências

  1. ^ Raghunathan, Srinivasan (2007). Protegendo o software antivírus sob ataques virais (M.Sc.). Universidade Estadual do Arizona. CiteSeerX  10.1.1.93.796 .
  2. ^ Wong, Asa; Selo, M. (2006). "Caça para motores metamórficos". Revista em Virologia Computacional . 2 (3): 211-229. CiteSeerX 10.1.1.108.3878 . doi : 10.1007/s11416-006-0028-7 . S2CID 8116065 .  
  3. ^ Wójcik, Bartosz (2015). Criptografia de String e Arquivo