Grundlegende und systematische Geschichte Zertifizierungs- / Autorisierungsgeschichte Remember-Me-Geschichte CSRF-Geschichte Session Management Story Geschichte des Antwortheaders Method Security Story CORS-Geschichte Die Geschichte von Run-As ACL-Geschichte Teststory

Sonderedition Was Spring Security kann und was nicht

Verwendung von Spring Security mit Spring MVC und Spring Boot usw.

Zusammenarbeit mit Spring MVC

Anforderungspfad Matcher

Versuchen Sie zunächst, sich normal zu integrieren

`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.3.RELEASE'
    compile 'org.springframework.security:spring-security-config:4.2.3.RELEASE'
    compile 'org.springframework:spring-webmvc:4.3.10.RELEASE'
}

Den Abhängigkeiten wurde "spring-webmvc" hinzugefügt

`MyMvcController.java`


package sample.spring.security.mvc;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyMvcController {
    
    @GetMapping("/foo")
    public String foo() {
        return "FOO!!";
    }
}

--Controller-Klasse, die "FOO !!" zurückgibt, wenn eine GET-Anfrage an "/ foo" kommt

namespace

`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">
    
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/mvc.xml
            /WEB-INF/security.xml
        </param-value>
    </context-param>

    <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>
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <servlet>
        <servlet-name>mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value></param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>mvc</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

Definieren Sie Spring Security DelegatingFilterProxy bzw. Spring MVC DispatcherServlet
Geben Sie "/ WEB-INF / mvc.xml" und "/ WEB-INF / security.xml" als Spring MVC- und Sicherheitskonfigurationsdateien an

`security.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="/foo" access="isAuthenticated()" />
        <sec:form-login />
    </sec:http>

    <sec:authentication-manager />
</beans>

Frühlingssicherheitseinstellungen
Für den Zugriff auf / foo ist eine Authentifizierung erforderlich

`mvc.xml`


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

    <mvc:annotation-driven />
    
    <bean class="sample.spring.security.mvc.MyMvcController" />
    
</beans>

--Einstellungen für Spring MVC

Java Configuration

`MySecurityInitializer.java`


package sample.spring.config;

import org.springframework.security.web.context.AbstractSecurityWebApplicationInitializer;

public class MySecurityInitializer extends AbstractSecurityWebApplicationInitializer {
}

Klasse zum Anwenden von Spring Security Filter
Nur im Fall von Spring Security wurde die Einstellungsklasse hier an den Konstruktor der übergeordneten Klasse übergeben, aber wenn sie in MVC integriert ist, wird sie in den Initializer für MVC verschoben.

`MyServletInitializer.java`


package sample.spring.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class MyServletInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[] {MySecurityConfig.class, MyMvcConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[] {};
    }
    
    @Override
    protected String[] getServletMappings() {
        return new String[] {"/"};
    }
}

--Initialisierungsklasse für Spring MVC

Sowohl die MVC-Einstellung (MyMvcConfig) als auch die Sicherheitseinstellung ( MySecurityConfig) werden als Stamm der Anwendung festgelegt (ich weiß nicht warum, aber wenn Sie dies nicht tun, funktionieren die später beschriebenen mvcMatchers nicht. T)

`MySecurityConfig.java`


package sample.spring.config;

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@EnableWebSecurity
public class MySecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/foo").authenticated()
            .and()
            .formLogin();
    }
}

--Spring Security-Konfigurationsklasse

Anfragen an / foo erfordern eine Authentifizierung

`MyMvcConfig.java`


package sample.spring.config;

import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import sample.spring.security.mvc.MyMvcController;

@EnableWebMvc
public class MyMvcConfig extends WebMvcConfigurerAdapter {

    @Bean
    public MyMvcController myMvcController() {
        return new MyMvcController();
    }

    @Bean
    public RequestMappingHandlerMapping requestMappingHandlerMapping() {
        return new RequestMappingHandlerMapping();
    }
}

--Einstellungen für Spring MVC --Registrierung des Controllers

Funktionsprüfung

Zuerst wird die Anfrage an "/ foo" gesendet, und dann wird die Anfrage an "/ foo.html" gesendet.

$ curl http://localhost:8080/namespace/foo -i
HTTP/1.1 302 Found
Server: Apache-Coyote/1.1
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-XSS-Protection: 1; mode=block
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Set-Cookie: JSESSIONID=0AD6574E5F43053B42E5C9926535AC0E; Path=/namespace/; HttpOnly
Location: http://localhost:8080/namespace/login
Content-Length: 0
Date: Mon, 31 Jul 2017 13:05:03 GMT


$ curl http://localhost:8080/namespace/foo.html -i
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-XSS-Protection: 1; mode=block
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Content-Disposition: inline;filename=f.txt
Content-Type: text/plain;charset=ISO-8859-1
Content-Length: 5
Date: Mon, 31 Jul 2017 13:05:06 GMT

FOO!!

Im Fall von "/ foo" wurde ich aufgefordert, zum Anmeldebildschirm umzuleiten, aber im Fall von "/ foo.html" wurde die Implementierung des Controllers normal aufgerufen.

Warum passiert das?

--Spring MVC vergleicht Pfade auch mit Erweiterungen wie / foo.html, abhängig von den Einstellungen, wenn der Pfad / foo dem Controller zugeordnet wird.

Dieses Verhalten selbst soll die Implementierung eines API-Typs vereinfachen, der das Umschalten zwischen Antwortformaten nach Erweiterung angibt.
Sowohl / foo.html als auch / foo.json werden derselben Controller-Methode zugeordnet.
Da Spring Security jedoch den Pfad im Ant-Format angibt, werden Anforderungen für andere Pfade als "/ foo" umgangen.

RequestMatcher für Spring MVC

Um dieses Problem zu beheben, bietet Spring Security "Matcher" an, der Pfade mit derselben Logik wie der Pfadanpassungsprozess von Spring MVC abgleichen kann.

namespace

`security.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 request-matcher="mvc">
        <sec:intercept-url pattern="/foo" access="isAuthenticated()" />
        <sec:form-login />
    </sec:http>

    <sec:authentication-manager />
