OAuth 2.0

不会叫的狼

已于 2025-03-07 11:34:09 修改

阅读量220

点赞数 2

分类专栏： Shiro 文章标签： OAuth

于 2024-11-01 23:59:30 首次发布

本文链接：https://blog.csdn.net/weixin_40017062/article/details/143443201

版权

Shiro 专栏收录该内容

4 篇文章

订阅专栏

文章目录

1. 概述
2. 授权模式
3. OAuth 2.0在SpringBoot的应用

1. 概述

OAuth(Open Authorization)

OAuth 协议为用户资源的授权提供了一个安全的、开放而又简易的标准。

与以往的授权方式不同之处是：OAuth 的授权不会使第三方触及到用户的账号信息（如用户名与密码），即第三方无需使用用户的用户名与密码就可以申请获得该用户资源的授权，因此 OAuth 是安全的。

OAuth 通俗易懂的解释参见廖老师的文章：🍂OAuth 2.0 的一个简单解释 🍂 理解OAuth 2.0

第三方应用程序想访问用户资源，传统方法是，用户将自己的用户名和密码告诉第三方，这种方式会造成用户信息泄露。

OAuth 的思路：在第三方应用程序与服务提供商之间，设置了一个授权层（authorization layer）。第三方应用程序不能直接登录服务提供商，只能登录授权层，以此将用户与客户端区分开来。第三方应用程序登录授权层所用的令牌（token），与用户的密码不同。用户可以在登录的时候，指定授权层令牌的 权限范围 和 有效期。

简单说，OAuth 就是一种授权机制。数据的所有者告诉系统，同意授权第三方应用进入系统，获取这些数据。系统从而产生一个短期的进入令牌（token），用来代替密码，供第三方应用使用。

2. 授权模式

客户端必须得到用户的授权（authorization grant），才能获得令牌（access token）。OAuth 2.0 定义了四种授权方式。

授权码模式（authorization code）
简化模式（implicit）
密码模式（resource owner password credentials）
客户端模式（client credentials）

授权码模式（authorization code）是 功能最完整、流程最严密 的授权模式。也是目前用的最多的模式，比如，APP 通过微信、支付宝授权登录。

在这里插入图片描述

用户访问 A 网站，A 网站提供一个链接，用户点击后就会跳转到 B 网站，授权用户数据给 A 网站使用。
用户跳转后，B 网站会要求用户登录，然后询问是否同意给予 A 网站授权。用户表示同意，这时 B 网站就会跳回 A 网站指定的网址。跳转时，会传回一个授权码。
A 网站收到授权码以后，就可以在后端向 B 网站请求令牌。
B 网站收到请求以后，确认授权码无误后，就会颁发令牌（access token）。
后续，A 网站携带令牌（access token）请求 B 网站，获取用户信息。

详细说明参见廖老师的文章：🍂OAuth 2.0 的四种方式

3. OAuth 2.0在SpringBoot的应用

📖 SpringBoot集成Shiro+Jwt+Redis 介绍了怎么使用 Shiro+Jwt+Redis 进行登录认证和权限控制，其中 token认证 就是基于 OAuth 原理实现的。

鉴于很多项目类命名格式都是以 OAuth2 开头，本节将以该格式进行改造。

3.1 ✨自定义OAuth2Token

该类将 string 的 token 转型成 AuthenticationToken，主要目的是在 Realm 的认证和授权的时候，能够获取到 token。

public class OAuth2Token implements AuthenticationToken {
    private String token;

    public OAuth2Token(String token) {
        this.token = token;
    }

    @Override
    public Object getPrincipal() {
        return token;
    }
    @Override
    public Object getCredentials() {
        return token;
    }
}

3.2 ✨自定义OAuth2Realm

自定义 Realm 的认证方法 doGetAuthenticationInfo() 主要用来校验 token 的合法性；doGetAuthorizationInfo() 获取权限用来授权。

public class OAuth2Realm extends AuthorizingRealm {
    public final static String GLOBE_SALT = "123456789abcdefg";

