Attacco di fissazione della sessione, sessioni basate su cookie su https

0

Un consulente di sicurezza di terze parti ha eseguito un test di penetrazione su alcune delle nostre applicazioni web. Uno dei risultati era una potenziale vulnerabilità alla fissazione della sessione.

Abbiamo diverse applicazioni web tutte Java con accesso singolo fornito da JASIG CAS. Per riassumere brevemente il flusso di lavoro CAS: quando una nuova richiesta arriva a webapp (servizio in terminologia CAS), reindirizza all'URL CAS preimpostato. Se l'utente non è già autenticato, presenta un modulo di accesso e dopo aver reindirizzato correttamente il browser torna al servizio con un token. Nel caso in cui l'utente sia già autenticato, reindirizza immediatamente al servizio con un token.

La vulnerabilità di cui sopra deriva dal fatto che il servizio in questione imposta il cookie di sessione (denominato JSESSIONID) quando si sta reindirizzando verso CAS cioè prima dell'autenticazione E continua a utilizzarlo dopo il reindirizzamento. Il reclamo è poiché lo stesso ID di sessione è usato prima e dopo l'autenticazione è aperto ai tipi di attacco di fissazione della sessione.

Dato che tutti i servizi e i CAS funzionano esclusivamente tramite https e il cookie di sessione è sicuro, solo http e generato sul server, c'è qualche modo in cui la fissazione della sessione può essere una minaccia qui?

    
posta mzzzzb 27.06.2017 - 12:10
fonte

4 risposte

1

Per ogni vulnerabilità di fissazione della sessione, l'utente malintenzionato deve conoscere l'identificatore di sessione. Esistono due modi per ottenerlo: rubandolo dal PC della vittima e attraverso un attacco a forza bruta.

L'attributo Httponly protegge i cookie contro gli attacchi XSS usando la politica del browser originale, ma ci sono molti altri modi per accedere al PC della vittima e rubare il cookie, incluso lo sfruttamento delle vulnerabilità nel browser della vittima.

Purtroppo non ho familiarità con CAS e ora so per quanto tempo l'ID della sessione viene mantenuto invariato. Se il tuo server continua a utilizzare lo stesso ID di sessione per un periodo di tempo significativo, è possibile forzarlo / prevederlo. Qui è dove la fissazione della sessione diventa pericolosa.

Il mio consiglio è di generare un nuovo token di sessione ogni 15-20 minuti per le sessioni attive. In questo modo sarà estremamente difficile forzarlo e la tua applicazione sarà protetta dagli attacchi di fissazione della sessione.

    
risposta data 27.06.2017 - 12:28
fonte
0

Da quello che posso vedere, CAS è una forma di autenticazione OAuth2, anche se non usano quel termine sul loro sistema.

Per rendere OAuth2 sicuro, il servizio che lo utilizza deve avere un insieme di chiavi (è più simile ad avere un login e una password segreti.) Senza tali chiavi, sarebbe molto facile inviare il l'utente direttamente al server CAS con un ID in modo che l'utente malintenzionato sappia esattamente quale ID si intende utilizzare.

+------------------+                   +----------------------+
|                  |                   |                      |
|  Your Server     +-------+---------->|  CAS Server          |
|                  |       |           |                      |
+------------------+       |           +--------+-------------+
                           |                    |
+------------------+       |                    |
|                  |       |                    |
|  Hacker Server   +-------+                    |
|                  |                            v
+---------+--------+                   +----------------------+
          .                            |                      |
          +...........................>|  Back to Your Server |
                                       |                      |
                                       +----------------------+

Senza alcuni segreti del tuo computer, abbiamo un modo molto semplice per sapere quale identificatore di sessione è un hacker. Generiamo solo detto ID e ti inviamo al server CAS. Attendi un po 'e poi accedi al server interessato.

Immagino che CAS abbia i segreti necessari, quindi questo non avrebbe funzionato.

Ora, se posso creare un attacco XSS che imposta un cookie con l'ID di sessione, allora posso anche acquisire le conoscenze necessarie per connettermi al server una volta che l'utente ha effettuato l'accesso.

