¿Qué es el nombre de usuario y la contraseña al iniciar Spring Boot con Tomcat?

Cuando implemento mi aplicación Spring a través de Spring Boot y localhost:8080tengo que autenticarme, ¿cuál es el nombre de usuario y la contraseña o cómo puedo configurarlo? Intenté agregar esto a mi tomcat-usersarchivo pero no funcionó:

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

Este es el punto de partida de la aplicación:

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

Y esta es la dependencia de Tomcat:

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

¿Cómo me autentico localhost:8080?

Creo que tiene Spring Security en su ruta de clase y luego Spring Security se configura automáticamente con un usuario predeterminado y una contraseña generada

Busque en su archivo pom.xml para:

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

Si tiene eso en su pom, entonces debería tener un mensaje de consola de registro como este:

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

Y en el indicador del navegador, importará el usuario usery la contraseña impresa en la consola.

O si desea configurar la seguridad de primavera, puede ver el ejemplo seguro de Spring Boot

Se explica en la documentación de Spring Boot Reference en la sección Seguridad , indica:

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 spring-securityse agregan jarras en classpath y también si es una spring-bootaplicación, todos los puntos finales http estarán protegidos por clase de configuración de seguridad predeterminadaSecurityAutoConfiguration

Esto hace que un navegador emergente solicite credenciales.

Los cambios de contraseña para cada aplicación se reinician y se pueden encontrar en la consola.

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

Para agregar su propia capa de seguridad de la aplicación frente a los valores predeterminados,

@EnableWebSecurity
public class SecurityConfig {

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

o si solo desea cambiar la contraseña, puede anular el valor predeterminado con,

application.xml

security.user.password = nueva_contraseña

o

application.properties

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

Al anular

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

en application.properties , no necesita "alrededor "username", solo use username. Otro punto, en lugar de almacenar la contraseña sin procesar , cifrarla con bcrypt / scrypt y almacenarla como

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

Si no puede encontrar la contraseña basada en otras respuestas que apuntan a una predeterminada, la redacción del mensaje de registro en las versiones recientes cambió a

Using generated security password: <some UUID>

También puede pedirle al usuario las credenciales y configurarlas dinámicamente una vez que se inicia el servidor (muy efectivo cuando necesita publicar la solución en un entorno de cliente):

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

(Mayo de 2018) Una actualización: esto funcionará en el arranque de primavera 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();
    }
}

Además de la respuesta aceptada:

Si la contraseña no se ve en los registros, habilite los registros "org.springframework.boot.autoconfigure.security".

Si ajusta su configuración de registro, asegúrese de que la categoría org.springframework.boot.autoconfigure.security esté configurada para registrar mensajes INFO, de lo contrario no se imprimirá la contraseña predeterminada.

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

Cuando comencé a aprender Spring Security, anulé el método userDetailsService () como en el fragmento de código siguiente:

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

Por lo tanto, podemos iniciar sesión en la aplicación utilizando los créditos mencionados anteriormente. (por ejemplo, admin / nimda)

Nota: Esto no deberíamos usarlo en producción.

Intente tomar el nombre de usuario y la contraseña del fragmento de código a continuación en su proyecto e inicie sesión y espero que esto funcione.

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