OAuth + Security

PS：此文章为系列文章，建议从第一篇开始阅读。

为什么使用JWT令牌

在上面的资源服务器中，通过配置，我们了解到，当我们程序是前后端分离时，在拿着token去获取资源时，程序会先去调用远程认证服务器的端点去验证解析token，这样毫无疑问，当访问量过大的时候，对认证服务器的压力可想而知，所以为了解决上面的问题，我们采用JWT令牌格式，可以优化上面的问题。

令牌采用JWT格式即可解决上边的问题，用户认证通过会得到一个JWT令牌，JWT令牌中已经包括了用户相关的信息，客户端只需要携带JWT访问资源服务，资源服务根据事先约定的算法自行完成令牌校验，无需每次都请求认证服务完成授权。

改造认证服务器

1. 修改TokenConfig类，如下：

@Configuration
public class TokenConfigure {

    private static final String SIGNING_KEY = "dimples";

    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(accessTokenConverter());
    }

    @Bean
    public JwtAccessTokenConverter accessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        //对称秘钥,资源服务器使用该秘钥来验证
        converter.setSigningKey(SIGNING_KEY);
        return converter;
    }


}

2. 修改认证服务器的配置

private TokenStore tokenStore;

private ClientDetailsService clientDetailsService;

private JwtAccessTokenConverter jwtAccessTokenConverter;
//通过构造方法注入
...


/**
 * 令牌管理服务
 *
 * @return TokenServices
 */
@Bean
public AuthorizationServerTokenServices tokenServices() {
    DefaultTokenServices services = new DefaultTokenServices();
    // 客户端详情服务
    services.setClientDetailsService(clientDetailsService);
    // 支持令牌刷新
    services.setSupportRefreshToken(true);
    // 令牌存储策略
    services.setTokenStore(tokenStore);
    
    // 配置令牌增强 JWT
    TokenEnhancerChain tokenEnhancerChain = new TokenEnhancerChain();
    tokenEnhancerChain.setTokenEnhancers(Collections.singletonList(jwtAccessTokenConverter));
    services.setTokenEnhancer(tokenEnhancerChain);
    
    // 令牌默认有效期2小时（如果客户端设置了会覆盖该值）
    services.setAccessTokenValiditySeconds(7200);
    // 刷新令牌默认有效期2天
    services.setRefreshTokenValiditySeconds(259200);
    return services;
}

3. 最后别忘了在pom中添加JWT的依赖，否则项目将会报错

<dependency>
	<groupId>org.springframework.security</groupId>
	<artifactId>spring-security-jwt</artifactId>
	<version>1.1.0.RELEASE</version>
</dependency>

测试结果如下：

可以使用OAuth的/oauth/check_token端点来解析验证一下该token

但是我们需要明白一点的是，这种令牌还是存储在内存中的，后期我们如何将其存储到redis中是我们研究的方向。

改造资源服务器

当我们使用了JWT令牌以后，由于在JWT令牌中我们存储了相应的用户信息和权限，这时我们可以直接在资源服务器中直接去解析对应令牌，就不用每次都去请求认证服务器端点，加大认证服务器的压力，下面我们开始改造资源服务器：

1. 将上面认证服务器中写的TokenConfigure类拷贝一份到资源服务器
2. 在资源服务器中屏蔽调之前的资源服务器令牌解析服务（ tokenService() ）
3. 注入TokenConfigure类，然后配置到ResourceServerSecurityConfigurer里

完整的配置如下：

@Configuration
@EnableResourceServer
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
public class DimplesResourceServerConfigurerAdapter extends ResourceServerConfigurerAdapter {

    public static final String RESOURCE_ID = "dimples";

    private TokenStore tokenStore;
    

    @Autowired
    public DimplesResourceServerConfigurerAdapter(TokenStore tokenStore) {
        this.tokenStore = tokenStore;
    }

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) {
        resources.resourceId(RESOURCE_ID)
                .tokenServices(tokenService())
                .stateless(true);
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                // 配置客户端权限scope
                .antMatchers("/**").access("#oauth2.hasScope('all')")
                .and().csrf().disable()
                // 关闭session
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }

}

然后重启服务，重新获取令牌，然后访问之前的测试接口：

待解决的问题

在此处的JWT的配置中，我们获取的令牌信息还是存在内存中的，这样不利于我们程序的扩展。那么我们如何将生产的令牌去存储到数据库中或者存储到redis中呢？请关注后续的文章。

