Emergenza Sicurezza in Italia: Crescono gli Attacchi Adwind/jRAT, avverte il CERT-AGID

Redazione RHC : 12 Giugno 2024 08:14

Da oltre una settimana il CERT-AGID sta osservando l’attività di una serie di campagne mirate contro l’Italia e finalizzate alla diffusione del malware Adwind/jRAT.

Solitamente, le email includono un archivio ZIP con file HTML denominati FATTURA.html o DOCUMENTO.html. In alcuni casi viene utilizzata anche una doppia estensione file come .pdf.html.

Il file HTML contiene un codice JavaScript che verifica la lingua impostata sul browser in cui viene aperto. Se la lingua del browser è impostata su italiano, viene mostrato il contenuto della pagina malevola, altrimenti viene visualizzata una pagina vuota.

CORSO NIS2 : Network and Information system 2
La direttiva NIS2 rappresenta una delle novità più importanti per la sicurezza informatica in Europa, imponendo nuovi obblighi alle aziende e alle infrastrutture critiche per migliorare la resilienza contro le cyber minacce. Con scadenze stringenti e penalità elevate per chi non si adegua, comprendere i requisiti della NIS2 è essenziale per garantire la compliance e proteggere la tua organizzazione.

Accedi All'Anteprima del Corso condotto dall'Avv. Andrea Capelli sulla nostra Academy e segui l'anteprima gratuita.
Per ulteriori informazioni, scrivici ad [email protected] oppure scrivici su Whatsapp al 379 163 8765 

Supporta RHC attraverso:

• L'acquisto del fumetto sul Cybersecurity Awareness
• Ascoltando i nostri Podcast
• Seguendo RHC su WhatsApp
• Seguendo RHC su Telegram
• Scarica gratuitamente "Dark Mirror", il report sul ransomware di Dark Lab

Ti piacciono gli articoli di Red Hot Cyber? Non aspettare oltre, iscriviti alla newsletter settimanale per non perdere nessun articolo.

Lo script visualizza un’immagine codificata in base64 all’interno del codice HTML. Il falso messaggio avverte che si sta utilizzando una versione obsoleta di Adobe Acrobat Reader e invita a cliccare su ‘OK’ per visualizzare correttamente il documento. Se la vittima clicca su ‘OK’, viene rilasciato un file denominato FATTURA.jar, anch’esso codificato in base64 all’interno della pagina HTML. In alcuni casi il file JAR viene scaricato da remoto.

Il file JAR non è valutato come completamente malevolo da VirusTotal e dalle sandbox online ed è quindi stato analizzato per determinarne la sua reale natura.

Analisi del file FATTURA.jar

Il file FATTURA.jar contiene una serie di stringhe cifrate con diversi algoritmi. Nello screenshot è evidente l’uso di Blowfish e DES, oltre alla funzione che verifica che la lingua del sistema in cui viene eseguito sia impostata su “Italiano”. Questo spiega anche il perché le sandbox online non lo rilevano come malware: sia il sistema che il browser delle sandbox sono configurati per impostazione predefinita in lingua inglese.

In generale, prima di procedere con la decifratura delle stringhe, devono essere soddisfatte due condizioni: la lingua del sistema deve essere impostata sull’italiano ed il file non deve essere eseguito in un ambiente virtuale.

Decifriamo le stringhe contenute

Bypassando le verifiche preliminari e richiamando direttamente le funzioni che decifrano le stringhe, costituite da una coppia di dati (la stringa e la chiave), è possibile ottenere le stringhe in chiaro. Di seguito il codice utilizzato su JDoodle:

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Arrays;

