Como o trojan Android Gustuff pilha (fiat e cripto) suas contas

Recentemente, a Group-IB informou sobre a atividade do trojan móvel Android Gustuff. Ele opera exclusivamente em mercados internacionais, atacando clientes dos 100 maiores bancos estrangeiros, usuários de 32 carteiras de criptomoedas, além de grandes plataformas de e-commerce. O desenvolvedor do Gustuff é um cibercriminoso de língua russa conhecido pelo pseudônimo Bestoffer. Há pouco tempo, ele elogiava seu trojan como "um produto sério para pessoas com conhecimento e experiência".

O especialista em análise de malware da Group-IB Ivan Pizarev em sua pesquisa, explica detalhadamente como o Gustuff funciona e quais são seus perigos.

Quem o Gustuff ataca

O Gustuff pertence a uma nova geração de malwares com funções totalmente automatizadas. Segundo o desenvolvedor, o trojan é uma nova versão aprimorada do malware AndyBot, que desde novembro de 2017 ataca telefones com sistema operacional Android e rouba dinheiro através de formulários de phishing disfarçados como aplicativos móveis de bancos internacionais conhecidos e sistemas de pagamento. Bestoffer informou que o aluguel do "Gustuff Bot" custava $800 por mês.

A análise da amostra do Gustuff mostrou que o trojan potenciais mira clientes que usam aplicativos móveis dos maiores bancos, como Bank of America, Bank of Scotland, J.P. Morgan, Wells Fargo, Capital One, TD Bank, PNC Bank, além de carteiras de criptomoedas como Bitcoin Wallet, BitPay, Cryptopay, Coinbase, entre outros.

Originalmente criado como um trojan bancário clássico, na versão atual, o Gustuff ampliou significativamente a lista de potenciais alvos para ataque. Além de aplicativos bancários Android, fintechs e serviços de criptomoedas, o Gustuff tem como alvo usuários de aplicativos de marketplaces, lojas online, sistemas de pagamento e mensageiros. Em particular, PayPal, Western Union, eBay, Walmart, Skype, WhatsApp, Gett Taxi, Revolut e outros.

Ponto de entrada: expectativa de infecção em massa

O Gustuff é caracterizado por um vetor de infiltração "clássico" em smartphones Android através de envios de SMS com links para APKs. Ao infectar um dispositivo Android, o trojan pode, por comando do servidor, se espalhar pela lista de contatos do telefone infectado ou pela base de dados do servidor. As funcionalidades do Gustuff são voltadas para infecções em massa e para a maximização da capitalização dos negócios de seus operadores – ele possui uma função única de "auto-upload" em aplicativos bancários móveis legítimos e carteiras de criptomoedas, o que permite acelerar e escalar o roubo de dinheiro.

A pesquisa sobre o trojan revelou que a função de auto-upload está implementada nele através do Accessibility Service — um serviço para pessoas com deficiência. O Gustuff não é o primeiro trojan a contornar com sucesso a proteção contra interação com elementos de janelas de outros aplicativos usando este serviço do Android. No entanto, o uso do Accessibility Service em combinação com o auto-upload ainda é um fenômeno relativamente raro.

Após ser baixado no telefone da vítima, o Gustuff, utilizando o Accessibility Service, obtém a habilidade de interagir com elementos de janelas de outros aplicativos (bancários, de criptomoedas, bem como aplicativos de compras online, mensagens, entre outros), realizando as ações necessárias para os criminosos. Por exemplo, a pedido do servidor, o trojan pode pressionar botões e alterar valores em campos de texto em aplicativos bancários. O uso do mecanismo Accessibility Service permite que o trojan contorne os mecanismos de proteção utilizados pelos bancos para combater trojans móveis de gerações anteriores, assim como as mudanças nas políticas de segurança implementadas pelo Google nas novas versões do sistema operacional Android. Assim, o Gustuff "sabe" desativar a proteção do Google Protect: segundo o autor, essa função é ativada em 70% dos casos.

