在 Spring 启动时删除 "Using default security password"

Question

我在 Spring 启动时在我的应用程序中添加了一个自定义安全配置，但是关于 "Using default security password" 的消息仍然存在于 LOG 文件中。

有什么可以去掉的吗？我不需要这个默认密码。似乎 Spring 启动无法识别我的安全策略。

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

Answer 1

查找：http://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-security.html

来自 AuthenticationManagerConfiguration.java looking at code, I see below. Also the in-memory configuration is a fallback if no authentication manager is provided as per Javadoc。您之前尝试注入身份验证管理器会成功，因为您将不再使用内存中身份验证，并且此 class 将不在画面中。

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

如果您使用默认的内存身份验证，请为 org.springframework.boot.autoconfigure.security.AuthenticationManagerConfiguration 自定义您的记录器配置并删除此消息。

Answer 2

我找到了排除 SecurityAutoConfiguration class.

的解决方案

示例：

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

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

Answer 3

在 application.properties 中添加以下对我有用，

security.basic.enabled=false

记得重新启动应用程序并在控制台中查看。

Answer 4

尽管它有效，但正如一些评论中指出的那样，当前的解决方案有点矫枉过正。所以这里有一个适合我的替代方案，使用最新的 Spring Boot (1.4.3).

默认安全密码在Spring Boot 的AuthenticationManagerConfiguration class 中配置。此 class 有一个条件注释，以防止在已定义 AuthenticationManager Bean 的情况下加载。

以下代码用于阻止 AuthenticationManagerConfiguration 中的代码的执行，因为我们将当前的 AuthenticationManager 定义为一个 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();
}

}

Answer 5

当使用 spring 引导时，我们应该在应用程序 class 以及您配置安全性的确切位置排除 SecurityAutoConfiguration.class，如下所示。

那么只有我们才能避开默认的安全密码。

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

Answer 6

查看 org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration 的文档，在某些情况下自动配置将停止。

就我而言，我忘记将我的自定义 AuthenticationProvider 定义为 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);
    }
}

Answer 7

当我使用@SpringBootApplication 注释排除 SecurityAutoConfiguration 时它对我不起作用，但当我在@EnableAutoConfiguration 中排除它时它起作用了：

@EnableAutoConfiguration(exclude = { SecurityAutoConfiguration.class })

Answer 8

如果您使用的是 Spring 引导版本 >= 2.0，请尝试在您的配置中设置此 bean：

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

参考：

Answer 9

使用 Spring Boot 2.0.4 我遇到了同样的问题。

排除 SecurityAutoConfiguration.class 确实破坏了我的应用程序。

现在我正在使用 @SpringBootApplication(exclude= {UserDetailsServiceAutoConfiguration.class})

适用于 @EnableResourceServer 和 JWT :)

Answer 10

如果您在单独的包中声明您的配置，确保像这样添加组件扫描：

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

    public class MyApplication {

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



    }

您可能还需要在配置 class 中添加 @component 注释，如下所示：

  @Component
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

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

.....

同时清除浏览器缓存和运行 spring 以隐身模式启动应用程序

Answer 11

在 spring boot 2 with webflux 你需要定义一个 ReactiveAuthenticationManager

Answer 12

也可以在属性中关闭特定 class 的日志记录：

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

Answer 13

只需使用以下行：

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

设置默认安全用户名和密码在 Spring 应用程序上下文中的 application.properties（名称可能不同）。

要完全避免默认配置（作为 SpringBoot 自动配置的一部分）- 使用前面的答案中提到的方法：

@SpringBootApplication(exclude = {SecurityAutoConfiguration.class })

或

@EnableAutoConfiguration(exclude = { SecurityAutoConfiguration.class })

Answer 14

对于 Reactive Stack (Spring Webflux, Netty) 你要么需要排除 ReactiveUserDetailsServiceAutoConfiguration.class

@SpringBootApplication(exclude = {ReactiveUserDetailsServiceAutoConfiguration.class})

或者定义ReactiveAuthenticationManager bean（有不同的实现，这里以JWT为例）

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

Answer 15

我遇到了同样的问题，将这一行添加到我的 application.properties 解决了这个问题。

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration

它是 Spring 的自动功能之一，您将其排除在外就像排除执行器等其他功能一样。我建议看看这个 link

Answer 16

要删除默认用户，您需要配置没有用户的身份验证管理器，例如：

