登录认证
# JWT
给 WebSocket 连接添加 JWT 认证,参考:websocket 之四:WebSocket 的鉴权授权方案 - duanxz - 博客园 (cnblogs.com) (opens new window)
# Web 认证概述
Cookie → Session → Token
本质上都是字段的校验
- Cookie 是服务端生成信息,客户端存储信息,服务端单向校验字段
- Session 是服务端存储信息,客户端仅存储 SessionId,通过服务端维护会话来实现认证
- Token 是无状态登录,由服务端生成令牌,客户端存储加密信息,服务端不存储,而只对加密信息认证
这么来看,Token 更像是一个使用了加密认证技术的 Cookie,Cookie 由于不加密,客户端可以伪造字段骗取服务器权限,但由于 Token 是服务器加密生成,天然对这个字段有校验权限,并且由于加密,客户端无法伪造
# Json Web Token
JWT 是一种基于 JSON 的 Token 认证方式,其核心特征是无状态,服务器不需要存储用户的会话信息,而是将所有必要的信息封装在 Token(令牌)里,让客户端在每次请求时携带,从而实现身份认证,其特点如下
- 无状态认证:服务器不需要存储 Token,每次请求独立验证用户身份
- 跨平台:JSON 格式通用性
- 安全:JWT 可加密和签名
- 高效:减少后端查询 Session
无状态登录导致,服务器端不需要存储会话 Session,这避免了分布式场景下用户会话丢失的情况
例如:登陆时请求打在服务器
- 登录信息故而存在服务器 a,而后续请求却被分流在服务器 b
- 如果用传统 Session,服务器 b 就会因为没有登录信息导致权限错误
一个朴素的解决方案:用 Redis 做分布式处理,把所有 Session 统一存在一个 Redis 里
而 JWT 其实是把认证逻辑放在了后端,而不使用 session 做校验
# JWT 鉴权应用
WebSocket 是基于 HTTP 的协议(而 HTTP 基于 TCP,有时我们也说 WebSocket 基于 TCP 协议),HTTP 有诸多缺点,如
- 不支持异步请求,解决方案如 Ajax
- 服务端无法进行主动推送,可使用 Comet 对请求进行挂起,延迟推送,这样客户端不需要忙等(但实际上服务端做了忙等的工作),常见的解决方案有 WS、SSE
- 本身无状态,每个 HTTP 连接无法对用户进行识别,需要服务端维护用户 Session,同时用户在本地 Cookie 中存储 SessionID,进行状态维护
- 安全方面欠缺,其明文封装在 TCP 报文中传输,解决方案是 HTTPS,通过在 HTTP 外层再套一层 TSL 协议,实现数据加密、身份验证、完整性验证,其中身份验证通过证书实现,完整性验证通过数字签名实现,证书的可信通过证书链实现
为了实现异步请求和服务端推送的功能,出现了 WebSocket 这样的全双工异步通信的协议,由于 WebSocket 基于 HTTP,他天然的继承了这些个 HTTP 的部分“缺点”如 3 和 4
WebSocket 协议的 RFC(Request For Comment) 提到,可以使用例如 Cookies、HTTP auth 或 TLS auth 来进行鉴权,在这使用 JWT 对 WebSocket 连接进行权限认证
首先实现一个简单的 WebSocket 服务器,在 Java 后端引入依赖
<!--WebSocket-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
2
3
4
5
在 Spring 主类上启动 WebSocket 服务
@SpringBootApplication
@MapperScan("com.northboat.bearchat.mapper")
@EnableWebSocket
public class BearChatApplication {
public static void main(String[] args) {
SpringApplication.run(BearChatApplication.class, args);
}
}
2
3
4
5
6
7
8
9
10
WebSocket 服务器
onlineCount变量是static的,一开始使用了synchronized来修改计数,这在高并发情况下可能仍然存在竞争问题,后使用AtomicInteger代替- 一开始采用
CopyOnWriteArraySet<WebSocketServer>去存放 WS 连接,后改成ConcurrentHashMap<String, WebSocketServer>,一是提高了查询效率O(1),二是避免了CopyOnWriteArraySet在高并发下的性能瓶颈
@Component
@Slf4j
@Service
@ServerEndpoint("/chat/{sid}")
public class WebSocketServer {
//静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。
private static final AtomicInteger onlineCount = new AtomicInteger(0);
//concurrent包的线程安全Set,用来存放每个客户端对应的MyWebSocket对象。
private static final ConcurrentHashMap<String, WebSocketServer> webSocketMap = new ConcurrentHashMap<>();
//与某个客户端的连接会话,需要通过它来给客户端发送数据
private Session session;
//接收sid
private String sid = "";
/**
* 连接建立成功调用的方法
*/
@OnOpen
public void onOpen(Session session, @PathParam("sid") String sid) {
this.session = session;
this.sid = sid;
webSocketMap.put(sid, this); //加入set中
addOnlineCount(); //在线数加1
try {
sendMessage("Connection Test Message");
log.info("有新窗口开始监听:" + sid + ", 当前总共在线人数为:" + getOnlineCount());
} catch (IOException e) {
log.error("websocket IO Exception");
}
}
/**
* 连接关闭调用的方法
*/
@OnClose
public void onClose() {
webSocketMap.remove(this.sid); //从set中删除
subOnlineCount(); //在线数减1
//断开连接情况下,更新主板占用情况为释放
log.info("释放的sid为:" + sid);
//这里写你 释放的时候,要处理的业务
log.info("有一连接关闭!当前在线人数为" + getOnlineCount());
}
/**
* 收到客户端消息后调用的方法
* @ Param message 客户端发送过来的消息
*/
// 全双工通信,服务器接收到客户端的消息后进行处理,可以是分发,可以是其他
// 这里是将信息发送给 sid 相同的所有连接
@OnMessage
public void onMessage(String message, Session session) {
log.info("收到来自窗口 " + sid + " 的信息:" + message);
//群发消息
try {
webSocketMap.get(sid).sendMessage(message);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* @ Param session
* @ Param error
*/
@OnError
public void onError(Session session, Throwable error) {
log.error("发生错误");
error.printStackTrace();
try {
session.close();
} catch (IOException e) {
log.error("关闭 WebSocket 失败", e);
}
}
/**
* 实现服务器主动推送
*/
public void sendMessage(String message) throws IOException {
this.session.getBasicRemote().sendText(message);
}
/**
* 群发自定义消息
*/
public static void sendInfo(String message, @PathParam("sid") String sid) throws IOException {
log.info("推送消息到窗口" + sid + ",推送内容:" + message);
//这里可以设定只推送给这个sid的,为null则全部推送
webSocketMap.values().forEach(item -> {
if (sid == null || item.sid.equals(sid)) {
try {
item.sendMessage(message);
} catch (IOException e) {
log.error("消息推送失败: {}", e.getMessage());
}
}
});
}
public static synchronized int getOnlineCount() {
return onlineCount;
}
public static synchronized void addOnlineCount() {
onlineCount.incrementAndGet();
}
public static synchronized void subOnlineCount() {
onlineCount.decrementAndGet();
}
public static CopyOnWriteArraySet<WebSocketServer> getWebSocketSet() {
return webSocketMap.valueSet();
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
JS 前端:简单的前端页面和朴实无华的 JS
<h2 class="major">共有<strong th:text="${count}"></strong>人在公共聊天室</h2>
<p id="user" th:text="${name}" style="display: none"></p>
<p id="login" th:text="${login}" style="display: none"></p>
<p id="room" th:text="${room}" style="display: none"></p>
<script>
let user = document.getElementById("user").innerText;
let login = document.getElementById("login").innerText;
console.log(name);
// 连接 websocket 服务器
let websocket = null;
let room = document.getElementById("room").innerText;
//判断当前浏览器是否支持WebSocket
if(room === "null"){
throw SyntaxError();
} else if('WebSocket' in window) {
//改成你的地址http
websocket = new WebSocket("ws://fx35xt.natappfree.cc/chat/"+room);
} else {
alert('当前浏览器 Not support websocket')
}
//连接发生错误的回调方法
websocket.onerror = function() {
setMessageInnerHTML("WebSocket 连接发生错误");
};
//连接成功建立的回调方法
websocket.onopen = function() {
setMessageInnerHTML("WebSocket 连接成功");
}
//let U01data, Uidata, Usdata;
//接收到消息的回调方法
websocket.onmessage = function(event) {
console.log(event);
setMessageInnerHTML(event.data);
//setechart()
}
//连接关闭的回调方法
websocket.onclose = function() {
setMessageInnerHTML("WebSocket 连接关闭");
}
//监听窗口关闭事件,当窗口关闭时,主动去关闭websocket连接,防止连接还没断开就关闭窗口,server端会抛异常。
window.onbeforeunload = function() {
closeWebSocket();
}
//将消息显示在网页上
function setMessageInnerHTML(innerHTML) {
while(innerHTML.length > 32){
document.getElementById('message').innerHTML += innerHTML.substring(0, 32) + '<br/>';
innerHTML = innerHTML.substring(32);
}
document.getElementById('message').innerHTML += innerHTML + '<br/><br/>';
}
//关闭WebSocket连接
function closeWebSocket() {
websocket.close();
}
//发送消息
function send() {
let message = document.getElementById('text').value;
if (message.length > 200) {
alert("消息过长,请限制在 200 字符以内!");
return;
}
websocket.send(message);
document.getElementById("text").value = "";
}
</script>
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
直接用 hutool 的 jwt 接口:Hutool (opens new window)
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.38</version>
</dependency>
2
3
4
5
创建 Token 和验证 Token
private final String key = "1234567";
private String createToken(Map<String, Object> map){
return JWTUtil.createToken(map, key.getBytes());
}
private boolean verify(String token){
return JWTUtil.verify(token, key.getBytes());
}
2
3
4
5
6
7
8
9
用户登录时,将用户信息打包为 map,生成 jwt 返回并存储在用户浏览器本地
给 WS 服务端添加 JWT 验证:修改请求路径,要求传入 token 并在 onOpen 函数中进行认证
@Component
@Slf4j
@Service
@ServerEndpoint("/chat/{sid}/{token}") // URL 里添加 token 参数
public class WebSocketServer {
// 存放所有连接的 WebSocket 实例(key = sid)
private static final Map<String, WebSocketServer> webSocketMap = new ConcurrentHashMap<>();
private Session session;
private String sid = "";
/**
* 校验 token
*/
private boolean isValidToken(String token, String sid) {
// 若为空直接返回 0
if (!StringUtils.hasText(token)) {
return false;
}
// 这里调用你的 JWT 解析方法,校验 token 是否正确
return JwtUtil.verifyToken(token, sid);
}
/**
* WebSocket 连接建立时触发
*/
@OnOpen
public void onOpen(Session session, @PathParam("sid") String sid, @PathParam("token") String token) {
log.info("尝试建立 WebSocket 连接:sid={},token={}", sid, token);
// 认证 token
if (!isValidToken(token, sid)) {
log.warn("认证失败,拒绝连接:sid={}", sid);
try {
session.close(new CloseReason(CloseReason.CloseCodes.VIOLATED_POLICY, "认证失败"));
} catch (IOException e) {
log.error("关闭连接失败", e);
}
return;
}
this.session = session;
this.sid = sid;
// 维护连接
webSocketMap.put(sid, this);
try {
sendMessage("连接成功,认证通过!");
log.info("WebSocket 连接建立成功:sid={},当前在线人数={}", sid, webSocketMap.size());
} catch (IOException e) {
log.error("WebSocket 发送消息失败", e);
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
前端 WS 客户端打请求时传入 JWT 字段即可
let token = localStorage.getItem("token"); // 这个 token 登录时获取并存入 localStorage
let room = document.getElementById("room").innerText;
let websocket = new WebSocket(`ws://localhost:8080/chat/${room}/${token}`);
2
3
# JWT 撤销问题
我们说,JWT 是无状态的,服务器并不存放 JWT 任何信息,全部的有效信息,包括生效时间、权限等等都加密存放在用户本地
如果有这样一种情况,用户操作完成后,想要退出登录,销毁当前本地机上的那份 JWT 权限,如何做到呢?答案是做不到
在 JWT 的鉴权中,服务端只是一个算法工具,只提供 verify 功能,不管用户本地如何“撤销”,只要 JWT 还是那个 Token,他就始终能通过服务器的检测,所以要实现这样的业务需求,就只能在后端加一个 JWT 的存储,例如存在 Redis 里
{ jwt:id:{token}, jwt_content }
然后在用户登出时,把这个键值对删了,这样用户下次再用这个 JWT,就会因为通不过 Redis 的检测拒绝登录
那么问题又来了,我 TM 都存了 Redis,为什么不直接存 SessionID 呢?这不脱裤子放屁吗,综上,其实 JWT 的应用场景十分有限
# 2FA
# 2FA 概述
2FA,Two-Factor Authentication,即双因素认证
- 传统的账号密码为单重认证,如 QQ 的登录;Stream 的登录则为双因素,一重为账号密码,二为手机接收的认证码短信
密码 + 某种个人物品是常见的双因素组合,如银行使用的 U 盾(一个 U 盘),在此处 U 盾 充当“某种个人物品”的作用,每位用户将配备各自的 U 盾,内置有用户的签名证书与加密证书,同时 U 盾的访问受 PIN 码保护
一种典型实现方案为
- 用户在完成口令、验证码的输入后,前端调用 USBKEY 的接口对登录请求数据进行签名,并且将该签名作为一个字段加入 HTTP 请求中
- 后端系统会部署一个签名验签服务器,接收到前端登录请求后,利用签名验签服务器完成验签,验签正确则身份鉴别通过,而后再进行密码的认证,实现双因素认证
奥联的 USBKEY 以及其相对应的密码机实现 U 盾的 2FA 认证,真的不得不说,奥联给的接口简直是一坨大芬🤮,文档更是牛头不对马嘴
一些前置工作
- 在后端签名验签服务器中注册用户 UKey 中所使用的签名证书
- 下载安装 UKEY 的插件环境(我不想说有多屎)
- 需要一个倒霉蛋将 U 盘从西安邮到秦皇岛
# UKey + Pwd
前端通过 Websocket 和 Ukey 交互实现签名,这里 UKey 接收一个 PIN 码和签名格式,通过异步回调的方式返回一份签名
插入 U 盘后,通过检测环境获取 UKey 的明文信息keyindex, container
核心在于一条加密函数
ntlsUtil.func.data_sm2_signature(ukey_val, identity_val, pass, inData, hashtype, format, this.doLogin);
其中ukey_val和identity_val为即为keyindex和container,pass为 UKEY 的 PIN 码,format是签名的格式,inData为登陆的表单原文(Json 数据),如
"{\"account\":\"wx\", \"password\":\"123456\", \"verify_code\":\"dQ3k\", \"PIN\":\"123456\"}"
this.doLogin为签名成功的回调函数,具体如下
// 打请求
doLogin(message){
if(!message || !message.data){
alert("签名失败, 请检查UKey是否插入或PIN码是否正确, 或PIN码是否被锁定");
this.loading = false;
return false;
}
console.log("签名所用证书为: " + this.cert + "\n前端签名原文为" + this.encodeBase64(this.loginForm.iniData) + "\n前端签名所得密文为: " + message.data)
this.loginForm.signature = message.data;
this.$store.dispatch('user/login', this.loginForm).then(() => {
localStorage.setItem("pin", this.loginForm.key);
localStorage.setItem("keyindex", this.keyindex);
localStorage.setItem("container", this.container);
this.$router.push({ path: this.redirect || '/' })
this.loading = false
}).catch(() => {
this.loading = false
})
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
传入的message为待签名数据,这份数据必须是 Base64 编码,并且在签名时,必须要规定传参format为asn.1,才能签名得到 Base64 编码的密文,什么狗屎
后端验签接受一个 User 对象
public class User {
@JsonSerialize(using = ToStringSerializer.class)
private Long id;
private String username;
private String password;
private String avatar;
private String email;
private Integer gender;
private Integer age;
private Integer role;
private Integer status;
private Integer code;
private String salt;
private Integer deleted;
private String certificate;
private String idCard;
private String payPassword;
private Date gmtCreate;
private Date gmtModified;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
对 user 的签名内容 inData 和 signature 进行验证
@Override
public String doLogin(LoginInfoDTO user) {
User uu = userMapper.findByName(user.getUsername());
String cert = uu.getCertificate();
String iniData = user.getIniData();
String signData = user.getSignature();
System.out.println("iniData: " + iniData);
System.out.println("signature: " + signData);
boolean flag = OlymSignature.verifySignature(cert, iniData, signData);
if(flag)
return doLogin(user.getUsername(), user.getPassword());
else
return null;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
verifySignature 实际上是一个对密码机的 HTTP 请求
public static boolean verify(String cert, String inData, String signature) throws Exception {
if(cert == null){
cert = Cert;
}
byte[] signerIDBytes = SignerID.getBytes();
Integer signerIDLen = signerIDBytes.length;
String signerID = Base64.getEncoder().encodeToString(signerIDBytes);
byte[] inDataBytes = inData.getBytes();
Integer inDataLen = inDataBytes.length;
System.out.println(inDataLen);
inData = Base64.getEncoder().encodeToString(inDataBytes);
System.out.println("验签所使用的证书为: " + cert);
System.out.println("验签所使用的原文为: " + inData);
System.out.println("验签所使用的签名密文为: " + signature);
System.out.println("验签所使用的签名ID为: " + signerID);
VerifySignedDataReq verifySignedDataReq = new VerifySignedDataReq();
verifySignedDataReq.setSignMethod(SGD_SM3_SM2);
verifySignedDataReq.setType(Type);
verifySignedDataReq.setCert(cert);
// Type为1时certSN没用,将使用cert
verifySignedDataReq.setInData(inData);
verifySignedDataReq.setInDataLen(inDataLen);
// 这个ID默认为"1234567812345678"
verifySignedDataReq.setSignerID(signerID);
verifySignedDataReq.setSignerIDLen(signerIDLen);
verifySignedDataReq.setSignature(signature);
verifySignedDataReq.setVerifyLevel(VerifyLevel);
System.out.println(verifySignedDataReq);
Integer verifySignedDataResult = SignVerifyUtil.verifySignedData(verifySignedDataReq);
System.out.println(
"单包验证数字签名结果:" + Objects.equals(SVSRESPONSE_RESPVALUE_SUCCESS, verifySignedDataResult));
return SignVerifyUtil.verifySignedData(verifySignedDataReq) == 0;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
非常垃圾的实现,通过签名验证之后,再对用户密码做一个比对,实现 2FA
# TOTP
GitHub 的 2FA 方案,参考:双因素认证(2FA)教程 - 阮一峰的网络日志 (ruanyifeng.com) (opens new window)
TOTP(Time-based One-time Password),基于时间的一次性口令,这是一种安全性高于密码 + 手机验证码的公认 2FA 可靠解决方案(因为 Sim 卡可伪造),已写入国际标准 RFC6238 (opens new window)
GitHub 在 23 年启用了 TOTP 的 2FA 登录,其核心原理基于对时间戳进行哈希实现,具体而言
- 用户和服务器协商好一份统一的密钥 key
- 用户本地采用一个计时程序,每 t 秒生成一串定长的短验证码,验证码的生成公式为
,其中,time 为当前时间戳,key 为协商好的密钥 - 在登陆时,系统要求用户输入当前的验证码 H1,后端接收到该登录请求后,将在后端根据当前时间和用户的密钥生成一份验证码 H2
- 将用户输入的 H1 和后端生成的 H2 作比较,若一致则通过认证,否则拒绝
考虑到网络延迟和计算延迟,时间 time 该如何统一呢?
- 其实很简单,通过除法向下取整的方式
- 举个简单的例子:95 和 107 在除以 30 并且向下取整时,得到的结果均为 3
对于每个时间戳,减去 1970.1.1 日的初始时间得到的时间间隔(以秒为单位),而后除以 30 并取整,则在同一个 30s 内能够得到相同的 time
具体认证过程
- 接受用户传参(用户名、密码哈希和哈希值),先与数据库中密码 password 进行比对,若不一致则返回状态 2(密码错误),若一致继续第二因素认证
- 通过 username 读数据库取出私钥 Key,对以下数据进行签名
,30s 是登录码的刷新频率 - 将传入的 Hash 与 Hash' 比对,若不一样,则返回状态 3(哈希错误),若一样,则返回状态 1(认证成功)
这里的 TC 计算是 TOTP 算法的精髓:本地计算 TC 后,将请求打到服务器,服务器会立马计算当前时间戳对应的 TC',由于向下取整的关系,在 30s 内,本地生成的 TC 和服务器的 TC' 将会保持一致,于是最后生成的哈希值将会一致(在私钥一致的前提下)
当然本地和服务器的时间需要是同步的,同时会有少许的网络延迟
# SSO
Single Sign On 单点登录
如何实现一个单点登录,使一个用户登陆一次便可访问所有的百度产品,如何设计跨域登陆状态同步和等处逻辑,以及如何避免状态不一致,This is a question
基本思路为
- 统一认证中心
- ticket 机制,一次性 ticket 验证
- 顶级域 cookie 共享
- Redis 存 sso session
- 单点注销回调所有 logout API
- 定期 SSO 校验与本地 Session 同步
# SSO 架构设计
核心是一个 统一认证中心(Auth Server)
+------------------+
| Auth Server |
| (login.baidu) |
+------------------+
/ \
/ \
+------------+ +------------+
| pan.baidu | | tieba.baidu|
+------------+ +------------+
\ /
\ /
用户浏览器
2
3
4
5
6
7
8
9
10
11
12
认证中心负责
- 用户登录
- 生成登录凭证
- 管理 Session
例如
https://login.baidu.com
而业务系统,例如
pan.baidu.com
tieba.baidu.com
wenku.baidu.com
2
3
不做登录,只负责校验凭证
# Session 建立
# SSO Session
第一步,用户访问业务系统
https://pan.baidu.com
发现没有登录,重定向到认证中心
redirect → login.baidu.com
并且带上回调地址
https://login.baidu.com/login?service=https://pan.baidu.com
用户在认证中心登录,输入
username
password
2
认证成功后,认证中心创建 SSO Session
sso_session_id = abc123
可以直接存储 Redis HMap 中
Redis {
authserver:session {
sso_session_id: user_info
}
}
2
3
4
5
然后返回浏览器 SSO Cookie,令其 Domain 为一级域名
Set-Cookie:
SSO_SESSION=abc123
Domain=.baidu.com
2
3
这样业务系统都能使用这个 SSO Session ID
pan.baidu.com
tieba.baidu.com
wenku.baidu.com
2
3
# 业务 Session
在上一步,用户通过了认证中心的登录,服务器会返回一个 SSO Session ID,同时将生成并返回一个一次性的 ticket,该凭证用于当前系统的认证,存储在 Redis HMap 中
redis {
auth:ticket{
ticket_content: user_info
}
}
2
3
4
5
因为用户通过业务系统https://pan.baidu.com,所以第一次访问认证中心,认证中心的重定向将会是
https://pan.baidu.com?ticket=ST-xxx
而后业务系统拿着这个 ticket 去请求认证中心
POST /validate
ticket=ST-xxx
2
认证中心若通过,则返回 Redis HMap 中存的用户信息user_info,返回业务系统
{
user_id: 10001,
username: xxx
}
2
3
4
而后业务系统建立本地 Session,至此一次登录完成
pan_session = abc123
然后只要访问其他子域名网站,浏览器携带 SSO Session ID 的顶级域名的 Cookie SSO Session ID 会被业务系统识别,然后再走一次认证中心生成 ticket,业务系统重定向 ticket 生成本地 Session 登录的流程
这里需要注意 ticket 的生命周期,这是一个很短的过程,可能 30s,认证成功之后就在 HMap 中删除 ticket
生成 ticket
↓
redirect 到业务系统
↓
业务系统 validate
↓
ticket 删除
2
3
4
5
6
7
# logout 统一登出
一种靠前端实现,在某一页面登出时,直接广播所有子网站,触发其 /logout 逻辑
<iframe src="https://pan.baidu.com/logout"></iframe>
<iframe src="https://tieba.baidu.com/logout"></iframe>
<iframe src="https://wenku.baidu.com/logout"></iframe>
2
3
另一种就是后端通知,认证中心记录当前 SSO Session ID 登陆过的所有网站,然后在注销时,回调每个系统的 logout API,实现注销
如何保证状态一致?
主要是一个过期时间的问题,因为在认证中心会有一份 SSO Session,在业务系统也会有各自的本地 Session,按道理来说,如果 SSO Session 过期,所有的本地 Session 都应该过期
一个简单的解决办法:设置短时效的本地 Session + 定期检查 SSO Session ,例如每十分钟校验一次 SSO Session
# Kerberos SSO
Kerberos 是一套网络认证协议,支持无密码传输、票据认证、域内一次登录全系统通行,是 Windows 域、AD、Hadoop、Kafka、Elasticsearch 等最主流的安全 SSO 方案
其思路和上述流程类似,其实相对于复杂的密码学,这是一个相对简易的工程系统
在 Kerberos 中,有三种角色,分别是
- Client:用户 / 浏览器 / 应用
- KDC(Key Distribution Center) 密钥分发中心,包括
- AS(Authentication Service)认证服务:验证身份,发 TGT
- TGS(Ticket Granting Service)票据授予服务:凭 TGT 发 Service Ticket
- Server:真正要访问的业务服务(Web、DB、API)
其认证流程如下
- 用户登录域 → 输密码
- Client → AS:若 AS 验证成功,则发给用户 TGT 票据(Ticket Granting Ticket)
- Client → TGS:出示 TGT,申请访问某个服务,若 TGS 验证通过,则发 ST 服务票据
- Client → Server:出示 ST 服务验证通过,直接登录成功,免输密码
核心的密钥管理分为两部分
- AS 认证服务:一部分负责分发 TGT(Ticket Granting Ticket)票据授权票据
- TGS 票据授予服务:一部分根据 TGT 分发 ST(Service Ticket)服务票据,用以真正的访问业务系统