Spring Security整合Spring Boot分布式认证

Spring Security整合Spring Boot分布式认证 一、分布式系统认证技术分析 1、分布式系统认证

随着软件环境和需求的变化，软件的架构通常都会由单体结构演变成具有分布式架构的分布式系统。而分布式系统的每个服务都会有认证、授权的需求。如果每个服务都实现一套认证逻辑，就会非常冗余并且不现实。而针对分布式系统的特点，一般就会需要一套独立的第三方系统来提供统一的授权认证服务。

分布式认证，即我们常说的单点登录，简称SSO。指的是在多应用系统的项目中，用户只需要登录一次，就可以访问所有互相信任的应用系统。

2、分布式认证方案

分布式环境下的认证方案主要有基于 Session和基于 Token两种方案。

2.1 基于 Session的认证方式
基于 Session的认证方式，是由服务端保存统一的用户信息。
只是在分布式环境下，将 Session信息同步到各个服务中，并对请求进行均衡的负载。一般不用，简单了解。

2.2 基于 Token的认证方式
基于 Token的认证方式，服务端不再存储认证数据，易维护，扩展性强。
客户端可以把 Token存在任意地方，并且可以实现 web和 app统一认证机制。
其缺点也很明显，客户端信息容易泄露，token由于包含了大量信息，因此一般数据量较大，而且每次请求都需要传递，因此比较占带宽。另外，token的签名延签 *** 作也会给系统带来额外的负担。

它的优点是：

适合统一认证的机制，客户端、一方应用、三方应用都遵循一致的认证机制。token认证方式对第三方应用接入更适合，因为它更开放，可使用当前有流行的开放协议Oauth2.0、JWT等。一般情况服务端无需存储会话信息，减轻了服务端的压力。 3、方案选型