public class Decoder {
    private static String I(String encrypted, String key) {
        try {
            SecretKeySpec secretKey = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(key.getBytes(StandardCharsets.UTF_8)), "Blowfish");
            Cipher cipher = Cipher.getInstance("Blowfish");
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            return new String(cipher.doFinal(Base64.getDecoder().decode(encrypted.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private static String lI(String encrypted, String key) {
        try {
            SecretKeySpec secretKey = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(key.getBytes(StandardCharsets.UTF_8)), 8), "DES");
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            return new String(cipher.doFinal(Base64.getDecoder().decode(encrypted.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private static String l(String encrypted, String key) {
        String decoded = new String(Base64.getDecoder().decode(encrypted.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8);
        StringBuilder result = new StringBuilder();
        char[] keyChars = key.toCharArray();
        int keyIndex = 0;
        
        for (char c : decoded.toCharArray()) {
            result.append((char) (c ^ keyChars[keyIndex % keyChars.length]));
            keyIndex++;
        }
        return result.toString();
    }

    public static void main(String[] args) {
        System.out.println(I("c4cP17/Ozgm4UJ4L/OUakHUO85Hd8xxIoiS/LdTP+3+cCoxcASMrgYEKi12LcXT2n9qwDp9k67k=", "XdZXl"));
        System.out.println(l("IT0JCisQIgdNKsKCbxYCPRRvFQgrUSoeCDoEOwcJNlEqC00qGDwSCDQQPEYONhxvDwkwHiIHTTAFLgoEOB8gSA==", "qOfmY"));
        System.out.println(I("qI2Nxm2h7RW8T6rl0/IzKrjPGf85prFO8cVbYSE10v3tGpqqnjwp12uPy2ZIw5MM", "HKGxY"));
        System.out.println(I("4K7haJfBFUjNcdGEyU4wUElF8WNjZBgkX5eFOgbJwX8=", "wiuwr"));
        System.out.println(lI("3OLsw4/8fBolWnKA82rdkFWfVh2M7WFMi2BiFcXKmKU=", "KyXRP"));
        System.out.println(l("OSc7JHN+LCw3cw==", "SFMES"));
        System.out.println(I("XhJKXq1hOAu09FXWTD+FpqdU0uQ6l1+tOY8Gi9Yj6Yg=", "cZGuC"));
        System.out.println(lI("VCwJQQXvuXRH1abDaCA3HwZkK00ujT5z", "qYlCP"));
        System.out.println(lI("AOThA7c08M/VArRAsjMTjw==", "MnJEM"));
        System.out.println(I("A2TWtQnOsHo=", "ruOpk"));
        System.out.println(lI("CCJPVcwtVwVcC9/nJPfs4Vq3aBFMTX17", "fjOyg"));
        System.out.println(I("MHAqSAt0tA0=", "Yujla"));
        System.out.println(I("HyLpIz3LmJR71AV4fjoMlHkuR2u9ruuBqkSmjmhs9kg=", "fLXov"));
        System.out.println(I("0HD7DEkuYgs=", "polhh"));
    }
}

L’output ottenuto è il seguente:

Il risultato ottenuto è di semplice comprensione: è evidente che viene scaricato un file (Imagem.jpg) da una risorsa remota e successivamente eseguito con il comando ‘java -jar‘, il che indica che il file jpg è in realtà un nuovo file JAR.

Analisi di Imagem.jar

Questo file, ad oggi, non risulta malevolo secondo VirusTotal. Procediamo quindi con l’analisi del codice utilizzando Bytecode Viewer.

Esattamente come nel caso del precedente file JAR, anche in questo caso vengono eseguiti gli stessi controlli prima di decifrare le stringhe mediante gli algoritmi standard. In particolare, notiamo che questo file scarica un altro file da una URL specifico (URLConnection) che corrisponde alla stringa llI[lll[2]].

Decifriamo quindi la URL

Procediamo come fatto precedentemente e utilizziamo ancora una volta il servizio JDoodle per ottenere rapidamente il risultato dal seguente codice:

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Base64;
import java.util.Arrays;

public class Decryptor {
    private static String lllII(String lllllIlIllIIlIl, String lllllIlIllIIlII) {
        try {
            SecretKeySpec lllllIlIllIlIlI = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(lllllIlIllIIlII.getBytes(StandardCharsets.UTF_8)), 8), "DES");
            Cipher lllllIlIllIIIlI = Cipher.getInstance("DES");
            lllllIlIllIIIlI.init(Cipher.DECRYPT_MODE, lllllIlIllIlIlI);
            byte[] decryptedBytes = lllllIlIllIIIlI.doFinal(Base64.getDecoder().decode(lllllIlIllIIlIl.getBytes(StandardCharsets.UTF_8)));
            return new String(decryptedBytes, StandardCharsets.UTF_8);
        } catch (Exception var4) {
            var4.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        String encryptedString = "NOLCvB8WVVJVCjn/M2XHbIA5HPX6pYFS4Sns11Ve2dpoyGIdYOIG4g==";
        String encryptionKey = "YCVrc";

        String decryptedString = lllII(encryptedString, encryptionKey);
        System.out.println("Decrypted String: " + decryptedString);
    }
}

L’output ottenuto è il seguente:

Anche questa volta ci troviamo di fronte a un nuovo file JAR camuffato da immagine (Imagem.png).

Ed ecco Adwind!

Siamo arrivati all’ultimo stadio: il file ottenuto viene correttamente identificato e classificato come Adwind / jRAT / njRAT dalla sandbox Any.Run. Questo perchè, avendo superato i due stadi iniziali, il codice finale non contiene più controlli particolari, ma si occupa solo di compiere le sue azioni malevole:

La struttura del codice è piuttosto nota: Adwind / jRAT sono già conosciuti e sono stati analizzati in passato.

Conclusioni

Adwind/jRAT è un trojan di accesso remoto (RAT), noto per la sua modularità, che sfrutta Java per assumere il controllo del sistema compromesso e raccogliere dati dalle macchine delle vittime. Grazie alla presenza dei due stadi iniziali, risulta difficile individuare o isolare subito il malware all’interno di una sandbox. È importante notare che, senza un’analisi dettagliata del codice e del comportamento dinamico del malware in un ambiente controllato, è difficile fornire una valutazione accurata delle sue capacità e degli obiettivi a cui mirano gli attaccanti.

In fine, anche se Adwind/jRAT è generalmente indipendente dalla piattaforma, questa variante, come le altre osservate negli anni precedenti, si concentra esclusivamente sulle macchine Windows e sulle applicazioni comuni.

Indicatori di Compromissione

Per facilitare le azioni di contrasto della campagna fraudolenta, di seguito vengono riportati gli IoC identificati durante l’analisi, che sono stati già condivisi con le PA accreditate al Flusso IoC del CERT-AgID.

Redazione
La redazione di Red Hot Cyber è composta da un insieme di persone fisiche e fonti anonime che collaborano attivamente fornendo informazioni in anteprima e news sulla sicurezza informatica e sull'informatica in generale.

Lista degli articoli