分布式系统要实现单点登录,通常将认证系统独立抽取出来,并且将用户身份信息存储在单独的存储介质,比如:MySQL、Redis,考虑性能要求,通常存储在Redis中
Java中有很多用户认证的框架都可以实现单点登录:
OAUTH协议为用户资源的授权提供了一个安全的、开放而又简易的标准。同时,任何第三方都可以使用OAUTH认 证服务,任何服务提供商都可以实现自身的OAUTH认证服务,因而OAUTH是开放的
JWT令牌由三部分组成,每部分中间使用点(.)分隔,比如:xxxxx.yyyyy.zzzzz
头部包括令牌的类型(即JWT)及使用的哈希算法(如HMAC SHA256或RSA)
{
"alg": "HS256",
"typ": "JWT"
}
将上边的内容使用Base64Url编码,得到一个字符串就是JWT令牌的第一部分。
第二部分是荷载,内容也是一个json对象,它是存放有效信息的地方,它可以存放jwt提供的现成字段,比 如:iss(签发者),exp(过期时间戳), sub(面向的用户)等,也可自定义字段。
此部分不建议存放敏感信息,因为此部分可以解码还原原始内容。
最后将第二部分负载使用Base64Url编码,得到一个字符串就是JWT令牌的第二部分。
例如
{
"sub": "1234567890",
"name": "张三",
"admin": true
}
第三部分是签名,此部分用于防止jwt内容被篡改。
这个部分使用base64url将前两部分进行编码,编码后使用点(.)连接组成字符串,最后使用header中声明 签名算法进行签名。
secret:签名所使用的密钥。
HMACSHA256(
base64UrlEncode(header) + "." +
base64UrlEncode(payload),
secret)
JWT令牌生成采用非对称加密算法
keytool -genkeypair -alias xiaomanhms -keyalg RSA -keypass xiaomanhms -keystore xiaomanhms.jks -storepass xiaomanhms
openssl是一个加解密工具包,使用openssl来导出公钥信息。
安装 openssl:http://slproweb.com/products/Win32OpenSSL.html
cmd进入xiaomanhms.jks文件所在目录执行如下命令:
keytool -list -rfc --keystore xiaomanhms.jks | openssl x509 -inform pem -pubkey
公钥部分为
-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAighoxR7gI5en9bGiTW/61mENj6Oy4RysI6yO6MTFdFoEpYNJUMxrarfT4baOGuKvFg5iAW6pSDDMzHK7Dy9EeOI2JAETLVC82HwJ2NQNDvzBzJ1mf16V11I+PI+ZbhsiLn3PJsm42Egvgktygf9TTIxd879etJR89vwEnmVSrVwYvhD4e0BkaL0gB0oOs8o431DY6SKPYoAOichdue8uB7gtn4UhvX5dJiCvKByknQTspHHp1Ufdc4obclWnxDv/h0OfRGOYO2itQPm/iKUZBY9VFRxKanG2r+8kCLCFwmRYnng/WkbJRXf+O8gVmftSFCfMlSvPqHzTdGPvz9M90wIDAQAB-----END PUBLIC KEY-----
将上边的公钥拷贝到文本public.key文件中,合并为一行
将hms_user_auth的工程导入到项目中去
然后在父工程pom文件中加入
<module>hms-user-oauth</module>
用私钥加密
/**
* @author cc
* 基于私钥生成jwt
*/
public class CreateJWTTest {
public static void main(String []args) {
// 1 创建秘钥工厂
ClassPathResource classPathResource = new ClassPathResource("xiaomanhms.jks");
// 2 秘钥库密码
String keyPass = "xiaomanhms";
/**
* 1秘钥位置
* 2秘钥库密码
*/
KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(classPathResource, keyPass.toCharArray());
// 2基于工厂拿到私钥
String alias="xiaomanhms";
String password="xiaomanhms";
KeyPair keyPair = keyStoreKeyFactory.getKeyPair(alias, password.toCharArray());
//转化为rsa私钥
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey)keyPair.getPrivate();
// 3生成jwt
Map<String,String> map = new HashMap<>();
map.put("conpany", "hbue");
map.put("address", "wuhan");
Jwt jwt = JwtHelper.encode(JSON.toJSONString(map), new RsaSigner(rsaPrivateKey));
String jwtEncoded = jwt.getEncoded();
System.out.println("jwtEncoded:"+jwtEncoded);
String claims = jwt.getClaims();
System.out.println("claims:"+claims);
}
}
公钥解密
/**
* @author cc
* 解析jwt令牌测试
*/
public class ParseJwtTest {
public static void main(String[] args) {
//基于公钥去解析jwt
String jwt = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJhZGRyZXNzIjoid3VoYW4iLCJjb25wYW55IjoiaGJ1ZSJ9.Zmo4igopc9mKBW4BnbIms4ux4fDq80iV0PvPbwegr9kWT_JP129WCVHn0BkXHTTfMGSmBAwg9XdzvldbWlgTn-IfLPFYfsRFsunwBxMMkqVi4R5IsHczYu-Js2Bg6lZpHwRlbjmyQU0TkzM6bJPnTIxhaxLto7OuLwpSrG27NZUC8BH3BSJPzIp-fzw9NJNrskdt9UWyHcuGmw0dmrFvNKvQ64vQE6_ns0tGHv1vNkkaJdsRbPKVQw-0JpXEbQOVrM3iTdBwbqqXzEkm5fpFEQJzT-SvRkJdRyulvEmS4XL4iO6qzQ3zRLDUoOhV5f3ApUSGfPExtexTcilLTFkiQA";
// 公钥
String publicKey = "-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAighoxR7gI5en9bGiTW/61mENj6Oy4RysI6yO6MTFdFoEpYNJUMxrarfT4baOGuKvFg5iAW6pSDDMzHK7Dy9EeOI2JAETLVC82HwJ2NQNDvzBzJ1mf16V11I+PI+ZbhsiLn3PJsm42Egvgktygf9TTIxd879etJR89vwEnmVSrVwYvhD4e0BkaL0gB0oOs8o431DY6SKPYoAOichdue8uB7gtn4UhvX5dJiCvKByknQTspHHp1Ufdc4obclWnxDv/h0OfRGOYO2itQPm/iKUZBY9VFRxKanG2r+8kCLCFwmRYnng/WkbJRXf+O8gVmftSFCfMlSvPqHzTdGPvz9M90wIDAQAB-----END PUBLIC KEY-----";
//解析令牌
Jwt token = JwtHelper.decodeAndVerify(jwt, new RsaVerifier(publicKey));
//获取负载
String claims = token.getClaims();
System.out.println(claims);
}
}
导入表oauth_client_details
oauth框架必须有的表
CREATE TABLE `oauth_client_details` (
`client_id` varchar(48) NOT NULL COMMENT '客户端ID,主要用于标识对应的应用',
`resource_ids` varchar(256) DEFAULT NULL,
`client_secret` varchar(256) DEFAULT NULL COMMENT '客户端秘钥,BCryptPasswordEncoder加密',
`scope` varchar(256) DEFAULT NULL COMMENT '对应的范围',
`authorized_grant_types` varchar(256) DEFAULT NULL COMMENT '认证模式',
`web_server_redirect_uri` varchar(256) DEFAULT NULL COMMENT '认证后重定向地址',
`authorities` varchar(256) DEFAULT NULL,
`access_token_validity` int(11) DEFAULT NULL COMMENT '令牌有效期',
`refresh_token_validity` int(11) DEFAULT NULL COMMENT '令牌刷新周期',
`additional_information` varchar(4096) DEFAULT NULL,
`autoapprove` varchar(256) DEFAULT NULL,
PRIMARY KEY (`client_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
导入1条初始化数据,其中加密字符明文为xiaoman
INSERT INTO `oauth_client_details` VALUES ('userweb', NULL, '$2a$10$ejwy6rInOvFWF44gAAgpA.iPWNhmVo7WSG98Yvg4lY9gCmVhxkNRa', 'app', 'authorization_code,password,refresh_token,client_credentials', 'http://localhost', NULL, 43200, 43200, NULL, NULL);
OAuth2.0协议一共支持 4 种不同的授权模式:
一般用的比较多的就是 授权码模式
和密码模式
启动hms_user_oauth微服务
浏览器访问
http://localhost:9200/oauth/authorize?client_id=userweb&response_type=code&scop=app&redirect_uri=http://localhost
client_id为username, client_secret为password
登陆后会进入进入授权页面:
点击Authorize,相当于我们微信登录qq音乐扫码后点击确认登陆,接下来返回授权码: 认证服务携带授权码跳转redirect_uri,code=9prf3B就是返回的授权码, 每一个授权码只能使用一次
注意观察:此接口为oauth2提供,项目中没有写controller。
拿到授权码后,申请令牌。
http://localhost:9200/oauth/token
参数
grant_type:授权类型,填写authorization_code,表示授权码模式
code:授权码,就是刚刚获取的授权码,注意:授权码只使用一次就无效了,需要重新申请。
redirect_uri:申请授权码时的跳转url,一定和申请授权码时用的redirect_uri一致。
此链接需要使用 http Basic认证。
什么是http Basic认证?
http协议定义的一种认证方式,将客户端id和客户端密码按照“客户端ID:客户端密码”的格式拼接,并用base64编 码,放在header中请求服务端,一个例子:
Authorization:Basic WGNXZWJBcHA6WGNXZWJBcHA=WGNXZWJBcHA6WGNXZWJBcHA= 是用户名:密码的base64编码。 认证失败服务端返回 401 Unauthorized。
以上测试使用poatman(apifox没成功)完成:
http basic认证:
Get:http://localhost:9200/oauth/check_token?token= [access_token]
刷新令牌是当令牌快过期时重新生成一个令牌,它与授权码授权和密码授权生成令牌不同,刷新令牌不需要授权码 也不需要账号和密码,只需要一个刷新令牌、客户端id和客户端密码。
Post:http://localhost:9200/oauth/token
grant_type: 固定为 refresh_token
refresh_token:刷新令牌
密码模式(Resource Owner Password Credentials)与授权码模式的区别是申请令牌不再使用授权码,而是直接 通过用户名和密码即可申请令牌
http://localhost:9200/oauth/token
此链接需要使用 http Basic认证
资源服务拥有要访问的受保护资源,客户端携带令牌访问资源服务,如果令牌合法则可成功访问资源服务中的资源,如下图:
1、配置公钥 ,将 hms_user_auth 项目中public.key复制到hms_service_user中
2、添加依赖
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-oauth2artifactId>
dependency>
3、配置每个系统的Http请求路径安全控制策略以及读取公钥信息识别令牌
@Configuration
@EnableResourceServer
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)//激活方法上的PreAuthorize注解
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
/**
* 公钥
*/
private static final String PUBLIC_KEY = "public.key";
/***
* 定义JwtTokenStore
* @param jwtAccessTokenConverter
* @return
*/
@Bean
public TokenStore tokenStore(JwtAccessTokenConverter jwtAccessTokenConverter) {
return new JwtTokenStore(jwtAccessTokenConverter);
}
/***
* 定义JJwtAccessTokenConverter
* @return
*/
@Bean
public JwtAccessTokenConverter jwtAccessTokenConverter() {
JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
converter.setVerifierKey(getPubKey());
return converter;
}
/**
* 获取非对称加密公钥 Key
* @return 公钥 Key
*/
private String getPubKey() {
Resource resource = new ClassPathResource(PUBLIC_KEY);
try {
InputStreamReader inputStreamReader = new InputStreamReader(resource.getInputStream());
BufferedReader br = new BufferedReader(inputStreamReader);
return br.lines().collect(Collectors.joining("\n"));
} catch (IOException ioe) {
return null;
}
}
/***
* Http安全配置,对每个到达系统的http请求链接进行校验
* @param http
* @throws Exception
*/
@Override
public void configure(HttpSecurity http) throws Exception {
//所有请求必须认证通过
http.authorizeRequests()
//下边的路径放行
.antMatchers(
"/user/add","/user/load/**"). //配置地址放行
permitAll()
.anyRequest().
authenticated(); //其他地址需要认证授权
}
}
启动user微服务
1.不携带令牌访问 http://localhost:9101/user/userList
2.携带令牌访问 http://localhost:9101/user/userList
在http header中添加 Authorization: Bearer 令牌 (注意,Bearer和令牌中间要加空格)
执行流程:
1登陆:认证服务认证通过,生成jwt令牌,将jwt,jti及相关信息写入Redis,并且将jti写入cookie
2访问:用户访问资源页面,带着cookie到网关,网关从cookie获取jti,并查询Redis校验token,如果token不存在则拒绝访问,否则放行
3退出:请求认证服务,清除redis中的token,并且删除cookie中的token
使用redis存储用户的身份令牌有以下作用:
思考:难到每次用户请求登录,我们每次用postman 发请求获取令牌吗?
所以,我们要在oauth微服务使用代码申请令牌
可以在hms_user_oauth 写controller, service,自己调用oauth接口
RestTemplate 配置
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
写测试类
@SpringBootTest(classes = OauthApplication.class)
@RunWith(SpringRunner.class)
public class ApplyTokenTest {
@Autowired
private RestTemplate restTemplate;
@Autowired
private LoadBalancerClient loadBalancerClient;
@Test
public void applyTokenTest() {
// 1 url
// String url = "http://localhost:9200/oauth/token"; //不要写死,要部署多个服务
ServiceInstance serviceInstance = loadBalancerClient.choose("user_auth");
URI uri = serviceInstance.getUri(); //http://localhost:9200
String url=uri+"/oauth/token";
// 2 请求头
// 2.1 请求头
MultiValueMap<String, String> headers=new LinkedMultiValueMap<>();
headers.add("Authorization", getHttpHeaders("userweb","xiaoman"));
// 2.2 请求体
MultiValueMap<String, String> body=new LinkedMultiValueMap<>();
body.add("grant_type","password");
body.add("username","userweb");
body.add("password","xiaoman");
// 400 401 不报错,返回回来
restTemplate.setErrorHandler(new DefaultResponseErrorHandler(){
//响应当中有错误 如何处理
@Override
public void handleError(URI url, HttpMethod method, ClientHttpResponse response) throws IOException {
if(response.getRawStatusCode() != 400 && response.getRawStatusCode()!= 401){
super.handleError(url,method,response);
}
}
});
HttpEntity<MultiValueMap<String, String>> requestEntity=new HttpEntity<>(body,headers);
//3发请求
ResponseEntity<Map> exchange = restTemplate.exchange(url, HttpMethod.POST, requestEntity, Map.class);
//4请求中 拿数据
Map body1 = exchange.getBody();
System.out.println(body1);
}
//请求头中Authorization值的计算方法
public String getHttpHeaders(String clientId, String clientSecret){
//Basic base64(客户端名称:客户端密码)
String str = clientId + ":" + clientSecret;
byte[] encode = Base64Utils.encode(str.getBytes());
return "Basic "+ new String(encode);
}
}
当前在认证服务中,用户密码是写死在用户认证类中。所以用户登录时,无论帐号输入什么,只要密码是xiaoman都可以访问。因此需要动态获取用户帐号与密码.
@GetMapping("findByAccount/{account}")
public Result<User> findByAccount(@PathVariable("account") String account) {
User user = userService.findByAccount(account);
return Result.success("查询成功", user);
}
@FeignClient("user")
public interface UserFeign {
/**
* 根据账号查询用户
* @param account
* @return
*/
@GetMapping("user/findByAccount/{account}")
public Result<User> findByAccount(@PathVariable("account") String account);
}
<dependency>
<groupId>com.wanggroupId>
<artifactId>hms_service_user_apiartifactId>
<version>1.0-SNAPSHOTversion>
dependency>
@EnableFeignClients(basePackages = {"com.wang.feign"})
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
@Autowired
private ClientDetailsService clientDetailsService;
@Autowired
private UserFeign userFeign;
/****
* 自定义授权认证
* @param username
* @return
* @throws UsernameNotFoundException
*/
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//取出身份,如果身份为空说明没有认证
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
//没有认证统一采用httpbasic认证,httpbasic中存储了client_id和client_secret,开始认证client_id和client_secret
if(authentication==null){
ClientDetails clientDetails = clientDetailsService.loadClientByClientId(username);
if(clientDetails!=null){
//秘钥
String clientSecret = clientDetails.getClientSecret();
//静态方式
//return new User(username,new BCryptPasswordEncoder().encode(clientSecret), AuthorityUtils.commaSeparatedStringToAuthorityList(""));
// 数据库查找方式
return new User(username,clientSecret, AuthorityUtils.commaSeparatedStringToAuthorityList(""));
}
}
if (StringUtils.isEmpty(username)) {
return null;
}
//根据用户名查询用户信息
com.wang.entity.User user = userFeign.findByAccount(username);
//创建User对象
String permissions = "goods_list,seckill_list";
UserJwt userDetails = new UserJwt(username, user.getPassword(), AuthorityUtils.commaSeparatedStringToAuthorityList(permissions));
return userDetails;
}
}
/user/findByAccount接口放行
为什么有系统网关还要web网关呢?
系统网关是让别的系统调用我的系统,比如引流,web网关是用户调用
依赖
<dependencies>
<dependency>
<groupId>io.jsonwebtokengroupId>
<artifactId>jjwtartifactId>
<version>0.9.0version>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-data-redis-reactiveartifactId>
dependency>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-gatewayartifactId>
dependency>
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
dependency>
<dependency>
<groupId>com.wanggroupId>
<artifactId>hms_commonartifactId>
<version>1.0-SNAPSHOTversion>
<exclusions>
<exclusion>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
exclusion>
exclusions>
dependency>
dependencies>
配置文件
server:
port: 11000
spring:
application:
name: webgatway
cloud:
nacos:
server-addr: localhost:8848
gateway:
routes: # 网关路由配置
- id: hospital # 路由id,自定义,只要唯一即可
uri: lb://hospital # 路由的目标地址 lb就是负载均衡,后面跟服务名称
predicates: # 路由断言,也就是判断请求是否符合路由规则的条件
- Path=/hosp/** # 这个是按照路径匹配,只要以/hosp/开头就符合要求
filters:
# - StripPrefix=1
- name: RequestRateLimiter #请求数限流 名字不能随便写
args:
key-resolver: "#{@ipKeyResolver}" # 取ipKeyResolver对象
redis-rate-limiter.replenishRate: 1 #令牌桶每秒填充平均速率
redis-rate-limiter.burstCapacity: 1 #令牌桶总容量
- id: user
uri: lb://user
predicates:
- Path=/user/**
filters:
- name: RequestRateLimiter
args:
key-resolver: "#{@ipKeyResolver}" # 取ipKeyResolver对象
redis-rate-limiter.replenishRate: 1 #令牌桶每秒填充平均速率
redis-rate-limiter.burstCapacity: 1 #令牌桶总容量
# 在gateway解决跨域问题,不用在controller加@CrossOrigin 注解
globalcors:
cors-configurations:
'[/**]': # 匹配所有请求
allowedOrigins: "*" #跨域处理 允许所有的域
allowedMethods: # 支持的方法
- GET
- POST
- PUT
- DELETE
redis:
host: localhost
port: 9736
登陆时:放行
用户访问时:
1)判断当前请求是否为登录请求,是的话,则放行
2 ) 判断cookie中是否存在信息, 没有的话,拒绝访问
3)判断redis中令牌是否存在,没有的话,拒绝访问
/**
* @author xiaoman
*/
@Component
public class AuthFilter implements GlobalFilter, Ordered {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
ServerHttpRequest request = exchange.getRequest();
ServerHttpResponse response = exchange.getResponse();
String path = request.getURI().getPath();
if(path.endsWith("/oauth/login")) {
return chain.filter(exchange);
}
// 判断cookie中有没有jti
HttpCookie cookie = request.getCookies().getFirst("jti");
if(cookie == null) {
response.setStatusCode(HttpStatus.UNAUTHORIZED);
return response.setComplete();
}
String jti = cookie.getValue();
String jwt = stringRedisTemplate.boundValueOps(jti).get();
if(StringUtils.isEmpty(jwt)){
//拒绝访问
response.setStatusCode(HttpStatus.UNAUTHORIZED);
return response.setComplete();
}
// 对当前请求增强,让其携带令牌信息(转发)
request.mutate().header("Authorization", "Bearer " + jwt);
return chain.filter(exchange);
}
@Override
public int getOrder() {
return 0;
}
}
启动gatewayweb
测试登录:http://localhost:11000/api/oauth/login
测试查询用户:http://localhost:11000/api/user/userList
查询成功,查看cookie中有jti