通常情况下，还是会选择更通用的基于token的方式，这样能保证整个系统更灵活的扩展性，并减轻服务端的压力。
在这种方案下，一般会独立出 统一认证服务（(UUA） 和API网关两个部分来一起完成认证授权服务。其中，

统一认证服务(UAA)，它承载了 OAuth2.0接入方认证、登入用户的认证、授权以及生成令牌的职责，完成实际的用户认证、授权功能。API网关，会作为整个分布式系统的唯一入口，API网关为接入方提供定制的 API结合，它本身还可能具有其他辅助职责，如身份验证、监控、负载均衡、缓存、协议转换等功能。API网关方式的核心要点是：所有的接入方和消费端都通过统一的网关接入微服务，在网关层处理所 有的非业务功能。

基于 Token的认证方式整体流程图如下（图来自网络）：

总结一下：基于 Token的认证方式，单点登录实现的两大环节：

用户认证：这一环节主要是用户向认证服务器发起认证请求，认证服务器给用户返回一个成功的令牌 token，主要在认证服务器中完成，认证系统只能有一个。身份校验：这一环节是用户携带 token去访问其他服务器时，在其他服务器中要对 token的真伪进行检验，主要在资源服务器中完成，资源服务系统可以有很多个。

注意：token的安全与否是分布式认证中最重要的环节。

4、JWT简介

从分布式认证流程中，我们不难发现，这中间起最关键作用的就是 token，token的安全与否，直接关系到系统的健壮性，这里我们选择使用 JWT来实现 token的生成和校验。

JWT，全称JSON Web Token，它是一款出色的分布式身份校验方案。可以生成 token，也可以解析检验 token。官网地址：https://jwt.io

4.1 JWT生成的 token
JWT生成的 token，由三部分组成：

头部：主要设置一些规范信息，签名部分的编码格式就在头部中声明。载荷：token中存放有效信息的部分，比如用户名，用户角色，过期时间等，但是不要放密码，会泄露！签名：将头部与载荷分别采用 base64编码后，用“.”相连，再加入盐，最后使用头部声明的编码类型进行编码，就得到了签名。

4.2 JWT生成 token的安全性分析
从 JWT生成的 token组成上来看，要想避免 token被伪造，主要就得看签名部分了，而签名部分又有三部分组成，其中头部和载荷的 base64编码，几乎是透明的，毫无安全性可言，那么最终守护 token安全的重担就落在了加入的盐上面了！

思考： 如果生成 token所用的盐与解析 token时加入的盐是一样的。岂不是大家可以用这个盐来解析 token，就能用来伪造 token。
所以，我们就需要对盐采用非对称加密的方式进行加密，以达到生成 token与校验 token方所用的盐不一致的安全效果。

5、RSA简介

RSA-非对称加密 算法
基本原理：同时生成两把密钥：私钥和公钥，私钥隐秘保存，公钥可以下发给信任客户端。
密钥加密的使用方式有两种：

私钥加密，持有私钥或公钥才可以解密（推荐使用）。公钥加密，持有私钥才可解密。

总结： 认证服务使用 私钥加密 token，资源服务使用公钥解密来验证 token的真伪。

二、Spring Security+JWT+RSA分布式认证

这里创建了一个maven项目。

1、common模块

common：公共模块，封装一些项目中常用的工具类等。

这里将 JWT和RSA工具类写到这里。

RSA：单元测试生成好公钥和私钥，作为盐供 JWT使用。JWT：提供生成 token与校验 token的方法。

2、SSO模块

SSO：分布式认证服务。单点登录主要实现两个功能：

用户认证授权登录用户退出

引入相关依赖，还要引入我们的 common模块。

 
      org.springframework.boot
      spring-boot-starter-web
    
    
      org.springframework.boot
      spring-boot-starter-security
    
    
      mysql
      mysql-connector-java
      8.0.23
    
    
      org.mybatis.spring.boot
      mybatis-spring-boot-starter
      2.1.0
    

    
      com.charge.learn.springsecurity.jwt.rsa.parent.common
      common
      1.0-SNAPSHOT
    

2.1 用户认证授权登录

Spring Security主要是通过过滤器来实现功能的。前面我们分析了Spring Security实现认证和校验身份的过滤器的源码分析。

用户认证：
使用 UsernamePasswordAuthenticationFilter过滤器中 attemptAuthentication方法实现认证功能，该过滤器父类中successfulAuthentication方法实现认证成功后的 *** 作。身份校验：
使用 BasicAuthenticationFilter过滤器中 doFilterInternal方法验证是否登录，以决定能否进入后续过滤器。

分布式认证流程就需要我们重写 Spring Security中的用户认证和身份校验的部分逻辑。

用户认证：
由于分布式项目，多数是前后端分离的架构设计，我们要满足可以接受异步 post请求的认证请求参数，需要重写 UsernamePasswordAuthenticationFilter过滤器中 attemptAuthentication方法，让其能够接收请求体。
另外，默认 successfulAuthentication方法在认证通过后，是把用户信息直接放入 session就结束了，现在我们需要重写这个方法，在认证通过后生成 token并返回给用户。身份校验：
原来 BasicAuthenticationFilter过滤器中 doFilterInternal方法校验用户是否登录，就是看 session中是否有用户信息，我们需要修改为验证用户携带的 token是否合法，并解析出用户信息，最后交给 Spring Security，以便于后续的授权功能可以正常使用。所以也需要重写 doFilterInternal方法。 2.1.1 用户认证过滤器

自定义用户认证过滤器，重写 UsernamePasswordAuthenticationFilter中的几个方法。

public class JwtLoginFilter extends UsernamePasswordAuthenticationFilter {

    // 不能 @Autowrid, 谁使用该类，就构造方法传入
    private AuthenticationManager authenticationManager;
    private RsaKeyProperties prop;

    public JwtLoginFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) {
        this.authenticationManager = authenticationManager;
        this.prop = prop;
    }

    
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        try {
            //将json格式请求体转成JavaBean对象
            SysUser sysUser = null;
            try {
                sysUser = new ObjectMapper().readValue(request.getInputStream(), SysUser.class);
            }catch (Exception outEx){
                //如果认证失败，提供自定义json格式异常
                response.setContentType("application/json;charset=utf-8");
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                PrintWriter out = response.getWriter();
                Map resultMap = new HashMap();
                resultMap.put("code", HttpServletResponse.SC_UNAUTHORIZED);
                resultMap.put("msg", "用户名或密码 json解析异常！");
                out.write(new ObjectMapper().writevalueAsString(resultMap));
                out.flush();
                out.close();
                outEx.printStackTrace();
            }
            UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(sysUser.getUsername(), sysUser.getPassword());
            // 去认证, 会抛异常
            return authenticationManager.authenticate(authRequest);
        }catch (Exception e){
            try {
                //如果认证失败，提供自定义json格式异常
                response.setContentType("application/json;charset=utf-8");
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                PrintWriter out = response.getWriter();
                Map resultMap = new HashMap();
                resultMap.put("code", HttpServletResponse.SC_UNAUTHORIZED);
                resultMap.put("msg", "用户名或密码错误！");
                out.write(new ObjectMapper().writevalueAsString(resultMap));
                out.flush();
                out.close();
            }catch (Exception outEx){
                outEx.printStackTrace();
            }
            throw new RuntimeException(e);
        }
    }

    
    @Override
    public void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        //得到当前认证的用户对象
        SysUser user = new SysUser();
        user.setUsername(authResult.getName());
        SysUser sysUser = (SysUser) authResult.getPrincipal();
        user.setUsername(sysUser.getUsername());
        user.setRoles((List) authResult.getAuthorities());
        //json web Jwt构建token，私钥加密
        String token = JwtUtils.generateTokenExpireInMinutes(user, prop.getPrivateKey(), 24 * 60);
        //返回token，在header中添加
        response.addHeader("Authorization", "Bearer "+token);
        try {
            //登录成功時，返回json格式进行提示
            response.setContentType("application/json;charset=utf-8");
            response.setStatus(HttpServletResponse.SC_OK);
            PrintWriter out = response.getWriter();
            Map resultMap = new HashMap();
            resultMap.put("code", HttpServletResponse.SC_OK);
            resultMap.put("msg", "认证通过！");
            out.write(new ObjectMapper().writevalueAsString(resultMap));
            out.flush();
            out.close();
        }catch (Exception outEx){
            outEx.printStackTrace();
        }
    }

    
    @Override
    public void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
        response.setContentType("application/json;charset=utf-8");
        response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        PrintWriter out = response.getWriter();
        Map map = new HashMap();
        map.put("code", HttpServletResponse.SC_FORBIDDEN);
        map.put("message", "用户名或者密码输入错误，请重新输入!");
        out.write(new ObjectMapper().writevalueAsString(map));
        out.flush();
        out.close();
    }
}

