wake-up-neo.com

Entfernen Sie "Verwenden des Standard-Sicherheitskennworts" bei Spring Boot

Ich habe eine benutzerdefinierte Sicherheitskonfiguration in meiner Anwendung zu Spring Boot hinzugefügt, aber die Meldung "Standard-Sicherheitskennwort verwenden" ist immer noch in der LOG-Datei enthalten.

Gibt es etwas, um es zu entfernen? Ich brauche dieses Standardpasswort nicht. Es scheint, dass Spring Boot meine Sicherheitsrichtlinie nicht erkennt.

@Configuration
@EnableWebSecurity
public class CustomSecurityConfig extends WebSecurityConfigurerAdapter {

    private final String uri = "/custom/*";

    @Override
    public void configure(final HttpSecurity http) throws Exception {
        http.csrf().disable();
        http.headers().httpStrictTransportSecurity().disable();
        http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);

        // Authorize sub-folders permissions
        http.antMatcher(uri).authorizeRequests().anyRequest().permitAll();
    }
}
45
Carlos Alberto

Ich habe eine Lösung zum Ausschließen von SecurityAutoConfiguration class gefunden.

Beispiel:

@SpringBootApplication(exclude = {SecurityAutoConfiguration.class })
public class ReportApplication {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(MyApplication.class, args);
    }
}
56
Carlos Alberto

Hinzufügen von Folgendem in application.properties arbeitete für mich,

security.basic.enabled=false

Denken Sie daran, die Anwendung neu zu starten und die Konsole einzuchecken.

37
Lucky

Obwohl es funktioniert, ist die derzeitige Lösung ein wenig übertrieben, wie in einigen Kommentaren erwähnt. Hier ist eine Alternative, die für mich funktioniert, indem ich den neuesten Spring Boot (1.4.3) verwende.

Das Standardsicherheitskennwort wird in der Spring Boot-Klasse AuthenticationManagerConfiguration konfiguriert. Diese Klasse verfügt über eine bedingte Anmerkung, um das Laden zu verhindern, wenn bereits ein AuthenticationManager-Bean definiert ist.

Der folgende Code verhindert die Ausführung des Codes in AuthenticationManagerConfiguration, da wir unseren aktuellen AuthenticationManager als Bean definieren.

@Configuration
@EnableWebSecurity
public class MyCustomSecurityConfig extends WebSecurityConfigurerAdapter{

[...]

@Override
protected void configure(AuthenticationManagerBuilder authManager) throws Exception {
    // This is the code you usually have to configure your authentication manager.
    // This configuration will be used by authenticationManagerBean() below.
}

@Bean
public AuthenticationManager authenticationManagerBean() throws Exception {
    // ALTHOUGH THIS SEEMS LIKE USELESS CODE,
    // IT'S REQUIRED TO PREVENT SPRING BOOT AUTO-CONFIGURATION
    return super.authenticationManagerBean();
}

}
26
Stefan

Mit Spring Boot 2.0.4 bin ich auf dasselbe Problem gestoßen.

Das Ausschließen von SecurityAutoConfiguration.class hat meine Anwendung zerstört.

Jetzt verwende ich @SpringBootApplication(exclude= {UserDetailsServiceAutoConfiguration.class})

Funktioniert gut mit @EnableResourceServer und JWT :) 

7
Benjamin M

Nachschlagen: http://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-security.html

Aus AuthenticationManagerConfiguration.Java beim Betrachten des Codes sehe ich unten. Auch die In-Memory-Konfiguration ist ein Fallback, wenn gemäß Javadoc kein Authentifizierungsmanager bereitgestellt wird. Ihr früherer Versuch, den Authentication Manager einzuspritzen, würde funktionieren, da Sie die In-Memory-Authentifizierung nicht mehr verwenden und diese Klasse nicht mehr im Bild ist.

@Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        if (auth.isConfigured()) {
            return;
        }
        User user = this.securityProperties.getUser();
        if (user.isDefaultPassword()) {
            logger.info("\n\nUsing default security password: " + user.getPassword()
                    + "\n");
        }
        Set<String> roles = new LinkedHashSet<String>(user.getRole());
        withUser(user.getName()).password(user.getPassword()).roles(
                roles.toArray(new String[roles.size()]));
        setField(auth, "defaultUserDetailsService", getUserDetailsService());
        super.configure(auth);
    }

Wenn Sie die In-Memory-Authentifizierung verwenden, die standardmäßig verwendet wird, passen Sie Ihre Logger-Konfiguration für org.springframework.boot.autoconfigure.security.AuthenticationManagerConfiguration an und entfernen Sie diese Nachricht.

