聊聊spring security的permitAll以及webIgnore

于 2024-02-17 15:35:43 发布
阅读量1.1k 收藏 11
点赞数 18
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33850805/article/details/136139751
版权

序

本文主要聊一下spring security的permitAll以及webIgnore的区别

permitAll配置实例

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/css/**", "/js/**","/fonts/**").permitAll()
                .anyRequest().authenticated();
    }
}

web ignore配置实例

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/css/**");
        web.ignoring().antMatchers("/js/**");
        web.ignoring().antMatchers("/fonts/**");
    }
}

二者区别

顾名思义，WebSecurity主要是配置跟web资源相关的，比如css、js、images等等，但是这个还不是本质的区别，关键的区别如下：

  • ingore是完全绕过了spring security的所有filter，相当于不走spring security
  • permitall没有绕过spring security，其中包含了登录的以及匿名的。

AnonymousAuthenticationFilter

spring-security-web-4.2.3.RELEASE-sources.jar!/org/springframework/security/web/authentication/AnonymousAuthenticationFilter.java

/**
 * Detects if there is no {@code Authentication} object in the
 * {@code SecurityContextHolder}, and populates it with one if needed.
 *
 * @author Ben Alex
 * @author Luke Taylor
 */
public class AnonymousAuthenticationFilter extends GenericFilterBean implements
		InitializingBean {
    //......
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
			throws IOException, ServletException {

		if (SecurityContextHolder.getContext().getAuthentication() == null) {
			SecurityContextHolder.getContext().setAuthentication(
					createAuthentication((HttpServletRequest) req));

			if (logger.isDebugEnabled()) {
				logger.debug("Populated SecurityContextHolder with anonymous token: '"
						+ SecurityContextHolder.getContext().getAuthentication() + "'");
			}
		}
		else {
			if (logger.isDebugEnabled()) {
				logger.debug("SecurityContextHolder not populated with anonymous token, as it already contained: '"
						+ SecurityContextHolder.getContext().getAuthentication() + "'");
			}
		}

		chain.doFilter(req, res);
	}

	protected Authentication createAuthentication(HttpServletRequest request) {
		AnonymousAuthenticationToken auth = new AnonymousAuthenticationToken(key,
				principal, authorities);
		auth.setDetails(authenticationDetailsSource.buildDetails(request));

		return auth;
	}
    
    //......
}

这个filter的主要功能就是给没有登陆的用户，填充AnonymousAuthenticationToken到SecurityContextHolder的Authentication，后续依赖Authentication的代码可以统一处理。

FilterComparator

spring-security-config-4.1.4.RELEASE-sources.jar!/org/springframework/security/config/annotation/web/builders/FilterComparator.java

final class FilterComparator implements Comparator<Filter>, Serializable {
	private static final int STEP = 100;
	private Map<String, Integer> filterToOrder = new HashMap<String, Integer>();

	FilterComparator() {
		int order = 100;
		put(ChannelProcessingFilter.class, order);
		order += STEP;
		put(ConcurrentSessionFilter.class, order);
		order += STEP;
		put(WebAsyncManagerIntegrationFilter.class, order);
		order += STEP;
		put(SecurityContextPersistenceFilter.class, order);
		order += STEP;
		put(HeaderWriterFilter.class, order);
		order += STEP;
		put(CorsFilter.class, order);
		order += STEP;
		put(CsrfFilter.class, order);
		order += STEP;
		put(LogoutFilter.class, order);
		order += STEP;
		put(X509AuthenticationFilter.class, order);
		order += STEP;
		put(AbstractPreAuthenticatedProcessingFilter.class, order);
		order += STEP;
		filterToOrder.put("org.springframework.security.cas.web.CasAuthenticationFilter",
				order);
		order += STEP;
		put(UsernamePasswordAuthenticationFilter.class, order);
		order += STEP;
		put(ConcurrentSessionFilter.class, order);
		order += STEP;
		filterToOrder.put(
				"org.springframework.security.openid.OpenIDAuthenticationFilter", order);
		order += STEP;
		put(DefaultLoginPageGeneratingFilter.class, order);
		order += STEP;
		put(ConcurrentSessionFilter.class, order);
		order += STEP;
		put(DigestAuthenticationFilter.class, order);
		order += STEP;
		put(BasicAuthenticationFilter.class, order);
		order += STEP;
		put(RequestCacheAwareFilter.class, order);
		order += STEP;
		put(SecurityContextHolderAwareRequestFilter.class, order);
		order += STEP;
		put(JaasApiIntegrationFilter.class, order);
		order += STEP;
		put(RememberMeAuthenticationFilter.class, order);
		order += STEP;
		put(AnonymousAuthenticationFilter.class, order);
		order += STEP;
		put(SessionManagementFilter.class, order);
		order += STEP;
		put(ExceptionTranslationFilter.class, order);
		order += STEP;
		put(FilterSecurityInterceptor.class, order);
		order += STEP;
		put(SwitchUserFilter.class, order);
	}

