web-dev-qa-db-fra.com

Supprimez "Utilisation du mot de passe de sécurité par défaut" au démarrage de printemps

J'ai ajouté une configuration de sécurité personnalisée dans mon application sur Spring Boot, mais le message "Utiliser un mot de passe de sécurité par défaut" est toujours présent dans le fichier journal.

Y a-t-il quelqu'un pour l'enlever? Je n'ai pas besoin de ce mot de passe par défaut. Il semble que Spring Boot ne reconnaisse pas ma politique de sécurité.

@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();
    }
}
javaspringspring-bootspring-security
45
Carlos Alberto

J'ai découvert une solution sur l'exclusion de SecurityAutoConfiguration class.

Exemple:

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

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

Ajouter ce qui suit dans application.properties a fonctionné pour moi,

security.basic.enabled=false

N'oubliez pas de redémarrer l'application et de vérifier dans la console.

37
Lucky

Bien que cela fonctionne, la solution actuelle est un peu excessive, comme indiqué dans certains commentaires. Voici donc une alternative qui fonctionne pour moi, utilisant la dernière version de Spring Boot (1.4.3).

Le mot de passe de sécurité par défaut est configuré dans AuthenticationManagerConfiguration class de Spring Boot. Cette classe a une annotation conditionnelle pour empêcher le chargement si un bean AuthenticationManager est déjà défini.

Le code suivant permet d’empêcher l’exécution du code dans AuthenticationManagerConfiguration car nous définissons notre AuthenticationManager actuel comme un bean.

@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

En utilisant Spring Boot 2.0.4, je suis tombé sur le même problème.

Exclure SecurityAutoConfiguration.class a détruit mon application.

Maintenant j'utilise @SpringBootApplication(exclude= {UserDetailsServiceAutoConfiguration.class})

Fonctionne bien avec @EnableResourceServer et JWT :) 

7
Benjamin M

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

De AuthenticationManagerConfiguration.Java en regardant le code, je vois ci-dessous. De plus, la configuration en mémoire est un secours si aucun gestionnaire d'authentification n'est fourni, comme indiqué dans Javadoc . Votre tentative précédente d'injection du gestionnaire d'authentification fonctionnerait, car vous n'utiliserez plus l'authentification en mémoire et cette classe sera hors de l'image.

@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);
    }

Si vous utilisez l'authentification unique par défaut, personnalisez la configuration de votre journal pour org.springframework.boot.autoconfigure.security.AuthenticationManagerConfiguration et supprimez ce message.

3
randominstanceOfLivingThing

Au démarrage de printemps 2 avec webflux, vous devez définir unReactiveAuthenticationManager

0
nekperu15739

Cela n'a pas fonctionné pour moi lorsque j'ai exclu SecurityAutoConfiguration à l'aide de l'annotation @SpringBootApplication, mais a fonctionné lorsque je l'ai exclu dans @EnableAutoConfiguration:

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

Consultez la documentation de org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration il existe des conditions dans lesquelles l'auto-configuration sera arrêtée.

Dans mon cas, j'ai oublié de définir mon fichier personnalisé AuthenticationProvider comme bean .

@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
Vova Perebykivskyi

Lorsque le démarrage à ressort est utilisé, nous devons exclure le SecurityAutoConfiguration.class à la fois dans la classe d’application et là où vous configurez exactement la sécurité comme ci-dessous.

Alors seulement nous pourrons éviter le mot de passe de sécurité par défaut.

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

Si vous utilisez la version Spring Boot> = 2.0, essayez de définir ce bean dans votre configuration:

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

Référence: https://stackoverflow.com/a/47292134/1195507

0
rvazquezglez

Si vous déclarez vos configurations dans un paquet séparé, assurez-vous d’ajouter le scan de composant de la manière suivante: 

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

    public class MyApplication {

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



    }

Vous devrez peut-être aussi ajouter une annotation @component dans la classe de configuration de la manière suivante:

  @Component
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

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

.....
  1. Effacez également le cache du navigateur et exécutez l'application Spring Boot en mode de navigation privée.
0
KHAN