Jaki jest najlepszy sposób, aby zapobiec porwaniu sesji?

SSL pomaga tylko w atakach sniffing. Jeśli atakujący ma dostęp do twojego komputera, zakładam, że może również skopiować twój bezpieczny plik cookie.

Przynajmniej upewnij się, że stare ciasteczka tracą swoją wartość po pewnym czasie. Nawet udany atak porywania zostanie udaremniony, gdy plik cookie przestanie działać. Jeśli użytkownik posiada plik cookie z sesji, która zalogowała się ponad miesiąc temu, wprowadź ponownie hasło. Upewnij się, że za każdym razem, gdy użytkownik kliknie na link "Wyloguj się" na swojej stronie, że Stary uuid sesji nigdy nie może być użyty ponownie.

Nie jestem pewien, czy ten pomysł zadziała, ale oto idzie: dodaj numer seryjny do pliku cookie sesji, może taki ciąg znaków:

SessionUUID, Numer Seryjny, Aktualna Data / Godzina

Zaszyfruj ten ciąg i użyj go jako pliku cookie sesji. Regularnie zmieniaj numer seryjny-może gdy plik cookie ma 5 minut, a następnie ponownie wyda plik cookie. Możesz nawet wznowić go na każdym widoku strony, jeśli chcesz. Po stronie serwera, zachowaj zapis ostatniego numeru seryjnego, który wydałeś na tę sesję. Jeśli ktoś wyśle plik cookie z błędnym numerem seryjnym, oznacza to, że atakujący może używać wcześniej przechwyconego pliku cookie, więc unieważnia uuid sesji i prosi użytkownika o ponowne wprowadzenie hasła, a następnie ponowne wydanie nowego pliku cookie.

Pamiętaj, że twój użytkownik może mieć więcej niż jeden komputer, więc może mieć więcej niż jedną aktywną sesję. Nie rób czegoś, co zmusza ich do ponownego logowania się za każdym razem, gdy przełączają się między Komputery.

Rozważałeś przeczytanie książki o zabezpieczeniach PHP? Gorąco polecam.

Odniosłem duży sukces dzięki następującej metodzie dla witryn bez certyfikatu SSL.

1. Dis-Zezwalaj na wiele sesji na tym samym koncie, upewniając się, że nie sprawdzasz tego wyłącznie przez adres IP. Raczej sprawdzić token generowany po zalogowaniu, który jest przechowywany z sesji użytkownika w bazie danych, a także adres IP, HTTP_USER_AGENT i tak dalej