    //......
}

这个类定义了spring security内置的filter的优先级，AnonymousAuthenticationFilter在倒数第五个执行，在FilterSecurityInterceptor这个类之前。

FilterSecurityInterceptor

spring-security-web-4.2.3.RELEASE-sources.jar!/org/springframework/security/web/access/intercept/FilterSecurityInterceptor.java

/**
 * Performs security handling of HTTP resources via a filter implementation.
 * <p>
 * The <code>SecurityMetadataSource</code> required by this security interceptor is of
 * type {@link FilterInvocationSecurityMetadataSource}.
 * <p>
 * Refer to {@link AbstractSecurityInterceptor} for details on the workflow.
 * </p>
 *
 * @author Ben Alex
 * @author Rob Winch
 */
public class FilterSecurityInterceptor extends AbstractSecurityInterceptor implements
		Filter {
    //......
}

这个相当于spring security的核心处理类了，它继承抽象类AbstractSecurityInterceptor

spring-security-core-4.2.3.RELEASE-sources.jar!/org/springframework/security/access/intercept/AbstractSecurityInterceptor.java

public abstract class AbstractSecurityInterceptor implements InitializingBean,
		ApplicationEventPublisherAware, MessageSourceAware {
    //......
    protected InterceptorStatusToken beforeInvocation(Object object) {
		Assert.notNull(object, "Object was null");
		final boolean debug = logger.isDebugEnabled();

		if (!getSecureObjectClass().isAssignableFrom(object.getClass())) {
			throw new IllegalArgumentException(
					"Security invocation attempted for object "
							+ object.getClass().getName()
							+ " but AbstractSecurityInterceptor only configured to support secure objects of type: "
							+ getSecureObjectClass());
		}

		Collection<ConfigAttribute> attributes = this.obtainSecurityMetadataSource()
				.getAttributes(object);

		if (attributes == null || attributes.isEmpty()) {
			if (rejectPublicInvocations) {
				throw new IllegalArgumentException(
						"Secure object invocation "
								+ object
								+ " was denied as public invocations are not allowed via this interceptor. "
								+ "This indicates a configuration error because the "
								+ "rejectPublicInvocations property is set to 'true'");
			}

			if (debug) {
				logger.debug("Public object - authentication not attempted");
			}

			publishEvent(new PublicInvocationEvent(object));

			return null; // no further work post-invocation
		}

		if (debug) {
			logger.debug("Secure object: " + object + "; Attributes: " + attributes);
		}

		if (SecurityContextHolder.getContext().getAuthentication() == null) {
			credentialsNotFound(messages.getMessage(
					"AbstractSecurityInterceptor.authenticationNotFound",
					"An Authentication object was not found in the SecurityContext"),
					object, attributes);
		}

		Authentication authenticated = authenticateIfRequired();

		// Attempt authorization
		try {
			this.accessDecisionManager.decide(authenticated, object, attributes);
		}
		catch (AccessDeniedException accessDeniedException) {
			publishEvent(new AuthorizationFailureEvent(object, attributes, authenticated,
					accessDeniedException));

			throw accessDeniedException;
		}

		if (debug) {
			logger.debug("Authorization successful");
		}

		if (publishAuthorizationSuccess) {
			publishEvent(new AuthorizedEvent(object, attributes, authenticated));
		}

		// Attempt to run as a different user
		Authentication runAs = this.runAsManager.buildRunAs(authenticated, object,
				attributes);

		if (runAs == null) {
			if (debug) {
				logger.debug("RunAsManager did not change Authentication object");
			}

			// no further work post-invocation
			return new InterceptorStatusToken(SecurityContextHolder.getContext(), false,
					attributes, object);
		}
		else {
			if (debug) {
				logger.debug("Switching to RunAs Authentication: " + runAs);
			}

			SecurityContext origCtx = SecurityContextHolder.getContext();
			SecurityContextHolder.setContext(SecurityContextHolder.createEmptyContext());
			SecurityContextHolder.getContext().setAuthentication(runAs);

			// need to revert to token.Authenticated post-invocation
			return new InterceptorStatusToken(origCtx, true, attributes, object);
		}
	}
    //......
}

