Quels sont le nom d'utilisateur et le mot de passe lors du démarrage de Spring Boot avec Tomcat ?

Question

Lorsque je déploie mon application Spring via Spring Boot et que j'accède à l'application localhost:8080 Je dois m'authentifier, mais quel est le nom d'utilisateur et le mot de passe ou comment puis-je les définir ? J'ai essayé d'ajouter ceci à mon tomcat-users mais ça n'a pas marché :

<role rolename="manager-gui"/>
    <user username="admin" password="admin" roles="manager-gui"/>

C'est le point de départ de la demande :

@SpringBootApplication
public class Application extends SpringBootServletInitializer {

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

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(Application.class);
    }
}

Et voici la dépendance de Tomcat :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

Comment s'authentifier sur localhost:8080 ?

Answer 1

Je pense que vous avez Spring Security dans votre chemin de classe et que Spring Security est automatiquement configuré avec un utilisateur par défaut et un mot de passe généré.

Veuillez regarder dans votre fichier pom.xml pour :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Si vous avez cela dans votre pom, vous devriez avoir un message de la console comme celui-ci :

Using default security password: ce6c3d39-8f20-4a41-8e01-803166bb99b6

Et dans l'invite du navigateur, vous importerez l'utilisateur user et le mot de passe s'affiche dans la console.

Ou si vous voulez configurer la sécurité de Spring, vous pouvez jeter un coup d'oeil à Exemple sécurisé de Spring Boot

Il est expliqué dans le document Spring Boot Documentation de référence dans le Sécurité section, il indique :

The default AuthenticationManager has a single user (‘user’ username and random password, printed at `INFO` level when the application starts up)

Using default security password: 78fa095d-3f4c-48b1-ad50-e24c31d5cf35

Answer 2

Si spring-security sont ajoutés dans le classpath et aussi s'il s'agit de spring-boot application tous les points d'extrémité http seront sécurisés par la classe de configuration de sécurité par défaut SecurityAutoConfiguration

Cela provoque l'apparition d'une fenêtre pop-up du navigateur qui demande des informations d'identification.

Le mot de passe change à chaque redémarrage de l'application et peut être trouvé dans la console.

Using default security password: 78fa095d-3f4c-48b1-ad50-e24c31d5cf35

Pour ajouter votre propre couche de sécurité applicative en plus des valeurs par défaut,

@EnableWebSecurity
public class SecurityConfig {

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .inMemoryAuthentication()
                .withUser("user").password("password").roles("USER");
    }
}

ou si vous voulez juste changer le mot de passe, vous pouvez remplacer le mot de passe par défaut,

application.xml

security.user.password=nouveau_mot_de_passe

ou

application.properties

spring.security.user.name=<>
spring.security.user.password=<>

Answer 3

Ainsi, en ajoutant simplement la dépendance Spring Boot Security Starter, la sécurité de base a déjà été configurée par défaut.

Nous pouvons personnaliser la configuration de la sécurité en écrivant nos propres autorisations et authentifications. Pour cela, créez une nouvelle classe SecurityConfig qui étend le WebSecurityConfigurerAdapter et surcharge ses méthodes.

@Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication().withUser("javainuse")
                .password("javainuse").roles("USER");
    }

Réf - Exemple de sécurité Spring Boot

Answer 4

Si vous ne pouvez pas trouver le mot de passe en vous basant sur d'autres réponses qui indiquent un mot de passe par défaut, le libellé du message de journal dans les versions récentes a été modifié comme suit

Using generated security password: <some UUID>

Answer 5

Vous pouvez également demander à l'utilisateur les informations d'identification et les définir dynamiquement une fois le serveur démarré (très efficace lorsque vous devez publier la solution sur un environnement client) :

@EnableWebSecurity
public class SecurityConfig {

    private static final Logger log = LogManager.getLogger();

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        log.info("Setting in-memory security using the user input...");

        Scanner scanner = new Scanner(System.in);
        String inputUser = null;
        String inputPassword = null;
        System.out.println("\nPlease set the admin credentials for this web application");
        while (true) {
            System.out.print("user: ");
            inputUser = scanner.nextLine();
            System.out.print("password: ");
            inputPassword = scanner.nextLine();
            System.out.print("confirm password: ");
            String inputPasswordConfirm = scanner.nextLine();

            if (inputUser.isEmpty()) {
                System.out.println("Error: user must be set - please try again");
            } else if (inputPassword.isEmpty()) {
                System.out.println("Error: password must be set - please try again");
            } else if (!inputPassword.equals(inputPasswordConfirm)) {
                System.out.println("Error: password and password confirm do not match - please try again");
            } else {
                log.info("Setting the in-memory security using the provided credentials...");
                break;
            }
            System.out.println("");
        }
        scanner.close();

        if (inputUser != null && inputPassword != null) {
             auth.inMemoryAuthentication()
                .withUser(inputUser)
                .password(inputPassword)
                .roles("USER");
        }
    }
}

(Mai 2018) Une mise à jour - cela fonctionnera sur spring boot 2.x :

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private static final Logger log = LogManager.getLogger();

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // Note: 
        // Use this to enable the tomcat basic authentication (tomcat popup rather than spring login page)
        // Note that the CSRf token is disabled for all requests
        log.info("Disabling CSRF, enabling basic authentication...");
        http
        .authorizeRequests()
            .antMatchers("/**").authenticated() // These urls are allowed by any authenticated user
        .and()
            .httpBasic();
        http.csrf().disable();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        log.info("Setting in-memory security using the user input...");

        String username = null;
        String password = null;

        System.out.println("\nPlease set the admin credentials for this web application (will be required when browsing to the web application)");
        Console console = System.console();

        // Read the credentials from the user console: 
        // Note: 
        // Console supports password masking, but is not supported in IDEs such as eclipse; 
        // thus if in IDE (where console == null) use scanner instead:
        if (console == null) {
            // Use scanner:
            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.print("Username: ");
                username = scanner.nextLine();
                System.out.print("Password: ");
                password = scanner.nextLine();
                System.out.print("Confirm Password: ");
                String inputPasswordConfirm = scanner.nextLine();

                if (username.isEmpty()) {
                    System.out.println("Error: user must be set - please try again");
                } else if (password.isEmpty()) {
                    System.out.println("Error: password must be set - please try again");
                } else if (!password.equals(inputPasswordConfirm)) {
                    System.out.println("Error: password and password confirm do not match - please try again");
                } else {
                    log.info("Setting the in-memory security using the provided credentials...");
                    break;
                }
                System.out.println("");
            }
            scanner.close();
        } else {
            // Use Console
            while (true) {
                username = console.readLine("Username: ");
                char[] passwordChars = console.readPassword("Password: ");
                password = String.valueOf(passwordChars);
                char[] passwordConfirmChars = console.readPassword("Confirm Password: ");
                String passwordConfirm = String.valueOf(passwordConfirmChars);

                if (username.isEmpty()) {
                    System.out.println("Error: Username must be set - please try again");
                } else if (password.isEmpty()) {
                    System.out.println("Error: Password must be set - please try again");
                } else if (!password.equals(passwordConfirm)) {
                    System.out.println("Error: Password and Password Confirm do not match - please try again");
                } else {
                    log.info("Setting the in-memory security using the provided credentials...");
                    break;
                }
                System.out.println("");
            }
        }

        // Set the inMemoryAuthentication object with the given credentials:
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        if (username != null && password != null) {
            String encodedPassword = passwordEncoder().encode(password);
            manager.createUser(User.withUsername(username).password(encodedPassword).roles("USER").build());
        }
        return manager;
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}