</beans>

Geben Sie "mvc" in "request-matcher" des "" -Tags an

Java Configuration

`MySecurityConfig.java`


package sample.spring.config;

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@EnableWebSecurity
public class MySecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .mvcMatchers("/foo").authenticated()
            .and()
            .formLogin();
    }
}

--Verwenden Sie "mvcMatchers ()" anstelle von "antMatchers ()"

`Funktionsprüfung`


$ curl http://localhost:8080/namespace/foo -i
HTTP/1.1 302 Found
Server: Apache-Coyote/1.1
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-XSS-Protection: 1; mode=block
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Set-Cookie: JSESSIONID=0322DCB394ED74B38CCA600DDEF8CBBF; Path=/namespace/; HttpOnly
Location: http://localhost:8080/namespace/login
Content-Length: 0
Date: Mon, 31 Jul 2017 13:07:48 GMT


$ curl http://localhost:8080/namespace/foo.html -i
HTTP/1.1 302 Found
Server: Apache-Coyote/1.1
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
Expires: 0
X-XSS-Protection: 1; mode=block
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
Set-Cookie: JSESSIONID=BE049E9C138392A8751351762B200D63; Path=/namespace/; HttpOnly
Location: http://localhost:8080/namespace/login
Content-Length: 0
Date: Mon, 31 Jul 2017 13:07:49 GMT

Dieses Mal wurde ich, selbst wenn ich ".html" hinzugefügt habe, zum Anmeldebildschirm übersprungen.

Empfangen Sie den aktuellen Principal als Controller-Argument

Implementierung

`MyMvcController.java`


package sample.spring.security.mvc;

import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.core.userdetails.User;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyMvcController {
    
    @GetMapping("/user")
    public String foo(@AuthenticationPrincipal User user) {
        System.out.println("username=" + user.getUsername() + ", authorities=" + user.getAuthorities());
        return "User!!";
    }
}

