Java -Authentifizierung und -autorisierung mit JWT

JWT ist ein offener Standard für die sichere Übertragung von Informationen. In Java kann Authentifizierung und Autorisierung über die JJWT -Bibliothek erreicht werden. 1. Fügen Sie JJWT API, Impl und Jackson -Abhängigkeiten hinzu; 2. Erstellen Sie die JWTUTIL -Werkzeugklasse, um das Token zu generieren, zu analysieren und zu überprüfen. 3. Schreiben Sie JWTFilter, um Anforderungen abzufangen, und überprüfen Sie das Trägertoken im Autorisierungsheader. V. 5. Geben Sie eine Anmeldeschnittstelle an, um JWT zurückzugeben, nachdem Sie den Benutzer überprüfen. 6. Die geschützte Schnittstelle erhält die Identität und Rolle des Benutzers für die Zugriffskontrolle durch Parsen des Tokens und realisiert letztendlich einen zustandslosen und erweiterbaren Sicherheitsmechanismus, der für verteilte Systemanwendungen geeignet ist. Achten Sie auf Sicherheitsvorschläge wie wichtige Sicherheit, Token -Ablauf und HTTPS -Übertragung.

In der modernen Webanwendungsentwicklung ist die Verwendung von JAVA zur Implementierung der Benutzerauthentifizierung (Authentifizierung) und der Autorisierung eine übliche Voraussetzung. JWT (JSON Web Token) ist aufgrund seiner staatenlosen, skalierbaren und Cross-Domänen-Unterstützung zu einer der Mainstream-Lösungen für die Implementierung der Sicherheitsauthentifizierung geworden. Im Folgenden wird beschrieben, wie Sie JWT verwenden, um die Authentifizierung und Autorisierung in Java -Anwendungen zu vervollständigen.

Was ist JWT?

JWT ist ein offener Standard (RFC 7519), mit dem Informationen als JSON -Objekt zwischen Parteien sicher übertragen werden. Es wird üblicherweise für die Authentifizierung und den Informationsaustausch verwendet. Ein JWT besteht aus drei Teilen:

• Header : Enthält Token -Typ und Signaturalgorithmus (wie HMAC SHA256)
• Nutzlast : Enthält Ansprüche wie Benutzer -ID, Rolle, Ablaufzeit usw.
• Signatur : Signatur die ersten beiden Teile, um sicherzustellen, dass die Daten nicht manipuliert wurden

Das Format ist: xxxxx.yyyyy.zzzzz

Grundprozess

1. Benutzeranmeldung, Benutzername und Passwort senden
2. Serverüberprüfungsanmeldeinformationen, Generieren Sie JWT und kehren zum Client zurück
3. Der Kunde trägt das JWT in nachfolgenden Anfragen (normalerweise im Authorization )
4. Der Server überprüft die Gültigkeit des JWT und entscheidet, ob der Zugriff auf die Ressource basierend auf den darin enthaltenen Aussagen autorisiert wird.

Verwenden Sie Java JWT, um Authentifizierung und Autorisierung zu implementieren

1. Fügen Sie Abhängigkeiten hinzu (wie ein Beispiel Maven einnehmen)

Verwenden Sie die JJWT -Bibliothek, um JWT zu verarbeiten:

 <De vorangehen>
    <gruppeID> io.jsonWebtoken </Groupid>
    <artifactid> jjwt-api </artifactid>
    <version> 0.11.5 </Version>
</abhängig>
<De vorangehen>
    <gruppeID> io.jsonWebtoken </Groupid>
    <artifactid> jjwt-impl </artifactid>
    <version> 0.11.5 </Version>
    <Scope> Laufzeit </Scope>
</abhängig>
<De vorangehen>
    <gruppeID> io.jsonWebtoken </Groupid>
    <artifactid> jjwt-jackson </artifactid>
    <version> 0.11.5 </Version>
    <Scope> Laufzeit </Scope>
</abhängig>

Hinweis: JJWT 0.11 unterstützt die Modularität und erfordert die Einführung von API, Impl und Jackson -Unterstützung.

2. Erstellen Sie die JWT -Toolklasse

 importieren io.jsonWebtoken.*;
import IO.jsonWebtoken.security.keys;

importieren javax.crypto.secretkey;
import Java.util.date;

öffentliche Klasse jwtutil {
    private static Final SecretKey Secret_key = keys.secretkeyfor (SignatureAlgorithm.hs256);
    private statische endgültige Langzeitablauf_Time = 86400000; // 24 Stunden

    // JWT erzeugen
    public static String GeneratEToken (String -Benutzername, String -Rolle) {
        return jwts.builder ()
                SETSUBJECT (Benutzername)
                .Claim ("Rolle", Rolle)
                .setISEDAT (neues Datum ())
                .setExpiration (neues Datum (System.CurrentTimemillis () expiration_time))
                .Signwith (Secret_key)
                .kompakt();
    }

    // JWT analysieren und überprüfen
    public statische Ansprüche parsetoken (String Token) {
        versuchen {
            Return jwts.parserbuilder ()
                    .SetsigningKey (Secret_key)
                    .bauen()
                    .Parseclaimsjws (Token)
                    .getBody ();
        } catch (abgelaufenJwTexception e) {
            System.out.println ("Token abgelaufen");
            null zurückkehren;
        } catch (MalmaleformedJwTexception | Signaturexception e) {
            System.out.println ("Invalid Token");
            null zurückkehren;
        }
    }

    // Benutzername öffentliche statische String GetUnernamefromToken (String Token) {
        Ansprüche Ansprüche = parsetoken (Token);
        Returnansprüche! = NULL? Ansprüche.GetSubject (): NULL;
    }

    // die Rolle öffentliche statische String GetRolefromToken (String Token) {
        Ansprüche Ansprüche = parsetoken (Token);
        return (string) caells.get ("Rolle");
    }

    // überprüfen
        String tokenusername = getUnernameFromToken (token);
        return (tokenusername! = null && tokenusername.equals (Benutzername) && parsetoken (token)! = null);
    }
}