主要的逻辑在这个beforeInvocation方法，它就依赖了authentication

private Authentication authenticateIfRequired() {
		Authentication authentication = SecurityContextHolder.getContext()
				.getAuthentication();

		if (authentication.isAuthenticated() && !alwaysReauthenticate) {
			if (logger.isDebugEnabled()) {
				logger.debug("Previously Authenticated: " + authentication);
			}

			return authentication;
		}

		authentication = authenticationManager.authenticate(authentication);

		// We don't authenticated.setAuthentication(true), because each provider should do
		// that
		if (logger.isDebugEnabled()) {
			logger.debug("Successfully Authenticated: " + authentication);
		}

		SecurityContextHolder.getContext().setAuthentication(authentication);

		return authentication;
	}

这个方法判断authentication如果是已经校验过的，则返回；没有校验过的话，则调用authenticationManager进行鉴权。

而AnonymousAuthenticationFilter设置的authentication在这个时候就派上用场了 spring-security-core-4.2.3.RELEASE-sources.jar!/org/springframework/security/authentication/AnonymousAuthenticationToken.java

public class AnonymousAuthenticationToken extends AbstractAuthenticationToken implements
		Serializable {
    private AnonymousAuthenticationToken(Integer keyHash, Object principal,
										Collection<? extends GrantedAuthority> authorities) {
		super(authorities);

		if (principal == null || "".equals(principal)) {
			throw new IllegalArgumentException("principal cannot be null or empty");
		}
		Assert.notEmpty(authorities, "authorities cannot be null or empty");

		this.keyHash = keyHash;
		this.principal = principal;
		setAuthenticated(true);
	}
    //......
}

它默认就是authenticated

小结

  • web ignore比较适合配置前端相关的静态资源，它是完全绕过spring security的所有filter的；
  • 而permitAll，会给没有登录的用户适配一个AnonymousAuthenticationToken，设置到SecurityContextHolder，方便后面的filter可以统一处理authentication。

doc

作者：go4it

原文地址：https://my.oschina.net/go4it/blog/1579826

喜欢 0
湖州太守
关注
  • 18
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Security--内置访问控制方法介绍
我和井盖都笑了博客
04-05 800
      Spring Security 匹配了 URL 后调用了 permitAll()表示不需要认证， 随意访问。在 Spring Security 中提供了多种内置控制。        1 permitAll()     &nbsp...