namespace

`mvc.xml`


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

    <mvc:annotation-driven>
        <mvc:argument-resolvers>
            <bean class="org.springframework.security.web.method.annotation.AuthenticationPrincipalArgumentResolver" />
        </mvc:argument-resolvers>
    </mvc:annotation-driven>
    
    <bean class="sample.spring.security.mvc.MyMvcController" />
    
</beans>

`security.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 request-matcher="mvc">
        <sec:intercept-url pattern="/login" access="permitAll" />
        <sec:intercept-url pattern="/**" access="isAuthenticated()" />
        <sec:form-login />
        <sec:logout />
    </sec:http>

    <sec:authentication-manager>
        <sec:authentication-provider>
            <sec:user-service>
                <sec:user name="foo" password="foo" authorities="GENERAL_USER, ADMINISTRATOR" />
            </sec:user-service>
        </sec:authentication-provider>
    </sec:authentication-manager>
</beans>

Java Configuration

MyMvcConfig.java bleibt unverändert

`MySecurityConfig.java`


package sample.spring.config;

import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@EnableWebSecurity
public class MySecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .mvcMatchers("/login").permitAll()
            .anyRequest().authenticated()
            .and()
            .formLogin();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("foo")
            .password("foo")
            .authorities("GENERAL_USER", "ADMINISTRATOR");
    }
}

Funktionsprüfung

Greifen Sie mit einem Browser zu, melden Sie sich als "foo" -Benutzer an und greifen Sie dann auf "/ user" zu.

`Ausgabe der Serverkonsole`


username=foo, authorities=[ADMINISTRATOR, GENERAL_USER]

Erläuterung

`MyMvcController.java`


import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.core.userdetails.User;

...

    @GetMapping("/user")
    public String foo(@AuthenticationPrincipal User user) {
        System.out.println("username=" + user.getUsername() + ", authorities=" + user.getAuthorities());
        return "User!!";
    }

Sie können das von "Authentication.getPrincipal ()" zurückgegebene Objekt als Controller-Argument empfangen.
Notieren Sie das Argument mit "@ AuthenticationPrincipal"
Die Auflösung des Arguments erfolgt über den von Spring Security bereitgestellten "AuthenticationPrincipalArgumentResolver".

`mvc.xml`


    <mvc:annotation-driven>
        <mvc:argument-resolvers>
            <bean class="org.springframework.security.web.method.annotation.AuthenticationPrincipalArgumentResolver" />
        </mvc:argument-resolvers>
    </mvc:annotation-driven>

Wenn Sie einen Namespace verwenden, müssen Sie "AuthenticationPrincipalArgumentResolver" mit "" angeben.
Wenn Sie die Java-Konfiguration verwenden, wird diese Einstellung automatisch mithilfe von "@ EnableWebSecurity" vorgenommen, sodass keine zusätzlichen Einstellungen erforderlich sind.

Erhalten Sie CSRF-Token

Implementierung

`MyMvcController.java`


package sample.spring.security.mvc;

import org.springframework.security.web.csrf.CsrfToken;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyMvcController {
    
    @GetMapping("/csrf")
    public String foo(CsrfToken token) {
        System.out.println("token=" + token.getToken() + ", headerName=" + token.getHeaderName() + ", parameterName=" + token.getParameterName());
        return "CSRF!!";
    }
}

namespace

`mvc.xml`


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

    <mvc:annotation-driven>
        <mvc:argument-resolvers>
            <bean class="org.springframework.security.web.method.annotation.CsrfTokenArgumentResolver" />
        </mvc:argument-resolvers>
    </mvc:annotation-driven>
    
    <bean class="sample.spring.security.mvc.MyMvcController" />
    
</beans>

`security.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 request-matcher="mvc">
        <sec:intercept-url pattern="/**" access="permitAll" />
        <sec:form-login />
        <sec:csrf />
    </sec:http>

    <sec:authentication-manager />
</beans>

Java Configuration