    @Autowired
    private SysUserService sysUserService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private JwtUtil jwtUtil;

    // 这个方法要重写，debug源码得知shiro会判断token的类型是不是自己支持的类型，不重写的话会报错
    @Override
    public boolean supports(AuthenticationToken authenticationToken) {
        return authenticationToken instanceof OAuth2Token;
    }

    /**
     * @MethodName doGetAuthenticationInfo
     * @Description 认证配置类，用于获取返回用户的凭证信息（用户名、密码）
     * @Param authenticationToken
     * @Return AuthenticationInfo
     * @return
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("enter doGetAuthenticationInfo");
        if (StringUtils.isEmpty((String) authenticationToken.getPrincipal())) {
            return null;
        }
        // OAuth2Token 中重写 getPrincipal 方法
        String token = authenticationToken.getPrincipal().toString();
        if (!jwtUtil.verify(token)){
            throw new AuthenticationException("token已失效，请重新登录");
        }
        // 从 Redis 读取用户信息
        SysUser user = (SysUser) redisUtil.get(RedisConstant.PREFIX_SHIRO_JWT + token);
        if (null == user) {
            throw new UnknownAccountException("用户在Redis不存在");
        }
        // SimpleAuthenticationInfo 是 Apache Shiro 中的一个核心类，用于封装认证信息。它主要用于在认证过程中传递用户的身份信息和凭证信息。
        // 查看源码，其实主要比对 credentials（凭证）。
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(
                user,  // 身份标识  封装成 SimplePrincipalCollection，传递给 doGetAuthorizationInfo() 方法
                token, // 凭证
                this.getName()  // Realm 名称
        );
        return simpleAuthenticationInfo;
    }
	
    /**
     * @MethodName doGetAuthorizationInfo
     * @Description 权限配置类，用于获取返回用户配置的角色和权限
     * @Param principalCollection
     * @Return AuthorizationInfo
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        System.out.println("enter doGetAuthorizationInfo");
        // 获取身份标识
        // getPrimaryPrincipal() 获取的是 doGetAuthenticationInfo() 返回对象 SimpleAuthenticationInfo 的身份标识 SimplePrincipalCollection 对象。
        SysUser principal = (SysUser) principals.getPrimaryPrincipal();
        System.out.println(principal);

        // 通过用户名获取角色权限集合
        SysUser user = sysUserService.listRolePermByName(principal.getUserName());
        System.out.println(user);
        // 添加角色和权限
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        for (SysRole role : user.getRoles()) {
            //添加角色
            simpleAuthorizationInfo.addRole(role.getRoleName());
            //添加权限
            for (SysPermissions permissions : role.getPermissions()) {
                simpleAuthorizationInfo.addStringPermission(permissions.getPermissionsName());
            }
        }
        return simpleAuthorizationInfo;
    }

    public static void main(String[] args) {
        String pwd = "123456";
        /*
         * SHA-256加密：
         * 使用SimpleHash类对原始密码进行加密。
         * 第一个参数代表使用 SHA-256 方式加密
         * 第二个参数为原始密码
         * 第三个参数为盐值
         * 第四个参数为加密次数
         * 最后用toHex()方法将加密后的密码转成String
         * */
        String shaPwd = new SimpleHash("SHA-256",
                pwd,
                ByteSource.Util.bytes(GLOBE_SALT),
                1024).toHex();
        System.out.println("shaPwd=" + shaPwd);
    }
}

3.3 ✨自定义过滤器OAuth2Filter

主要作用就是拦截请求，判断请求头中是否携带 token。如果携带，就交给自定义 Realm 处理。

@Slf4j
@Component
public class OAuth2Filter extends BasicHttpAuthenticationFilter {
    private String errorMsg;