使用非对称加密

在上面的jwt加密中，我们的JWT签名是写死的字符串，可能我们的项目为了安全考虑，需要使用非对称的加密，我们该怎么配置呢？

首先获取加密文件的私钥和公钥，需要先安装安装OpenSSL工具，参考链接【https://blog.csdn.net/qq_39081974/article/details/81059022】

1. 生成JKS Java KeyStore文件

命令行执行：keytool -genkeypair -alias dimples -keyalg RSA -keypass dimples -keystore dimples.jks -storepass dimples

将生成一个名为medical.jks的文件，其中包含我们的密钥 - 公钥和私钥。 还要确保keypass和storepass是一样的

2. 导出公钥

keytool -list -rfc --keystore dimples.jks | openssl x509 -inform pem -pubkey

或 keytool -importkeystore -srckeystore dimples.jks -destkeystore dimples.jks -deststoretype pkcs12

将其复制到我们的资源服务器 src/main/resources/public.txt 中

3. 配置认证服务器（TokenConfigure）

/**
 * 配置jwt生成token的转换
 * 使用RSA Sign Key 进行加密
 *
 * @return JwtAccessTokenConverter
 */
@Bean
public JwtAccessTokenConverter jwtAccessTokenConverter() {
    KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(new ClassPathResource("medical.jks"), "medical".toCharArray());
    JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
    converter.setKeyPair(keyStoreKeyFactory.getKeyPair("medical"));
    return converter;
}

5. 配置资源服务器（TokenConfigure）

/**
 * 配置jwt生成token的转换
 *
 * @return JwtAccessTokenConverter
 */
@Bean
public JwtAccessTokenConverter accessTokenConverter() {
    JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
    Resource resource = new ClassPathResource("public.txt");
    String publicKey;
    try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(resource.getInputStream()))) {
        publicKey = bufferedReader.lines().collect(Collectors.joining("
"));
    } catch (final IOException e) {
        throw new RuntimeException(e);
    }
    converter.setSigningKey(publicKey);
    return converter;
}

扩展JWT的存储信息

当我们使用如上的配置获取Token后，将access_token中的内容复制到https://jwt.io/网站解析下：

可以看到在jwt中只是保存了我们的user_name，那么我们怎么去扩展呢？让其可以保存我们需要的用户详细信息，这里有两种方案：

• 实现TokenEnhancer（Token增强器）

public class JWTokenEnhancer implements TokenEnhancer {
    @Override
    public OAuth2AccessToken enhance(OAuth2AccessToken oAuth2AccessToken, OAuth2Authentication oAuth2Authentication) {
        Map<String, Object> info = new HashMap<>();
        info.put("other", "hello world");
        ((DefaultOAuth2AccessToken) oAuth2AccessToken).setAdditionalInformation(info);
        return oAuth2AccessToken;
    }
}

然后在TokenConfigure 中配置该Bean：

@Configuration
public class TokenConfigure {
    ......

    @Bean
    public TokenEnhancer tokenEnhancer() {
        return new JWTokenEnhancer();
    }
}

最后在认证服务器里配置该增强器：

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private TokenEnhancer tokenEnhancer;

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) {
        .....
        
        TokenEnhancerChain enhancerChain = new TokenEnhancerChain();
        List<TokenEnhancer> enhancers = new ArrayList<>();
        enhancers.add(tokenEnhancer);
        enhancers.add(jwtAccessTokenConverter);
        enhancerChain.setTokenEnhancers(enhancers);

        endpoints.tokenEnhancer(enhancerChain);
    }
    ......
}

• 扩展username的内容

比如存入json数据内容作为username的内容。相比较而言，方案二比较简单还不用破坏UserDetails的结构

@Override 
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    //登录账号
    System.out.println("username="+username);
    //根据账号去数据库查询...
    UserDto user = userDao.getUserByUsername(username);
    if(user == null){
        return null;
    }
    //查询用户权限
    List<String> permissions = userDao.findPermissionsByUserId(user.getId());
    String[] perarray = new String[permissions.size()];
    permissions.toArray(perarray);
    //创建userDetails
    //这里将user转为json，将整体user存入userDetails
    String principal = JSON.toJSONString(user);
    UserDetails userDetails = User.withUsername(principal).password(user.getPassword()).authorities(perarray).build();
    return userDetails;
}