MyMvcConfig bleibt unverändert

`MySecurityConfig.java`


package sample.spring.config;

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@EnableWebSecurity
public class MySecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .mvcMatchers("/**").permitAll()
            .and()
            .formLogin()
            .and()
            .csrf();
    }
}

Ausführungsergebnis

Zugriff auf / csrf

`Ausgabe der Serverkonsole`


token=bcac7b2e-f2c0-424c-a563-4b957ff7133e, headerName=X-CSRF-TOKEN, parameterName=_csrf

Erläuterung

`MyMvcController.java`


import org.springframework.security.web.csrf.CsrfToken;

...
    
    @GetMapping("/csrf")
    public String foo(CsrfToken token) {
        System.out.println("token=" + token.getToken() + ", headerName=" + token.getHeaderName() + ", parameterName=" + token.getParameterName());
        return "CSRF!!";
    }

CSRF-Token können in Controllermethodenargumenten empfangen werden --Tokens können als "CsrfToken" -Instanzen abgerufen werden

`mvc.xml`


    <mvc:annotation-driven>
        <mvc:argument-resolvers>
            <bean class="org.springframework.security.web.method.annotation.CsrfTokenArgumentResolver" />
        </mvc:argument-resolvers>
    </mvc:annotation-driven>

Im Fall eines Namespace muss "CsrfTokenArgumentResolver" in "" angegeben werden, um "CsrfToken" als Argument zu erhalten.
Bei der Java-Konfiguration wird sie automatisch mithilfe von "@ EnableWebSecurity" registriert, sodass keine zusätzlichen Einstellungen erforderlich sind.

Zusammenarbeit mit Spring Boot

Hello World Implementierung

`build.gradle`


buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.springframework.boot:spring-boot-gradle-plugin:1.5.6.RELEASE'
    }
}

apply plugin: 'java'
apply plugin: 'spring-boot'

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

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.springframework.boot:spring-boot-starter-web'
    compile 'org.springframework.boot:spring-boot-starter-security'
}

`Main.java`


package sample.boot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Main {

    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}

`src/main/resources/static/hello.html`


<!doctype html>
<html>
    <head>
        <meta charset="UTF-8" />
        <title>Hello Spring Security with Spring Boot</title>
    </head>
    <body>
        <h1>Hello Spring Security!!</h1>
    </body>
</html>

** Funktionsprüfung **

$ gradle bootRun
The plugin id 'spring-boot' is deprecated. Please use 'org.springframework.boot' instead.
:compileJava
:processResources
:classes
:findMainClass
:bootRun

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.6.RELEASE)

2017-08-02 22:55:17.710  INFO 13608 --- [           main] sample.boot.Main                         : Starting Main on .....
 with PID 13608 (...\spring-boot-security\build\classes\main started by .... in ...\spring-boot-security)

(Weggelassen)

2017-08-02 22:55:19.756  INFO 13608 --- [           main] b.a.s.AuthenticationManagerConfiguration :

Using default security password: 40890087-600d-417d-962d-a856e139b9c4

2017-08-02 22:55:19.808  INFO 13608 --- [           main] o.s.s.web.DefaultSecurityFilterChain     : Creating filter chain: OrRequestMatcher [requestMatchers=[Ant [pattern='/css/**'], Ant [pattern='/js/**'], Ant [pattern='/images/**'], Ant [pattern='/webjars/**'], Ant [pattern='/**/favicon.ico'], Ant [pattern='/error']]], []

(Weggelassen)

Gehen Sie zu "http: // localhost: 8080 / hello.html".

In einem Dialogfeld werden Sie aufgefordert, Ihren Benutzernamen und Ihr Kennwort einzugeben. Geben Sie Folgendes ein.

Elemente eingeben	Wert
Nutzername	`user`
Passwort	起動時にコンソールに出力されたPasswort

Das Kennwort wird beim Starten der Anwendung an die Konsole ausgegeben.

`Kennwortausgabe an die Konsole`


Using default security password: 40890087-600d-417d-962d-a856e139b9c4

