Archivio dell'autore: RotAn-CoMon

Shellshock, il ‘bash bug’ che fa tremare la rete: quanto è pericoloso?

Posted on by

C’è chi lo definisce peggiore di HeartBleed e chi, invece, mantiene la calma: scopriamo la natura di questa nuova vulnerabilità

L’ultima volta che il mondo dell’open source è caduto letteralmente nel panico risale ai tempi della scoperta di Heartbleed, un potente bug nel protocollo (e nelle annesse librerie) OpenSSH che ha letteralmente messo in ginocchio server da ogni dove. Oggi la storia si ripete con un secondo bug, “adulto” più o meno quanto un quarto di secolo, che riguarda la shell Bash (o Bourne Again Shell) e prende appunto il nome di bash bug – o di Shellshock, come il simpatico R. Graham l’ha ribattezzato.

Secondo alcuni importanti esponenti della sicurezza, tra cui lo stesso Graham, Shellshock sarebbe addirittura più pericoloso di Hearbleed: la causa è da ritrovarsi al diffusissimo utilizzo della shell bash – sia come applicazione attiva che come applicazione in background da parte di altri programmi – e la semplicità con cui agisce il criterio di sfruttamento della falla.

Prima di farne una pandemia, però, capiamone qualcosa in più!

Cosa è Shellshock?

Shellshock – il bash bug – altri non è che un bug insito nella shell Bash, la “console dei comandi” tipicamente inclusa in quasi tutti i sistemi operativi GNU/Linux-based (incluso Android) e Mac. Sostanzialmente il funzionamento di Shellshock coinvolge la dichiarazione e l’utilizzo di variabili d’ambiente, con un modus operandi che cercheremo di semplificare il più possibile.

In pratica, prima dell’esecuzione di Bash è possibile definire in determinati file - richiamabili anche da programmi esterni – delle variabili, che servono spesso a “semplificare” l’eventuale passaggio dei parametri al programma eseguito tramite bash.

Il problema è nella dichiarazione di tali variabili: se una variabile viene dichiarata e sulla stessa riga viene specificato un particolare comando, tale comando può essere eseguito arbitrariamente da qualsiasi applicazione abbia accesso a quella variabile. In parole povere, dichiarando una o più variabili con una particolare sintassi può rendere il sistema vulnerabile.

Se masticate lo scripting bash, il tutto sarà più chiaro con un esempio. Considerate questa dichiarazione di variabile:

env x='() { :;}; echo vulnerable' bash -c "echo this is a test"

Shellshock fa si che Bash intepreti la parte di codice in grassetto (quindi echo vulnerable) come un vero e proprio comando da eseguire, cosa che in condizioni “normali” non dovrebbe succedere.

Infatti, eseguendo questo codice su una versione di Bash vulnerabile, l’output ottenuto è il seguente:

$ env x='() { :;}; echo vulnerable' bash -c "echo this is a test"
vulnerable
this is a test

Se invece lo stesso codice viene eseguito su una versione di Bash non vulnerabile, il codice echo vulnerable viene riconosciuto da Bash come una potenziale dichiarazione di funzione e viene ignorato, generando un warning e lasciando la variabile non inizializzata ed il comando non eseguito (comportamento normale).