3.. Abfanganfragen: Implementieren von Filtern (Filter)

Erstellen Sie einen JwtFilter um Anforderungen abzufangen und JWT zu überprüfen.

 Javax.servlet importieren.*;
importieren javax.servlet.http.httpServletRequest;
importieren javax.servlet.http.httpServletResponse;
importieren java.io.ioException;

öffentliche Klasse JWTFilter implementiert Filter {

    @Override
    Public Void Dofilter (ServletRequest Request, ServletResponse -Antwort, Filterchain -Kette)
            löst ioException, ServletException {aus

        HttpServletRequest httprequest = (httpServletRequest) Anfrage;
        HttpServletResponse httpresponse = (httpServletResponse) Antwort;

        String token = httprequest.Getheader ("Autorisierung");

        if (token! = null && token.startswith ("Bearer")) {
            token = token.substring (7); // "Träger" entfernen
            String username = jwtutil.getUnernameFromToken (Token);

            if (Benutzername! = null && jwtutil.istokenvalid (Token, Benutzername)) {
                // Benutzerinformationen können im Anforderungsattribut oder im Sicherheitskontext gespeichert werden
                httprequest.setAttribute ("CurrentUser", Benutzername);
                httprequest.setAttribute ("Rolle", jwtutil.getRolfromToken (Token));
                chain.dofilter (Anfrage, Antwort);
            } anders {
                httpresponse.setStatus (httpServletResponse.sc_unauthorized);
                httPresponse.getWriter (). Schreiben ("Ungültig oder abgelaufener Token");
            }
        } anders {
            httpresponse.setStatus (httpServletResponse.sc_unauthorized);
            httPresponse.getWriter (). Schreiben ("fehlendes Token");
        }
    }
}

4. Konfigurieren Sie den Filter (Federstart als Beispiel)

Wenn Sie Spring Start verwenden, können Sie den Filter in der Konfigurationsklasse registrieren:

 @Bohne
public filterregistrationBean <Jwtfilter> jwtfilter () {
    FilterregistrationBean <Jwtfilter> RegistrierungBean = new FilterregistrationBean <> ();
    RegistrierungBean.SetFilter (New JWTFilter ());
    RegistrierungBean.addurlpatterns ("/api/sichere/*"); // geschützte Pfadrückgaberegistrierung;
}

5. Beispiel für Login -Schnittstelle

 @Postmapping ("/login")
public responseentity <?> Login (@RequestBody userLoginRequest -Anfrage) {{
    // vereinfacht: Tatsächlich sollte das Datenbankkennwort zur Verschlüsselungsüberprüfung überprüft werden, wenn ("admin" .equals (request.getUnername ()) && "password" .equals (request.getPassword ()) {
        String token = jwtutil.generatetoken (request.getUnername (), "admin");
        return responseentity.ok (). body (map.of ("token", token));
    }
    return responseentity.status (401) .body ("unter Benutzername oder Passwort");
}

6. Beschützter Grenzflächenbeispiel

 @Getmapping ("/sicher/data")
public responseentity <?> GetSecuredata (httpServletRequest -Anfrage) {{
    String user = (String) request.getAttribute ("currentUser");
    String rol = (String) request.getAttribute ("rollen");

    if ("admin" .equals (rolle)) {
        return responseentity.ok ("Hallo" Benutzer ", Sie haben Administratorzugriff!");
    } anders {
        Return Responseentity.Status (403) .Body ("unzureichende Erlaubnis");
    }
}

Sicherheitsberatung

• Schlüsselverwaltung : Hardcode -Tasten in Code, verwenden Sie Umgebungsvariablen oder Konfigurationszentren nicht
• Token -Ablaufzeit : Legen Sie die Ablaufzeit vernünftig fest. Es wird empfohlen, kurzfristige Token bei sensiblen Operationen zu verwenden.
• TEFRESH -Token : Kann die Benutzererfahrung mit dem Aktualisierungs -Token -Mechanismus verbessern
• HTTPS : Stellen Sie sicher
• Vermeiden Sie sensible Informationen : Speichern Sie keine sensiblen Daten wie Passwörter in der JWT -Nutzlast

Zusammenfassen

Die Verwendung von JWT zur Implementierung der Authentifizierung und Autorisierung in Java ist nicht kompliziert, der Kern ist:

• Generieren Sie Token nach erfolgreichem Anmeldung
• Der Kunde trägt eine Token -Anfrage
• Der Server überprüft das Token über Filter und extrahiert Benutzerinformationen
• Implementieren Sie die Autorisierungskontrolle gemäß der Rolle

Dieser Mechanismus eignet sich für verteilte und Microservice -Architekturen, wodurch der Overhead von Serverspeichersitzungen vermieden wird.

Grundsätzlich ist es nicht kompliziert, aber es ist leicht, Details wie Ausnahmehandhabung und wichtige Sicherheit zu ignorieren.

Das obige ist der detaillierte Inhalt vonJava -Authentifizierung und -autorisierung mit JWT. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!