Além disso, o Gustuff pode mostrar notificações PUSH falsas com ícones de aplicativos móveis legítimos. O usuário clica na notificação PUSH e vê uma janela de phishing carregada do servidor, onde ele mesmo insere os dados do cartão bancário ou da carteira de criptomoedas solicitados. Em outro cenário de operação do Gustuff, ocorre a abertura do aplicativo, do qual a notificação PUSH foi exibida. Nesse caso, o malware, por comando do servidor através do Accessibility Service, pode preencher os campos do formulário do aplicativo bancário para uma transação fraudulenta.

As funcionalidades do Gustuff também incluem o envio de informações sobre o dispositivo infectado para o servidor, capacidade de ler/enviar mensagens SMS, enviar solicitações USSD, iniciar SOCKS5 Proxy, acessar links, enviar arquivos (incluindo digitalizações de documentos, capturas de tela, fotos) para o servidor, e restaurar o dispositivo para as configurações de fábrica.

Análise do malware

Antes da instalação do aplicativo malicioso, o sistema operacional Android exibe para o usuário uma janela contendo uma lista de permissões solicitadas pelo Gustuff:

A instalação do aplicativo só ocorrerá após a obtenção do consentimento do usuário. Após o lançamento do aplicativo, o trojan mostrará ao usuário uma janela:

Após isso, ele removerá seu ícone.

O Gustuff é empacotado, segundo o autor, pelo empacotador da FTT. Após a execução, o aplicativo periodicamente se conecta ao servidor CnC para receber comandos. Em vários arquivos que analisamos, foi utilizado como servidor de controle um endereço IP 88.99.171[.]105 (daqui em diante denominado como <%CnC%>).

Após a inicialização, o programa começa a enviar mensagens para o servidor http:///api/v1/get.php.

Como resposta, espera-se um JSON no seguinte formato:

{
    "results" : "OK",
    "command":{
        "id": "",
        "command":"",
        "timestamp":"",
        "params":{
		
        },
    },
}

A cada solicitação, o aplicativo envia informações sobre o dispositivo infectado. O formato da mensagem é apresentado abaixo. Vale ressaltar que os campos full, extra, apps e permission são opcionais e serão enviados apenas em caso de solicitação de comando de CnC.

{
 "info":
 {
 "info":
 {
 "cell":<<%Sim operator name%>,
 "country":<<%Country ISO%>,
 "imei":<<%IMEI%>,
 "number":<<%Phone number%>,
 "line1Number":<<%Phone number%>,
 "advertisementId":<<%ID%>
 },
 "state":
 {
 "admin":<<%Has admin rights%>,
 "source":<<%String%>,
 "needPermissions":<<%Application needs permissions%>,
 "accesByName":<<%Boolean%>,
 "accesByService":<<%Boolean%>,
 "safetyNet":<<%String%>,
 "defaultSmsApp":<<fault Sms Application%>,
 "isDefaultSmsApp":<<%Current application is Default Sms Application%>,
 "dateTime":<<%Current date time%>,
 "batteryLevel":<<ttery level%>
 },
 "socks":
 {
 "id":<<%Proxy module ID%>,
 "enabled":<<%Is enabled%>,
 "active":<<%Is active%>
 },
 "version":
 {
 "versionName":<<%Package Version Name%>,
 "versionCode":<<%Package Version Code%>,
 "lastUpdateTime":<<%Package Last Update Time%>,
 "tag":<<%Tag, default value: "TAG"%>,
 "targetSdkVersion":<<%Target Sdk Version%>,
 "buildConfigTimestamp":1541309066721
 },
 },
 "full":
 {
 "model":<<vice Model%>,
 "localeCountry":<<%Country%>,
 "localeLang":<<%Locale language%>,
 "accounts":<<%JSON array, contains from "name" and "type" of accounts%>,
 "lockType":<<%Type of lockscreen password%>
 },
 "extra":
 {
 "serial":<<%Build serial number%>,
 "board":<<%Build Board%>,
 "brand":<<%Build Brand%>,
 "user":<<%Build User%>,
 "device":<<%Build Device%>,
 "display":<<%Build Display%>,
 "id":<<%Build ID%>,
 "manufacturer":<<%Build manufacturer%>,
 "model":<<%Build model%>,
 "product":<<%Build product%>,
 "tags":<<%Build tags%>,
 "type":<<%Build type%>,
 "imei":<<%imei%>,
 "imsi":<<%imsi%>,
 "line1number":<<%phonenumber%>,
 "iccid":<<%Sim serial number%>,
 "mcc":<<%Mobile country code of operator%>,
 "mnc":<<%Mobile network codeof operator%>,
 "cellid":<<%GSM-data%>,
 "lac":<<%GSM-data%>,
 "androidid":<<%Android Id%>,
 "ssid":<<%Wi-Fi SSID%>
 },
 "apps":{<%List of installed applications%>},
 "permission":<<%List of granted permissions%>
} 

