Single-Sign-On-Prinzip und einfache Implementierung

1. Einzelsystem-Anmeldemechanismus

1. httpKeineStatusProtokoll

WebAnwendungverwendet Browser/ ServerArchitektur, http als Kommunikationsprotokoll. http ist ein zustandsloses Protokoll. Jede Anfrage vom Browser wird unabhängig vom -Dienst--Server verarbeitet und nicht mit vorherigen oder nachfolgenden Anfragen verknüpft. Es besteht keine Verbindung zwischen die drei Anfrage-/Antwortpaare

Dies bedeutet aber auch, dass jeder Benutzer über einen Browser auf Serverressourcen zugreifen kann. Sie müssen Browseranfragen begrenzen, Sie müssen Browseranfragen identifizieren, auf legitime Anfragen reagieren und illegale Anfragen ignorieren. Sie müssen den Status der Browseranfragen kennen. Da das http-Protokoll zustandslos ist, lassen Sie Server und Browser gemeinsam einen Zustand aufrechterhalten! Dies ist der Sitzungsmechanismus

2. Sitzungsmechanismus

Wenn der Browser zum ersten Mal den Server anfordert, erstellt der Server eine Sitzung und sendet die Sitzungs-ID als Teil der Antwort an den Browser Der Browser speichert die Sitzungs-ID und übermittelt die Sitzungs-ID in der zweiten und dritten nachfolgenden Anfrage. Der Server erkennt, ob es sich um denselben Benutzer handelt, indem er die Sitzungs-ID in der folgenden Anfrage abruft das Gleiche wie bei der ersten Anfrage. Es gibt eine Zuordnung

Der Server speichert das Sitzungsobjekt im Speicher. Wie speichert der Browser die Sitzungs-ID? Sie können sich zwei Möglichkeiten vorstellen:

1. Parameter anfordern

2. Cookie

Unter Verwendung der Sitzungs-ID als Parameter jeder Anfrage kann der Server die Parameter auf natürliche Weise analysieren, um die Sitzungs-ID beim Empfang der Anfrage zu erhalten, und diese verwenden, um festzustellen, ob sie von derselben Sitzung stammt. Diese Methode ist unzuverlässig. Lassen Sie den Browser dann die Sitzungs-ID selbst verwalten, wenn eine HTTP-Anfrage gesendet wird. Dazu wird der Cookie-Mechanismus verwendet. Cookie ist ein Mechanismus, der vom Browser zum Speichern einer kleinen Datenmenge verwendet wird. Die Daten werden in der Form „

Schlüssel/Wert“ gespeichert. Wenn der Browser eine HTTP-Anfrage sendet, fügt er automatisch die Cookie-Informationen hinzu

Natürlich sind auch Cookies im Tomcat-Server implementiert. Beim Zugriff auf den Tomcat-Server wird im Browser ein Cookie mit dem Namen „J

SESSIONID“ angezeigt Der vom Tomcat-Sitzungsmechanismus verwaltete Anfrage-Antwort-Prozess ist wie folgt: Abbildung

3. Anmeldestatus

Mit dem Sitzungsmechanismus der Anmeldestatus Es ist leicht zu verstehen, dass der Browser den Benutzernamen und das Passwort zum ersten Mal eingeben muss, um die Identität zu überprüfen richtig, es bedeutet, dass der Benutzer, der diese Sitzung gerade hält, ein legitimer Benutzer ist. Diese Sitzung sollte als „autorisiert“ oder „angemeldet“ usw. markiert werden. Der Status muss natürlich gespeichert werden, da es sich um den Status der Sitzung handelt im Sitzungsobjekt. Tomcat legt den Anmeldestatus im Sitzungsobjekt wie folgt fest

HttpSession session = request.getSession();
session.setAttribute("isLogin", true);

Wenn der Benutzer ihn erneut besucht, zeigt Tomcat den Anmeldestatus im Sitzungsobjekt an

HttpSession session = request.getSession();
session.getAttribute("isLogin");

Der Browser-Anfrageserver, der das Anmeldestatus-

-Modell implementiert, wird in der folgenden Abbildung

Der Anmeldestatus im Sitzungsobjekt wird bei jeder Anforderung einer geschützten Ressource überprüft. Es kann nur auf Sitzungen mit isLogin=true zugegriffen werden, und der Anmeldemechanismus wird entsprechend implementiert.

2. Die Komplexität mehrerer Systeme

Das Websystem hat sich in der Antike längst von einem einzelnen System zu einer aus mehreren Systemen bestehenden Anwendungsgruppe entwickelt Müssen Sie sich nacheinander anmelden und dann nacheinander abmelden? Genau wie das Bild unten