这里我们将 token放到了请求头中，身份校验时也要按相同的方式处理。

2.1.2 身份校验过滤器

自定义身份校验过滤器，重写 BasicAuthenticationFilter中的几个方法。

public class JwtVerifyFilter extends BasicAuthenticationFilter {

	// 不能 @Autowrid, 谁使用该类，就构造方法传入
	private RsaKeyProperties prop;

	public JwtVerifyFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) {
		super(authenticationManager);
		this.prop = prop;
	}

	

	@Override
	public void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
		try {
			// 请求体的头中是否包含Authorization
			// Authorization中是否包含Bearer，不包含直接返回, 放到hender是我们约定好的
			String header = request.getHeader("Authorization");
			if (header == null || !header.startsWith("Bearer ")) {
				responseJson(response);
				chain.doFilter(request, response);
				return;
			}
			//获取权限失败，会抛出异常
			UsernamePasswordAuthenticationToken authResult =getAuthentication(request);
			// 获取后，将Authentication写入SecurityContextHolder中供后序使用，这一步，必须要做
			SecurityContextHolder.getContext().setAuthentication(authResult);
			chain.doFilter(request, response);
		} catch (Exception e) {
			responseJson(response);
			e.printStackTrace();
		}

	}

	
	private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
		// 如果携带了正确格式的token要先得到token
		String token = request.getHeader("Authorization");
		if (token != null) {
			// 通过token 公钥解析出载荷信息，即验证token是否正确
			Payload payload = JwtUtils.getInfoFromToken(token.replace("Bearer ", ""), prop.getPublicKey(), SysUser.class);
			SysUser user = payload.getUserInfo();
			// 不为null，返回
			if (user != null) {
				return new UsernamePasswordAuthenticationToken(user, null, user.getRoles());
			}
			return null;
		}
		return null;
	}

	
	private void responseJson(HttpServletResponse response) {
		try {
			// 未登录提示
			response.setContentType("application/json;charset=utf-8");
			response.setStatus(HttpServletResponse.SC_FORBIDDEN);
			PrintWriter out = response.getWriter();
			Map map = new HashMap();
			map.put("code", HttpServletResponse.SC_FORBIDDEN);
			map.put("message", "请登录！");
			out.write(new ObjectMapper().writevalueAsString(map));
			out.flush();
			out.close();
		} catch (Exception e1) {
			e1.printStackTrace();
		}
	}

}

2.2 用户退出

当用户退出时，需要会做以下几件事情：

清除 SecurityContextHolder和 token响应数据

Spring Security默认实现了 logout退出 *** 作。通过 LogoutFilter拦截器处理。

所以，我们直接要重写 LogoutSuccessHandler类的 onLogoutSuccess方法，来清除我们的 token数据和响应数据即可。

2.2.1 自定义退出成功处理器

public class JwtLogoutSuccessHandler implements LogoutSuccessHandler{