Armazenamento de dados de configuração

O Gustuff armazena informações essenciais para o funcionamento em um arquivo de preferências. O nome do arquivo, assim como os nomes dos parâmetros, resulta do cálculo do hash MD5 de uma string 15413090667214.6.1<<%name%>, onde <%name%> — o nome-valor original. Interpretação em Python da função de geração de nome:

 nameGenerator(input):
    output = md5("15413090667214.6.1" + input) 

No futuro, nos referiremos como nameGenerator(input).
Assim, o nome do primeiro arquivo: nameGenerator("API_SERVER_LIST"), ele contém valores com os seguintes nomes:

Módulo de processamento de comandos do servidor

O aplicativo armazena os endereços dos servidores CnC como um array codificado em Base85 strings. A lista CnC pode ser alterada ao receber o comando correspondente, e nesse caso, os endereços serão armazenados no arquivo de preferências. servidores Em resposta à solicitação, o servidor envia um comando ao aplicativo. Vale ressaltar que os comandos e parâmetros são apresentados em formato JSON. O aplicativo pode processar os seguintes comandos:

forwardStart

Formato do comando notificação:

{
 "results" : "OK",
 "command":{
 "id": ,
 "command":"notificação",
 "timestamp":,
 "params":{
 "openApp":,
 "array":[
 {"title":,
 "desc":,
 "app":}
 ]
 },
 },
}

A notificação gerada pelo arquivo em análise se parece exatamente com as notificações geradas pelo aplicativo mencionado no campo app. Se o valor do campo openApp — True, ao abrir a notificação, o aplicativo mencionado no campo é iniciado, app. Se o valor do campo openApp — False, então:

• abre uma janela de phishing, cujo conteúdo é baixado do diretório /hgps/
• abre uma janela de phishing, cujo conteúdo é baixado do servidor ?id=&app=
• abre uma janela de phishing disfarçada de Google Play Card, com a possibilidade de inserir os dados do cartão.

O resultado da execução de qualquer comando é enviado pelo aplicativo para set_state.php na forma de um objeto JSON no seguinte formato:

{
    "command":
    {
        "command":,
        "id":,
        "state":
    }
    "id":
}

ActionsService
A lista de comandos que o aplicativo processa inclui ação. Ao receber um comando, o módulo de processamento de comandos acessa este serviço para executar o comando expandido. Como parâmetro, o serviço aceita um objeto JSON. O serviço pode executar os seguintes comandos:

1. PARAMS_ACTION — ao receber tal comando, o serviço primeiro obtém do parâmetro JSON o valor pela chave Type, que pode ser o seguinte:

• serviceInfo – o subcomando obtém do parâmetro JSON o valor pela chave includeNotImportant. Se a flag for igual a True — o aplicativo define a flag FLAG_ISOLATED_PROCESS para o serviço que utiliza o Accessibility Service. Assim, o serviço será iniciado em um processo separado.
• root — obter e enviar ao servidor informações sobre a janela que está atualmente em foco. O aplicativo obtém informações através da classe AccessibilityNodeInfo.
• admin — solicitar privilégios de administrador.
• delay — suspender a operação do ActionsService pelo número de milissegundos indicado no parâmetro pela chave "data".
• windows — enviar uma lista de janelas visíveis ao usuário.
• install — instalar o aplicativo no dispositivo comprometido. O nome do pacote do arquivo está na chave "fileName". O próprio arquivo está no diretório Downloads.
• global – o subcomando é destinado a realizar uma transição da janela atual:
  • para o menu Quick Settings
  • voltar
  • para a tela inicial
  • para as notificações
  • para a janela de aplicativos recentemente abertos