Das Websystem hat sich von einem Einzelsystem zu einer Anwendungsgruppe bestehend aus mehreren Systemen entwickelt. Die Komplexität sollte vom System selbst getragen werden, nicht von den Benutzern. Unabhängig davon, wie komplex das Websystem intern ist, ist es für Benutzer ein einheitliches Ganzes. Das heißt, der Zugriff der Benutzer auf die gesamte Anwendungsgruppe des Websystems ist dasselbe wie der Zugriff auf ein einzelnes System. Nur eine Anmeldung/Abmeldung ist ausreichend 🎜>

Obwohl die Single-System-Login-Lösung perfekt ist, ist sie nicht mehr für Multi-System-Anwendungsgruppen geeignet.

Der Kern der Single-System-Login-Lösung ist das Cookie. Das Cookie trägt die Sitzungs-ID, um den Sitzungsstatus zwischen dem Browser und dem Server aufrechtzuerhalten. Es gibt jedoch Einschränkungen für Cookies. Diese Einschränkung bezieht sich auf die Domäne des Cookies (normalerweise entsprechend dem Domänennamen der Website). Wenn der Browser eine HTTP-Anfrage sendet, überträgt er automatisch Cookies, die mit der Domäne übereinstimmen, nicht alle Cookies >

Warum vereinheitlichen Sie in diesem Fall nicht die Domänennamen aller Subsysteme in der Webanwendungsgruppe unter einem Domänennamen der obersten Ebene, z. B. „*.baidu.com“ und Setzen Sie dann ihre Cookie-Domänen auf „baidu.com“, dieser Ansatz ist theoretisch möglich, und sogar viele frühe Multi-System-Anmeldungen verwendeten diese Methode zum Teilen von Cookies mit demselben Domänennamen.

Nur ​​weil es möglich ist, heißt das jedoch nicht, dass es gut ist, und es gibt viele Einschränkungen beim Teilen von Cookies. Erstens muss der Domänenname der Anwendungsgruppe einheitlich sein; zweitens muss die von jedem System in der Anwendungsgruppe (zumindest dem Webserver) verwendete Technologie identisch sein, andernfalls muss der Schlüsselwert des Cookies (JSESSIONID für Tomcat) identisch sein ) ist anders, die Sitzung kann nicht aufrechterhalten werden und die Methode zum Teilen von Cookies kann nicht über Grenzen hinweg implementiert werden, z. B. zwischen Java-, PHP- und .net-Systemen. Drittens sind Cookies selbst nicht

sicher

. Daher benötigen wir eine neue Anmeldemethode, um die Anmeldung von Anwendungsgruppen mit mehreren Systemen zu realisieren, nämlich Single Sign-On

3. Single Sign-On

Was Ist Single Sign-On? Klicken Sie hier, um sich anzumelden? Der vollständige Name von Single Sign-On lautet Single Sign On (im Folgenden als SSO bezeichnet). Dies bedeutet, dass Sie, wenn Sie sich bei einem System in einer Multisystem-Anwendungsgruppe anmelden, in allen anderen Systemen autorisiert werden können, ohne sich erneut anzumelden . Es umfasst Single Sign-On und Single Logout

1. Im Vergleich zum Single-System-Login ist für SSO ein unabhängiges Authentifizierungszentrum erforderlich. Nur das Authentifizierungscenter kann den Benutzernamen und das Passwort akzeptieren Andere Sicherheitsinformationen. Andere Systeme bieten keine Anmeldezugänge. Es werden nur indirekte Autorisierungen durch die Zertifizierungsstelle akzeptiert. Die indirekte Autorisierung wird über Token implementiert. Das SSO-Authentifizierungscenter überprüft, ob der Benutzername und das Passwort des Benutzers in Ordnung sind, und erstellt einen Autorisierungstoken. Im nächsten Sprungprozess wird der Autorisierungstoken als Parameter an jedes Subsystem gesendet und das Subsystem erhält das Das heißt, Sie sind berechtigt, eine Teilsitzungs-Anmeldemethode zu erstellen. Dieser Prozess, der das Prinzip des Single Sign-On darstellt, wird durch die folgende Abbildung veranschaulicht:

Im Folgenden finden Sie eine kurze Beschreibung der obigen Abbildung von System 1. System 1 stellt fest, dass der Benutzer nicht angemeldet ist, springt zum SSO-Authentifizierungscenter und verwendet seine eigene Adresse als Parameter

SSO-Authentifizierungscenter stellt fest, dass der Benutzer angemeldet ist nicht angemeldet, und der Benutzer wird zur Anmeldeseite weitergeleitet