    /**
     * 过滤器拦截请求的入口方法
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        // 判断请求头是否带上token
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("Authorization");
        // token不存在，禁止访问
        if (StringUtils.isEmpty(token)) {
            return false;
        }
        try {
            // 交给 OAuth2Realm
            // getSubject(request, response).login(new OAuth2Realm(token));  //getSubject(request, response) 等同于 SecurityUtils.getSubject()
            SecurityUtils.getSubject().login(new OAuth2Token(token));
            return true;
        } catch (Exception e) {
            errorMsg = e.getMessage();
            e.printStackTrace();
            return false;
        }
    }

    /**
     * isAccessAllowed()方法返回false，即认证不通过时进入onAccessDenied方法
     */
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setStatus(400);
        httpServletResponse.setContentType("application/json;charset=utf-8");
        PrintWriter out = httpServletResponse.getWriter();
        out.println(JSONUtil.toJsonStr(Result.error(errorMsg)));
        out.flush();
        out.close();
        return false;
    }

    /**
     * 对跨域访问提供支持
     *
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
        // 跨域发送一个option请求
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }

}

3.4 ✨ShiroConfig

配置 SecurityManager 策略、指定哪些 URL 需要认证。

@Configuration
public class ShiroConfig {
    /*@Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        // 散列算法：这里使用 SHA-256 算法;
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher("SHA-256");
        // 散列的次数，比如散列两次，相当于 SHA-256(SHA-256(""));
        credentialsMatcher.setHashIterations(1024);
        // storedCredentialsHexEncoded 默认是 true，此时用的是密码加密用的是 Hex 编码；false 时用 Base64 编码
        credentialsMatcher.setStoredCredentialsHexEncoded(true);
        return credentialsMatcher;
    }*/

    @Bean
    public OAuth2Realm customRealm() {
        OAuth2Realm customRealm = new OAuth2Realm();
        // 将 HashService 注入到自定义的 Realm 中，告诉 realm，使用 hashedCredentialsMatcher 加密算法类来验证密文
        //customRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return customRealm;
    }

    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 设置自定义 Realm
        securityManager.setRealm(customRealm());
        // 禁用 Shiro 的 Session 存储，这样可以确保 shiro 不会创建或使用 Session，而是依赖于无状态的 Token 来进行认证。
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        securityManager.setSubjectDAO(subjectDAO);
        return securityManager;
    }

    @Bean(name = "shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 注入 securityManager
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        // 添加自定义 Filter，并且取名为 oauth2
        Map<String, Filter> filterMap = new HashMap<>();
        filterMap.put("oauth2", new OAuth2Filter());
        shiroFilterFactoryBean.setFilters(filterMap);

        /*//登录
        shiroFilterFactoryBean.setLoginUrl("/login");
        //首页
        shiroFilterFactoryBean.setSuccessUrl("/index");
        //错误页面，认证不通过跳转
        shiroFilterFactoryBean.setUnauthorizedUrl("/notRole");
        shiroFilterFactoryBean.setUnauthorizedUrl("/error");*/

        // 设置 Shiro 的过滤器链来指定哪些 URL 需要进行 JWT 认证。
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        // authc：所有url都必须认证通过才可以访问; anon：所有url都都可以匿名访问
        filterChainDefinitionMap.put("/sys/login", "anon");
        filterChainDefinitionMap.put("/api/**", "anon");
        // /** 必须放在所有权限设置的最后，表示对所有资源起作用，本例使用自定义 oauth2
        filterChainDefinitionMap.put("/**", "oauth2");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }


    /**
     * *
     *  开启 Shiro 的注解（如@RequiresRoles、@RequiresPermissions），需借助 SpringAOP 扫描使用 Shiro 注解的类，并在必要时进行安全逻辑验证
     * *
     *  配置以下两个 bean （DefaultAdvisorAutoProxyCreator（可选）和 AuthorizationAttributeSourceAdvisor）即可实现此功能
     * * @return
     */
    // 配置 DefaultAdvisorAutoProxyCreator，执行权限注解 @RequiresPermissions 会调用两次 doGetAuthorizationInfo() 方法。故不注入该配置。
    /*@Bean
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    @Bean
    @DependsOn({"lifecycleBeanPostProcessor"})
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }*/

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor() {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager());
        return authorizationAttributeSourceAdvisor;
    }
}