• launch — iniciar o aplicativo. O nome do aplicativo é recebido como parâmetro pela chave data.
• sounds — alterar o modo de som para silenciar.
• unlock — ativa a luz de tela e teclado na máxima intensidade. O aplicativo executa essa ação utilizando WakeLock, indicando a string como tag [Application lable]:INFO
• permissionOverlay — função não implementada (resposta à execução do comando — {"message":"Not support"} ou {"message":"low sdk"})
• gesture — função não implementada (resposta à execução do comando — {"message":"Not support"} ou {"message":"Low API"})
• permissions — este comando é necessário para solicitar permissões para o aplicativo. No entanto, a função de solicitação não foi implementada, portanto, o comando não faz sentido. A lista de permissões solicitadas vem como um array JSON com a chave "permissions". Lista padrão:
  • android.permission.READ_PHONE_STATE
  • android.permission.READ_CONTACTS
  • android.permission.CALL_PHONE
  • android.permission.RECEIVE_SMS
  • android.permission.SEND_SMS
  • android.permission.READ_SMS
  • android.permission.READ_EXTERNAL_STORAGE
  • android.permission.WRITE_EXTERNAL_STORAGE

• open — exibir na tela uma janela de phishing. Dependendo do parâmetro recebido do servidor, o aplicativo pode exibir as seguintes janelas de phishing:
  • Mostrar a janela de phishing, cujo conteúdo está descrito no arquivo no diretório /hgps/. O resultado da interação do usuário com a janela será enviado para o endereço /records.php
  • Mostrar uma janela de phishing, cujo conteúdo é carregado previamente do endereço ?id=&app=. O resultado da interação do usuário com a janela será enviado para o endereço /records.php
  • Mostrar uma janela de phishing disfarçada de Google Play Card.

• interativa — o comando é destinado à interação com elementos de janelas de outros aplicativos através do AcessibilityService. Para interação, foi implementado um serviço especial no aplicativo. O aplicativo investigado pode interagir com janelas:
  • Ativas no momento. Nesse caso, o parâmetro contém o id ou text (nome) do objeto com o qual é necessário interagir.
  • Visíveis para o usuário no momento da execução do comando. O aplicativo seleciona janelas por id.

  Recebendo objetos AccessibilityNodeInfo para os elementos de interesse da janela, o aplicativo pode executar ações dependendo dos parâmetros:

  • focus — definir o foco no objeto.
  • click — clicar no objeto.
  • actionId — executar uma ação pelo ID.
  • setText — alterar o texto do objeto. A alteração do texto pode ser feita de duas maneiras: executando a ação ACTION_SET_TEXT (se a versão do Android do dispositivo infectado for inferior ou igual a LOLLIPOP), ou colocando a string na área de transferência e colando-a no objeto (para versões superiores). Este comando pode ser utilizado para alterar dados em um aplicativo bancário.

2. PARAMS_ACTIONS — é o mesmo que PARAMS_ACTION, apenas chega um array JSON de comandos.

Parece que muitos estarão interessados em ver como é a função de interação com elementos da janela de outro aplicativo. Esta é a forma como essa funcionalidade foi implementada no Gustuff:

