Spring Security权限控制（三）

最新推荐文章于 2024-04-04 09:56:48 发布
最新推荐文章于 2024-04-04 09:56:48 发布
阅读量462 收藏
点赞数
分类专栏： 2021SC@SDUSC 文章标签： spring java restful
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30262407/article/details/125240695
版权

学生程序设计能力提升平台 Spring Security的应用（三）

JSON WEB TOKEN与spring security

json web token简介

JWT 是一个很长的字符串，由 . 分割为三段

Header(头部)

存储 JWT 的元数据，与生成 Token API jwt.sign(payload, secretOrPrivateKey, [options, callback])中的 options 对应

Payload(负载数据)

存放需要实际传递的数据，官方定义了7个官方字段

Signature(签名)

是对前两部分的签名，防止数据篡改

JwtUtil工具类

/**
 * JWT工具类
 * @author widealpha
 * @date 2021/7/13
 */
public class JwtUtil {
    private static final String SECRET = "secret"; //JWT签证密钥
    private static final String ROLE = "ROLE"; //Jwt中携带的身份key
    private static final String USER_ID = "USER_ID"; //Jwt中携带的用户ID的key
    private static final Long EXPIRATION = 60 * 60 * 24 * 7L; //过期时间7天
    public static final String TOKEN_HEADER = "Authorization"; //Header标识JWT
    public static final String TOKEN_PREFIX = "Bearer "; //JWT标准开头,注意空格

    /**
     * 创建JWT
     * @param username 账户名
     * @param userId 用户ID
     * @param roles 用户角色,以英文逗号(,)分隔开
     * @return 创建好的Token
     */
    public static String createToken(String username,Integer userId, String roles) {
        Map<String, Object> map = new HashMap<>();
        map.put(ROLE, roles);
        map.put(USER_ID, userId);
        return Jwts.builder().signWith(SignatureAlgorithm.HS256, SECRET)
                .setClaims(map).setSubject(username).setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION * 1000))
                .compact();
    }

    /**
     * 根据token获取用户名
     * @param token JWT
     * @return 用户名
     */
    public static String getUsername(String token) {
        try {
            return getTokenBody(token).getSubject();
        } catch (Exception e) {
            return null;
        }
    }

    /**
     *  获取Token载体信息
     * @param token JWT
     * @return token携带的claim
     */
    private static Claims getTokenBody(String token) {
        Claims claims = null;
        try {
            claims = Jwts.parser().setSigningKey(SECRET).parseClaimsJws(token).getBody();
        } catch (ExpiredJwtException | UnsupportedJwtException | MalformedJwtException | SignatureException | IllegalArgumentException e) {
            e.printStackTrace();
        }
        return claims;
    }

    /**
     * 获取token携带的用户角色列表
     * @param token JWT
     * @return 用户角色,以英文逗号(,)分隔开
     */
    public static String getUserRole(String token) {
        return (String) getTokenBody(token).get(ROLE);
    }

    /**
     * 获取token携带的用户ID
     * @param token JWT
     * @return 用户ID
     */
    public static Integer getUserId(String token){
        return (Integer) getTokenBody(token).get(USER_ID);
    }

    /**
     * 判断token是否国企
     * @param token JWT
     * @return 是否过期
     */
    public static Boolean isExpiration(String token) {
        try {
            return getTokenBody(token).getExpiration().before(new Date());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return true;
    }

    /**
     * 获取签发日期
     * @param token JWT
     * @return 签发Token的日期
     */
    public static Date getIssuedAt(String token){
        return getTokenBody(token).getIssuedAt();
    }
}

通过工具类可以十分便捷的获取到所有的token的属性等数据

Config

依然首先是通过config进行注入配置

@Configuration
public class JwtLoginConfig<T extends JwtLoginConfig<T, B>, B extends HttpSecurityBuilder<B>> extends AbstractHttpConfigurer<T, B> {

    private final JwtAuthenticationFilter authFilter;

    public JwtLoginConfig() {
        this.authFilter = new JwtAuthenticationFilter();
    }

    @Override
    public void configure(B http) {
        authFilter.setAuthenticationManager(http.getSharedObject(AuthenticationManager.class));
        authFilter.setAuthenticationFailureHandler(new HttpStatusLoginFailureHandler());
        //将filter放到logoutFilter之前
        JwtAuthenticationFilter filter = postProcess(authFilter);
        http.addFilterBefore(filter, LogoutFilter.class);
    }

    //设置匿名用户可访问url
    public JwtLoginConfig<T, B> permissiveRequestUrls(String... urls) {
        authFilter.setPermissiveUrl(urls);
        return this;
    }

    public JwtLoginConfig<T, B> tokenValidSuccessHandler(AuthenticationSuccessHandler successHandler) {
        authFilter.setAuthenticationSuccessHandler(successHandler);
        return this;
    }
}

