[JAVA] Wie Spring Security mit Hello World funktioniert

Vorstellen

Worüber man heute reden soll

Erläutern Sie die Grundlagen der Funktionsweise von Spring Security in einer kurzen Hello World

――Welche Klassen arbeiten zusammen und wie --Wie die Konfigurationsdatei zusammenhängt

Hintergrund

Abstrakte Einstellungen

Zielperson

Indem Sie lernen, wie Spring Security über Hello World funktioniert

Vorausgesetztes Wissen

  • Hat gute Kenntnisse in Servlet und JSP
  • Wenn Sie "Filter" usw. kennen, können Sie "web.xml" schreiben, um eine Servlet-App zu erstellen
  • Hat ein anständiges Wissen über den Frühling
  • Bohnen und AOPs von DI-Behältern verstehen

Hallo Welt App (Prämisse)

Verwenden Sie keinen Spring Boot

  • Ziel ist es, die Grundlagen von Spring Security zu erlernen
  • Verwenden Sie nur einfache Federsicherheit

Verwenden Sie keine Java-Konfiguration

--Schreiben Sie die Einstellungen in XML ―― Immerhin ist Java Config gleich

Verwenden Sie keine Servlet 3.0-Funktionen

  • Wenn Sie die Funktion von Servlet 3.0 verwenden, können Sie sie ohne web.xml festlegen. ――Der Zweck besteht darin, die Grundlagen des Mechanismus zu erlernen. Verwenden Sie ihn daher auch nicht.

Hallo Welt App (Umgebungskonstruktion)

Quelle

https://github.com/opengl-8080/spring-security-hello-world

Betriebsüberprüfungsumgebung

  • Java 1.8.0_121
  • Tomcat 8.0.35