Für Reactive Stack (Spring Webflux, Netty) müssen Sie entweder ReactiveUserDetailsServiceAutoConfiguration.class ausschließen

@SpringBootApplication(exclude = {ReactiveUserDetailsServiceAutoConfiguration.class})

Oder definieren Sie die ReactiveAuthenticationManager-Bean (es gibt verschiedene Implementierungen, hier ist das JWT ein Beispiel).

@Bean
public ReactiveJwtDecoder jwtDecoder() {
    return new NimbusReactiveJwtDecoder(keySourceUrl);
}
@Bean
public ReactiveAuthenticationManager authenticationManager() {
    return new JwtReactiveAuthenticationManager(jwtDecoder());
}
1
alexkov

Bei Spring Boot 2 mit webflux müssen Sie einenReactiveAuthenticationManagerdefinieren.

0
nekperu15739

Es hat für mich nicht funktioniert, als ich SecurityAutoConfiguration mit der @SpringBootApplication-Annotation ausgeschlossen habe, aber es funktionierte, als ich es in @EnableAutoConfiguration ausgeschlossen habe:

@EnableAutoConfiguration(exclude = { SecurityAutoConfiguration.class })
0
adlerer

Es ist auch möglich, die Protokollierung für diese bestimmte Klasse in den Eigenschaften einfach zu deaktivieren:

logging.level.org.springframework.boot.autoconfigure.security.AuthenticationManagerConfiguration=WARN

0
WaBayang

Verwenden Sie einfach die folgenden Zeilen:

spring.security.user.name=XXX
spring.security.user.password=XXX

festlegen des standardmäßigen Sicherheitsbenutzernamens und -kennworts in Ihrem application.properties (Name kann abweichen) im Kontext der Spring Application.

Um die Standardkonfiguration (als Teil der automatischen Konfiguration des SpringBoot) überhaupt zu vermeiden, verwenden Sie den in den vorherigen Antworten beschriebenen Ansatz:

@SpringBootApplication(exclude = {SecurityAutoConfiguration.class })

oder

@EnableAutoConfiguration(exclude = { SecurityAutoConfiguration.class })
0

Überprüfen Sie die Dokumentation für org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration. Es gibt Bedingungen, unter denen die automatische Konfiguration angehalten wird.

In meinem Fall habe ich vergessen, meinen benutzerdefinierten AuthenticationProvider als bean zu definieren.

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(getAuthenticationProvider());
    }

    @Bean
    AuthenticationProvider getAuthenticationProvider() {
        return new CustomAuthenticationProvider(adminService, onlyCorporateEmail);
    }
}
0

Wenn Spring Boot verwendet wird, sollten wir die SecurityAutoConfiguration.class sowohl in der Anwendungsklasse als auch dort, wo Sie die Sicherheit genau konfigurieren, wie unten beschrieben ausschließen.

Dann können nur wir das Standardsicherheitskennwort umgehen.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;

@SpringBootApplication(exclude = {SecurityAutoConfiguration.class })
@EnableJpaRepositories
@EnableResourceServer
public class Application {

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

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Configuration;
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;

    @Configuration
    @EnableWebSecurity
    @EnableAutoConfiguration(exclude = { 
            org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration.class 
        })
    public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

        @Override
        protected void configure(HttpSecurity httpSecurity) throws Exception {
            httpSecurity.authorizeRequests().anyRequest().authenticated();
            httpSecurity.headers().cacheControl();
        }
    }
0
Sasidhar

Wenn Sie die Spring Boot-Version> = 2.0 verwenden, setzen Sie diese Bean in Ihrer Konfiguration:

@Bean
public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
    http.authorizeExchange().anyExchange().permitAll();
    return http.build();
}

Referenz: https://stackoverflow.com/a/47292134/1195507

0
rvazquezglez

Wenn Sie Ihre Konfigurationsdateien in einem separaten Paket deklarieren, stellen Sie sicher, dass Sie einen Komponentenscan wie folgt hinzufügen: 

@SpringBootApplication
@ComponentScan("com.mycompany.MY_OTHER_PACKAGE.account.config")

    public class MyApplication {

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



    }

Möglicherweise müssen Sie auch @component-Annotation in der config-Klasse hinzufügen:

  @Component
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()

.....
  1. Außerdem können Sie den Browser-Cache leeren und die Spring-Boot-App im Inkognito-Modus ausführen
0
KHAN