SpringSecurity.zip
06-08
​ Spring Security：spring家族一员。是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转...
说一下Spring Security中@PermitAll和@PreAuthorize的使用
qq_55754838的博客
11-25 1986
本文主要来自于看Java开源项目，方便理解开源项目的代码是怎么实现的，加深自己的基本功。
SpringSecurity框架
w_rj0824的博客
07-20 676
用户登录系统时我们协助 SpringSecurity 把 用户对应的角色、权限组装好，同时把各个资源所要求的权限信息设定好，剩下的“登录验证”、“权限验证”等等工作都交给SpringSecurity。
Spring Security permitAll()不允许匿名访问
java牛牛的博客
02-07 5097
修改前 http .addFilterBefore(muiltpartFilter, ChannelProcessingFilter.class) .addFilterBefore(cf, ChannelProcessingFilter.class) .authorizeRequests() .anyRequest() ...
基于注解方式实现Spring Security忽略拦截
皓亮君的博客
12-22 4610
一般像一些静态资源文件需要过滤掉安全认证，例如图片,.css,.js等静态资源文件，像这种在配置文件中指定比较方便。: String url=baseUrl+接口访问路径(/login) =/test/login。像这种需要忽略某个接口需要在Spring Security配置类中在代码中写死,非常的不灵活。测试用注解修饰的接口路径,可以正常访问,由此可看配置是正常。如果从配置文件中删除了过滤的接口名称则访问接口会返回403。忽略的接口访问路径规则以下文3.3的测试接口为例,添加配置类注入配置的参数。
SpringSecurity课程文档下载 pdf 教学
05-05
SpringSecurity课程文档下载 pdf 教学
Spring Security实现验证码登录功能
08-25
"Spring Security实现验证码登录功能" Spring Security是Java应用程序安全性框架，广泛应用于Web应用程序的身份验证、授权和访问控制。验证码登录功能是Spring Security中的一个重要组件，主要用于防止自动化程序...
SpringSecurity.pdf
05-24
SpringSecurity入门到进阶到高级,是我们老师给我们讲课用的,我们都照着配就没有问题,可以跑通,
Spring Security架构以及源码详析
08-27
Spring Security 是一个强大的安全框架，主要用于Java应用的安全管理，包括认证和授权。它提供了一套完整的解决方案，确保应用程序的数据和用户访问控制得到妥善处理。在本文中，我们将深入探讨Spring Security的...
SpringSecurity的PermitAll、WebSecurityCustomizer和授权
qq_18841277的博客
12-09 3861
当使用PermitAll的时候，SpringSecurity会拿到你放行的请求进行判断，因此不会被SpringSecurity默认的过滤器所拦截，但是可能会被我们重写的过滤器所拦截，但是当在授权的时候如果实现了。的时候，过滤器会忽略后面请求的路径，默认就不会走springSecurity的过滤器和重写的springSecurity的过滤器。在SpringSecurity的日常开发中，可能使用SpringSecurity的PermitAll()请求还是会被拦截，这是为什么呢？决定此次请求是否被允许访问的。
Spring Security OAuth2 permitAll() 方法小记
weixin_42073629的博客
06-02 1209
1. 前言 在使用spring-security-oauth2时，虽然配置了.antMatchers("/permitAll").permitAll()，但如果在header中 携带Authorization Bearer xxxx，OAuth2AuthenticationProcessingFilter还是会去校验Token的正确性，如果Token合法，可以正常访问，否则，请求失败。他的需求是当配置.permitAll()时，即使携带Token，也可以直接访问。 2. 解决思路 根据Spring..
一个注解搞定 Spring Security 忽略拦截
Java知音
12-20 1697
点击关注公众号，实用技术文章及时了解Spring Security 拦截问题一个注解搞定Spring Security 忽略拦截基于注解形式基于配置形式总结源码地址https://github.com/galaxy-sea/galaxy-blogs/tree/master/code/security-annotationSpring Security 拦截问题Spring Security是干啥的...
SpringSecurity(十）--配置权限以及相关限制（上）----代码搭建
学习不止境的博客
10-24 1480
市面上很多教程都说Spring Security是一个解决身份验证、授权管理的安全框架，截至目前，我们只讨论了身份验证，正如之前介绍过的，身份验证是应用程序标识资源的调用者的过程。前面的学习中我们并没有实现任何决定是否批准请求的规则。其中仅关注了系统是否知道该用户，即productConfig中的anyRequest,permitAll/authenticated.在大多数应用程序中，并非系统识别出的所有用户都能访问系统中的每个资源，这就牵扯出授权，授权是系统决定已识别的客户端是否有权限访问所请求得资源得过
Spring Security入门宝典（二）中篇
长夜漫漫，无心睡眠
10-10 2821
使用正则表达式进行匹配。和主要的区别就是参数，antMatchers()参数是ant表达式，参数是正则表达式。演示所有以.js结尾的文件都被放行。
Spring Security自定义Filter后设置permitAll()不生效
mynameiswhite的博客
08-10 1816
1.之所以设置http.authorizeRequests().antMatchers().permitAll后，请求仍会走自定义过滤器，是因为这设置的是请求不走框架的权限校验，如token啥的，而不是不走过滤器链。
Spring Security核心组件之授权
clyu的博客
01-01 3784
Spring Security 中对于权限控制默认已经提供了很多了，但是，一个优秀的框架必须具备良好的扩展性，恰好，Spring Security 的扩展性就非常棒，我们既可以使用 Spring Security 提供的方式做授权，也可以自定义授权逻辑。一句话，你想怎么玩都可以！ 一、 URL层面的授权 1.1 访问控制url的匹配 在配置类中http.authorizeRequests()主要是对url进行控制。配置顺序会影响之后授权的效果，越是具体的应该放在前面，越是笼统的应该放到后面。 anyRequ
SpringSecurity6解决requestMatchers().permitAll()后依然执行自定义过滤器的问题
m0_54250110的博客
06-04 7952
Spring容器会自动识别被注册成为Bean对象的Filter过滤器(即继承自Filter对象的类)，将这个Bean对象自动注册到SpringBoot的过滤器链中。如果你的过滤器类使用注解注册成为了一个Bean对象，那么他就已经加到了SpringBoot的过滤器链中，所以就算你的SpringSecurity配置中设置了permitAll，可能还会去走SpringBoot的过滤器链。
SpringSecurity教学讲义.docx
最新发布
12-04
1. `spring-security-core`: 这个包包含基础认证和权限控制类，支持远程应用、客户端和服务层方法的安全，以及JDBC用户数据源等基本功能。 2. `spring-security-web`: 这个包提供了与Servlet API相关的过滤器，对于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值