boolean interactiveAction(List aiList, JSONObject action, JsonObject res) {
    int count = action.optInt("repeat", 1);
    Iterator aiListIterator = ((Iterable)aiList).iterator();
    int count = 0;
    while(aiListIterator.hasNext()) {
        Object ani = aiListIterator.next();
        if(1 <= count) {
            int index;
            for(index = 1; true; ++index) {
                if(action.has("focus")) {
                    if(((AccessibilityNodeInfo)ani).performAction(1)) {
                        ++count;
                    }
                }
                else if(action.has("click")) {
                    if(((AccessibilityNodeInfo)ani).performAction(16)) {
                        ++count;
                    }
                }
                else if(action.has("actionId")) {
                    if(((AccessibilityNodeInfo)ani).performAction(action.optInt("actionId"))) {
                        ++count;
                    }
                }
                else if(action.has("setText")) {
                    customHeader ch = CustomAccessibilityService.a;
                    Context context = this.getApplicationContext();
                    String text = action.optString("setText");
                    if(performSetTextAction(ch, context, ((AccessibilityNodeInfo)ani), text)) {
                        ++count;
                    }
                }
                if(index == count) {
                    break;
                }
            }
        }
        ((AccessibilityNodeInfo)ani).recycle();
    }
    res.addPropertyNumber("res", Integer.valueOf(count));
}

Função de substituição de texto:

boolean performSetTextAction(Context context, AccessibilityNodeInfo ani, String text) {
    boolean result;
    if(Build$VERSION.SDK_INT >= 21) {
        Bundle b = new Bundle();
        b.putCharSequence("ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE", ((CharSequence)text));
        result = ani.performAction(0x200000, b);  // ACTION_SET_TEXT
    }
    else {
        Object clipboard = context.getSystemService("clipboard");
        if(clipboard != null) {
        ((ClipboardManager)clipboard).setPrimaryClip(ClipData.newPlainText("autofill_pm", ((CharSequence)text)));
        result = ani.performAction(0x8000);  // ACTION_PASTE
        }
        else {
            result = false;
        }
    }
    return result;
}

Assim, ao configurar corretamente o servidor de gerenciamento, o Gustuff pode preencher campos de texto em aplicativos bancários e pressionar os botões necessários para realizar transações. O Trojan não precisa passar pela autorização no aplicativo — basta enviar um comando para demonstrar uma notificação PUSH com a abertura posterior do aplicativo bancário previamente instalado. O usuário completará a autorização, após o que o Gustuff poderá realizar o auto preenchimento.

Módulo de processamento de mensagens SMS

O aplicativo define um manipulador de eventos para a recepção de mensagens SMS no dispositivo infectado. O aplicativo em questão pode receber comandos do operador que chegam no corpo da mensagem SMS. Os comandos são enviados no formato:

7!5=

O aplicativo procura em todas as mensagens SMS recebidas a string 7!5=, ao detectar a linha - decodifica a string do Base64 com deslocamento 4 e executa o comando. Os comandos são semelhantes aos comandos de CnC. O resultado da execução é enviado para o mesmo número de onde o comando foi recebido. Formato da resposta:

7*5=

Opcionalmente, o aplicativo pode enviar todas as mensagens recebidas para o número Root. Para isso, no arquivo de preferências deve ser especificado o número Root e habilitada a flag de redirecionamento de mensagens. A SMS é enviada para o número do atacante no formato:

—

Além disso, opcionalmente o aplicativo pode enviar mensagens para CnC. A SMS é enviada para o servidor em formato JSON:

{
    "id":,
    "sms":
    {
        "text":,
        "number":,
        "date":
    }
}

Se a flag estiver ativada nameGenerator(«DEFAULT_APP_SMS») – o aplicativo interrompe o processamento da mensagem SMS e limpa a lista de mensagens recebidas.

Módulo Proxy

O aplicativo em análise contém um módulo Backconnect Proxy (daqui em diante Módulo Proxy), que possui uma classe separada, incluindo campos estáticos com a configuração. Os dados de configuração são armazenados em um template em texto claro:

Todas as ações executadas pelo Módulo Proxy são registradas em arquivos. Para isso, o aplicativo cria um diretório chamado "logs" no Armazenamento Externo (campo ProxyConfigClass.logsDir na classe de configuração), onde os arquivos de log são armazenados. O registro ocorre em arquivos com os nomes:

1. main.txt – neste arquivo são registrados os logs do funcionamento da classe chamada CommandServer. O registro da string str neste arquivo será chamado de mainLog(str).
2. session-.txt – neste arquivo são salvos os dados de log relacionados a uma determinada sessão de proxy. O registro da string str neste arquivo será chamado de sessionLog(str).
3. server.txt – neste arquivo são registrados todos os dados gravados nos arquivos mencionados acima.

Formato dos dados de log:

[Thread[], id[]]: log-string

As exceções que ocorrem durante a operação do Módulo Proxy também são registradas em um arquivo. Para isso, o aplicativo forma um objeto JSON no formato:

{
 "uncaughtException":
 "thread":
 "message":
 "trace": //Stack trace info
 [
 {
 "ClassName":
 "FileName":
 "LineNumber":
 "MethodName":
 },
 {
 "ClassName":
 "FileName":
 "LineNumber":
 "MethodName":
 }
 ]
}

Em seguida, converte-o em uma representação de string e registra.

A execução do módulo Proxy ocorre após a recepção do comando apropriado. Ao receber o comando para iniciar o módulo Proxy, o aplicativo inicia o serviço denominado MainService, que é responsável pela gestão do funcionamento do módulo Proxy – seu início e parada.

Etapas para iniciar o serviço:

1. Inicia um temporizador que dispara uma vez por minuto e verifica a atividade do módulo Proxy. Se o módulo não estiver ativo, ele o inicia.
Além disso, ao ocorrer o evento android.net.conn.CONNECTIVITY_CHANGE o módulo Proxy é iniciado.

2. O aplicativo cria um wake-lock com o parâmetro PARTIAL_WAKE_LOCK e o captura. Assim, impede que a CPU do dispositivo entre em modo de espera.

3. Inicia a classe de processamento de comandos do módulo Proxy, registrando previamente a string mainLog("start server") e

Server::start() host[], commandPort[], proxyPort[]

onde proxy_cnc, command_port e proxy_port são parâmetros obtidos da configuração do servidor Proxy.

A classe de processamento de comandos é chamada CommandConnection. Imediatamente após a inicialização, executa as seguintes ações:

4. Conecta-se a ProxyConfigClass.host: ProxyConfigClass.commandPort e envia os dados sobre o dispositivo infectado no formato JSON:

{
    "id":,
    "imei":,
    "imsi":,
    "model":,
    "manufacturer":,
    "androidVersion":,
    "country":,
    "partnerId":,
    "packageName":,
    "networkType":,
    "hasGsmSupport":,
    "simReady":,
    "simCountry":,
    "networkOperator":,
    "simOperator":,
    "version":
}

Onde:

• id – um identificador, tenta obter do arquivo de Preferência compartilhada com o nome "x" o valor do campo "id". Se esse valor não puder ser obtido, um novo é gerado. Assim, o módulo Proxy tem seu próprio identificador, que é gerado de forma semelhante ao Bot ID.
• imei – IMEI do dispositivo. Se ocorrer um erro no processo de obtenção do valor, uma mensagem de erro será registrada nesse campo.
• imsi — Identidade do assinante móvel internacional do dispositivo. Se ocorrer um erro ao obter o valor, uma mensagem de erro em texto será gravada neste campo.
• model — O nome visível para o usuário final do produto final.
• manufacturer — O fabricante do produto/hardware (Build.MANUFACTURER).
• androidVersion — string no formato « (),»
• country — localização atual do dispositivo.
• partnerId – string vazia.
• packageName – nome do pacote.
• networkType — tipo da conexão de rede atual (exemplo: «WIFI», «MOBILE»). Em caso de erro, retorna null.
• hasGsmSupport – true – se o telefone suporta GSM, caso contrário false.
• simReady – estado do cartão SIM.
• simCountry — código ISO do país (com base no provedor do cartão SIM).
• networkOperator — nome do operador. Se ocorrer um erro ao obter o valor, uma mensagem de erro em texto será gravada neste campo.
• simOperator — Nome do Provedor de Serviço (SPN). Se ocorrer um erro ao obter o valor, uma mensagem de erro em texto será gravada neste campo.
• version — este campo é armazenado na classe de configuração; para as versões do bot investigadas, foi igual a «1.6».

