Dependency Confusion: come hackerare oltre 35 aziende con un solo attacco
19 minAudio
Alex Birsan ha da poco portato a segno un nuovo tipo di attacco informatico basato sull’installazione delle dipendenze software. Proviamo insieme a capire di cosa si tratta e come funziona. Entra a far parte della community Canale Telegram Gruppo Telegram Sostieni il progetto Sostieni tramite Satispay Sostieni tramite Revolut Sostieni tramite PayPal (applica commissioni) Sostieni utilizzando i link affiliati di Pensieri in codice: Amazon, Todoist, Readwise Reader, Satispay Partner Runtime Radio GrUSP - Codice sconto per tutti gli eventi: community_PIC Schrödinger Hat Fonti dell'episodio Dependency Confusion: How I Hacked Into Apple, Microsoft and Dozens of Other Companies - @alex.birsan/dependency-confusion-4a5d60fec610 PHP: News Archive Attrezzatura Shure Microfono Podcast USB MV7 Link affiliati: il costo per te non cambia, ma una piccola parte del ricavato sostiene il podcast. Crediti Montaggio - Daniele Galano - https://www.instagram.com/daniele_galano/ Voce intro - Costanza Martina Vitale Musica - Kubbi - Up In My Jam Musica - Light-foot - Moldy Lotion Cover e trascrizione - Francesco Zubani
Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.
Transcript
From the show. Tap a time to play from there.
Pensieri in codice. Idee dal mondo del software a cura di Valerio Galano. Salve a tutti ragazzi e bentornati su Pensieri in codice. Non capita spesso di poter definire avvicente una storia di informatica o di informatici. Tuttavia qualche settimana fa mi è capitato
di leggere un interessante articolo su Medium in cui l'autore Alex Birsan descriveva il modo in cui ha hackerato oltre 35 aziende grazie ad un particolare tipo di attacco informatico da lui inventato. Questo attacco si basa su di una tecnica di uso estremamente comune nella moderna programmazione e leggerne la descrizione e il tasso di successo mi ha fatto riflettere su alcuni aspetti del modo in cui si sviluppa il software oggigiorno. Come vedremo
fra poco l'attacco è stato sì eseguito sfruttando degli specifici linguaggi di programmazione, ma il concetto alla base è molto ampio e può essere facilmente esteso ad altri linguaggi e ad altri livelli dello sviluppo software. Quindi nell'episodio di oggi parleremo di come è avvenuto questo attacco, del perché è stato eseguito, di che cosa lo ha reso possibile e infine di come questa storia debba servire da lezione a tutti noi sviluppatori.
Alex Birsan è un cacciatore di bug. Ciò vuol dire che il suo lavoro, o almeno parte di esso, consiste nel cercare i bug nei software e nelle piattaforme online. Molte aziende infatti premiano i ricercatori che scovano falle nei loro sistemi. Grosse realtà come Google, Apple e altri hanno
dei programmi di bug counting ai quali è possibile partecipare e che elargiscono compensi in base alle entità dei bug individuati. E così, alla sua ennesima esperienza alla ricerca di bug, Alex ha ben pensato di provare a sfruttare un concetto che nella programmazione moderna è ampiamente diffuso e cioè il concetto di dipendenza. Quando in informatica si parla di dipendenza, solitamente si intende il fatto che un componente o un software sfrutta le
funzionalità di un altro componente o software per svolgere le proprie attività. In altre parole, per fare un esempio semplice e pratico, è molto comune che un programma o un sito web utilizzi porzioni di codice create in precedenza da altre persone. Tali codici vengono comunemente definiti librerie e i loro autori li creano tendenzialmente o per soddisfare necessità abbastanza comuni o per condividere funzionalità fra più software. In generale, quando un programma
o una piattaforma per funzionare includono al proprio interno delle librerie, si dice che queste rappresentano delle dipendenze per il progetto. Ora, inizialmente, e con inizialmente intendo 10, forse 15 o 20 anni fa, le dipendenze si concretizzavano con il copiare materialmente il codice delle librerie necessarie all'interno del codice del nostro programma. Se infatti un nostro software avesse avuto fra le sue varie funzioni quella di creare un file pdf, ad esempio,
invece di scriverci l'intero codice per generare il file in quel particolare formato, avremmo scaricato un'apposita libreria, possibilmente open source e possibilmente nella versione più recente disponibile, e l'avremmo integrata al resto del nostro codice. E così facendo, il nostro programma avrebbe quindi contenuto il nostro codice più una parte di codice scritta da qualcun altro. Il vantaggio di una simile scelta è ovvio, ci avrebbe risparmiato tempo e
fatica evitandoci di riscrivere qualcosa che qualcun altro aveva già scritto e messo a nostra disposizione. E allo stesso modo però anche lo svantaggio è piuttosto chiaro, essendo codice scritto da altri avrebbe potuto contenere dei bug, o addirittura in casi estremi del codice malevolo di qualche tipo. Ora, giusto per essere chiari, non è che se il programma fosse scritto interamente da noi, allora sarebbe esente da bug. Ma è ovvio che è diverso individuare e risolvere i nostri bug
rispetto a quelli presenti nel codice di qualcun altro. In teoria, quando infatti si include una libreria, si dà per scontato che essa funzioni già correttamente e non la si va a ritestare in dettaglio, altrimenti questo vanificherebbe i vantaggi descritti prima. Ad ogni modo, questo concetto di dipendenza fin qui descritto, negli ultimi anni si è andato, diciamo così, istituzionalizzando, entrando a far parte di parecchi linguaggi di programmazione e di parecchi componenti che sono poi diventati lo standard de facto. Pensiamo al Python, al PHP, al Ruby,
Node, Deno... la lista è lunghissima ed elenca tutta una serie di linguaggi di programmazione corredati di un meccanismo atto ad includere in modo automatizzato librerie nei propri progetti e quindi dipendenze. Questo meccanismo è realizzato da un altro componente software che, in linea generale, prende il nome di gestore di pacchetti o in inglese Package Manager. Per me che sviluppo principalmente in PHP, ad esempio, esiste un gestore chiamato Composer che mi
permette di includere librerie di ogni genere, le quali risiedono su di un enorme archivio online. Quando lancio il comando composer require seguito dal nome di un pacchetto, l'operazione eseguita in modo totalmente automatico è molto simile al modo in cui si includevano le dipendenze una volta che abbiamo descritto prima, ma ovviamente è anche un'operazione molto più sofisticata. Il Package Manager, infatti, in pratica ricerca e identifica il pacchetto che ho richiesto e lo fa
su degli archivi chiamati repository, uno dei quali è pubblico e accessibile a tutti mentre altri possono essere privati, creati da noi, dalla nostra azienda o da qualche altra entità che successivamente ci ha concesso l'accesso. Una volta individuato il pacchetto, poi, il Package Manager scarica in un apposito percorso del nostro progetto il codice corrispondente alla versione da noi richiesta o, se non abbiamo specificato alcuna versione, quello corrispondente alla
versione considerata la stabile del momento. Contemporaneamente a tutto questo però il gestore dei pacchetti ha anche un altro compito, in realtà ne ha molti ma in questo momento a noi interessa questo in particolare e cioè quello di creare e mantenere aggiornata una lista di tutte le dipendenze del progetto. Il vantaggio di un approccio del genere è, presto detto, dal momento che esiste una precisa lista delle dipendenze e che queste sono inoltre reperibili online,
poco importa se su repository pubblici o se provengono da server privati o di accesso esclusivo dello sviluppatore, allora è possibile evitare di includere materialmente tutti i file che compongono il progetto all'interno dell'archivio, portando così ad una notevole riduzione della dimensione del codice, cosa che lo rende più facile da maneggiare, da archiviare, da installare. Ora non scenderò in dettaglio perché non è argomento di questo episodio ma
i vantaggi dal punto di vista dello sviluppo e della distribuzione del software rendono questo approccio sicuramente molto migliore di quello descritto in precedenza, ma come per qualsiasi altra cosa non è sempre tutto rose e fiori. Infatti è proprio su questo meccanismo che Alex Birsan ha potuto basare il proprio attacco. In pratica Alex ha pensato di sfruttare i package manager di alcuni linguaggi di programmazione molto diffusi per provare a installare un proprio
codice all'interno dei progetti di moltissime grandi aziende. In particolare si è concentrato su tre linguaggi molto diffusi, Python, Node e Ruby. Cercando su repository pubblici, su motori di ricerca e all'interno di progetti e siti web, si è procurato tutta una serie di file contenenti liste di dipendenze di software utilizzati e sviluppati nelle aziende prese di mira. Ovviamente ciò è stato possibile perché spesso accade che questi file finiscano per sbaglio all'interno di
progetti successivamente resi pubblici, o addirittura in altri progetti ai quali non dovrebbero appartenere, o ancora che vengano pubblicati direttamente online. Ma ad ogni modo, una volta reperita questa serie di file, Alex ha potuto filtrare al loro interno tutte le dipendenze che si trovano pubblicamente disponibili online. L'obiettivo di Alex era procurarsi una lista delle dipendenze private di queste varie aziende, quindi non ha dovuto fare
altro che lavorare per sottrazione, prendere tutte le dipendenze elencate e sottrarre tutte quelle librerie che è riuscito a trovare pubblicamente accessibili sul web. Eliminando quindi tutte le librerie pubbliche dalla lista, gli sono per forza di cose rimaste le dipendenze private, quelle che evidentemente le varie aziende rendevano disponibili ai propri sviluppatori tramite server privati. E a questo punto l'hacker ha potuto sferrare il proprio attacco,
semplicemente creando sui repository pubblici dei vari linguaggi una serie di pacchetti contenenti tutti lo stesso codice, ma aventi ciascuno il nome di uno dei pacchetti privati della lista. Proviamo a capire meglio questo processo con un esempio. Mettiamo che Alex sia riuscito a trovare il file del package manager di un progetto di una grande azienda come ad esempio Paypal. In questo file saranno elencate le dipendenze di tale progetto. Facciamo finta
che siano tre librerie che chiameremo A, B e C. Ora per sferrare il proprio attacco Alex dovrebbe controllare se tutte queste librerie risultano presenti sul repository pubblico. E sempre per amore di esempio immaginiamo che la libreria A non sia fra queste, quindi sia identificabile come una libreria privata di Paypal. A questo punto Alex non dovrebbe far altro che prendere il suo codice e utilizzarlo per creare una libreria sul repository pubblico chiamata A. Al termine di questo processo,
ripetuto per tutte le librerie private identificate, la speranza era quella che gli sviluppatori e magari i sistemi automatizzati adibiti all'installazione dei vari progetti scegliessero di scaricare i pacchetti falsi pubblici di Alex invece di quelli veri privati dell'azienda. E indovinate un po', in effetti è stato così. L'autore ha battezzato questo suo tipo di attacco Dependency Confusion e nell'articolo che vi lascio in descrizione per maggiori dettagli e che vi
consiglio di leggere perché è davvero interessante, Alex racconta di oltre 35 compagnie colpite tra cui Shopify, Apple e Paypal, ciascuna delle quali ha riconosciuto al giovane cacciatore una taglia di 30 mila dollari per il bug individuato.
Se vi venisse voglia di provare a fare come Alex e diventare bug hunters, tenete presente che le aziende che attaccate devono essere informate prima e che dovete stipulare dei contratti o iscrivervi al programma di bug hunting, altrimenti è illegale e si rischia grosso. Inoltre i tentativi di hacking non devono essere mirati al danneggiamento dei sistemi o alle sfiltrazioni dei dati, altrimenti anche in questo caso potrebbero esserci ripercussioni legali.
Il codice contenuto nei pacchetti falsi di Alex Birsen infatti conteneva solo dei meccanismi di notifica per avvisare dell'avvenuta installazione e identificare l'azienda colpita. Ma a parte questo, cosa possiamo imparare noi programmatori, professionisti o meno, da questa storia? Io sarei felice di sapere voi cosa ne pensate, magari sul canale telegram o sul gruppo o anche tramite messaggi o commenti, trovate tutti i riferimenti in descrizione. Nel frattempo però
una cosa mi sento di dirla, perché è un pensiero che già mi girava in testa da molto tempo e questa storia non fa altro che avallarlo. In informatica si dice sempre che non bisogna reinventare la ruota, se una cosa già esiste ed è già disponibile non è necessario ricrearla e in generale sono tutti i ragionamenti corretti. Tuttavia io però credo che come in tutte le cose anche queste affermazioni vadano ragionate e contestualizzate. È vero che in linea generale conviene sfruttare componenti già esistenti, ma non in modo circotuso.
Una dipendenza aggiunta al nostro progetto ci risparmia tempo di sviluppo e a volte anche molto, ma allo stesso tempo aumenta la possibilità che si verifichino dei problemi. In gergo si dice che allarga il perimetro della sicurezza. E non mi riferisco solo all'attacco di Dependency Confusion scoperto da Birsan, esistono molti altri attacchi. La libreria installata ad esempio potrebbe contenere dei bug di sicurezza ancora non scoperti e questo
implica un potenziale pericolo, ma anche la necessità di rimanere al passo con gli aggiornamenti. Oppure potremmo paradossalmente sbagliare ad installare dipendenza. Basta sbagliare infatti una lettera e magari c'è qualche furbone che ha potuto creare un pacchetto con il nome appositamente sbagliato e delle backdoor all'interno. Oppure ancora qualcuno potrebbe riuscire ad inserire del codice malevolo in un pacchetto pubblico molto conosciuto ed utilizzato. Poco tempo fa c'è stato un tentativo di inserire delle backdoor nel codice del linguaggio PHP che
fortunatamente è stato individuato e corretto immediatamente, ma il tentativo c'è stato. E poi attenzione non è un discorso che si ferma solo al codice o solo alle librerie. Giusto per fare un esempio nel quale si potrebbe rivedere anche chi non sviluppa codice, pensate ad esempio a quanti siti sono realizzati con WordPress o con altri content management system e a quanti plugin essi utilizzano. Per molti di questi plugin vengono scoperti e risolti bug in continuazione. E se un
giorno un plugin, magari anche molto utilizzato, sparisse dal repository pubblico e un malintenzionato lo rimpiazzasse immediatamente con una versione modificata, quanti utenti lo installerebbero per sbaglio, quanti siti lo aggiornerebbero in modo automatico. Certo poi verrebbe scoperto, magari anche abbastanza velocemente, ma nel frattempo quanti siti sarebbero stati infettati, quanti lo saprebbero, quanti si renderebbero conto che è necessario eliminare o sostituire il plugin. Si tratta solo di esempi e alcuni anche abbastanza estremi, ma secondo me fermarsi
un attimo a chiedersi se quel nuovo componente ci serve effettivamente, se la sua aggiunta ci risparmia abbastanza tempo di sviluppo per giustificare l'ampliamento della superficie di attacco del nostro software e lo sforzo di manutenzione, secondo me è una cosa da fare sempre.
Bene, come al solito vi ringrazio per avere ascoltato fin qui, spero che l'episodio vi sia piaciuto. Ci tengo davvero a sapere voi cosa ne pensate, che linguaggi utilizzate, se ne utilizzate, quante librerie installate solitamente e se magari vi è mai capitato qualche problema di questo tipo. Come avrete capito io in generale sono uno che cerca di evitare di aggiungere componenti esterni quando non è indispensabile, ma ci sono dei linguaggi che si basano fortemente su questa pratica come ad esempio javascript, quindi probabilmente fra
voi c'è chi la pensa molto diversamente e un confronto non può farci che bene. Detto questo vi ricordo che se volete dare una mano a far crescere il progetto potete condividere questo e gli altri episodi magari aggiungendo una piccola nota su cosa vi è piaciuto e cosa vi è interessato o addirittura facendolo ascoltare a qualcuno. Magari potrebbe diventare un ascoltatore assiduo e un'altra bella persona con cui discutere. Quindi ancora grazie per avere ascoltato fin qui, vi saluto, vi do appuntamento al prossimo episodio e vi ricordo che un informatico
risolve problemi, a volte anche usando il computer.
Quanto inquina una domanda fatta a un chatbot? In rete le risposte non mancano, ma quanto sono affidabili? In questo episodio della Community Edition Paola Zubani, consulente in ambito sostenibilità, ci accompagna tra...
Da quando lavoro con gli agenti di Intelligenza Artificiale, il mio Second Brain ha rischiato di morire: a cosa serve prendere appunti, se tanto la macchina sa già tutto? In questo episodio ti racconto perché invece è...
Per festeggiare i 150 episodi, stavolta al microfono non ci sono solo io: Nox, speaker artificiale di Runtime by Night, mi intervista per provare a raccontarti la vera anima di Pensieri in codice, tra idee da smontare,...
Oggi parliamo del legame tra tecnologia e memoria: come gli strumenti digitali cambiano il nostro modo di ricordare, come funziona la memoria umana e in cosa differisce da quella digitale. E sul finale una bella...
Oggi ti racconto la storia dell’Elea 9003, il primo calcolatore elettronico commerciale italiano: un’avventura tra Olivetti, ricerca, transistor e design che ha provato a portare l’Italia nel futuro dell’elettronica....