Campagne Adwind / jRAT attive contro obiettivi italiani
adwind jRAT
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.
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.
Decifriamo la configurazione
import hashlib
from Crypto.Cipher import AES
import base64
base64_string = "8pVpyH1XanKgmZlCjbBfYDdBFQiPYlMOHS+SxH0H7fZlxZVK1HzVv1VPcwKJp4KMBshByxQqOxbueYoNprVsZBmlvBG9GmlGteB/Y0VTU8p8Lge8BpUFAf+lhVzKccyN2af52Dkt8527qfVSH/2TL/1TucT676Oa8UkW19lFQVfX7qVYJqJKjZogvoNOF3JApxFPWDyZW1Gr7Fp70mc32WHDZa8aFTvO0870rM5rlcgM+7uI523yaM0ngwJrTTrP"
sha1_hash = hashlib.sha1(b"checksum").digest()
key = sha1_hash[:16]
decoded_data = base64.b64decode(base64_string)
cipher = AES.new(key, AES.MODE_ECB)
decrypted_data = cipher.decrypt(decoded_data)
decrypted_text = decrypted_data.decode('utf-8', errors='ignore').rstrip('\x00')
print(decrypted_text)La stringa ‘base64_string’ è estratta dal file checksum, il quale contiene la configurazione crittografata utilizzando AES in modalità ECB.
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.
Link: Download IoC (ultimo aggiornamento 12/06/2024 @ 10:15)