5. Troca para o modo de espera por comandos do servidor. Os comandos do servidor são enviados no formato:

• 0 offset – comando
• 1 offset – sessionId
• 2 offset – comprimento
• 4 offset — dados

Ao receber um comando, o aplicativo registra:
mainLog(«Header { sessionId], type[], length[] }»)

Os seguintes comandos do servidor são possíveis:

A mensagem PONG é composta por 4 bytes e se apresenta da seguinte forma: 0x04000000.

Ao receber o comando connectionId (para a criação de uma nova conexão) CommandConnection cria uma instância da classe ProxyConnection.

• Aos envolvidos na proxy, há dois classes: ProxyConnection e end. Ao criar a classe ProxyConnection é estabelecida uma conexão ao endereço ProxyConfigClass.host: ProxyConfigClass.proxyPort e um objeto JSON é enviado:

 {
    "id":
}

Em resposta, o servidor envia uma mensagem SOCKS5, que contém o endereço do servidor remoto ao qual deve ser estabelecida a conexão. A interação com este servidor ocorre por meio da classe end. De forma esquemática, o estabelecimento da conexão pode ser representado da seguinte maneira:

Interações de rede

Para evitar a análise de tráfego por sniffers de rede, a interação entre o servidor CnC e o aplicativo pode ser protegida através do protocolo SSL. Todos os dados transmitidos, tanto do servidor quanto para o servidor, estão em formato JSON. Durante a operação, o aplicativo executa as seguintes solicitações:

• http:///api/v1/set_state.php — resultado da execução do comando.
• http:///api/v1/get.php — recebimento do comando.
• http:///api/v1/load_sms.php — extração de mensagens SMS do dispositivo infectado.
• http:///api/v1/load_ab.php — extração da lista de contatos do dispositivo infectado.
• http:///api/v1/aevents.php – a solicitação é feita na atualização dos parâmetros presentes no arquivo de preferências.
• http:///api/v1/set_card.php — extração de dados obtidos através de uma janela de phishing disfarçada de Google Play Market.
• http:///api/v1/logs.php – extração de dados de log.
• http:///api/v1/records.php – extração de dados obtidos através de janelas de phishing.
• http:///api/v1/set_error.php – notificação sobre um erro ocorrido.

Recomendações

Para proteger seus clientes contra a ameaça de trojans móveis, as empresas devem utilizar soluções abrangentes que permitam monitorar e alertar sobre atividades maliciosas sem a necessidade de instalação adicional de software nos dispositivos dos usuários.

Para isso, os métodos de detecção baseados em assinatura de trojans móveis devem ser reforçados com tecnologias de análise comportamental tanto do cliente quanto do próprio aplicativo. A proteção também deve incluir uma função de identificação de dispositivos usando tecnologia de impressão digital, permitindo entender quando uma conta está sendo utilizada em um dispositivo atípico e já foi comprometida por um fraudador.

Um ponto crucial é a possibilidade de análise cross-channel, que permite que as empresas controlem os riscos que surgem não apenas na camada de internet, mas também na camada móvel, por exemplo, em aplicativos de banco móvel, para operações com criptomoedas e quaisquer outros onde uma transação financeira possa ocorrer.

Regras de segurança para usuários:

• não instalar aplicativos para dispositivos móveis com sistema operacional Android de quaisquer fontes além do Google Play, prestando especial atenção às permissões solicitadas pelo aplicativo;
• atualizar regularmente o sistema operacional Android;
• prestar atenção às extensões dos arquivos carregados;
• não visitar recursos suspeitos;
• não clicar em links recebidos por mensagens SMS.

Com a participação de Semena Rogacheva, especialista júnior na pesquisa de malware do Laboratório de Criminalística Digital Group-IB.

Fonte: habr.com