Nach erfolgreicher Anmeldung wird der Inhalt von hello.html angezeigt.

Erläuterung

`build.gradle`


dependencies {
    compile 'org.springframework.boot:spring-boot-starter-web'
    compile 'org.springframework.boot:spring-boot-starter-security'
}

Durch Hinzufügen von "Spring-Boot-Starter-Sicherheit" werden Spring-Sicherheitsabhängigkeiten hinzugefügt
Wenn Sie nichts tun, wird die Standardauthentifizierung standardmäßig aktiviert und ein Benutzer mit dem Namen "Benutzer" wird im Speicher vorbereitet (das Kennwort ändert sich beim Neustart).
Das Passwort kann auch mit der Eigenschaft security.user.password angegeben werden
Auch der Zugriff auf "/ js / **", "/ css / **", "/ images / **", "/ webjars / ", " / favicon.js" ist ohne Authentifizierung. Stellen Sie ein, um möglich zu sein

Geben Sie die Einstellungen an

Implementierung

`MySecurityConfig.java`


package sample.boot.config;

import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@EnableWebSecurity
public class MySecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .mvcMatchers("/login").permitAll()
            .anyRequest().authenticated()
            .and()
            .formLogin();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("foo").password("foo").authorities("TEST_USER");
    }
}

** Funktionsprüfung **

Greifen Sie auf "http: // localhost: 8080 / hello.html" zu

Der Standard-Anmeldebildschirm wird angezeigt. Melden Sie sich daher als foo-Benutzer an.

Erläuterung

Das Standardverhalten kann beliebig umgeschrieben werden, indem die mit "@ EnableWebSecurity" versehene Konfigurationsklasse hinzugefügt und die Spring Security-Konfiguration erläutert wird.

[JAVA] Verwendungshinweis zu Spring Security: Zusammenarbeit mit Spring MVC und Boot

Zusammenarbeit mit Spring MVC

Anforderungspfad Matcher

Versuchen Sie zunächst, sich normal zu integrieren

build.gradle

MyMvcController.java

web.xml

security.xml

mvc.xml

MySecurityInitializer.java

MyServletInitializer.java

MySecurityConfig.java

MyMvcConfig.java

Funktionsprüfung

Warum passiert das?

RequestMatcher für Spring MVC

security.xml

MySecurityConfig.java

Funktionsprüfung

Empfangen Sie den aktuellen Principal als Controller-Argument

Implementierung

MyMvcController.java

mvc.xml

security.xml

MySecurityConfig.java

Funktionsprüfung

Ausgabe der Serverkonsole

Erläuterung

MyMvcController.java

mvc.xml

Erhalten Sie CSRF-Token

Implementierung

MyMvcController.java

mvc.xml

security.xml

MySecurityConfig.java

Ausführungsergebnis

Ausgabe der Serverkonsole

Erläuterung

MyMvcController.java

mvc.xml

Zusammenarbeit mit Spring Boot

build.gradle

Main.java

src/main/resources/static/hello.html

Kennwortausgabe an die Konsole

build.gradle

Geben Sie die Einstellungen an

MySecurityConfig.java

Referenz

`build.gradle`

`MyMvcController.java`

`web.xml`

`security.xml`

`mvc.xml`

`MySecurityInitializer.java`

`MyServletInitializer.java`

`MySecurityConfig.java`

`MyMvcConfig.java`

`security.xml`

`MySecurityConfig.java`

`Funktionsprüfung`

`MyMvcController.java`

`mvc.xml`

`security.xml`

`MySecurityConfig.java`

`Ausgabe der Serverkonsole`

`MyMvcController.java`

`mvc.xml`

`MyMvcController.java`

`mvc.xml`

`security.xml`

`MySecurityConfig.java`

`Ausgabe der Serverkonsole`

`MyMvcController.java`

`mvc.xml`

`build.gradle`

`Main.java`

`src/main/resources/static/hello.html`

`Kennwortausgabe an die Konsole`

`build.gradle`

`MySecurityConfig.java`