Con l'XSS potrebbero probabilmente sfruttare un problema sui tuoi sistemi. Quindi l'hacker ha un link al tuo server che qualcosa di sbagliato ed esegue il codice dell'hacker (JavaScript o meta tag). Quel codice imposta l'ID di sessione o controlla l'ID di sessione esistente e lo POST su uno dei computer del pirata informatico.

+------------------+                   +----------------------+
|                  |                   |                      |
|  Your Server     +------------------>|  CAS Server          |
|                  |                   |                      |
+------------+-----+                   +--------+-------------+
         ^   |                                  |
         |   |                                  |
         |   v                                  v
+--------+---------+                   +----------------------+
|                  |                   |                      |
|  Hacker Server   +..................>|  Back to Your Server |
|                  |                   |                      |
+------------------+                   +----------------------+

In questo caso, poiché l'ID della sessione non cambierà, avranno accesso al tuo server per 15 o 20 minuti dopo che l'utente ha effettuato l'accesso. Un attacco XSS è piuttosto facile da evitare, ma ho sentito parlare di molti di questi attacchi (ho lavorato su Drupal per un po 'e ne ho scoperti parecchi da parte di programmatori che non pensano fuori dagli schemi e utilizzano dati potenzialmente macchiati così com'è).

Un esempio di questo è per colpire una pagina 404 utilizzando il codice nell'URI:

http://example.com/<script>document.cookie = "JSESSIONID=123";</script>

Un programmatore che crea una pagina 404 e mostra il tag <script> così com'è (cioè senza sostituire < con &lt; e > con &gt; ) consente una attacco cross-site in quanto il rogue JavaScript verrà eseguito sul tuo sito.

Nota che con un attacco Man In The Middle (MITM), non hai nemmeno bisogno di un XSS o di una cattiva implementazione di OAuth2. Ma è più difficile eseguire un MITM e nella maggior parte dei casi richiede un luogo pubblico in modo che le persone al lavoro abbiano meno probabilità di avere un collega hacker che sa come essere un MITM.

    
risposta data 05.08.2018 - 23:57
fonte
0

O non hai capito il consulente di sicurezza o non sanno di cosa stanno parlando.

Devi scavare un po 'più a fondo per scoprire la verità.

Chiedere al consulente di sicurezza di dimostrare che la vulnerabilità potrebbe dimostrarsi la prima, ma un fallimento non prova la seconda.

I cookie di sessione devono essere impostati con il flag di sicurezza. Se l'ID di sessione non viene risolto quando presentato da un client, il server deve generare un nuovo ID di sessione. È buona norma generare un nuovo ID di sessione (e impostarlo sul client) quando lo stato di autenticazione cambia (nel tuo scenario, quando la tua app convalida il token con il servizio di autenticazione e quando l'utente si disconnette, dopo aver distrutto i dati di riferimento dal vecchio id).

Supponendo che i cookie siano impostati con il flag di sicurezza ....

Affinché la tua implementazione sia vulnerabile, deve accettare un ID di sessione relativo a una sessione inesistente. Se questo non è il caso, allora il consulente è sbagliato, tuttavia dovresti comunque applicare la terza raccomandazione sopra.

Considera che stai sfogliando link . Un utente malintenzionato può iniettare un'intestazione in una risposta del server impostando l'id di sessione su un valore noto. Se successivamente accedi al link il tuo browser invierà l'ID di sessione impostato dall'attaccante (la parte SSO non è pertinente). Se il tuo server non ha cambiato l'id di sessione quando è stato presentato per la prima volta (e quindi facendo riferimento a dati di sessione nulli) ora è quello scelto dal tuo aggressore.

Usare le hsts sarebbe d'aiuto, ma le cose importanti sono i tre passaggi precedenti.

    
risposta data 06.08.2018 - 01:29
fonte
0

Suppongo che la tua applicazione web non generi un nuovo ID di sessione dopo che il client è stato reindirizzato alla tua applicazione nel flusso di lavoro CAS. Pertanto un utente malintenzionato può ottenere un ID sessione valido senza effettuare il login e provare a ingannare un altro client per utilizzarlo ancora dopo aver effettuato correttamente il login.

La best practice consiste nel generare un nuovo ID di sessione dopo ogni accesso.

Vedi anche: OWASP - Correzione della sessione

    
risposta data 18.09.2018 - 18:15
fonte

Leggi altre domande sui tag