1. Der Benutzer gibt den Benutzernamen und das Passwort ein, um den Anmeldeantrag einzureichen

2. Das SSO-Zertifizierungszentrum überprüft Benutzerinformationen, erstellt Benutzer und führt eine SSO-Authentifizierung durch. Die Sitzung zwischen Zentren wird als globale Sitzung bezeichnet, und gleichzeitig wird ein Autorisierungstoken erstellt.

3. Das SSO-Authentifizierungszentrum wird dies tun Springen Sie mit dem Token zur ursprünglichen Anforderungsadresse (System 1)

4. System 1 erhält das Token und geht zum SSO-Zertifizierungszentrum, um zu überprüfen, ob das Token gültig ist

5. Das SSO-Zertifizierungszentrum überprüft das Token, gibt es als gültig zurück und registriert das System 1

6. System 1 verwendet das Token, um eine Sitzung mit dem Benutzer, genannt, zu erstellen eine Teilsitzung, die die geschützte Ressource zurückgibt

7. Benutzer greift auf System 2 zu. Die geschützte Ressource

8. System 2 stellt fest, dass der Benutzer nicht angemeldet ist, Springt zum SSO-Authentifizierungszentrum und verwendet seine eigene Adresse als Parameter

9. sso Das Authentifizierungszentrum stellt fest, dass sich der Benutzer angemeldet hat, springt zurück zur Adresse von System 2 und fügt eine Verbindung hinzu das Token

10. System 2 erhält das Token und geht zum SSO-Authentifizierungszentrum, um zu überprüfen, ob das Token gültig ist

11. SSO-Zertifizierungszentrum überprüft das Token, gibt gültig zurück, registriert System 2

12. System 2 verwendet das Token, um eine Teilsitzung mit dem Benutzer zu erstellen, Geschützte Ressourcen zurückgeben

　　用户登录成功之后，会与sso认证中心及各个子系统建立会话，用户与sso认证中心建立的会话称为全局会话，用户与各个子系统建立的会话称为局部会话，局部会话建立之后，用户访问子系统受保护资源将不再通过sso认证中心，全局会话与局部会话有如下约束关系

1. 局部会话存在，全局会话一定存在

2. 全局会话存在，局部会话不一定存在

3. 全局会话销毁，局部会话必须销毁

　　你可以通过博客园、百度、csdn、淘宝等网站的登录过程加深对单点登录的理解，注意观察登录过程中的跳转url与参数

2、注销

　　单点登录自然也要单点注销，在一个子系统中注销，所有子系统的会话都将被销毁，用下面的图来说明

　　sso认证中心一直监听全局会话的状态，一旦全局会话销毁，监听器将通知所有注册系统执行注销操作

　　下面对上图简要说明

1. 用户向系统1发起注销请求

2. 系统1根据用户与系统1建立的会话id拿到令牌，向sso认证中心发起注销请求

3. sso认证中心校验令牌有效，销毁全局会话，同时取出所有用此令牌注册的系统地址

4. sso认证中心向所有注册系统发起注销请求

5. 各注册系统接收sso认证中心的注销请求，销毁局部会话

6. sso认证中心引导用户至登录页面

四、部署图

　　单点登录涉及sso认证中心与众子系统，子系统与sso认证中心需要通信以交换令牌、校验令牌及发起注销请求，因而子系统必须集成sso的客户端，sso认证中心则是sso服务端，整个单点登录过程实质是sso客户端与服务端通信的过程，用下图描述

　　sso认证中心与sso客户端通信方式有多种，这里以简单好用的httpClient为例，web service、rpc、restful api都可以

五、实现

　　只是简要介绍下基于java的实现过程，不提供完整源码，明白了原理，我相信你们可以自己实现。sso采用客户端/服务端架构，我们先看sso-client与sso-server要实现的功能（下面：sso认证中心=sso-server）

　　sso-client

1. 拦截子系统未登录用户请求，跳转至sso认证中心

2. 接收并存储sso认证中心发送的令牌

3. 与sso-server通信，校验令牌的有效性

4. 建立局部会话

5. 拦截用户注销请求，向sso认证中心发送注销请求

6. 接收sso认证中心发出的注销请求，销毁局部会话

　　sso-server

1. 验证用户的登录信息

2. 创建全局会话

3. 创建授权令牌

4. 与sso-client通信发送令牌

5. 校验sso-client令牌有效性

6. 系统注册

7. 接收sso-client注销请求，注销所有会话

　　接下来，我们按照原理来一步步实现sso吧！