@configuration
class WebSecurityConfig extends WebSecurityConfigurerAdapter {

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

这将删除默认密码消息和默认用户，因为在这种情况下，您正在配置 InMemoryAuthentication，您将不会在后续步骤中指定任何用户

Answer 17

在 Spring Boot 2 应用程序中，您可以从自动配置中排除服务配置：

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration

或者如果您只想在日志中隐藏消息，您只需更改日志级别即可：

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

可在此处找到更多信息：https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/boot-features-security.html

Answer 18

如果您启用了 actuator 功能 (spring-boot-starter-actuator)，则应在 application.yml:

中添加额外的排除项

spring:
  autoconfigure:
    exclude: org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,org.springframework.boot.actuate.autoconfigure.security.servlet.ManagementWebSecurityAutoConfiguration

在 Spring 引导版本 2.3 中测试。4.RELEASE。

Answer 19

您只需要排除 UserDetailsServiceAutoConfiguration。

spring:
  autoconfigure:
    exclude: org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration

Answer 20

只需将属性以下添加到 application.properties

spring.security.user.name=xyz
spring.security.user.password=xxxxxxx

Answer 21

如果您使用 Spring 安全与 spring 云网关，您可以排除 ReactiveUserDetailsServiceAutoConfiguration.class。

像这样

@SpringBootApplication(exclude = ReactiveUserDetailsServiceAutoConfiguration.class)
public class SpringClientApplication {

Answer 22

密码生成由

完成

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({AuthenticationManager.class})
@ConditionalOnBean({ObjectPostProcessor.class})
@ConditionalOnMissingBean(
    value = {AuthenticationManager.class, AuthenticationProvider.class, UserDetailsService.class},
    type = {"org.springframework.security.oauth2.jwt.JwtDecoder", "org.springframework.security.oauth2.server.resource.introspection.OpaqueTokenIntrospector", "org.springframework.security.oauth2.client.registration.ClientRegistrationRepository"}
)
public class UserDetailsServiceAutoConfiguration {

如果缺少以下 bean（JwtDecoder、OpaqueTokenIntrospector、ClientRegistrationRepository）——那么我们会看到已调用密码生成

所以在我们的案例中我们也遇到了这个问题然后我们

@SpringBootApplication(exclude = {FlywayAutoConfiguration.class, UserDetailsServiceAutoConfiguration.class})

将 UserDetailsServiceAutoConfiguration.class 添加到排除项中，然后我们在日志中看不到密码生成

Answer 23

我们应该从 spring 启动自动配置中排除 UserDetailsServiceAutoConfiguration.class 来解决这个问题

示例：

@SpringBootApplication(exclude = {UserDetailsServiceAutoConfiguration.class })
public class MyClass {

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

Answer 24

所以这个问题的大部分答案都推荐：

不包括一些auto-configuration
设置用户and/or密码

然而，排除 auto-configuration 几乎不是答案。如果您的应用程序没有任何用户，则第二种解决方案也不是很好。

我们应该使用 Spring Boot.

日志消息由 UserDetailsServiceAutoConfiguration 生成，让我们知道 Spring 引导设置了合理的默认值。查看 UserDetailsServiceAutoConfiguration 的源代码和文档，我们看到：

/**
 * {@link EnableAutoConfiguration Auto-configuration} for a Spring Security in-memory
 * {@link AuthenticationManager}. Adds an {@link InMemoryUserDetailsManager} with a
 * default user and generated password. This can be disabled by providing a bean of type
 * {@link AuthenticationManager}, {@link AuthenticationProvider} or
 * {@link UserDetailsService}.
 *
 * @author Dave Syer
 * @author Rob Winch
 * @author Madhura Bhave
 * @since 2.0.0
 */
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(AuthenticationManager.class)
@ConditionalOnBean(ObjectPostProcessor.class)
@ConditionalOnMissingBean(
        value = { AuthenticationManager.class, AuthenticationProvider.class, UserDetailsService.class,
                AuthenticationManagerResolver.class },
        type = { "org.springframework.security.oauth2.jwt.JwtDecoder",
                "org.springframework.security.oauth2.server.resource.introspection.OpaqueTokenIntrospector",
                "org.springframework.security.oauth2.client.registration.ClientRegistrationRepository" })
public class UserDetailsServiceAutoConfiguration {

我们可以看到，当提供以下任一 bean 时，UserDetailsServiceAutoConfiguration 被禁用：AuthenticationManager、AuthenticationProvider、UserDetailsService 或 AuthenticationManagerResolver。

这意味着当告诉 Spring Boot 我们要如何验证我们的用户时，Spring Boot 将不会 auto-configure 一个合理的默认值。由于我们不想对任何用户进行身份验证，因此我们可以提供：

@Configuration
public class ApplicationConfiguration {

    @Bean
    public AuthenticationManager noopAuthenticationManager() {
        return authentication -> {
            throw new AuthenticationServiceException("Authentication is disabled");
        };
    }
}

在 Spring 启动时删除 "Using default security password"

Remove "Using default security password" on Spring Boot

java

spring

spring-security

spring-boot