Qu'est-ce que le nom d'utilisateur et le mot de passe lors du démarrage de Spring Boot avec Tomcat?

Lorsque je déploie mon application Spring via Spring Boot et y accède, localhost:8080je dois m'authentifier, mais quel est le nom d'utilisateur et le mot de passe ou comment puis-je le définir? J'ai essayé d'ajouter ceci à mon tomcat-usersfichier mais cela n'a pas fonctionné:

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

C'est le point de départ de l'application:

@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 Tomcat:

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

Comment m'authentifier sur localhost:8080?

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

Veuillez consulter 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 console de journal comme celui-ci:

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

Et dans l'invite du navigateur, vous importerez l'utilisateur useret le mot de passe imprimés dans la console.

Ou si vous souhaitez configurer la sécurité Spring, vous pouvez jeter un œil à l' exemple sécurisé Spring Boot

Il est expliqué dans la documentation de référence de Spring Boot dans la section Sécurité , 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

Si des spring-securityfichiers JAR sont ajoutés dans classpath et également s'il s'agit d'une spring-bootapplication, tous les points de terminaison http seront sécurisés par la classe de configuration de sécurité par défautSecurityAutoConfiguration

Cela provoque une fenêtre contextuelle du navigateur pour demander des informations d'identification.

Le mot de passe change pour chaque application redémarre 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 devant les 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 simplement changer le mot de passe, vous pouvez remplacer la valeur par défaut avec,

application.xml

security.user.password = nouveau_mot de passe

ou

application.properties

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

Lors du remplacement

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

dans application.properties , vous n'avez pas besoin de vous "déplacer "username", utilisez simplement username. Un autre point, au lieu de stocker le mot de passe brut , cryptez-le avec bcrypt / scrypt et stockez-le comme

spring.security.user.password={bcrypt}encryptedPassword

Si vous ne trouvez pas le mot de passe en fonction d'autres réponses qui pointent vers une réponse par défaut, le libellé du message du journal dans les versions récentes est devenu

Using generated security password: <some UUID>

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

Ajout à la réponse acceptée -

Si le mot de passe n'apparaît pas dans les journaux, activez les journaux «org.springframework.boot.autoconfigure.security».

Si vous affinez votre configuration de journalisation, assurez-vous que la catégorie org.springframework.boot.autoconfigure.security est définie pour consigner les messages INFO, sinon le mot de passe par défaut ne sera pas imprimé.

https://docs.spring.io/spring-boot/docs/1.4.0.RELEASE/reference/htmlsingle/#boot-features-security

Quand j'ai commencé à apprendre Spring Security, j'ai remplacé la méthode userDetailsService () comme dans l'extrait de code ci-dessous:

@Configuration
@EnableWebSecurity
public class ApplicationSecurityConfiguration extends WebSecurityConfigurerAdapter{

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .csrf().disable()
                .authorizeRequests()
                .antMatchers("/", "/index").permitAll()
                .anyRequest().authenticated()
                .and()
                .httpBasic();
    }

    @Override
    @Bean
    public UserDetailsService userDetailsService() {
        List<UserDetails> users= new ArrayList<UserDetails>();
        users.add(User.withDefaultPasswordEncoder().username("admin").password("nimda").roles("USER","ADMIN").build());
        users.add(User.withDefaultPasswordEncoder().username("Spring").password("Security").roles("USER").build());
        return new InMemoryUserDetailsManager(users);
    }
}

Nous pouvons donc nous connecter à l'application en utilisant les crédits mentionnés ci-dessus. (par exemple, admin / nimda)

Remarque: nous ne devons pas l'utiliser en production.

Essayez de prendre le nom d'utilisateur et le mot de passe de l'extrait de code ci-dessous dans votre projet et connectez-vous et espérez que cela fonctionnera.

@Override
    @Bean
    public UserDetailsService userDetailsService() {
        List<UserDetails> users= new ArrayList<UserDetails>();
        users.add(User.withDefaultPasswordEncoder().username("admin").password("admin").roles("USER","ADMIN").build());
        users.add(User.withDefaultPasswordEncoder().username("spring").password("spring").roles("USER").build());
        return new UserDetailsManager(users);
    }