Holen Sie sich die Kriegsakte

  • Laden Sie spring-security.war von [hier] herunter (https://github.com/opengl-8080/spring-security-hello-world/releases/tag/v1.0.0)
  • Wenn Sie aus dem Quellcode erstellen, laden Sie den Quellcode herunter und führen Sie "gradlew war" im Stammverzeichnis Ihres Projekts aus.

Funktionsprüfung

  • Stellen Sie spring-security.war für Tomcat bereit
  • Zugriff auf http: // localhost: 8080 / spring-security

Hallo Welt App (Betrieb)

Greifen Sie auf "http: // localhost: 8080 / spring-security" zu

spring-security.jpg

Geben Sie "foo" in Benutzer, Passwort ein, um sich anzumelden

spring-security.jpg

403 Fehler

Als nächstes melden Sie sich mit bar an

spring-security.jpg

spring-security.jpg

Die Indexseite wird angezeigt.

Sie können sich abmelden, indem Sie auf die Schaltfläche Abmelden klicken.

Hallo Welt App (Implementierung)

Dateiorganisation


|-build.gradle :Gradle Build-Datei
|
`-src/main/webapp/
  |
  |-index.jsp :Indexseite
  |
  `-WEB-INF/
    |
    |-applicationContext.xml :Federkonfigurationsdatei
    |
    `-web.xml :Servlet-Konfigurationsdatei
  • Alle 4 Dateien ――Eine ist eine Build-Datei, daher werden tatsächlich drei Dateien bereitgestellt. --Ultra-einfache Konfiguration ohne Java-Quelle

build.gradle


apply plugin: 'war'

sourceCompatibility = '1.8'
targetCompatibility = '1.8'
compileJava.options.encoding = 'UTF-8'

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.springframework.security:spring-security-web:4.2.1.RELEASE'
    compile 'org.springframework.security:spring-security-config:4.2.1.RELEASE'
}

war.baseName = 'spring-security'

task wrapper(type: Wrapper) {
    gradleVersion = '3.2.1'
}

index.jsp


<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>
      Hello Spring Security!!
    </title>
  </head>
  <body>
    <h1>
      Hello Spring Security!!
    </h1>
    
    <form action="logout" method="post">
      <input type="submit"
             value="logout" />
      <input type="hidden"
             name="${_csrf.parameterName}"
             value="${_csrf.token}" />
    </form>
  </body>
</html>
  • Die oberste Seite wird nach der Anmeldung angezeigt --Nur eine Nachricht und eine Abmeldeschaltfläche -- _csrf ist festgelegt, da es standardmäßig aktiviert ist. Da es jedoch in der folgenden Erläuterung nicht angezeigt wird, wird eine ausführliche Erläuterung weggelassen.
  • Weitere Informationen finden Sie in Spring Security Usage Memo CSRF | Qiita.

web.xml


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

  <listener>
    <listener-class>
      org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>
  
  <filter>
    <filter-name>
      springSecurityFilterChain
    </filter-name>
    <filter-class>
      org.springframework.web.filter.DelegatingFilterProxy
    </filter-class>
  </filter>

  <filter-mapping>
    <filter-name>
      springSecurityFilterChain
    </filter-name>
    <url-pattern>
      /*
    </url-pattern>
  </filter-mapping>
</web-app>

applicationContext.xml


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/security
         http://www.springframework.org/schema/security/spring-security.xsd">

  <sec:http>
    <sec:intercept-url
            pattern="/login"
            access="permitAll" />
    <sec:intercept-url
            pattern="/**"
            access="isAuthenticated() and hasAuthority('BAR')" />
    <sec:form-login />
    <sec:logout />
  </sec:http>
  
  <sec:authentication-manager>
    <sec:authentication-provider>
      <sec:user-service>
        <sec:user name="foo"
                  password="foo"
                  authorities="" />
        <sec:user name="bar"
                  password="bar"
                  authorities="BAR" />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>
</beans>

Lesen Sie Hallo Welt

  1. Starten Sie die Serverakzeptanzanforderung
  2. Spring Security Eingang
  3. Anmeldevorgang
  4. Zugangskontrolle
  5. Abmeldevorgang

Lesen Sie Hallo Welt

  1. ** Server starten - Anfrage empfangen **
  2. Spring Security Eingang
  3. Anmeldevorgang
  4. Zugangskontrolle
  5. Abmeldevorgang

Federbehälterinitialisierung

web.xml


<listener>
  <listener-class>
    org.springframework.web.context.ContextLoaderListener
  </listener-class>
</listener>
  • <listener>
  • Mit der Servlet-Funktion können Sie den Prozess definieren, der beim Start der Anwendung ausgeführt werden soll.
  • ContextLoaderListener
  • Klasse, die den Spring-Container initialisiert
  • Standardmäßig wird "XmlWebApplicationContext" verwendet --WEB-INF / applicationContext.xml wird als Konfigurationsdatei verwendet

Registrierung von DelegatingFilterProxy

web.xml


  <filter>
    <filter-name>
      springSecurityFilterChain
    </filter-name>
    <filter-class>
      org.springframework.web.filter.DelegatingFilterProxy
    </filter-class>
  </filter>

  <filter-mapping>
    <filter-name>
      springSecurityFilterChain
    </filter-name>
    <url-pattern>
      /*
    </url-pattern>
  </filter-mapping>
  • Registrieren Sie einen Filter mit dem Namen "DelegatingFilterProxy" mit dem Namen "springSecurityFilterChain" --Filter ist eine Funktion von Servlet
  • Vor und nach der Anfrage kann eine beliebige Verarbeitung eingefügt werden
  • Geben Sie "/ *" für "URL-Muster" an, um alle Anforderungen zu verarbeiten

Rolle von DelegatingFilterProxy

DelegatingFilterProxyの役割.png

--DelegatingFilterProxy durchsucht den Spring-Container nach Bohnen, die den folgenden Kriterien entsprechen:

  • Der Name der Bean entspricht dem Filternamen (springSecurityFilterChain)
  • Implementieren der Schnittstelle "javax.servlet.Filter"
  • Delegieren Sie die Verarbeitung auf die erworbene Bean
  • Da die Klasse, an die DelegatingFilterProxy die Verarbeitung delegiert hat, eine vom Spring-Container erhaltene Bean ist, können die Funktionen des Spring-Containers verwendet werden.
    • DI
    • AOP
    • etc...
  • Die Rolle von DelegatingFilterProxy besteht darin, den Servlet-Container und den Spring-Container zu überbrücken.

Spring Security-Einstellungen

applicationContext.xml


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>

  <sec:http>
    <sec:intercept-url
            pattern="/login"
            access="permitAll" />
    <sec:intercept-url
            pattern="/**"
            access="isAuthenticated() and hasAuthority('BAR')" />
    <sec:form-login />
    <sec:logout />
  </sec:http>

  ...

--applicationContext.xml ist die Spring-Konfigurationsdatei

  • Definieren Sie eine Bean mit dem Tag
  • Keine Konfigurationsdatei für Spring Security
  • Ein spezielles Tag ermöglicht das präzise Schreiben von Spring Security-Einstellungen.
  • In der Referenz ** Namespace ** genannt --Lesen mit xmlns: sec

<http> ist der Schlüssel

applicationContext.xml


  <sec:http>
    ...
  </sec:http>

--Dieses ist der Schlüssel zum Einstellen von Spring Security

  • Eine große Anzahl wichtiger Bohnen ist registriert

FilterChainProxy

  • Eine der Bohnen, die vom Tag registriert wurden
  • Vererbung der Filter Schnittstelle
  • Im Spring-Container mit dem Namen "springSecurityFilterChain" registriert
  • Die Identität der von "DelegatingFilterProxy" delegierten Bean

Zusammenfassung (Server-Empfangsanforderung starten) </ span>

test

  1. Der Servlet-Container wird gestartet und "ContextLoaderListener", der in "web.xml" als "Listener" registriert ist, wird ausgeführt.
  2. Eine Instanz von "XmlWebApplicationContext" wird erstellt und "/ WEB-INF / applicationContext.xml" wird geladen.
  3. Das Tag registriert eine Instanz von FilterChainProxy im Spring-Container mit dem Namen springSecurityFilterChain.
  4. DelegateFilterProxy, das in web.xml als Filter registriert ist, wird vom Servlet-Container generiert.
  5. Auf Anfrage wird "DelegateFilterProxy" aufgerufen, um die Bean aus dem Spring-Container mit ihrem eigenen Namen ("springSecurityFilterChain") abzurufen ("FilterChainProxy" wird abgerufen).
  6. Die Verarbeitung wird an "FilterChainProxy" delegiert.
  • Genau genommen ist es möglicherweise nicht korrekt, da es leicht zu verstehen ist. Bitte schauen Sie sich die Atmosphäre an.

Lesen Sie Hallo Welt

  1. Server-Empfangsanforderung starten </ del>
  2. ** Spring Security Eingang **
  3. Anmeldevorgang
  4. Zugangskontrolle
  5. Abmeldevorgang

SecurityFilterChain

  • Eine der wichtigen Klassen, die <http> registriert
  • Wie der Name schon sagt, ist "Filter" verkettet. --FilterChainProxy delegiert die empfangene Anfrage an die Filters von SecurityFilterChain
  • Beispiel für standardmäßig registrierten Filter
    • SecurityContextPersistenceFilter
    • CsrfFilter
    • AnonymousAuthenticationFilter
    • ExceptionTranslationFilter
    • FilterSecurityInterceptor
    • etc...

Federsicherheit und Filter

SpringSecurityとFilter.jpg

--Spring Security wird durch eine Kombination von "Filter" realisiert

  • Für jede Funktion wird ein Filter vorbereitet, und Sie können die Funktion aktivieren / deaktivieren, indem Sie den Filter in der SecurityFilterChain registrieren.

SecurityFilterChain für jedes URL-Muster

patternごとのSecurityFilterChain.jpg

--SecurityFilterChain kann für jedes URL-Muster definiert werden

  • Verwenden Sie für den Zugriff auf eine URL, die mit "/ api / **" übereinstimmt, den für die REST-API festgelegten Satz "SecurityFilterChain". --Für den Zugriff auf andere URLs (/ **) verwenden Sie das für den normalen Bildschirmzugriff festgelegte SecurityFilterChain. --Kann man sagen
  • Beispielsweise werden Funktionen wie "Formularanmeldung" beim Zugriff mit der REST-API nicht mehr benötigt.

Die Konfigurationsdatei sieht folgendermaßen aus:

applicationContext.xml


  <sec:http pattern="/api/**">
    ...
  </sec:http>
  
  <sec:http pattern="/**">
    ...
  </sec:http>
  • Geben Sie im Attribut "pattern" des Tags "" an (Kann im Ant-Format angegeben werden) --Die Einstellungen werden in der Reihenfolge von oben angewendet. Bringen Sie also die Einstellungen mit eingeschränkteren Einstellungen nach oben. (Wenn die Einstellung "/ **" über "/ api / **" liegt, entspricht der Zugriff auf "/ api / **" zuerst der Einstellung "/ **".)

Zusammenfassung (Spring Security-Eingang) </ span>

--<http>registriert SecurityFilterChain als Bean --SecurityFilterChain enthält mehrereFilters

  • Spring Security bietet Filter für jede Funktion
  • Durch Kombinieren von "Filter" können Sie "SecurityFilterChain" nur mit den erforderlichen Funktionen definieren.
  • Da "SecurityFilterChain" für jedes URL-Muster definiert werden kann, --SecurityFilterChain für die REST-API --SecurityFilterChain für normalen Bildschirmzugriff Kann eingestellt werden

patternごとのSecurityFilterChain.jpg

Lesen Sie Hallo Welt

  1. Server-Empfangsanforderung starten </ del>
  2. Spring Security-Eingang </ del>
  3. ** Anmeldevorgang **
  4. Zugangskontrolle
  5. Abmeldevorgang

Aktivieren Sie die Formularanmeldung

applicationContext.xml


  <sec:http>
    ...
    <sec:form-login />
    ...
  </sec:http>
  • Durch Hinzufügen des Tags "" wird die Formularanmeldung aktiviert
  • Der für die Formularanmeldung erforderliche Filter wird zu SecurityFilterChain hinzugefügt

Standard-Anmeldeseite

spring-security.jpg

  • Wenn das Attribut login-page von <form-login> nicht angegeben ist, wird ein Filter namens DefaultLoginPageGeneratingFilter registriert.
  • Erzeugt und gibt eine einfache Anmeldeseite zurück, wenn in / login eine GET-Methodenanforderung vorliegt
  • Praktisch, wenn Sie die Funktionsprüfung schnell ausprobieren möchten
  • Ein Kontrollkästchen für Remember-Me wird automatisch hinzugefügt, wenn die Remember-Me-Authentifizierung aktiviert ist.

Anmeldeanfragen verarbeiten

  • Die Anmeldeverarbeitung wird von "Filter" mit dem Namen "UsernamePasswordAuthenticationFilter" durchgeführt --Wenn eine Anfrage von der POST-Methode bei / login eintrifft, startet der Authentifizierungsprozess.
  • Der eigentliche Authentifizierungsprozess wird jedoch an "AuthenticationManager" delegiert.

AuthenticationManagerに委譲.png

Bitte beachten Sie, dass hier viel "Delegation" herauskommt und es verwirrend ist! </ span>

AuthenticationManager

applicationContext.xml


  <sec:authentication-manager> ★
    <sec:authentication-provider>
      <sec:user-service>
        <sec:user name="foo" ... />
        <sec:user name="bar" ... />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>
  • Durch Deklarieren des Tags "" wird "ProviderManager", eine Implementierungsklasse von "AuthenticationManager", im Spring-Container registriert. --Klasse, die den Zugang zum Authentifizierungsprozess darstellt
  • Der ProviderManager selbst führt jedoch keine Authentifizierungsverarbeitung durch und ** delegiert ** an den AuthenticationProvider.

ProviderManagerとAuthenticationProvider.png

ProviderManager und AuthenticationProvider

AuthenticationProviderの実装クラス達.png

--AuthenticationProvider verfügt über viele Implementierungsklassen für jeden Authentifizierungstyp --ProviderManager enthält mehrere Instanzen von AuthenticationProvider gemäß der von der Anwendung unterstützten Authentifizierungsmethode.

  • Jeder "AuthenticationProvider" wird erstellt, um zu beurteilen, ob die aktuelle Authentifizierungsanforderung unterstützt wird. Wenn dies unterstützt wird, wird der Authentifizierungsprozess von "AuthenticationProvider" ausgeführt. --ProviderManager ist verantwortlich für die gemeinsame Verwaltung mehrererAuthenticationProviders (genau ProviderManager).

AuthenticationProvider für die Kennwortauthentifizierung

applicationContext.xml


  <sec:authentication-manager>
    <sec:authentication-provider> ★
      <sec:user-service>
        <sec:user name="foo" ... />
        <sec:user name="bar" ... />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>
  • Durch Verwendung des Tags "" wird eine Klasse mit dem Namen "DaoAuthenticationProvider" als Implementierung von "AuthenticationProvider" registriert. --DaoAuthenticationProvider führt die Authentifizierungsverarbeitung mit einer Kombination aus Benutzername und Kennwort durch.
  • Zu diesem Zeitpunkt wird Dao (Datenzugriffsobjekt) verwendet, um Benutzerinformationen zu erfassen.
  • Der Teil, der Dao entspricht, wird an UserDetailsService ** delegiert **.

UserDetailsServiceに委譲.png

UserDetailsService

UserDetailsService


public interface UserDetailsService {

    UserDetails
        loadUserByUsername(String username)
            throws UsernameNotFoundException;
}
  • Hat eine Methode, die Benutzerinformationen (UserDetails) basierend auf dem Benutzernamen zurückgibt
  • Löst UsernameNotFoundException aus, wenn kein Benutzer gefunden wird --Spring Security bietet mehrere Klassen, die diese Schnittstelle implementieren

InMemoryUserDetailsManager Implementierung zum Speichern von Benutzerinformationen im Speicher

JdbcUserDetailsManager Implementierung, die Benutzerinformationen über JDBC aus der Datenbank abruft

Verwenden Sie InMemoryUserDetailsManager

applicationContext.xml


  <sec:authentication-manager>
    <sec:authentication-provider>
      <sec:user-service> ★
        <sec:user name="foo" ... />
        <sec:user name="bar" ... />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>
  • Wenn Sie das Tag "" verwenden, wird "InMemoryUserDetailsManager" im Spring-Container als Implementierung von "UserDetailsService" registriert.

UserDetails

UserDetails.java


public interface UserDetails extends Serializable {

    String getUsername();
    String getPassword();
    Collection<? extends GrantedAuthority>
        getAuthorities();

    boolean isAccountNonExpired();
    boolean isAccountNonLocked();
    boolean isCredentialsNonExpired();
    boolean isEnabled();
}

--UserDetails ist eine Schnittstelle, die detaillierte Informationen über den angemeldeten Benutzer bereitstellt.

  • Sie können den Status wie Benutzername und Passwort, Sammlung der gewährten Berechtigungen, abgelaufen und gesperrt abrufen.
  • Eine Klasse namens "Benutzer" wird als Klasse vorbereitet, die diese Schnittstelle implementiert.

Benutzer verwenden

applicationContext.xml


  <sec:authentication-manager>
    <sec:authentication-provider>
      <sec:user-service>
        <sec:user name="foo" ... /> ★
        <sec:user name="bar" ... /> ★
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>
  • Wenn Sie das Tag verwenden, werden Benutzerinformationen mit der Klasse User generiert.
  • Die generierten Benutzerinformationen werden in "" gespeichert, dh in "InMemoryUserDetailsManager".

Organisieren Sie den Fluss so weit

ログイン処理整理.png

  1. Wenn eine POST-Anfrage an / login kommt, führt UsernamePasswordAuthenticationFilter den Authentifizierungsprozess durch.
  2. Die Authentifizierungsverarbeitung wird an "AuthenticationManager" delegiert
  3. "ProviderManager", eine Implementierungsklasse von "AuthenticationManager", delegiert die Authentifizierungsverarbeitung an seinen eigenen "AuthenticationProvider".
  4. DaoAuthenticationProvider, der mit dem Tag ` registriert ist, führt die Authentifizierungsverarbeitung basierend auf dem Benutzernamen und dem Kennwort durch.
  5. Zu diesem Zeitpunkt wird die Suche nach Benutzerinformationen an "UserDetailsService" delegiert.
  6. Der mit dem Tag registrierte InMemoryUserDetailsManager speichert die mit dem Tag definierten Benutzerinformationen (UserDetails) im Speicher.

Die obigen Beziehungen sind in den folgenden Einstellungen enthalten.

applicationContext.xml


  <sec:authentication-manager>
    <sec:authentication-provider>
      <sec:user-service>
        <sec:user name="foo" ... />
        <sec:user name="bar" ... />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>

Wenn die Authentifizierung erfolgreich ist

AuthenticationProvider.java


public interface AuthenticationProvider {

    Authentication authenticate(Authentication authentication)
        throws AuthenticationException;
}
  • Wenn der Authentifizierungsprozess von "AuthenticationProvider" erfolgreich ist, wird das "Authentication" -Objekt zurückgegeben, das die Informationen des angemeldeten Benutzers enthält.
  • Dieses "Authentifizierungs" -Objekt wird in der Sitzung gespeichert und in nachfolgenden Anforderungen usw. referenziert.

Zusammenfassung (Anmeldevorgang) </ span>

--<form-login>aktiviert die Formularauthentifizierung --UsernamePasswordAuthenticationFilter wird hinzugefügt und der Authentifizierungsprozess gestartet. --AuthenticationManager steuert den Authentifizierungsprozess --AuthenticationProvider führt eine bestimmte Authentifizierungsverarbeitung durch --UserDetailsService ruft Benutzerinformationen Dao ab --UserDetails bietet detaillierte Informationen über den Benutzer

  • Wenn die Authentifizierung erfolgreich ist, wird das Objekt "Authentifizierung" in der Sitzung gespeichert.

Lesen Sie Hallo Welt

  1. Server-Empfangsanforderung starten </ del>
  2. Spring Security-Eingang </ del>
  3. Anmeldevorgang </ del>
  4. ** Zugangskontrolle **
  5. Abmeldevorgang

FilterSecurityInterceptor

  • Einer der wichtigen Filter, die durch Definieren des Tags hinzugefügt wurden --- Fügen Sie den Prozess vor und nach dem Ausführen des Prozesses von ** Secure Object ** ein
  • Die Zugriffssteuerung für HTTP-Anforderungen wird in diesem FilterSecurityInterceptor initiiert

Objekt sichern

  • ** Geschützte Objekte ** werden in der Spring Security-Referenz als ** Sicheres Objekt ** bezeichnet.
  • Obwohl "Objekt" steht, bedeutet es (wahrscheinlich) das ursprüngliche Objekt "Objekt" und nicht ein bestimmtes Java-Objekt.
  • "HTTP-Anfrage an eine bestimmte URL" oder "Ausführungsmethode" ist ein sicheres Objekt.

Delegation der Zugangskontrolle

AccessDecisionManagerに委譲.png

--FilterSecurityInterceptor selbst überprüft die Zugriffskontrolle nicht

  • Delegation der Beurteilung der Zugangskontrolle zu "AccessDecisionManager"

Zugangskontrolle durch Abstimmung

投票によるアクセス制御

  • Die von Spring Security bereitgestellte Implementierungsklasse von "AccessDecisionManager" steuert den Zugriff durch "** Abstimmung **". --AccessDecisionManager lässt AccessDecisionVoter für den Zugriff stimmen
  • Zugegeben: Zugänglich </ font>
  • verweigert: Unzugänglich </ font>
  • Abbruch: Nicht unterstützt </ font> --AccessDecisionManager fasst die Abstimmungsergebnisse zusammen und zieht Schlussfolgerungen
  • Wenn ja, nichts tun
  • Werfen Sie "AccessDeniedException", wenn dies nicht möglich ist

AccessDecisionManager-Implementierungsklasse

AccessDecisionManagerと実装クラス.png

--AccessDecisionManager verfügt über drei Implementierungsklassen

  • AffirmativeBased
  • Zugriff, wenn es nur einen "Zuschuss" gibt --Diese Klasse wird standardmäßig verwendet
  • ConsensusBased
  • Zugriff auf "Ablehnen" <"Geben"
  • UnanimousBased
  • Zugänglich, wenn alle "gewährt" sind

Ausdrucksbasierte Zugriffskontrolle

applicationContext.xml


  <sec:http>
    <sec:intercept-url
            pattern="/login"
            access="permitAll" />
    <sec:intercept-url
            pattern="/**"
            access="isAuthenticated() and hasAuthority('BAR')" />
    ...
  </sec:http>
  • Standardmäßig wird "WebExpressionVoter" verwendet, um "AccessDecisionVoter" zu implementieren. --Expression Das heißt, steuern Sie die Zugänglichkeit basierend auf Ausdrücken
  • Der Ausdruck für die Zugriffssteuerung wird durch das Attribut "access" des Tags "" angegeben.
  • Das Attribut pattern gibt das Muster der URL an, für die das Steuerelement gilt.

Spring Expression Language (SpEL)

applicationContext.xml


  access="permitAll"
  access="isAuthenticated() and hasAuthority('BAR')"

--Verwenden Sie die Spring-eigene Ausdruckssprache Spring Expression Language für Zugriffssteuerungsausdrücke

  • Stellen Sie sicher, dass das Ergebnis der Auswertung des Ausdrucks "boolean" ist --Wenn true, zugänglich </ font> --Wenn false, nicht zugänglich </ font>
  • Funktionen und Konstanten wurden für Spring Security erweitert --permitAll: Immer wahr --isAuthenticated () : true wenn authentifiziert --hasAuthority () : true, wenn Sie die angegebene Berechtigung haben

Zusammenfassung (Zugriffskontrolle) </ span>

  • Die Zugriffssteuerung wird mit "FilterSecurityInterceptor" gestartet
  • Die eigentliche Steuerung erfolgt über den AccessDecisionManager
  • Die Standardimplementierung verwendet "Voting", um den Zugriff zu bestimmen.
  • "AccessDecisionVoter" -Stimmen und "AccessDecisionManager" aggregieren die Abstimmungsergebnisse und ziehen eine Schlussfolgerung.
  • Standardmäßig ist die ausdrucksbasierte Zugriffssteuerung mit SpEL von WebExpressionVoter aktiviert.

Lesen Sie Hallo Welt

  1. Server-Empfangsanforderung starten </ del>
  2. Spring Security-Eingang </ del>
  3. Anmeldevorgang </ del>
  4. Zugriffskontrolle </ del>
  5. ** Abmeldevorgang **

Abmelden aktivieren

applicationContext.xml


  <sec:http>
    ...
    <sec:logout />
  </sec:http>
  • Mit dem Tag wird ein LogoutFilter hinzugefügt
  • Wenn eine POST-Anfrage an / logout kommt, übernimmt LogoutFilter die Abmeldung.

Rückblick auf das Ganze

Empfang der Serverstartanforderung

test

Spring Security Eingang

SpringSecurityとFilter.jpg

Anmeldevorgang

ログイン処理整理.png

Zugangskontrolle

投票によるアクセス制御

Dies ist die einzige Bedeutung in dieser Einstellung

web.xml


<?xml version="1.0" encoding="UTF-8"?>
<web-app ...>
  <listener>
    <listener-class>
      org.springframework.web.context.ContextLoaderListener
    </listener-class>
  </listener>
  
  <filter>
    <filter-name>
      springSecurityFilterChain
    </filter-name>
    <filter-class>
      org.springframework.web.filter.DelegatingFilterProxy
    </filter-class>
  </filter>

  <filter-mapping>
    <filter-name>
      springSecurityFilterChain
    </filter-name>
    <url-pattern>
      /*
    </url-pattern>
  </filter-mapping>
</web-app>

applicationContext.xml


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:sec="http://www.springframework.org/schema/security"
       ...>

  <sec:http>
    <sec:intercept-url
            pattern="/login"
            access="permitAll" />
    <sec:intercept-url
            pattern="/**"
            access="isAuthenticated() and hasAuthority('BAR')" />
    <sec:form-login />
    <sec:logout />
  </sec:http>
  
  <sec:authentication-manager>
    <sec:authentication-provider>
      <sec:user-service>
        <sec:user name="foo"
                  password="foo"
                  authorities="" />
        <sec:user name="bar"
                  password="bar"
                  authorities="BAR" />
      </sec:user-service>
    </sec:authentication-provider>
  </sec:authentication-manager>
</beans>

Wie war es?
Spring Security Hast du gedacht, es ist einfach? </ span>

[Traurige Nachricht] Immer noch Hallo Welt

Funktionen und Elemente, über die ich heute nicht spreche

  • GrantedAuthority
  • Rollenschichtung
  • Methodensicherheit
  • CSRF
  • Memember-Me
  • Passwortkodierung
  • Verschiedene Anpassungsmethoden --Prüfung
  • etc...

Aber wenn die heutige Geschichte eine Wissensgrundlage ist, sollte sie (wahrscheinlich) überwunden werden </ span>

das ist alles

Recommended Posts