在这里代码里把filter放置在Logout之前，是因为logout是需要鉴权的操作，每次logout都必须有授权才能logout

这里通过配置filter实现登录请求的拦截

对一些数据的实体类进行IOC控制反转，降低内存的使用

public class JwtAuthenticationFilter extends OncePerRequestFilter {
    private final RequestHeaderRequestMatcher requiresAuthenticationRequestMatcher;
    private List<RequestMatcher> permissiveRequestMatchers;
    private AuthenticationManager authenticationManager;

    private AuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler();
    private AuthenticationFailureHandler failureHandler = new SimpleUrlAuthenticationFailureHandler();

    public JwtAuthenticationFilter() {
        //拦截header中带Authorization的请求
        this.requiresAuthenticationRequestMatcher = new RequestHeaderRequestMatcher("Authorization");
    }

    protected String getJwtToken(HttpServletRequest request) {
        return request.getHeader(JwtUtil.TOKEN_HEADER);
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (!requiresAuthentication(request)) {
            chain.doFilter(request, response);
            return;
        }
        String tokenHeader = getJwtToken(request);
        if (tokenHeader == null || !tokenHeader.startsWith(JwtUtil.TOKEN_PREFIX)) {
            chain.doFilter(request, response);
            return;
        }
        try {
            if (!JwtUtil.isExpiration(tokenHeader.replace(JwtUtil.TOKEN_PREFIX, ""))) {
                UsernamePasswordAuthenticationToken authentication = getAuthentication(tokenHeader);
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        } catch (ExpiredJwtException e) {
            response.setCharacterEncoding("UTF-8");
            response.setHeader("Content-Type", "text/html;charset=UTF-8");
            response.getWriter().print(ResultEntity.error(StatusCode.USER_TOKEN_OVERDUE));
            return;
        } catch (JwtException e) {
            response.setCharacterEncoding("UTF-8");
            response.setHeader("Content-Type", "text/html;charset=UTF-8");
            response.getWriter().print(ResultEntity.error(StatusCode.USER_TOKEN_ERROR));
            return;
        } catch (Exception e) {
            response.setCharacterEncoding("UTF-8");
            response.setHeader("Content-Type", "text/html;charset=UTF-8");
            response.getWriter().print(ResultEntity.error(StatusCode.COMMON_FAIL));
            return;
        }
        chain.doFilter(request, response);
    }

    //获取用户信息
    private UsernamePasswordAuthenticationToken getAuthentication(String tokenHeader) {
        String token = tokenHeader.replace(JwtUtil.TOKEN_PREFIX, "");
        String account = JwtUtil.getUsername(token);
        Integer userId = JwtUtil.getUserId(token);
        if (account == null || userId == null) {
            return null;
        }
        // 获得权限 添加到权限上去
        String roles = JwtUtil.getUserRole(token);
        PtaUser ptaUser = new PtaUser(account, "[PROTECTED]", AuthorityUtils.commaSeparatedStringToAuthorityList(roles));
        ptaUser.setUserId(userId);
        return new UsernamePasswordAuthenticationToken(ptaUser, null, AuthorityUtils.commaSeparatedStringToAuthorityList(roles));
    }

    protected boolean requiresAuthentication(HttpServletRequest request) {
        return requiresAuthenticationRequestMatcher.matches(request);
    }

    protected AuthenticationManager getAuthenticationManager() {
        return authenticationManager;
    }

    public void setAuthenticationManager(AuthenticationManager authenticationManager) {
        this.authenticationManager = authenticationManager;
    }


    protected boolean permissiveRequest(HttpServletRequest request) {
        if (permissiveRequestMatchers == null)
            return false;
        for (RequestMatcher permissiveMatcher : permissiveRequestMatchers) {
            if (permissiveMatcher.matches(request))
                return true;
        }
        return false;
    }

    public void setPermissiveUrl(String... urls) {
        if (permissiveRequestMatchers == null)
            permissiveRequestMatchers = new ArrayList<>();
        for (String url : urls)
            permissiveRequestMatchers.add(new AntPathRequestMatcher(url));
    }

    public void setAuthenticationSuccessHandler(
            AuthenticationSuccessHandler successHandler) {
        Assert.notNull(successHandler, "successHandler cannot be null");
        this.successHandler = successHandler;
    }

    public void setAuthenticationFailureHandler(
            AuthenticationFailureHandler failureHandler) {
        Assert.notNull(failureHandler, "failureHandler cannot be null");
        this.failureHandler = failureHandler;
    }

    protected AuthenticationSuccessHandler getSuccessHandler() {
        return successHandler;
    }

    protected AuthenticationFailureHandler getFailureHandler() {
        return failureHandler;
    }

首先通过重写filter对指定的数据进行拦截

通过config配置拦截器的具体请求，这里是将符合的请求(header中携带有anthentication的)拦截下来，接着通过header获取到token

这里获取token的时候，进行了一次jwt签证的校验，通过exception来判断验证的结果

当验证通过的时候，从jwt的payload中读取用户名和权限信息，将用户名和权限信息，放置到UsernameAuthenticationToken容器中，接着将生成好的容器注入到SercurityContextHolder中

这里我们读一下SercurityContextHolder的源码

final class GlobalSecurityContextHolderStrategy implements SecurityContextHolderStrategy {

	private static SecurityContext contextHolder;

	@Override
	public void clearContext() {
		contextHolder = null;
	}

	@Override
	public SecurityContext getContext() {
		if (contextHolder == null) {
			contextHolder = new SecurityContextImpl();
		}
		return contextHolder;
	}

	@Override
	public void setContext(SecurityContext context) {
		Assert.notNull(context, "Only non-null SecurityContext instances are permitted");
		contextHolder = context;
	}

	@Override
	public SecurityContext createEmptyContext() {
		return new SecurityContextImpl();
	}

}

这里通过全局的唯一实例进行注入，所以这次设置之后，在系统的任何地方调用SercurityContextHolder均会获取到用户名和权限信息

这里我认为原来的代码这一部分并没有完全使用spring security，按照security的思路，更适合使用authentication->provider->manager的一整套流程。我会在另一篇播客里写一下思路

Refresh

JWT可以减轻服务器的负担，解决一部分的跨域难题，但是同时，为保证安全性jwt的签发是有一定的时间的，在时间将要过期的时候，我们应当及时的为jwt刷新token

public class JwtRefreshSuccessHandler implements AuthenticationSuccessHandler {

    private static final int tokenRefreshInterval = 24;  //刷新间隔1天

    public JwtRefreshSuccessHandler() {
    }

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
        String tokenHeader = request.getHeader(JwtUtil.TOKEN_HEADER);
        boolean shouldRefresh = shouldTokenRefresh(JwtUtil.getIssuedAt(tokenHeader.replace(JwtUtil.TOKEN_PREFIX, "")));
        if (shouldRefresh) {
            String roles = authentication.getAuthorities().stream()
                    .map(Object::toString).collect(Collectors.joining(","));
            String newToken = JwtUtil.createToken(authentication.getName(), ((PtaUser) authentication.getPrincipal()).getUserId(), roles);
            response.setHeader("Authorization", newToken);
        }
    }

    protected boolean shouldTokenRefresh(Date issueAt) {
        LocalDateTime issueTime = LocalDateTime.ofInstant(issueAt.toInstant(), ZoneId.systemDefault());
        return LocalDateTime.now().minusHours(tokenRefreshInterval).isAfter(issueTime);
    }

}

在项目中采用的是successHandler的方式，当jwt校验成功之后，会自动调用这个handler，完全可以在handler中检验日期是否临近截至日期

在这里，当距离截至日期的时间不足一个tokenRefreshInteval的时候就会触发刷新，刷新的机制也很简单，将刷新有效期之后的token放置到header中

客户端只需要检测是否有authentication就可以判断是不是需要更新本地的token，更新token的操作也可以通过不侵入的拦截器操作进行

controller

controller层只需要通过hasRole注解即可进行