2. Using Relation based hiperłącza Generuje link ( np. http://example.com/secure.php?token=2349df98sdf98a9asdf8fas98df8 ) Link jest dołączany za pomocą x-bajtowego ( preferowanego rozmiaru ) losowego ciągu MD5, przy przekierowaniu strony losowo wygenerowany token odpowiada żądanej stronie.

   • po przeładowaniu wykonujemy kilka kontroli.
   • pochodzący adres IP
   • HTTP_USER_AGENT
   • Token Sesji
   Rozumiesz.

3. Krótkie Plik cookie uwierzytelniania sesji. jak wspomniano powyżej, dobrym pomysłem jest plik cookie zawierający Bezpieczny ciąg znaków, który jest jednym z bezpośrednich odniesień do ważności sesji. Spraw, aby wygasał co X minut, ponownie wydając token i ponownie synchronizując sesję z nowymi danymi. W przypadku błędnego dopasowania danych Wyloguj użytkownika lub poproś o ponowne uwierzytelnienie sesji.

Nie jestem w żaden sposób ekspertem w tym temacie, miałem trochę doświadczenia w tym konkretnym temacie, mam nadzieję, że to komuś pomoże.

// Collect this information on every request
$aip = $_SERVER['REMOTE_ADDR'];
$bip = $_SERVER['HTTP_X_FORWARDED_FOR'];
$agent = $_SERVER['HTTP_USER_AGENT'];
session_start();

// Do this each time the user successfully logs in.
$_SESSION['ident'] = hash("sha256", $aip . $bip . $agent);

// Do this every time the client makes a request to the server, after authenticating
$ident = hash("sha256", $aip . $bip . $agent);
if ($ident != $_SESSION['ident'])
{
    end_session();
    header("Location: login.php");
    // add some fancy pants GET/POST var headers for login.php, that lets you
    // know in the login page to notify the user of why they're being challenged
    // for login again, etc.
}

To, co robi, to przechwytywanie "kontekstowych" informacji o sesji użytkownika, informacji, które nie powinny się zmieniać w trakcie trwania pojedynczej sesji. Użytkownik nie będzie jednocześnie przy komputerze w USA i Chinach, prawda? Jeśli więc adres IP nagle zmieni się w tej samej sesji, co silnie implikuje próbę przejęcia sesji, zabezpieczasz sesję, kończąc sesję i zmuszając użytkownika do ponownego uwierzytelnienia. To udaremnia próbę włamania, atakujący jest również zmuszony do zalogowania się zamiast uzyskania dostępu do sesji. Powiadom użytkownika o próbie (ajax to trochę), a vola, lekko zirytowany + poinformowany użytkownik i ich sesja/informacje są chronione.

Dorzucamy User Agent i X-FORWARDED-FOR, aby dołożyć wszelkich starań, aby uchwycić wyjątkowość sesji dla Systemów stojących za proxy/sieciami. Możesz być w stanie użyć więcej informacji, a następnie, nie krępuj się być kreatywnym.

Jest więcej, które możesz zrobić, aby chronić sesje, wygasać je, gdy użytkownik opuści stronę internetową i wróci, może zmusić go do ponownego zalogowania. Możesz wykryć opuszczającego i powracającego użytkownika, przechwytując pusty HTTP_REFERER (domena została wpisana na pasku adresu URL) lub sprawdzić, czy wartość w HTTP_REFERER jest równa Twojej domenie, czy nie (użytkownik kliknął zewnętrzny / spreparowany link, aby dostać się do twojej witryny).

Wygasają sesje, nie pozwól, aby pozostały ważne na czas nieokreślony.

Don ' t rely na ciasteczkach mogą zostać skradzione, jest to jeden z wektorów ataku na session hijacking.

W tym artykule Liu, Kovacs, Huang i Gouda można znaleźć informacje na temat bezpiecznego protokołu Cookie opisanego w This paper by Liu, Kovacs, Huang, and Gouda:

Jak podano w dokumencie:

A secure protokół cookie, który działa między Klientem a serwerem musi zapewnić następujące cztery usługi: uwierzytelnianie, poufność, integralność i zapobieganie powtórce.

Co do łatwości wdrożenia:

Jeśli chodzi o wydajność, nasz protokół nie obejmuje żadnej bazy danych wyszukiwanie lub kryptografia klucza publicznego. Jeśli chodzi o możliwość wdrożenia, nasz protokół można łatwo wdrożyć na istniejącym serwerze WWW i nie wymaga żadnych zmian Internet cookie Specification.

W skrócie: jest bezpieczny, lekki, działa dla mnie po prostu świetnie.

Nie ma sposobu, aby zapobiec przechwytywaniu sesji w 100%, ale przy pewnym podejściu możemy skrócić czas, aby atakujący przejął sesję.

Metoda zapobiegania przechwytywaniu Sesji:

1-Zawsze używaj sesji z certyfikatem ssl;

2-wysyłaj plik cookie sesji tylko z httponly ustawionym na true (uniemożliwia javascript dostęp do pliku cookie sesji)

2-Użyj session regenerate id przy logowaniu i wylogowaniu (uwaga: nie używaj session regenerate przy każdym żądaniu, ponieważ jeśli masz kolejne żądanie ajax wtedy masz szansę utworzyć wiele sesji.)

3-Ustaw limit czasu sesji

4-przechowuje agenta użytkownika przeglądarki w zmiennej $_SESSION porównując z $_SERVER['HTTP_USER_AGENT'] przy każdym żądaniu

5-ustaw tokenowy plik cookie i ustaw czas wygaśnięcia tego pliku cookie na 0(do momentu zamknięcia przeglądarki). Zregeneruj wartość pliku cookie dla każdego żądania.(Dla żądania ajax nie regeneruj token cookie). EX:

    //set a token cookie if one not exist
    if(!isset($_COOKIE['user_token'])){
                    //generate a random string for cookie value
        $cookie_token = bin2hex(mcrypt_create_iv('16' , MCRYPT_DEV_URANDOM));

        //set a session variable with that random string
        $_SESSION['user_token'] = $cookie_token;
        //set cookie with rand value
        setcookie('user_token', $cookie_token , 0 , '/' , 'donategame.com' , true , true);
    }

    //set a sesison variable with request of www.example.com
    if(!isset($_SESSION['request'])){
        $_SESSION['request'] = -1;
    }
    //increment $_SESSION['request'] with 1 for each request at www.example.com
    $_SESSION['request']++;

    //verify if $_SESSION['user_token'] it's equal with $_COOKIE['user_token'] only for $_SESSION['request'] > 0
    if($_SESSION['request'] > 0){

        // if it's equal then regenerete value of token cookie if not then destroy_session
        if($_SESSION['user_token'] === $_COOKIE['user_token']){
            $cookie_token = bin2hex(mcrypt_create_iv('16' , MCRYPT_DEV_URANDOM));

            $_SESSION['user_token'] = $cookie_token;

            setcookie('user_token', $cookie_token , 0 , '/' , 'donategame.com' , true , true);
        }else{
            //code for session_destroy
        }

    }

            //prevent session hijaking with browser user agent
    if(!isset($_SESSION['user_agent'])){
        $_SESSION['user_agent'] = $_SERVER['HTTP_USER_AGENT'];
    }

    if($_SESSION['user_agent'] != $_SERVER['HTTP_USER_AGENT']){
      die('session hijaking - user agent');
    }

Uwaga: Nie regeneruj tokena plik cookie z żądaniem ajax Uwaga: powyższy kod jest przykładem. uwaga: jeśli użytkownik wyloguje się, token cookie musi zostać zniszczony, a także sesja

6-używanie IP użytkownika do zapobiegania przechwytywaniu sesji nie jest dobrym podejściem, ponieważ ip niektórych użytkowników zmienia się przy każdym żądaniu. KTÓRE WPŁYWAJĄ NA WAŻNYCH UŻYTKOWNIKÓW

7 - osobiście przechowuję dane sesji w bazie danych , od Ciebie zależy jaką metodę zastosujesz

Upewnij się, że nie używasz liczb całkowitych do identyfikatorów sesji. Znacznie lepiej jest użyć GUID lub innego długiego, losowo generowanego ciągu znaków.

Istnieje wiele sposobów ochrony przed przechwyceniem sesji, jednak wszystkie z nich albo zmniejszają satysfakcję użytkownika, albo nie są bezpieczne.

• IP i / lub X-FORWARDED-do kontroli. To działa i jest całkiem bezpieczne... ale wyobraź sobie ból użytkowników. Przychodzą do biura z WiFi, otrzymują nowy adres IP i tracą sesję. Muszę się zalogować.

• Kontrola agenta użytkownika. Podobnie jak powyżej, nowa wersja przeglądarki jest wyłączona, a Ty tracisz sesję. Dodatkowo, są naprawdę łatwe do"włamania". To trywialne, że hakerzy wysyłają fałszywe struny UA.

• Token LocalStorage. Po zalogowaniu Wygeneruj token, przechowuj go w pamięci przeglądarki i przechowuj w zaszyfrowanym pliku cookie (zaszyfrowanym po stronie serwera). Nie ma to żadnych skutków ubocznych dla użytkownika(localStorage utrzymuje się dzięki aktualizacjom przeglądarki). To nie jest tak bezpieczne - jak to jest po prostu bezpieczeństwo poprzez ciemność. Dodatkowo możesz dodać trochę logiki (szyfrowanie/deszyfrowanie) do JS, aby jeszcze bardziej zaciemnić to.

• Reissuing Cookie. To chyba właściwy sposób. Sztuczka polega na tym, aby zezwolić tylko jednemu klientowi na używanie Plików cookie na raz. Tak więc aktywny użytkownik będzie miał ponownie wydany plik cookie co godzinę lub mniej. Stary plik cookie jest unieważniany, jeśli zostanie wydany nowy. Hacks są nadal możliwe , ale znacznie trudniejsze do zrobienia-albo haker lub ważny użytkownik otrzyma dostęp odrzucony.

Weźmy pod uwagę, że podczas fazy logowania klient i serwer mogą uzgodnić tajną wartość salt. Następnie serwer dostarcza wartość count przy każdej aktualizacji i oczekuje, że klient odpowie Hashem (secret salt + count). Potencjalny porywacz nie ma żadnego sposobu, aby uzyskać tę tajemną wartość soli, a tym samym nie może wygenerować następnego hasha.

AFAIK obiekt sesji nie jest dostępny u klienta, ponieważ jest przechowywany na serwerze WWW. Jednak identyfikator sesji jest przechowywany jako plik Cookie i umożliwia serwerowi www Śledzenie sesji użytkownika.

Aby zapobiec przechwytywaniu sesji przy użyciu identyfikatora sesji, można przechowywać zahaszowany łańcuch wewnątrz obiektu sesji, wykonany przy użyciu kombinacji dwóch atrybutów, zdalnego addr i zdalnego portu, które mogą być dostępne na serwerze WWW wewnątrz obiektu żądania. Te atrybuty wiążą sesję użytkownika z przeglądarka, w której zalogował się użytkownik.

Jeśli użytkownik loguje się z innej przeglądarki lub trybu incognito w tym samym systemie, adres IP pozostanie taki sam, ale port będzie inny. W związku z tym, gdy aplikacja jest dostępna, użytkownik zostanie przypisany inny identyfikator sesji przez serwer WWW.

Poniżej znajduje się kod, który zaimplementowałem i przetestowałem kopiując identyfikator sesji z jednej sesji do drugiej. Działa całkiem dobrze. Jeśli istnieje luka, daj mi znać, jak symulowałem to.

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    HttpSession session = request.getSession();
    String sessionKey = (String) session.getAttribute("sessionkey");
    String remoteAddr = request.getRemoteAddr();
    int remotePort = request.getRemotePort();
    String sha256Hex = DigestUtils.sha256Hex(remoteAddr + remotePort);
    if (sessionKey == null || sessionKey.isEmpty()) {
        session.setAttribute("sessionkey", sha256Hex);
        // save mapping to memory to track which user attempted
        Application.userSessionMap.put(sha256Hex, remoteAddr + remotePort);
    } else if (!sha256Hex.equals(sessionKey)) {
        session.invalidate();
        response.getWriter().append(Application.userSessionMap.get(sessionKey));
        response.getWriter().append(" attempted to hijack session id ").append(request.getRequestedSessionId()); 
        response.getWriter().append("of user ").append(Application.userSessionMap.get(sha256Hex));
        return;
    }
    response.getWriter().append("Valid Session\n");
}

Użyłem algorytmu SHA-2 do hashowania wartości za pomocą przykładu podanego w SHA-256 hashowanie w baeldung

Czekam na Wasze komentarze.

Aby zmniejszyć ryzyko, Możesz również powiązać adres IP z sesją. W ten sposób atakujący musi znajdować się w tej samej sieci prywatnej, aby móc korzystać z sesji.

Sprawdzanie nagłówków referer może być również opcją, ale te są łatwiejsze do sfałszowania.

Chroń przez:

$ip=$_SERVER['REMOTE_ADDER'];
$_SESSEION['ip']=$ip;