Tweet
[COLOR="rgb(46, 139, 87)"]
Neste artigo vamos ver como malwares codificar ou criptografar dados que exfiltrated ao Comando e Controle de Servidor de máquinas infectadas. Isso geralmente é feito usando uma codificação personalizada ou algoritmo de criptografia.
É cada vez mais comum nos dias de hoje para ver o malware usando esta técnica para evitar Analistas de Segurança de compreender o tipo de dados que estão sendo trocados entre o malware e seu Servidor. Da mesma forma, estes algoritmos podem também ser usados para randomizar os detalhes do artefato, como nomes dos arquivos ou chaves de registro criadas na máquina infectada.
Em todos esses casos, Análise Comportamental do malware não é suficiente. Só depois de analisar o código utilizado pelo malware podem estes algoritmos ser compreendido.
[COLOR="rgb(46, 139, 87)"]
A maioria dos malwares criar certos artefatos de disco, uma vez que executar. Se esses artefatos disco têm nomes que permanecem os mesmos em várias execuções do malware, então torna-se fácil de descobrir a presença do malware em outras máquinas que utilizam os indicadores recolhidos durante Análise Comportamental.
Para evitar isso, malwares podem usar algoritmos personalizados que são usados para gerar nomes aleatórios para os artefatos de disco que eles criam.
Da mesma forma, a maioria dos malwares vai reunir alguns dados a partir da máquina infectada e enviá-lo para o servidor controlado pelo invasor. Se este canal de comunicação não é criptografada, ou então envia os dados em texto simples, então torna-se trivial para entender a intenção do malware e sua natureza.
Há certas APIs Win32 que muitas vezes são usados para gerar um valor aleatório que por sua vez é usado em um obscurecimento personalizado ou algoritmo de criptografia para embaralhar os nomes de artefatos de disco ou criptografar o canal de comunicação.
Duas dessas APIs Win32 que são bastante utilizados são: GetTickCount () e QueryPerformanceCounter ().
Neste artigo, vamos olhar para a criptografia personalizada e algoritmo de codificação que utiliza QueryPerformanceCounter para gerar um 16 byte Random Seed.
Para efeitos de completude, vamos olhar para como os dados são coletados a partir do tipo de dados que é, seguidos pelos detalhes da criptografia e algoritmos de codificação da máquina e que.
[COLOR="rgb(46, 139, 87)"]
Uma vez que o malware tenha executado com sucesso na máquina, ele passa a reunir vários detalhes específicos para a máquina como o endereço MAC, nome de usuário, nome da máquina, endereço IP, Timestamp e nome de domínio de destino.
Abaixo está uma visão geral de alto nível de como essas informações são coletadas e em que formato eles são capturados.
Os dados são coletados chamando APIs Win32 como GetAdaptersAddresses, GetUserNameA, GetCurrentProcessId, gethostname, gethostbyname e GetLocalTime.
Os dados são coletados usando os valores de retorno das funções acima e armazenado a 0041C1D0 como mostrado abaixo:
Aqui marca: xxsy é um marcador para os dados coletados.
Em seguida, ele chama a principal rotina de criptografia em 00401768 para criptografar dados:
Pilha argumentos:
0041C1D0 - Ponteiro para os dados coletados a partir da máquina
0041C360 - dados criptografados serão armazenados aqui
[COLOR="rgb(46, 139, 87)"]
Depois que os dados foram coletados a partir do sistema, começa a rotina de criptografia. O primeiro passo para a rotina de criptografia é gerar o aleatório que irá ser usado no algoritmo.
Para gerar a semente aleatória, a API QueryPerformanceCounter é usado como mostrado abaixo:
O protótipo da função de QueryPerformanceCounter () é:
Ele aceita um argumento, que é um ponteiro para o contador de desempenho. Uma vez que a API foi executado, ele irá retornar o valor do contador de desempenho no endereço de memória. O valor de retorno tem um tamanho de 2 DWORDs.
No nosso caso, o algoritmo usa apenas a primeira DWORD.
Pilha argumentos pouco antes da chamada para QueryPerformanceCounter:
Assim, o valor de retorno será armazenado no endereço, 0012FD78:
Abaixo está uma explicação do código usado para gerar o byte 16 Semente aleatória:
Depois recupera o valor do contador de desempenho, a primeira DWORD é passado para a subrotina a 00404E27 endereços:
Esta sub-rotina vai modificar o valor do DWORD e finalmente armazenar o byte inferior do termo de ordem elevada em AL. Este valor será, então, escreveu para o novo local de memória.
Em cada ciclo, um byte de semente aleatória é gerada. Uma vez que o comprimento total da semente é de 16 bytes, haverá 16 invocações de QueryPerformanceCounter e ele vai escrever um novo byte de cada vez, para o endereço de memória em que a semente aleatória é armazenado.
A semente aleatória será armazenado no endereço de memória [EDI + ESI], que é 00922D00 no nosso caso.
Antes da geração de semente aleatória:
Ele contém 0xBAADF00D porque é um novo bloco de memória alocada pelo RtlAllocateHeap.
Após a primeira execução do loop, o byte 0 × 27 está escrito a este local:
Depois que o loop acima concluída ea 16 semente aleatória byte completo é gerado e armazenado em 00922D00, ele irá copiar a semente aleatória para um novo local.
Abaixo está uma explicação do código:
EBX aponta para o local onde o valor da semente aleatória serão copiados. Este endereço de memória é 00B30018 no nosso caso. O primeiro byte do este é fixo e é 0 × 01.
A sub-rotina em 00403ED0 é usado para escrever a semente aleatória para o novo local de memória.
Ele copia a semente aleatória da seguinte forma:
1 - Ele copia primeiros 3 bytes da semente aleatória para o novo local, byte por byte.
2 - Em seguida, ele copia 3 DWORDs da semente aleatória para o novo local, DWORD DWORD como mostrado abaixo.
1 - Em seguida, ele escreve um byte para o novo local.
Após a sub-rotina acima foi executada, a nova semente aleatória é armazenado, como mostrado abaixo.
[COLOR="rgb(46, 139, 87)"]
Uma vez que a semente aleatória é gerada e copiado para 00B30018, ele chama uma sub-rotina de 00.401.083 para formar a chave de criptografia.
Os argumentos da pilha:
0012ED30 - Localização da nova chave de criptografia
00922D00 - localização original da semente aleatória
00B30019 - Nova localização da semente aleatória
Depois de entrar na rotina de 00401083:
O malware tem a chave privada usada para a criptografia armazenadas no endereço, 00416CA0. O tamanho desta chave é 0 × 12 DWORDs ou 72 bytes. Esta chave, juntamente com a semente aleatória será usada para formar uma nova chave localizada no 0012ED30.
72 chave byte localizado na 00416CA0:
Aqui está o laço usado para gerar a nova chave:
Aqui está a explicação do código:
Aqui está uma explicação sobre a rotina de criptografia:
Ele lê um DWORD (byte por byte) da semente aleatória.
Ele XORs o DWORD ler a partir da semente aleatória com o DWORD lido chave privada.
Ele armazena o resultado para o local da nova chave de encriptação.
Ele lê os bytes da semente aleatória em uma ordem cíclica. Uma vez que o comprimento da semente aleatória é 0 × 10 bytes ou 4 DWORDs eo comprimento da chave privada é 0 × 48 bytes ou 0 × 12 DWORDs, ele lê os bytes da semente aleatória desde o início, uma vez que tenha terminado de ler todo o bytes.
Antes da rotina chave formação tenha concluído a execução, no endereço 0012ED30:
Uma vez que o loop acima foi executado, a nova chave de criptografia é armazenada em 0012ED30 como mostrado abaixo:
[COLOR="rgb(46, 139, 87)"]
Uma vez que a nova chave codificada é formada e armazenada a 0012ED30, no próximo ciclo esta chave é modificado. Lê dois DWORDs em um tempo e modifica-los usando uma sub-rotina em 00.401.040.
Abaixo está uma explicação do código:
Antes da execução do circuito acima, a chave é a 0012ED30:
Uma vez que a sub-rotina acima foi executada, a chave é alterada, como mostrado abaixo:
[COLOR="rgb(46, 139, 87)"]
Uma vez que a chave de criptografia foi formada, os dados que foram recolhidos anteriormente a partir da máquina será criptografada usando.
Na sub-rotina de criptografia de dados, lemos duas DWORDs de cada vez a partir dos dados e use a chave de criptografia para modificá-los. Uma vez feito isso, cada uma dessas duas DWORDs são escritas para o novo local de memória.
A sub-rotina de 00401040 é utilizada para encriptar DWORDs dois de cada vez.
Ele passa dois parâmetros:
12FD8C - Um dos dois DWORDs criptografados serão armazenados aqui.
41C1D0 - aponta para que os dados sejam criptografados
Lê dois DWORDs em um momento de que os dados sejam criptografados e armazena-os em endereços 12FD88 e 12FD8C como mostrado abaixo:
Uma vez que a sub-rotina em 00401040 foi executado, estes dois DWORDs serão criptografadas, como mostrado abaixo:
Agora, esses dois DWORDs será escrito para o novo local de memória.
Abaixo está uma explicação da sub-rotina de criptografia:
A sub-rotina de 00403ED0 serão usados para escrever o DWORD para o local de memória.
Como pode ser visto acima, o DWORDs em 12FD88 e 12FD8C são trocados e escrita para o novo local de memória, 00B30029.
Além disso, é importante observar que durante a geração da semente aleatória, a 16 semente aleatória byte escrito para o endereço de memória, 00B30018.
Assim, os dados criptografados são armazenados após a semente aleatória.
O circuito continua a executar por cima de todo o comprimento dos dados.
Depois do ciclo foi executado completamente, os dados criptografados são armazenados como mostrado abaixo:
[COLOR="rgb(46, 139, 87)"]
Uma vez que os dados são codificados e armazenados a 00B30029, no próximo sub-rotina de 004011E8 seja ofuscado.
Os dois parâmetros passados para a rotina de ofuscamento são:
00B30018 - Ponteiro para a semente aleatória e dados criptografados
0041C360 - Os dados ofuscado finais serão armazenados aqui
Se entrar no sub-rotina em 004011E8, podemos ver o algoritmo ofuscação aqui:
O loop interno irá correr três vezes e escrever três bytes para o novo local de memória. O loop externo usará o terceiro byte da seqüência anterior de bytes e modificá-lo e escrever para o novo local de memória.
Loop externo será executado 0 × 39 vezes, ele vai escrever quatro bytes para o novo local de memória de cada vez.
Abaixo está uma explicação do código:
Como pode ser visto acima, ele modifica os bytes de dados criptografados e a semente aleatória. Também adiciona um byte extra após cada 3 bytes, que é uma modificação do terceiro byte na sequência de byte anterior.
Antes da ofuscação de dados criptografados:
Após a ofuscação de dados criptografados:
Assim, o novo tamanho dos dados ofuscado é maior do que os dados criptografados.
[COLOR="rgb(46, 139, 87)"]
Uma vez que os dados são criptografados e armazenados em 0041C360, no próximo sub-rotina o malware irá codificar esses dados como mostrado abaixo:
Abaixo está uma explicação do código:
Esse algoritmo de codificação irá verificar o valor de cada byte lido a partir dos dados criptografados e modificá-lo com base em diversas comparações. Os dados criptografados resultantes consistirá em caracteres ASCII legível, conforme mostrado abaixo:
[COLOR="rgb(46, 139, 87)"]
Uma vez que os dados criptografados são recebidos pelo servidor, ele irá usar o algoritmo de descriptografia para recuperar os dados. No entanto, a fim de decifrar, o servidor requer a semente aleatória que foi gerado no lado do cliente e usado para formar os dados criptografados.
Todos os outros elementos utilizados para realizar a codificação, tais como a chave privada já estão disponíveis para o servidor.
Se olharmos para os dados criptografados armazenados em 0041C360 como mostrado acima, o primeiro byte é sempre fixo como 0 × 41. Os próximos 16 bytes são a versão ofuscada da semente aleatória.
Na seção de geração de semente aleatória, podemos ver que a semente aleatória de 16 bytes é escrito na memória 00B30019 endereço. Depois, é usado para formar a chave de encriptação e encriptar os dados, na fase de obscurecimento, o aleatório si também é ofuscado.
Assim, a semente aleatória está presente no cabeçalho dos dados criptografados enviados para o servidor. Desta forma, o servidor agora tem todos os elementos necessários para decifrar e recuperar os dados.
[COLOR="rgb(46, 139, 87)"]
Agora que os dados estão codificados e armazenadas a 00413C60, está pronto para ser transferido para o servidor. No nosso caso, o malware faz uso do protocolo HTTP para enviar esses dados para o servidor.
Primeiro, ele forma o campo de cabeçalho HTTP, "Set-Cookie:" como mostrado abaixo:
Pilha argumentos:
A sub-rotina em 00404A40 leva dois argumentos.
00B30018 - ponteiro para o Set-Cookie: Header
0041C360 - Ponteiro para os dados criptografados
Após esta sub-rotina foi executado:
Uma vez feito isso, ele irá adicionar esse campo para os cabeçalhos da requisição HTTP:
Pilha argumentos:
00CC000C - identificador retornado por HTTPOpenRequestA
00B30018 - ponteiro para o conjunto de campos-biscoito que precisa de ser adicionada ao pedido cabeçalhos HTTP
Em seguida, ele cria um Thread no estado suspenso:
Pilha argumentos:
Ele retoma a linha chamando WaitForSingleObject:
0x1C8 é o identificador do tópico criado acima.
Uma vez WaitForSingleObject foi executado, nós quebramos a função de thread em 0040196C.
Esta função segmento será usado para enviar a solicitação HTTP para o servidor:
Uma vez HTTPSendRequestA foi executado, ele irá enviar a solicitação HTTP para o servidor, juntamente com os dados criptografados enviados no campo de cabeçalho Set-Cookie.
Desta forma, podemos ver como o malware proteger os dados trocados entre eles e seus servidores a partir de análise comportamental. Estes métodos também podem ser utilizados para randomizar os detalhes do artefato para evitar a descoberta de malware em outras máquinas.
Introdução
[/COLOR]Neste artigo vamos ver como malwares codificar ou criptografar dados que exfiltrated ao Comando e Controle de Servidor de máquinas infectadas. Isso geralmente é feito usando uma codificação personalizada ou algoritmo de criptografia.
É cada vez mais comum nos dias de hoje para ver o malware usando esta técnica para evitar Analistas de Segurança de compreender o tipo de dados que estão sendo trocados entre o malware e seu Servidor. Da mesma forma, estes algoritmos podem também ser usados para randomizar os detalhes do artefato, como nomes dos arquivos ou chaves de registro criadas na máquina infectada.
Em todos esses casos, Análise Comportamental do malware não é suficiente. Só depois de analisar o código utilizado pelo malware podem estes algoritmos ser compreendido.
[COLOR="rgb(46, 139, 87)"]
Randomização
[/COLOR]A maioria dos malwares criar certos artefatos de disco, uma vez que executar. Se esses artefatos disco têm nomes que permanecem os mesmos em várias execuções do malware, então torna-se fácil de descobrir a presença do malware em outras máquinas que utilizam os indicadores recolhidos durante Análise Comportamental.
Para evitar isso, malwares podem usar algoritmos personalizados que são usados para gerar nomes aleatórios para os artefatos de disco que eles criam.
Da mesma forma, a maioria dos malwares vai reunir alguns dados a partir da máquina infectada e enviá-lo para o servidor controlado pelo invasor. Se este canal de comunicação não é criptografada, ou então envia os dados em texto simples, então torna-se trivial para entender a intenção do malware e sua natureza.
Há certas APIs Win32 que muitas vezes são usados para gerar um valor aleatório que por sua vez é usado em um obscurecimento personalizado ou algoritmo de criptografia para embaralhar os nomes de artefatos de disco ou criptografar o canal de comunicação.
Duas dessas APIs Win32 que são bastante utilizados são: GetTickCount () e QueryPerformanceCounter ().
Neste artigo, vamos olhar para a criptografia personalizada e algoritmo de codificação que utiliza QueryPerformanceCounter para gerar um 16 byte Random Seed.
Para efeitos de completude, vamos olhar para como os dados são coletados a partir do tipo de dados que é, seguidos pelos detalhes da criptografia e algoritmos de codificação da máquina e que.
[COLOR="rgb(46, 139, 87)"]
Coleta de Dados
[/COLOR]Uma vez que o malware tenha executado com sucesso na máquina, ele passa a reunir vários detalhes específicos para a máquina como o endereço MAC, nome de usuário, nome da máquina, endereço IP, Timestamp e nome de domínio de destino.
Abaixo está uma visão geral de alto nível de como essas informações são coletadas e em que formato eles são capturados.
Os dados são coletados chamando APIs Win32 como GetAdaptersAddresses, GetUserNameA, GetCurrentProcessId, gethostname, gethostbyname e GetLocalTime.
Os dados são coletados usando os valores de retorno das funções acima e armazenado a 0041C1D0 como mostrado abaixo:
Aqui marca: xxsy é um marcador para os dados coletados.
Em seguida, ele chama a principal rotina de criptografia em 00401768 para criptografar dados:
Pilha argumentos:
0041C1D0 - Ponteiro para os dados coletados a partir da máquina
0041C360 - dados criptografados serão armazenados aqui
[COLOR="rgb(46, 139, 87)"]
Geração Random Seed
[/COLOR]Depois que os dados foram coletados a partir do sistema, começa a rotina de criptografia. O primeiro passo para a rotina de criptografia é gerar o aleatório que irá ser usado no algoritmo.
Para gerar a semente aleatória, a API QueryPerformanceCounter é usado como mostrado abaixo:
O protótipo da função de QueryPerformanceCounter () é:
Código:
BOOL WINAPI QueryPerformanceCounter( _Out_ LARGE_INTEGER *lpPerformanceCount );
No nosso caso, o algoritmo usa apenas a primeira DWORD.
Pilha argumentos pouco antes da chamada para QueryPerformanceCounter:
Assim, o valor de retorno será armazenado no endereço, 0012FD78:
Abaixo está uma explicação do código usado para gerar o byte 16 Semente aleatória:
Código:
LEA EAX,DWORD PTR SS:[EBP-1C] PUSH EAX ; pointer to Performance Counter CALL DWORD PTR DS:[<&KERNEL32.QueryPerf>; QueryPerformanceCounter PUSH DWORD PTR SS:[EBP-1C] ; Arg1 (1st DWORD of Performance Counter) CALL sysmgr.00404E15 POP ECX CALL sysmgr.00404E27 ; Subroutine to modify the first DWORD MOV BYTE PTR DS:[EDI+ESI],AL ; Form the Random Seed byte by byte TEST AL,AL JNZ SHORT sysmgr.004017B7 MOV BYTE PTR DS:[EDI+ESI],1 INC EDI CMP EDI,10 ; Total Length of the seed is 0x10 bytes JL SHORT sysmgr.00401794
Esta sub-rotina vai modificar o valor do DWORD e finalmente armazenar o byte inferior do termo de ordem elevada em AL. Este valor será, então, escreveu para o novo local de memória.
Em cada ciclo, um byte de semente aleatória é gerada. Uma vez que o comprimento total da semente é de 16 bytes, haverá 16 invocações de QueryPerformanceCounter e ele vai escrever um novo byte de cada vez, para o endereço de memória em que a semente aleatória é armazenado.
A semente aleatória será armazenado no endereço de memória [EDI + ESI], que é 00922D00 no nosso caso.
Antes da geração de semente aleatória:
Ele contém 0xBAADF00D porque é um novo bloco de memória alocada pelo RtlAllocateHeap.
Após a primeira execução do loop, o byte 0 × 27 está escrito a este local:
Depois que o loop acima concluída ea 16 semente aleatória byte completo é gerado e armazenado em 00922D00, ele irá copiar a semente aleatória para um novo local.
Abaixo está uma explicação do código:
Código:
PUSH 10 LEA EAX,DWORD PTR DS:[EBX+1] PUSH ESI PUSH EAX MOV BYTE PTR DS:[EBX],1 ; EBX is 00B30018 where the random seed is copied to. CALL sysmgr.00403ED0
A sub-rotina em 00403ED0 é usado para escrever a semente aleatória para o novo local de memória.
Código:
MOV AL,BYTE PTR DS:[ESI] ; ESI points to the original location of random seed. MOV BYTE PTR DS:[EDI],AL ; EDI points to the new location of random seed. MOV AL,BYTE PTR DS:[ESI+1] MOV BYTE PTR DS:[EDI+1],AL MOV AL,BYTE PTR DS:[ESI+2] SHR ECX,2 MOV BYTE PTR DS:[EDI+2],AL ADD ESI,3 ADD EDI,3 CMP ECX,8 JB SHORT sysmgr.00403F54
1 - Ele copia primeiros 3 bytes da semente aleatória para o novo local, byte por byte.
2 - Em seguida, ele copia 3 DWORDs da semente aleatória para o novo local, DWORD DWORD como mostrado abaixo.
1 - Em seguida, ele escreve um byte para o novo local.
Após a sub-rotina acima foi executada, a nova semente aleatória é armazenado, como mostrado abaixo.
[COLOR="rgb(46, 139, 87)"]
Formação chave de criptografia
[/COLOR]Uma vez que a semente aleatória é gerada e copiado para 00B30018, ele chama uma sub-rotina de 00.401.083 para formar a chave de criptografia.
Os argumentos da pilha:
0012ED30 - Localização da nova chave de criptografia
00922D00 - localização original da semente aleatória
00B30019 - Nova localização da semente aleatória
Depois de entrar na rotina de 00401083:
Código:
MOV ECX,sysmgr.00416CA0 ; 00416CA0 is the location of the private key PUSH 12 ; The total size of the key is 0x12 DWORDs XOR EDX,EDX SUB ECX,EAX // subtract 12ED30 from 416CA0 POP EDI ; EDI will be used as the outer loop counter
72 chave byte localizado na 00416CA0:
Aqui está o laço usado para gerar a nova chave:
Aqui está a explicação do código:
Código:
XOR ESI,ESI MOV DWORD PTR SS:[EBP-8],4 ; Inicializar o contador de loop interno para 4 MOV EBX,DWORD PTR SS:[EBP+C] ;EBX aponta para o local original de semente aleatória MOVZX EBX,BYTE PTR DS:[EDX+EBX] ; Leia um byte de cada vez a partir da semente aleatória SHL ESI,8 OR ESI,EBX ; ESI será armazenada uma DWORD da semente aleatória INC EDX CMP EDX,10 ; Verifique se todos os bytes da semente aleatória foram lidos JL SHORT sysmgr.004010C7 XOR EDX,EDX ; Se todos os bytes da semente aleatória são lidos em seguida, redefinir EDX DEC DWORD PTR SS:[EBP-8] JNZ SHORT sysmgr.004010B3 MOV EBX,DWORD PTR DS:[ECX+EAX] XOR EBX,ESI ; XOR o DWORD de semente aleatória com o privado chave MOV DWORD PTR DS:[EAX],EBX ; nova chave de encriptação será armazenado a 0012ED30 ADD EAX,4 DEC EDI ; Há um total de 12 DWORDs na chave JNZ SHORT sysmgr.004010AA
Ele lê um DWORD (byte por byte) da semente aleatória.
Ele XORs o DWORD ler a partir da semente aleatória com o DWORD lido chave privada.
Ele armazena o resultado para o local da nova chave de encriptação.
Ele lê os bytes da semente aleatória em uma ordem cíclica. Uma vez que o comprimento da semente aleatória é 0 × 10 bytes ou 4 DWORDs eo comprimento da chave privada é 0 × 48 bytes ou 0 × 12 DWORDs, ele lê os bytes da semente aleatória desde o início, uma vez que tenha terminado de ler todo o bytes.
Antes da rotina chave formação tenha concluído a execução, no endereço 0012ED30:
Uma vez que o loop acima foi executado, a nova chave de criptografia é armazenada em 0012ED30 como mostrado abaixo:
[COLOR="rgb(46, 139, 87)"]
Chave Modificação de rotina
[/COLOR]Uma vez que a nova chave codificada é formada e armazenada a 0012ED30, no próximo ciclo esta chave é modificado. Lê dois DWORDs em um tempo e modifica-los usando uma sub-rotina em 00.401.040.
Abaixo está uma explicação do código:
Código:
MOV ECX,DWORD PTR SS:[EBP+8] ; ECX points to the key LEA EAX,DWORD PTR SS:[EBP-4] ; This will hold the final modified value of the first DWORD PUSH EAX ; EAX points to 0012ED00 LEA EBX,DWORD PTR SS:[EBP-8] ; This will hold the final modified value of the second DWORD CALL sysmgr.00401040 MOV EAX,DWORD PTR SS:[EBP+8] ; EAX points again to the start of the Key, 0012ED30 POP ECX ; 0012ED00 MOV ECX,DWORD PTR SS:[EBP-4] ; Final DWORD from previous iteration is stored in ECX MOV DWORD PTR DS:[EAX+ESI*4],ECX ; Modify the first DWORD of the key MOV ECX,DWORD PTR SS:[EBP-8] ; MOV DWORD PTR DS:[EAX+ESI*4+4],ECX ; Modify the second DWORD of the key INC ESI INC ESI ; Increment ESI two times since we are modifying two DWORDs at a time CMP ESI,12 ; The total length of the key is 0x12 DWORDs JL SHORT sysmgr.004010E1
Uma vez que a sub-rotina acima foi executada, a chave é alterada, como mostrado abaixo:
[COLOR="rgb(46, 139, 87)"]
Criptografia de Dados
[/COLOR]Uma vez que a chave de criptografia foi formada, os dados que foram recolhidos anteriormente a partir da máquina será criptografada usando.
Na sub-rotina de criptografia de dados, lemos duas DWORDs de cada vez a partir dos dados e use a chave de criptografia para modificá-los. Uma vez feito isso, cada uma dessas duas DWORDs são escritas para o novo local de memória.
A sub-rotina de 00401040 é utilizada para encriptar DWORDs dois de cada vez.
Ele passa dois parâmetros:
12FD8C - Um dos dois DWORDs criptografados serão armazenados aqui.
41C1D0 - aponta para que os dados sejam criptografados
Lê dois DWORDs em um momento de que os dados sejam criptografados e armazena-os em endereços 12FD88 e 12FD8C como mostrado abaixo:
Uma vez que a sub-rotina em 00401040 foi executado, estes dois DWORDs serão criptografadas, como mostrado abaixo:
Agora, esses dois DWORDs será escrito para o novo local de memória.
Abaixo está uma explicação da sub-rotina de criptografia:
Código:
MOV EAX,DWORD PTR SS:[EBP+8] ; EAX holds the data to be encrypted MOV ECX,DWORD PTR DS:[EAX+EDI*8] ; First DWORD from the data to be encrypted is stored in ECX MOV EAX,DWORD PTR DS:[EAX+EDI*8+4] ; Second DWORD from the data to be encrypted is stored in EAX MOV DWORD PTR SS:[EBP-C],EAX ; Store second DWORD at 0012FD88 LEA EAX,DWORD PTR SS:[EBP-8] MOV DWORD PTR SS:[EBP-8],ECX ; Store the first DWORD at 0012FD8C PUSH EAX LEA EBX,DWORD PTR SS:[EBP-C] LEA ECX,DWORD PTR SS:[EBP-1064] ; Points to the 0x48 byte key CALL sysmgr.00401040 ; Modify the first and second DWORDs stored at 0012FD88 and 0012FD8C PUSH 4 LEA EAX,DWORD PTR SS:[EBP-8] PUSH EAX LEA EAX,DWORD PTR DS:[ESI-4] PUSH EAX CALL sysmgr.00403ED0 ; Store the second DWORD at new memory address PUSH 4 MOV EAX,EBX PUSH EAX PUSH ESI CALL sysmgr.00403ED0 ; Store the first DWORD at the new memory address ADD ESP,1C INC EDI ; Increment EDI to read the next DWORDs from the data to be encrypted ADD ESI,8 CMP EDI,DWORD PTR SS:[EBP+10] ; Total of 13 iterations are required to read all data JL SHORT sysmgr.004017FA
Como pode ser visto acima, o DWORDs em 12FD88 e 12FD8C são trocados e escrita para o novo local de memória, 00B30029.
Além disso, é importante observar que durante a geração da semente aleatória, a 16 semente aleatória byte escrito para o endereço de memória, 00B30018.
Assim, os dados criptografados são armazenados após a semente aleatória.
O circuito continua a executar por cima de todo o comprimento dos dados.
Depois do ciclo foi executado completamente, os dados criptografados são armazenados como mostrado abaixo:
[COLOR="rgb(46, 139, 87)"]
Ofuscação de dados criptografados
[/COLOR]Uma vez que os dados são codificados e armazenados a 00B30029, no próximo sub-rotina de 004011E8 seja ofuscado.
Os dois parâmetros passados para a rotina de ofuscamento são:
00B30018 - Ponteiro para a semente aleatória e dados criptografados
0041C360 - Os dados ofuscado finais serão armazenados aqui
Se entrar no sub-rotina em 004011E8, podemos ver o algoritmo ofuscação aqui:
O loop interno irá correr três vezes e escrever três bytes para o novo local de memória. O loop externo usará o terceiro byte da seqüência anterior de bytes e modificá-lo e escrever para o novo local de memória.
Loop externo será executado 0 × 39 vezes, ele vai escrever quatro bytes para o novo local de memória de cada vez.
Abaixo está uma explicação do código:
Código:
MOV EDI,EDX MOV DWORD PTR SS:[EBP-8],2 ; Initialize local variable (this will be incremented in steps of 2) MOV BYTE PTR SS:[EBP-1],0 ; Initialize local variable MOV EAX,ESI MOV DWORD PTR SS:[EBP-C],6 ; Initialize local variable (this will be decremented in steps of 2) SUB EDI,ESI MOV DWORD PTR SS:[EBP-10],3 ; Inner loop counter MOV BL,BYTE PTR DS:[EAX] ; Read a byte from the encrypted data MOV CL,BYTE PTR SS:[EBP-8] ADD DWORD PTR SS:[EBP-8],2 ; Increment local variable by 2 SHR BL,CL ; modify BL MOV ECX,DWORD PTR SS:[EBP-C] SUB DWORD PTR SS:[EBP-C],2 ; Decrement local variable by 2 OR BL,BYTE PTR SS:[EBP-1] ; Modify BL MOV BYTE PTR DS:[EDI+EAX],BL ; Write BL to new location MOV BL,BYTE PTR DS:[EAX] SHL BL,CL SHR BL,2 INC EAX DEC DWORD PTR SS:[EBP-10] ; Decrement inner loop counter MOV BYTE PTR SS:[EBP-1],BL ; This value will be used in OR operation in next iteration JNZ SHORT sysmgr.0040122B MOV AL,BYTE PTR DS:[ESI+2] AND AL,3F MOV BYTE PTR DS:[EDX+3],AL ADD ESI,3 ADD EDX,4 DEC DWORD PTR SS:[EBP-14] ; Decrement outer loop counter JNZ SHORT sysmgr.0040120C
Antes da ofuscação de dados criptografados:
Após a ofuscação de dados criptografados:
Assim, o novo tamanho dos dados ofuscado é maior do que os dados criptografados.
[COLOR="rgb(46, 139, 87)"]
Codificar os dados ofuscados
[/COLOR]Uma vez que os dados são criptografados e armazenados em 0041C360, no próximo sub-rotina o malware irá codificar esses dados como mostrado abaixo:
Abaixo está uma explicação do código:
Código:
MOV ESI,EAX SHL ESI,2 ; ESI will be the total length of the encrypted data above (0xE4 bytes) XOR EDX,EDX TEST ESI,ESI JLE SHORT sysmgr.004012B5 MOV EAX,DWORD PTR SS:[EBP+C] ; EAX points to encrypted data LEA ECX,DWORD PTR DS:[EDX+EAX] ; EDX is the counter used as an offset into the encrypted data MOV AL,BYTE PTR DS:[ECX] ; Read a byte from the encrypted data CMP AL,19 ; If less than 19 then add 41 to it JA SHORT sysmgr.00401286 ADD AL,41 JMP SHORT sysmgr.0040129C CMP AL,1A ; If it is greater than 19 then it checks if it is lesser than 1A JB SHORT sysmgr.00401292 CMP AL,33 JA SHORT sysmgr.00401292 ADD AL,47 ; Add 47 if it is greater than 1A but less than 33 JMP SHORT sysmgr.0040129C CMP AL,34 JB SHORT sysmgr.004012A0 CMP AL,3D JA SHORT sysmgr.004012A0 SUB AL,4 ; If greater than 34 but less than 3D then subtract 4 MOV BYTE PTR DS:[ECX],AL ; Write the modified byte into encrypted data JMP SHORT sysmgr.004012B0 CMP AL,3E JNZ SHORT sysmgr.004012A9 MOV BYTE PTR DS:[ECX],2B JMP SHORT sysmgr.004012B0 CMP AL,3F JNZ SHORT sysmgr.004012B0 MOV BYTE PTR DS:[ECX],2F INC EDX CMP EDX,ESI JL SHORT sysmgr.00401276
[COLOR="rgb(46, 139, 87)"]
Transferência Random Seed
[/COLOR]Uma vez que os dados criptografados são recebidos pelo servidor, ele irá usar o algoritmo de descriptografia para recuperar os dados. No entanto, a fim de decifrar, o servidor requer a semente aleatória que foi gerado no lado do cliente e usado para formar os dados criptografados.
Todos os outros elementos utilizados para realizar a codificação, tais como a chave privada já estão disponíveis para o servidor.
Se olharmos para os dados criptografados armazenados em 0041C360 como mostrado acima, o primeiro byte é sempre fixo como 0 × 41. Os próximos 16 bytes são a versão ofuscada da semente aleatória.
Na seção de geração de semente aleatória, podemos ver que a semente aleatória de 16 bytes é escrito na memória 00B30019 endereço. Depois, é usado para formar a chave de encriptação e encriptar os dados, na fase de obscurecimento, o aleatório si também é ofuscado.
Assim, a semente aleatória está presente no cabeçalho dos dados criptografados enviados para o servidor. Desta forma, o servidor agora tem todos os elementos necessários para decifrar e recuperar os dados.
[COLOR="rgb(46, 139, 87)"]
Enviar os dados criptografados
[/COLOR]Agora que os dados estão codificados e armazenadas a 00413C60, está pronto para ser transferido para o servidor. No nosso caso, o malware faz uso do protocolo HTTP para enviar esses dados para o servidor.
Primeiro, ele forma o campo de cabeçalho HTTP, "Set-Cookie:" como mostrado abaixo:
Pilha argumentos:
A sub-rotina em 00404A40 leva dois argumentos.
00B30018 - ponteiro para o Set-Cookie: Header
0041C360 - Ponteiro para os dados criptografados
Após esta sub-rotina foi executado:
Uma vez feito isso, ele irá adicionar esse campo para os cabeçalhos da requisição HTTP:
Pilha argumentos:
00CC000C - identificador retornado por HTTPOpenRequestA
00B30018 - ponteiro para o conjunto de campos-biscoito que precisa de ser adicionada ao pedido cabeçalhos HTTP
Em seguida, ele cria um Thread no estado suspenso:
Pilha argumentos:
Ele retoma a linha chamando WaitForSingleObject:
0x1C8 é o identificador do tópico criado acima.
Uma vez WaitForSingleObject foi executado, nós quebramos a função de thread em 0040196C.
Esta função segmento será usado para enviar a solicitação HTTP para o servidor:
Uma vez HTTPSendRequestA foi executado, ele irá enviar a solicitação HTTP para o servidor, juntamente com os dados criptografados enviados no campo de cabeçalho Set-Cookie.
Conclusão
Desta forma, podemos ver como o malware proteger os dados trocados entre eles e seus servidores a partir de análise comportamental. Estes métodos também podem ser utilizados para randomizar os detalhes do artefato para evitar a descoberta de malware em outras máquinas.
Comment