    @PostMapping("/getProblemByAuthorId")
    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_TEACHER')")
    public ResultEntity getProblemByAuthorId(@RequestParam("page") int page, @RequestParam("size") int size) throws ServletException, IOException {
        if (UserUtil.getCurrentUserId() == null) {
            return ResultEntity.error(StatusCode.NO_PERMISSION);
        }
        try {
            Pager<Problem> problemPager = problemService.getProblemByAuthorId(UserUtil.getCurrentUserId(), page, size);
            return ResultEntity.success("ok", problemPager);
        } catch (Exception e) {
            log.error("获取题目失败", e);
            return ResultEntity.error("error");
        }

    }

在没有登录，或者是登录时候检测权限的过程中没有发现对应的ADMIN或者TEACHER的，就会被403拦下来，剩下的请求才可以正常的通过进行请求的校验。

widealpha
关注
专栏目录
SpringSecurity权限控制实现原理解析
08-24
SpringSecurity 权限控制实现原理解析 SpringSecurity 权限控制实现原理是指在应用程序中对用户的操作权限进行控制和限制，以确保应用程序的安全性和可靠性。权限控制是指在应用程序中对用户的操作权限进行控制和...
SpringSecurity权限控制
qq_61544409的博客
03-21 7860
Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。 正如你可能知道的关于安全方面的两个核心功能是“认证”和“授权”，一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分，这两点也是 SpringSecurity 重要核心功
Spring Security 权限控制
m0_48922996的博客
07-16 8550
项目版本BootSecurity官网文档在前面的文章中，所有的接口只需要登录就能访问。并没有对每个接口进行权限限制。在正式的系统中，一个用户会拥有一个或者多个角色，而不同的角色会拥有不同的接口权限。如果要实现这些功能，需要重写中的。HttpSecurity用于构建一个安全过滤器链SecurityFilterChain，可以通过它来进行自定义安全访问策略。@Bean}@Override.and()}@Overridehttp.authorizeRequests()//开启配置。...
Spring Security权限控制
m0_56409614的博客
03-20 2464
该文章为学习Spring Security(权限控制)的一点基础知识
Spring security权限管理
weixin_47072986的博客
04-02 4027
​ Spring Security是一个高度自定义的安全框架。利用Spring IoC/DI和AOP功能，为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。​ 使用Spring Secruity的原因有很多，但大部分都是发现了javaEE的Servlet规范或EJB规范中的安全功能缺乏典型企业应用场景。同时认识到他们在WAR或EAR级别无法移植。因此如果你更换服务器环境，还有大量工作去重新配置你的应用程序。
springboot springsecurity动态权限控制
09-18
在这个“springboot springsecurity动态权限控制”的主题中，我们将深入探讨如何在Spring Boot项目中集成Spring Security，实现动态权限控制，让菜单权限的管理更加灵活和高效。 首先，我们需要理解Spring Security...
Spring security实现登陆和权限角色控制
09-09
在这个场景中，我们将探讨如何使用Spring Security来实现登录和权限角色控制。首先，确保你正在使用的Spring版本为4.3.2.RELEASE，而Spring Security版本是4.1.2.RELEASE。在开始之前，你需要对Spring MVC、SPeL...
spring security权限控制
10-15
在本文中，我们将深入探讨Spring Security如何实现权限控制，并通过一个名为"springsecuritydemo4"的示例项目来理解其核心概念。 首先，Spring Security 的权限控制主要涉及以下几个关键组件： 1. **认证...
Spring Security如何使用URL地址进行权限控制
08-25
Spring Security如何使用URL地址进行权限控制 Spring Security是一个功能强大且广泛应用的Java安全框架，它提供了许多功能，包括身份验证、授权、加密等。其中，权限控制是Spring Security的一个重要组件，它允许...
SpringSecurity实现角色权限控制（SpringBoot+SpringSecurity+JWT）
lans_g的博客
05-14 7756
通过springboot整合jwt和security，以用户名/密码的方式进行认证和授权。认证通过jwt+数据库的，授权这里使用了两种方式，分别是SpringSecurity自带的hasRole方法+SecurityConfig和 我们自定义的permission+@PreAuthorize注解。用来存储和获取当前线程关联的 SecurityContext 对象的类。
SpringSecurity--权限管理架构介绍
qq_53868937的博客
07-13 2066
也有很多公司选择⾃定义权限，即⾃⼰开发权限管理。但是⼀个系统的安全，不仅 仅是登录和权限控制这么简单，我们还要考虑种各样可能存在的⽹络政击以及防彻 策略，从这个⻆度来说，开发者自己实现安全管理也并⾮是⼀件容易的事情，只有 ⼤公司才有⾜够的⼈⼒物⼒去⽀持这件事情。
Spring Security进行权限控制
geejkse_seff的博客
08-02 1169
先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。springsecurity中在用户同步提交表单时设置了一个隐藏的token，不但会对用户提交的信息进行核实，还会对token进行核实，在异步提交的时候则需要自行在前端加入token提交。在用户提交表单时，不法网站可能窃取用户提交的信息进行提交从而造成安全问题。...
Spring Security 中的四种权限控制方式
最新发布
2401_84048542的博客
04-04 847
Spring Security 支持在 URL 和方法权限控制时使用 SpEL 表达式，如果表达式返回值为 true 则表示需要对应的权限，否则表示不需要对应的权限。可以看到，SecurityExpressionRoot 有两个实现类，表示在应对 URL 权限控制和应对方法权限控制时，分别对 SpEL 所做的拓展，例如在基于 URL 路径做权限控制时，增加了 hasIpAddress 选项。| authentication | 从 SecurityContext 中提取出来的用户对象 |
权限控制_SpringSecurity
cvpatient的博客
04-20 530
Security案例，使用方法
SpringBoot与Spring Security权限控制实战教程
资源摘要信息:"SpringBoot与Spring Security集成实现权限控制的教程，包含完整源代码和数据库文件，适合对Spring Security感兴趣的初学者和希望深入理解其权限控制机制的开发者。" 知识点详细说明： 1. SpringBoot...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值