	private RsaKeyProperties prop;

	public JwtLogoutSuccessHandler(RsaKeyProperties prop) {
		this.prop = prop;
	}

	@Override
	public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication)
			throws IOException, ServletException {
		String header = request.getHeader("Authorization");
		if (header == null || !header.startsWith("Bearer ")) {
			//如果携带错误的token，则给用户提示请登录！
			response.setContentType("application/json;charset=utf-8");
			response.setStatus(HttpServletResponse.SC_FORBIDDEN);
			PrintWriter out = response.getWriter();
			Map resultMap = new HashMap();
			resultMap.put("code", HttpServletResponse.SC_FORBIDDEN);
			resultMap.put("msg", "token 为空！");
			out.write(new ObjectMapper().writevalueAsString(resultMap));
			out.flush();
			out.close();
		} else {
			//如果携带了正确格式的token要先得到token
			String token = header.replace("Bearer ", "");
			//验证tken是否正确
			Payload payload = JwtUtils.getInfoFromToken(token, prop.getPublicKey(), SysUser.class);
			SysUser user = payload.getUserInfo();
			if(user != null){
				//清除token
				JwtUtils.generateTokenExpireInMinutes(user, prop.getPrivateKey(), 0);
				//响应数据
				responseJson(response);
			}else{
				//如果携带错误的token，则给用户提示请登录！
				response.setContentType("application/json;charset=utf-8");
				response.setStatus(HttpServletResponse.SC_FORBIDDEN);
				PrintWriter out = response.getWriter();
				Map resultMap = new HashMap();
				resultMap.put("code", HttpServletResponse.SC_FORBIDDEN);
				resultMap.put("msg", "token 不正确！");
				out.write(new ObjectMapper().writevalueAsString(resultMap));
				out.flush();
				out.close();
			}
		}

	}

	
	private void responseJson(HttpServletResponse response) {
		try {
			// 退出成功提示
			response.setContentType("application/json;charset=utf-8");
			response.setStatus(HttpServletResponse.SC_FORBIDDEN);
			PrintWriter out = response.getWriter();
			Map map = new HashMap();
			map.put("code", HttpServletResponse.SC_OK);
			map.put("message", "退出成功。请重新登录！");
			out.write(new ObjectMapper().writevalueAsString(map));
			out.flush();
			out.close();
		} catch (Exception e1) {
			e1.printStackTrace();
		}
	}


}

2.3 创建公钥和私钥的类

// 使用 @Configuration或者 启动类上加 @EnableConfigurationProperties(RsaKeyProperties.class)，二选一都可以
// 该类放入IOC容器，推荐使用@EnableConfigurationProperties
//@Configuration
@ConfigurationProperties("rsa.key")
public class RsaKeyProperties {

    private String pubKeyFile;
    private String priKeyFile;

    private PublicKey publicKey;
    private PrivateKey privateKey;

    // 理解bean的生命周期，根据文件创建 PublicKey和PrivateKey对象
    // @PostConstruct  类对象构建完成之后调用
    @PostConstruct
    public void createRsaKey() throws Exception {
        publicKey = RsaUtils.getPublicKey(pubKeyFile);
        privateKey = RsaUtils.getPrivateKey(priKeyFile);
    }

//get、set
}

2.4 创建 Spring Security配置类

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true) // 开启SpringSecurity权限注解
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

	@Autowired
	private SysUserService userService;

	@Autowired
	private RsaKeyProperties prop;

	// 加密对象注入IOC容器
	@Bean
	public BCryptPasswordEncoder passwordEncoder() {
		return new BCryptPasswordEncoder();
	}

	// 指定认证对象的来源
	@Override
	public void configure(AuthenticationManagerBuilder auth) throws Exception {
		auth.userDetailsService(userService).passwordEncoder(passwordEncoder());
	}

	// SpringSecurity配置信息
	@Override
	public void configure(HttpSecurity http) throws Exception {
		http
				// 关闭跨站请求防护
				//.cors().and()
				.csrf().disable()
				.authorizeRequests()
				//.antMatchers("/login").permitAll() //释放这些资源，不拦截
				// 指定拦截规则
				.anyRequest().authenticated() // 其他请求，必须认证通过之后才能访问
				.and()
				.logout()
				// 增加自定义退出处理器
				.logoutSuccessHandler(new JwtLogoutSuccessHandler(prop))
				.and()
				// 增加自定义认证过滤器
				.addFilter(new JwtLoginFilter(super.authenticationManager(), prop))
				// 增加自定义验证认证过滤器
				.addFilter(new JwtVerifyFilter(super.authenticationManager(), prop))
				// 前后端分离是无状态的，不用session了，直接禁用
				.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
	}
}

