Principe d'authentification unique et mise en œuvre simple

1. Mécanisme de connexion au système unique

1. httpAucunStatutProtocole

Application Webutilise le navigateur/ serveurarchitecture, http comme protocole de communication. http est un protocole sans état. Chaque requête du navigateur sera traitée indépendamment par le serveur du service et ne sera pas associée aux requêtes précédentes ou ultérieures. Ce processus est illustré dans la figure ci-dessous. les trois paires requête/réponse. Tout contact

Mais cela signifie aussi que n'importe quel utilisateur peut accéder aux ressources du serveur via un navigateur. Si vous souhaitez protéger certaines ressources sur le serveur, vous devez limiter les requêtes du navigateur ; pour limiter les requêtes du navigateur, vous devez identifier les requêtes du navigateur, répondre aux requêtes légitimes et ignorer les requêtes illégales, pour identifier les requêtes du navigateur, vous devez connaître l'état de la requête du navigateur ; Puisque le protocole http est sans état, laissez le serveur et le navigateur maintenir conjointement un état ! Il s'agit du mécanisme de session

2. Mécanisme de session

La première fois que le navigateur demande au serveur, le serveur crée une session et envoie l'identifiant de session au navigateur dans le cadre de la réponse, et le navigateur stocke l'ID de session et apporte l'ID de session dans les deuxième et troisième requêtes suivantes. Le serveur saura s'il s'agit du même utilisateur en obtenant l'ID de session dans la requête. Ce processus est illustré dans la figure ci-dessous. la même chose que la première requête. Il y a une association

Le serveur enregistre l'objet

de session en mémoire. Comment le navigateur enregistre-t-il l'identifiant de session ? Vous pouvez penser à deux façons

1. Paramètres de demande

2. cookie

En utilisant l'identifiant de session comme paramètre de chaque requête, le serveur peut naturellement analyser les paramètres pour obtenir l'identifiant de session lors de la réception de la requête, et l'utiliser pour déterminer si elle provient de la même session. cette méthode n'est pas fiable. Laissez ensuite le navigateur conserver lui-même l'ID de session. Le navigateur envoie automatiquement l'ID de session à chaque fois qu'une requête http est envoyée. Le mécanisme de cookie est utilisé pour ce faire. Le cookie est un mécanisme utilisé par le navigateur pour stocker une petite quantité de données. Les données sont stockées sous la forme de "

clé/valeur". Lorsque le navigateur envoie une requête http, il joint automatiquement les informations du cookie.

Bien entendu, le mécanisme de session Tomcat est également implémenté. Lors de l'accès au serveur Tomcat, vous pouvez voir un cookie nommé "J

SESSIONID" dans le navigateur. maintenu par le mécanisme de session Tomcat. Le processus de réponse aux demandes utilisant les cookies est le suivant Figure

3. Statut de connexion

Avec le mécanisme de session, le statut de connexion est facile à comprendre. Nous supposons que le navigateur doit saisir l'utilisateur pour la première fois lors de la demande au serveur. Le nom et le mot de passe sont utilisés pour vérifier l'identité. Le serveur obtient le nom d'utilisateur et le mot de passe et les compare avec la base de données. correct, cela signifie que l'utilisateur qui détient actuellement cette session est un utilisateur légitime. Cette session doit être marquée comme "autorisée" ou "connectée", etc. Le statut, puisqu'il s'agit du statut de la session, doit naturellement être enregistré. dans l'objet de session. Tomcat définit le statut de connexion dans l'objet de session comme suit

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

Lorsque l'utilisateur visite à nouveau, Tomcat affiche l'état de connexion dans l'objet de session

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

Le serveur de requêtes du navigateur qui implémente le statut de connexion

modèle est décrit dans la figure suivante

L'état de connexion dans l'objet de session est vérifié chaque fois qu'une ressource protégée est demandée. Seules les sessions avec isLogin=true sont accessibles et le mécanisme de connexion est implémenté en conséquence.

2. La complexité de plusieurs systèmes

Le système Web est depuis longtemps passé d'un système unique à un groupe d'applications composé de plusieurs systèmes aujourd'hui. Face à autant de systèmes, les utilisateurs doivent-ils y aller. un par un ? Vous connecter puis vous déconnecter un par un ? Tout comme l'image ci-dessous

Le système Web est passé d'un système unique à un groupe d'applications composé de plusieurs systèmes. La complexité devrait être supportée par le système lui-même, et non par les utilisateurs. Quelle que soit la complexité interne du système Web, il s'agit d'un tout unifié pour les utilisateurs. Autrement dit, les utilisateurs accédant à l'ensemble du groupe d'applications du système Web équivaut à accéder à un seul système. Une seule connexion/déconnexion suffit. 🎜>

Bien que la solution de connexion à système unique soit parfaite, elle n'est plus adaptée aux groupes d'applications multi-systèmes. Pourquoi ?