$ env x='() { :;}; echo vulnerable' bash -c "echo this is a test"
 bash: warning: x: ignoring function definition attempt
 bash: error importing function definition for `x'
 this is a test

Shellshock è davvero pericoloso come dicono?

Diciamo che non è un gioco da ragazzi usare vulnerabilità del genere e che c’è bisogno del verificarsi di condizioni ben precise – uno script deve essere presente sul sistema con delle dichiarazioni di variabili alterate, pronte per essere usate dal programma comandato da un utente malintenzionato – ma, purtroppo, bisogna ammettere che a causa della diffusione di Bash e dell’interazione imprevista di Shellshock con i vari programmi (innumerabili) che interagiscono con essa il rischio esiste. 

Purtroppo Bash non è soltanto la “classica” shell dei sistemi operativi GNU/Linux based di conoscenza comune come Ubuntu, Debian, Gentoo, Red Hat, CentOS e via discorrendo, ma è presente in tante altre varianti di Linux presenti anche su dispositivi differenti dai PC - come router, NAS, sistemi embedded, computer di bordo, che se obsoleti potrebbero essere davvero a rischio.

Senza contare che, inoltre, Bash è presente anche su Android e su tutti i sistemi operativi Mac.

 

Chi è vulnerabile a Shellshock?

Categorizzare i dispositivi vulnerabili non è possibile, tuttavia esistono diverse linee guida per intuire se si è vulnerabili o meno. Innanzitutto bisogna specificare che le versioni di Bash vulnerabili a Shellshock vanno dalla 4.3 (inclusa) in giù, per cui la prima cosa da fare è indubbiamente aggiornare il proprio sistema operativo all’ultima versione dei pacchetti, se possibile.

Particolare attenzione va posta inoltre in ambiente server: si è comunque a rischio se la versione di Bash installata è inferiore alla 4.3 (inclusa), ma bisogna aprire gli occhi e correre ancor più rapidamente ai ripari, a causa dei danni collaterali potenziali causati da Shellshock, in caso il server esegua:

  • una configurazione di sshd che prevede attiva la clausola ForceCommand;
  • vecchie versioni di Apache che usano mod_cgi o mod_cgid, estremamente vulnerabili se gli script CGI sono scritti in bash o lanciano a loro volta shell bash (ciò non succede invece con gli script eseguiti tramite mod_php, neanche se questi lanciano shell bash a loro volta); tuttavia, i potenziali comandi indesiderati vengono eseguiti con gli stessi privilegi d’accesso del server web;
  • server DHCP che invocano script da shell per configurare il sistema; solitamente, tali script vengono eseguiti con privilegi di root, il che è estremamente pericoloso;
  • i vari demoni o i programmi SUID che agiscono sul sistema con privilegi da superutente utilizzando però variabili settate da utenti non root.

In generale, il sistema può rimanere vittima di qualsiasi altra applicazione che venga eseguita da shell o esegue uno script shell che prevede l’interprete bash – solitamente, tali script iniziano con la dicitura #!/bin/bash.

Ma non finisce qui: purtroppo qualsiasi altro dispositivo obsoleto è a rischio, specie quelli per cui non è prevista la verifica della versione di Bash installata e per cui non sia possibile procedere semplicemente all’aggiornamento. Ancora una volta, ciò rappresenta un rischio ma non è detto che tali dispositivi siano effettivamente exploitabili (ad esempio, è difficile fare in modo che un computer di bordo o un NAS non collegato ad Internet eseguano codice arbitrario).

Per correttezza, è bene specificare ancora una volta che alcune versioni di Android e di Mac OS X sono vulnerabili – ad esempio, Mavericks lo è.

 

Quali dati sono a rischio e come faccio a proteggermi?

Purtroppo, anche se in precise e difficilmente coincidenti condizioni, ad essere a rischio è qualsiasi cosa sia presente sulla memoria del sistema; tenendo comunque conto dei meccanismi intrinsechi di protezione di Bash e di GNU/Linux come l’assegnazione dei permessi d’esecuzione, il margine di rischio potrebbe diventare comunque molto minore.

Prima di preoccuparsi, bisogna verificare se si è effettivamente vulnerabili a Shellshock. Ciò è possibile semplicemente verificando la versione di Bash installata sul proprio sistema: se questa non è precedente alla 4.3 - Bash 4.3.0 e inferiori sono VULNERABILI ma non le versioni successive – allora il vostro sistema non è vulnerabile. 

In caso contrario, se possibile aggiornate Bash ed i pacchetti dell’intero sistema operativo all’ultima versione disponibile, in attesa di un’eventuale patch che dovrebbe comunque essere rilasciata in maniera celere per la maggior parte dei sistemi operativi e dei pacchetti di Bash interessati, a prescindere dalla piattaforma su cui essi sono installati.

Per verificare di essere protetti, aprite una shell bash ed eseguite il test spiegato nella sezione “Cosa è Shellshock”.

 

In definitiva…

Purtroppo Shellshock è un bug che cade come un fulmine a ciel sereno e non è possibile affermare che sia innocuo poiché, come visto fino ad ora, i rischi materiali esistono.

Come vi ho detto all’inizio non bisogna comunque farne una pandemia: se si tratta di sistemi operativi casalinghi, è necessario accertarsi che il proprio OS sia ancora ufficialmente supportato ed aggiornarlo all’ultima versione disponibile, che si tratti di GNU/Linux o di Mac. Stessa cosa per i sistemi operativi server, per i quali ci si aspetta una “correzione” dei pacchetti relativi alle versioni di Bash pari o inferiori alla 4.3 quanto prima.

Discorso differente va fatto per i vari sistemi embedded, per i NAS, per i router o per tutti quei dispositivi non verificabili facilmente: accertatevi di avere installata l’ultima versione disponibile del firmware e, nel caso, contattate il produttore per ulteriori delucidazioni.

Shellshock è purtroppo un bug molto grande, reso enorme dalla diffusione di Bash, tuttavia gli eventuali danni possono essere arginati usando un po’ di prudenza ed attenzione in più.

Purtroppo, come disse il grande Spaf, la verità è soltanto una:

L’unico vero sistema sicuro è quello spento, gettato in una colata di cemento, sigillato in una stanza rivestita da piombo e protetta da guardie.
Ma anche in quel caso ho i miei dubbi.

 

fonte: (http://www.chimerarevo.com/linux/shellshock-bash-bug-terrorizza-rete-quanto-pericoloso-176876/)

Protocollo USB: sicurezza addio, c’è una falla enorme

Posted on by

Un gruppo di ricercatori ha scoperto una falla gravissima nel protocollo USB. BadUSB può trasformare qualsiasi prodotto in un veicolo per sottrarre informazioni confidenziali. La cosa peggiore? Non sembrano esistere contromisure valide.

Protocollo USB, sicurezza fantasma. Un film? No, un gravissimo problema. A lanciare l’allarme sono i Security Research Labs di Berlino, e a quanto pare il problema è serio, serissimo. La falla, ribattezzata BadUSB, riguarda infatti i miliardi di dispositivi USB e permette di prendere controllo del computer tramite il versatile connettore che negli anni ci ha reso la vita un po’ più facile.

Ed è proprio la versatilità ad aver compromesso la sicurezza. L’USB Implementers Forum, che si occupa di delineare le specifiche degli standard, ha infatti dovuto compiere delle scelte per rendere l’USB uno standard tanto flessibile da trovare rapidamente casa in moltissimi prodotti, praticamente ovunque. Lo stesso USB IF afferma che l’unica difesa contro la vulnerabilità è quella di usare dispositivi di cui siete al 100% sicuri, ma anche così non è detto che la protezione sia assicurata.

La vulnerabilità conta sul fatto che ogni dispositivo USB ha un chip di controllo al suo interno. Secondo gli SR Labs questi controller hanno un firmware – cioè il software fondamentale che li fa funzionare – che può essere interamente riprogrammato senza soluzioni hardware ad hoc per fare cose spiacevoli. Il problema? La riprogrammazione è quasi impossibile da rilevare, a meno che non si sappia dove guardare – ergo, è una cosa complicatissima.

Poiché un prodotto USB può essere connesso praticamente a qualsiasi sistema grazie alla versatilità offerta da quelle che sono definite “classificazioni”, riprogrammando il firmware è possibile presentare un prodotto sotto una classificazione differente. L’esempio pratico è presto fatto. Un malintenzionato potrebbe riprogrammare una chiavetta USB in modo che si mascheri come un controller di rete, facendo sì che tutte le comunicazioni – siti web visitati, password, eccetera – vengano reindirizzate al dispositivo.

O, peggio ancora, è possibile riprogrammare una chiavetta in modo che venga vista come una periferica HID (Human interface device), in modo da poter impartire comandi al computer come se vi fossero una tastiera e mouse. Tali comandi potrebbero consentire l’installazione di malware o altre operazioni. Al momento non esiste un fix di sicurezza, non ci sono strumenti per bloccare l’attacco, per cui qualcuno potrebbe progettare un virus ad hoc, infettare migliaia di chiavette e sottrarre informazioni importanti. E formattare potrebbe non servire a niente, assicurano i ricercatori.

Fortunatamente gli SR Labs non sembra siano intenzionati a condividere i dettagli di quanto scoperto con il primo venuto, ma alla BlackHat 2014 del 7 agosto rilasceranno ulteriori informazioni e daranno una dimostrazione. Una possibile soluzione, ma attuabile in futuro, potrebbe essere quella di realizzare una firma univoca digitale per ogni dispositivo, in modo che i computer a cui si collegano le periferiche la verifichino continuamente. Questo però richiedere uno sforzo enorme a tutta l’industria.

fonte: http://www.tomshw.it/cont/news/protocollo-usb-sicurezza-addio-c-e-una-falla-enorme/58277/1.html

‎HeartBleed‬ di cosa si tratta esattamente!

Posted on by

INsicurezze/ L’insostenibile leggerezza del software

La scoperta di Heartbleed, uno dei bug più potenzialmente devastanti della storia, suscita riflessioni non solo sulla vulnerabilità dei sistemi. Ma anche sui modelli di sviluppo del software “mission critical”

 heartbleed
Roma – Il folklore dei programmatori annovera da decenni molteplici istanze specifiche della più generale legge di Murphy, le quali descrivono ironicamente ma non tanto i molteplici modi in cui la generale perversità della Natura si manifesta anche nello specifico settore dello sviluppo del software. Dice ad esempio la Seconda legge di Weinberg che “Se gli ingegneri costruissero gli edifici come i programmatori sviluppano i programmi, il primo picchio di passaggio raderebbe al suolo l’intera civiltà”; mentre il primo dei Postulati di Troutman afferma che “L’errore che produce il danno maggiore sarà scoperto solo dopo almeno sei mesi di uso del programma”.Ebbene, il famoso e famigerato bug denominato Heartbleed identificato nella libreria OpenSSL, che da alcuni giorni monopolizza l’attenzione persino dei media generalisti e dei quotidiani mainstream (i quali continuano a scriverne in modo grossolanamente impreciso, ma tant’è…), sembra confermare in pieno quanto presagito dalla saggezza della categoria sin da tempi davvero non sospetti. Esso infatti, se da un lato ha rischiato di mettere in ginocchio una parte significativa del sistema mondiale sul quale si basano la sicurezza e la riservatezza delle comunicazioni in Rete, minando alla base l’infrastruttura preposta alla garanzia sulle identità dei corrispondenti e l’inviolabilità delle comunicazioni, dall’altro è rimasto in circolazione, non ufficialmente scoperto, per oltre due anni dalla sua involontaria (o così almeno pare) introduzione nel codice di produzione. Peggio di così, insomma, non poteva andare.Ma di cosa esattamente si tratta, e perché è così pericoloso? E, soprattutto: com’è potuto succedere? Proviamo a fare il punto della situazione.
Cos’è Heartbleed
Il bug denominato Heartbleed, formalmente identificato mediante il codice CVE-2014-0160 con cui è catalogato nel database Common Vulnerabilities and Exposures, tecnicamente non è altro che un classico e banale caso di “memory out of bound”, ossia di accesso ad un’area di memoria indebita a causa di un indice inizializzato male ed in assenza di controlli specifici atti ad impedirlo. Un errore insidioso ma tra i più comuni, specie tra i programmatori principianti, favorito dal fatto che linguaggi come il C per motivi di efficienza non effettuano automaticamente a run-time il controllo del superamento dei limiti.Nella fattispecie il bug venne introdotto all’interno della libreria OpenSSL nel lontano 2011 quando tale Robin Seggelmann, all’epoca dottorando all’Università di Duisburg-Essen in Germania, implementò la cosiddetta estensione Heartbeat nel protocollo SSL/TLS. Questa, che letteralmente significa “battito cardiaco”, era stata proposta alla IETF (Internet Engineering Task Force) proprio da Seggelmann ed altri, e sarebbe stata da lì a poco emanata come standard formale di Internet col nome di “Transport Layer Security (TLS) and Datagram Transport Layer Security (DTLS) Heartbeat Extension” (RFC 6520, febbraio 2012). Essa consiste essenzialmente in uno scambio continuo di speciali pacchetti fra client e server autenticati, allo scopo di mantenere attiva e verificata una sessione sicura senza dover rinegoziare ogni volta la connessione.

Il bug nel codice di Seggelmann si trova nella funzione invocata per costruire il pacchetto di Heartbeat da scambiarsi fra client e server, e consiste nel non verificare la validità del valore memorizzato in una variabile, usata come parametro, che dovrebbe contenere la lunghezza del pacchetto stesso. In pratica alla funzione vanno passati come parametri sia il contenuto da assegnare al pacchetto (sotto forma di un array di caratteri) che la lunghezza del pacchetto stesso, ma la mancanza di validazione fa sì che la lunghezza del pacchetto creata dalla funzione possa essere diversa, ed in particolare molto maggiore, di quella dell’array che ne costituirà il contenuto effettivo. Una dimenticanza apparentemente banale ma profondamente pericolosa, come vedremo tra un attimo.

Seggelmann inviò dunque il suo codice per revisione a Stephen N. Henson, uno dei quattro sviluppatori principali di OpenSSL, il quale apparentemente non notò il problema ed incluse il tutto nel repository dei sorgenti della libreria il 31 dicembre 2011. Il codice incriminato entrò quindi a far parte della versione ufficiale 1.0.1 di OpenSSL rilasciata pubblicamente il 14 marzo 2012, e subito adottata da un numero enorme di siti e di distribuzioni di sistemi operativi. Anche le successive release minori, fino alla 1.0.1f, contengono tutte il bug, il quale è stato corretto solo nella versione 1.0.1g rilasciata il 7 aprile 2014 in seguito alla scoperta del problema da parte di alcuni ricercatori indipendenti (Riku, Antti and Matti dell’azienda finlandese Codenomicon e Neel Mehta di Google Security). Per la cronaca, il nome Heartbleed (sanguinamento del cuore) con cui il problema è oggi noto era stato assegnato informalmente al bug dai ricercatori di Codenomicon come gioco di parole su Heartbeat (battito del cuore), ma è subito diventato il nome “ufficiale” con cui esso è universalmente identificato.

Chiarito qual è il bug, vediamo come sia possibile sfruttarlo per carpire informazioni ad un server vulnerabile. Purtroppo è molto facile: basta infatti semplicemente richiedere la restituzione di un pacchetto Heartbeat creato assegnando valori opportunamente malformati ai parametri che ne regolano la costruzione. In pratica occorre passare alla funzione una stringa di inizializzazione corta (ad esempio “pippo”) ed un valore esageratamente ampio come descrizione della sua lunghezza (ad esempio 1.000 o più), ciò che corrisponde a chiedere al server di restituirci un pacchetto costituito dalla stringa “pippo” di mille caratteri! A questa richiesta apparentemente insensata e contraddittoria il server, in mancanza di una specifica validazione, non obietta ma reagisce stolidamente allocando in memoria un buffer di mille caratteri, copiandovi la stringa “pippo” e rimandando indietro tutti e mille i caratteri.

Otterremo così in risposta dal server un pacchetto di mille caratteri nel quale i primi cinque sono la striunga “pippo” e i rimanenti 995 caratteri contengono fedelmente i valori che erano contenuti nella particolare area di memoria del server nella quale è avvenuta l’allocazione del buffer!

In pratica con questo espediente riusciamo ad ottenere dal server la copia di una parte della sua memoria di lavoro, che può in realtà essere di ben 64K per volta; e, trattandosi di memoria dello spazio dati usato dall’istanza attiva del codice OpenSSL, è molto probabile che contenga informazioni significative per il processo stesso, quali ad esempio la chiave privata del server o le credenziali dei client utilizzate nelle sessioni aperte o comunque recenti. Nulla vieta inoltre di inviare centinaia o migliaia di richieste analoghe, per ricostruire così a colpi di 64K alla volta aree assai ampie della memoria del server ed aumentare le probabilità di trovarvi informazioni utili.

In pratica, a furia di richieste ripetute, un client malevolo può riuscire a mapparsi completamente o almeno in buona parte lo spazio di memoria logicamente allocato dal server al processo relativo all’istanza attiva di OpenSSL, di fatto rivelando in chiaro ogni e qualsiasi dato ad esso collegato: comprese quindi le chiavi private e/o le password degli utenti. Un “leakage” di proporzioni colossali, e soprattutto attuabile con facilità e senza lasciare alcuna traccia.

Prove realmente svolte da diversi ricercatori hanno confermato in modo evidente che, effettuando alcune migliaia di richieste, è effettivamente assai probabile riuscire ad ottenere password in chiaro ed altre informazioni critiche dall’analisi dei segmenti di memoria ottenuti. Il problema è infatti aggravato dal fatto che la libreria OpenSSL, per allocare memoria, non utilizza le classiche chiamate standard di sistema quali malloc(), ma implementa delle proprie routine, cosa che comporta due effetti collaterali sfavorevoli: il primo è che così facendo si massimizzano le probabilità che la memoria allocata sia stata precedentemente utilizzata dallo stesso processo, e contenga quindi informazioni sensibili per il suo funzionamento e soprattutto “fresche”; il secondo è che si vanificano gli effetti di eventuali azioni mitigatrici di “sanitarizzazione” della memoria svolte dagli allocatori di sistema, i quali non vengono affatto invocati.

Cosa fare dunque per risolvere il problema? Lato utente, purtroppo, ben poco: l’onere infatti è soprattutto a carico dei gestori dei server vulnerabili. Gli utenti non possono fare altro che attendere che i vari server adottino una versione di OpenSSL priva del problema: solo allora dovranno, per buona norma di prudenza, cambiare la propria password di accesso al servizio erogato da quel server. Sarebbe anche auspicabile che i gestori dei servizi revocassero i certificati usati per autenticare le sessioni SSL/TLS e ne installassero di nuovi, per evitare il rischio che qualcuno possa usare le chiavi private compromesse per costruire attacchi di tipo “man-in-the-middle” a danno degli utenti.Tuttavia il messaggio, come ha anche tenuto a dire l’Agenzia europea per la sicurezza delle reti e dell’informazione (ENISA), è “niente panico”: una sana politica di gestione delle password, che prevede l’utilizzo di password differenti per ciascun servizio e la loro sostituzione frequente, è un’ottimo baluardo di difesa anche contro questo spiacevole problema. Inoltre va ricordato che non tutti i siti che impiegano SSL/TLS lo fanno utilizzando la libreria OpenSSL: quelli che utilizzano altre implementazioni sono ovviamente immuni dal problema, il quale riguarda solo tale libreria e non il protocollo in sé.Alla fine della fiera tuttavia, e senza neppure cedere alle tentazioni complottiste secondo cui l’introduzione del bug è stata pilotata o quantomeno sfruttata per anni dalla solita NSA madre-di-tutte-le-iatture-della-rete, rimane comunque l’amaro in bocca per come sono andate le cose: è infatti possibile che un pezzo di codice di tale criticità, impiegato da circa due terzi dei siti mondiali per rendere sicure le sessioni di lavoro più delicate dei propri utenti, vada in distribuzione definitiva portando con sé un bug così banale ma al tempo stesso così micidiale?In una recente intervista Seggelmann ha riconosciuto di aver scritto codice stupidamente insicuro, omettendo un controllo che avrebbe dovuto essere inserito come semplice pratica di buon senso, ma ha ribaltato la responsabilità del problema sul team addetto alla manutenzione della libreria OpenSSL che non ha effettuato gli opportuni controlli di qualità. OpenSSL dal canto suo ha risposto che la libreria è mantenuta da sole tre persone, le quali sono evidentemente troppo poche per poter assicurare un’adeguata supervisione in tal senso. Altri osservatori hanno recentemente osservato che il codice prodotto da Seggelmann era scritto così male che la sua analisi sarebbe stata comunque lenta e difficoltosa, il che ha probabilmente disincentivato ulteriormente chi avrebbe dovutro assicurarsi della sua correttezza.A prescindere dalle reali colpe, che tutto sommato non ci interessano più di tanto, è il contesto in sé ad essere drammatico: questo incidente infatti mina alle fondamenta la convinzione, diffusa tra tutti gli esperti di sicurezza, che un codice open source sia più sicuro di un codice chiuso in quanto indipendentemente verificato (o verificabile) da decine o centinaia di sviluppatori differenti, cosa che in sé dovrebbe sia minimizzare la probabilità che un bug critico passi inosservato sia consentirne la sua rapida correzione una volta identificato. In questo caso invece il bug non solo non è stato scoperto all’origine, ma è rimasto in un codice di produzione per oltre due anni: un record negativo che solo pochi prodotti commerciali proprietari sembrano aver raggiunto.

Occorre quindi forse ripensare l’intero modello di trust del codice open source ad elevata criticità, introducendo step formali di “quality assurance” come quelli presenti nei prodotti industriali. Il solo fatto che un pezzo di codice “possa essere esaminato” da sviluppatori indipendenti non dà alcuna garanzia che esso sia stato realmente esaminato. Cullarsi in un falso senso di sicurezza è peggio che non avere sicurezza, lo sappiamo. Porre fiducia nell’open source è cosa buona e giusta, ma dobbiamo avere la certezza che tale fiducia sia ben riposta se non vogliamo trovarci di fronte a problemi sempre più gravi.

E la domanda a questo punto sorge spontanea: quanti altri pezzi di codice open source critico, cui affidiamo quotidianamente la nostra sicurezza, potrebbero portare in sé da tempi immemorabili bug potenzialmente devastanti? E soprattutto, chi dovrebbe accorgersene prima che lo facciano quelli sbagliati?

Corrado “NightGaunt” Giustozzi
nightgaunt.org

fonte: http://punto-informatico.it/4033843/PI/Commenti/insicurezze-insostenibile-leggerezza-del-software.aspx