1、sso-client拦截未登录请求

　　java拦截请求的方式有servlet、filter、listener三种方式，我们采用filter。在sso-client中新建LoginFilter.java类并实现Filter接口，在doFilter()方法中加入对未登录用户的拦截

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest req = (HttpServletRequest) request;
    HttpServletResponse res = (HttpServletResponse) response;
    HttpSession session = req.getSession();
    if (session.getAttribute("isLogin")) {
        chain.doFilter(request, response);
        return;
    }
    //跳转至sso认证中心
    res.sendRedirect("sso-server-url-with-system-url");
}

2、sso-server拦截未登录请求

　　拦截从sso-client跳转至sso认证中心的未登录请求，跳转至登录页面，这个过程与sso-client完全一样

3、sso-server验证用户登录信息

　　用户在登录页面输入用户名密码，请求登录，sso认证中心校验用户信息，校验成功，将会话状态标记为“已登录”

@RequestMapping("/login")
public String login(String username, String password, HttpServletRequest req) {
    this.checkLoginInfo(username, password);
    req.getSession().setAttribute("isLogin", true);
    return "success";
}

4、sso-server创建授权令牌

　　授权令牌是一串随机字符，以什么样的方式生成都没有关系，只要不重复、不易伪造即可，下面是一个例子

String token = UUID.randomUUID().toString();

5、sso-client取得令牌并校验

　　sso认证中心登录后，跳转回子系统并附上令牌，子系统（sso-client）取得令牌，然后去sso认证中心校验，在LoginFilter.java的doFilter()中添加几行

// 请求附带token参数
String token = req.getParameter("token");
if (token != null) {
    // 去sso认证中心校验token
    boolean verifyResult = this.verify("sso-server-verify-url", token);
    if (!verifyResult) {
        res.sendRedirect("sso-server-url");
        return;
    }
    chain.doFilter(request, response);
}

　　verify()方法使用httpClient实现，这里仅简略介绍，httpClient详细使用方法请参考官方文档

HttpPost httpPost = new HttpPost("sso-server-verify-url-with-token");
HttpResponse httpResponse = httpClient.execute(httpPost);

6、sso-server接收并处理校验令牌请求

　　用户在sso认证中心登录成功后，sso-server创建授权令牌并存储该令牌，所以，sso-server对令牌的校验就是去查找这个令牌是否存在以及是否过期，令牌校验成功后sso-server将发送校验请求的系统注册到sso认证中心（就是存储起来的意思）

　　令牌与注册系统地址通常存储在key-value数据库（如redis）中，redis可以为key设置有效时间也就是令牌的有效期。redis运行在内存中，速度非常快，正好sso-server不需要持久化任何数据。

　　令牌与注册系统地址可以用下图描述的结构存储在redis中，可能你会问，为什么要存储这些系统的地址？如果不存储，注销的时候就麻烦了，用户向sso认证中心提交注销请求，sso认证中心注销全局会话，但不知道哪些系统用此全局会话建立了自己的局部会话，也不知道要向哪些子系统发送注销请求注销局部会话

7、sso-client校验令牌成功创建局部会话

　　令牌校验成功后，sso-client将当前局部会话标记为“已登录”，修改LoginFilter.java，添加几行

if (verifyResult) {
    session.setAttribute("isLogin", true);
}

　　sso-client还需将当前会话id与令牌绑定，表示这个会话的登录状态与令牌相关，此关系可以用java的hashmap保存，保存的数据用来处理sso认证中心发来的注销请求

8、注销过程

　　用户向子系统发送带有“logout”参数的请求（注销请求），sso-client拦截器拦截该请求，向sso认证中心发起注销请求

String logout = req.getParameter("logout");
if (logout != null) {
    this.ssoServer.logout(token);
}

　　sso认证中心也用同样的方式识别出sso-client的请求是注销请求（带有“logout”参数），sso认证中心注销全局会话

@RequestMapping("/logout")
public String logout(HttpServletRequest req) {
    HttpSession session = req.getSession();
    if (session != null) {
        session.invalidate();//触发LogoutListener
    }
    return "redirect:/";
}

　　sso认证中心有一个全局会话的监听器，一旦全局会话注销，将通知所有注册系统注销

public class LogoutListener implements HttpSessionListener {
    @Override
    public void sessionCreated(HttpSessionEvent event) {}
    @Override
    public void sessionDestroyed(HttpSessionEvent event) {
        //通过httpClient向所有注册系统发送注销请求
    }
}

Das obige ist der detaillierte Inhalt vonSingle-Sign-On-Prinzip und einfache Implementierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!