Le cœur de la solution de connexion à système unique est le cookie. Le cookie porte l'ID de session pour maintenir l'état de session entre le navigateur et le serveur. Mais il existe des restrictions sur les cookies. Cette restriction concerne le domaine du cookie (correspondant généralement au nom de domaine du site Web). Lorsque le navigateur envoie une requête http, il transportera automatiquement les cookies qui correspondent au domaine, pas tous les cookies <🎜. >

Dans ce cas, pourquoi ne pas unifier les noms de domaine de tous les sous-systèmes du groupe d'applications Web sous un seul nom de domaine de premier niveau, tel que "*.baidu.com", et puis définissez leurs domaines de cookies sur "baidu.com", cette approche est théoriquement possible, et même de nombreuses premières connexions multi-systèmes utilisaient cette méthode de partage de cookies avec le même nom de domaine.

Cependant, ce n’est pas parce que c’est possible que c’est bon, et il existe de nombreuses limites à la façon dont vous partagez les cookies. Tout d'abord, le nom de domaine du groupe d'applications doit être unifié ; deuxièmement, la technologie utilisée par chaque système du groupe d'applications (au moins le serveur web) doit être la même, sinon la valeur clé du cookie (JSESSIONID pour tomcat ) est différent, la session ne peut pas être maintenue et la méthode de partage des cookies ne peut pas être mise en œuvre au-delà des frontières. 🎜>.

Par conséquent, nous avons besoin d'une nouvelle méthode de connexion pour réaliser la connexion de groupes d'applications multi-systèmes, qui est l'authentification unique 3. Authentification unique

Quoi 'est-ce que l'authentification unique ? Cliquez pour vous connecter ? Le nom complet de l'authentification unique est Single Sign On (ci-après dénommé SSO). Cela signifie que si vous vous connectez à un système dans un groupe d'applications multi-systèmes, vous pouvez être autorisé à accéder à tous les autres systèmes sans vous reconnecter. . Il comprend une connexion unique et une déconnexion unique

1. Connexion

Par rapport à la connexion à un système unique, l'authentification unique nécessite un centre d'authentification indépendant. Seul le centre d'authentification peut accepter le nom d'utilisateur, le mot de passe et le mot de passe de l'utilisateur. autres informations de sécurité. Les autres systèmes ne fournissent pas d'entrées de connexion. Seule l'autorisation indirecte du centre de certification est acceptée. L'autorisation indirecte est mise en œuvre via des jetons. Le centre d'authentification SSO vérifie que le nom d'utilisateur et le mot de passe de l'utilisateur sont corrects et crée un jeton d'autorisation lors du processus de saut suivant, le jeton d'autorisation est envoyé en tant que paramètre à chaque sous-système, et le sous-système obtient le jeton d'autorisation. token. , c'est-à-dire que vous êtes autorisé à créer une session partielle. La méthode de connexion à une session partielle est la même que la méthode de connexion à un seul système. Ce processus, qui est le principe de l'authentification unique, est illustré par la figure suivante

Ce qui suit est une brève description de la figure ci-dessus. du système 1. Le système 1 constate que l'utilisateur n'est pas connecté, accède au centre d'authentification sso et utilise sa propre adresse comme paramètre

le centre d'authentification sso constate que l'utilisateur est non connecté, et le sera L'utilisateur est dirigé vers la page de connexion

1. L'utilisateur saisit le nom d'utilisateur et le mot de passe pour soumettre la demande de connexion

2. Le centre de certification sso vérifie les informations des utilisateurs, crée des utilisateurs et s'authentifie sso. La session entre les centres est appelée session globale, et un jeton d'autorisation est créé en même temps

3. Le centre d'authentification sso va accédez à l'adresse de demande initiale (système 1) avec le jeton

4. Le système 1 récupère le jeton et se rend au centre de certification SSO pour vérifier si le jeton est valide

5. Le centre de certification SSO vérifie le jeton, le renvoie valide et enregistre le système 1

6. Le système 1 utilise le jeton pour créer une session avec l'utilisateur, appelée une session partielle, renvoyant la ressource protégée

7. L'utilisateur accède au système 2 La ressource protégée

8. Le système 2 constate que l'utilisateur n'est pas connecté, saute vers le centre d'authentification sso et utilise sa propre adresse comme paramètre

9. sso Le centre d'authentification constate que l'utilisateur s'est connecté, revient à l'adresse du système 2 et se joint le jeton

10. Le système 2 récupère le jeton et se rend au centre d'authentification SSO pour vérifier si le jeton est valide

11. Le centre de certification SSO vérifie le jeton, renvoie valide, enregistre le système 2

12. Le système 2 utilise le jeton pour créer une session partielle avec l'utilisateur, renvoie les ressources protégées

　　用户登录成功之后，会与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向所有注册系统发送注销请求
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!