2.5 application.xml配置文件

注意：指定我们自定义的 RSA生成的 公钥私钥文件。

server:
  port: 18081

# jsp配置
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/security_authority?useUnicode=true;characterEncoding=utf8;useSSL=true;serverTimezone=GMT
    username: root
    password: 123456

# mybatis配置
mybatis:
  configuration:
    map-underscore-to-camel-case: true
  mapper-locations: classpath:mybatis/mapper/*.xml

logging:
  level:
    com.charge.learn.springsecurity.jwt.rsa.parent.sso.dao: debug

# 指定我们自定义的 RSA 公钥私钥文件
rsa:
  key:
    pubKeyFile: D:/rsa_key/rsa.publicKey
    priKeyFile: D:/rsa_key/rsa.key

用户和角色/权限的类和使用数据库认证授权一样。这里简单截几个图。

2.6 启动类

@SpringBootApplication
@MapperScan("com.charge.learn.springsecurity.jwt.rsa.parent.sso.dao")
@EnableConfigurationProperties(RsaKeyProperties.class) // 注入到 IOC容器中
public class SsoServerApplication {

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

3、system模块

system模块：用户、角色的CRUD等。
可以有多个其他的模板，比如订单，产品等，方式都是一样的，这里就用 system模板来实现公钥校验 token。
比较简单，只需要将 SSO中身份校验的代码拿过来即可。记得删除私钥。

3.1 身份校验过滤器

public class JwtVerifyFilter extends BasicAuthenticationFilter {

    private RsaKeyProperties prop;

    public JwtVerifyFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) {
        super(authenticationManager);
        this.prop = prop;
    }

    public void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        String header = request.getHeader("Authorization");
        if (header == null || !header.startsWith("Bearer ")) {
            //如果携带错误的token，则给用户提示请登录！
            chain.doFilter(request, response);
            response.setContentType("application/json;charset=utf-8");
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
            PrintWriter out = response.getWriter();
            Map resultMap = new HashMap();
            resultMap.put("code", HttpServletResponse.SC_FORBIDDEN);
            resultMap.put("msg", "请登录！");
            out.write(new ObjectMapper().writevalueAsString(resultMap));
            out.flush();
            out.close();
        } else {
            //如果携带了正确格式的token要先得到token
            String token = header.replace("Bearer ", "");
            //验证tken是否正确
            Payload payload = JwtUtils.getInfoFromToken(token, prop.getPublicKey(), SysUser.class);
            SysUser user = payload.getUserInfo();
            if(user!=null){
                UsernamePasswordAuthenticationToken authResult = new UsernamePasswordAuthenticationToken(user.getUsername(), null, user.getAuthorities());
                SecurityContextHolder.getContext().setAuthentication(authResult);
                chain.doFilter(request, response);
            }
        }
    }

}

3.2 创建公钥的类

这里使用另一种方式注入。

3.3 创建 Spring Security配置类

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled=true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private RsaKeyProperties prop;

    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    //SpringSecurity配置信息
    public void configure(HttpSecurity http) throws Exception {
        http.csrf()
            .disable()
            .authorizeRequests()
            .antMatchers("/**").hasAnyRole("USER")
            .anyRequest()
            .authenticated()
            .and()
            .addFilter(new JwtVerifyFilter(super.authenticationManager(), prop))
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }
}

3.4 application.xml配置文件

server:
  port: 18082

# jsp配置
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/security_authority?useUnicode=true;characterEncoding=utf8;useSSL=true;serverTimezone=GMT
    username: root
    password: 123456

# mybatis配置
mybatis:
  configuration:
    map-underscore-to-camel-case: true
  mapper-locations: classpath:mybatis/mapper/*.xml

logging:
  level:
    com.charge.learn.springsecurity.jwt.rsa.parent.system.dao: debug

# 指定我们自定义的 RSA 公钥文件
rsa:
  key:
    pubKeyFile: D:/rsa_key/rsa.publicKey

认证登录访问 ok，权限控制开启了注解方式，使用也ok的。

这样就简单实现了 使用 Spring Security来处理 分布式认证服务。

注意：上面也可以完善的，比如将 token放到 Redis中，每次校验都去 Redis中获取数据校验，校验成功记得续期等。

– Stay Hungry, Stay Foolish. 求知若饥，虚心若愚。