首页-教程-Web前端

聊聊基于Node实现单点登录（SSO）的方法

 3505

什么是单点登录？原理是什么？怎么实现？下面本篇文章带大家了解一下单点登录，并聊聊使用Node实现单点登录SSO的方法，希望对大家有所帮助！



聊聊基于Node实现单点登录（SSO）的方法


什么是单点登录

随着公司业务的增多，必然会产生各个不同的系统，如果每个系统都需要单独登录的话就会很不方便。

因此产生了单点登录这样的解决方案,单点登录全称 Single Sign On，简称SSO，意思是在多个系统应用群中登录一个系统，便可在其他所有系统中得到授权而无需再次登录。

比如小明今天登录了淘宝，如果没有登录，就会被要求输入认证信息(用户名密码等)，登录过后再去访问天猫的页面时就不需要登录可以直接访问。

单点登录原理

聊聊基于Node实现单点登录（SSO）的方法

SSO 需要有一个独立的认证中心，只有独立的验证中心能接受用户的用户名密码等安全信息，其他系统不提供登录入口，只接受认证中心的间接授权。 整个过程可以简单的用上图描述：

当用户登录访问应用A时，应用A发现用户未登录,跳转至SSO认证中心，并将自己的地址作为参数方便回调

SSO认证中心发现用户没有登录过，将用户引导至登录页面;用户填写用户名密码提交登录申请;SSO认证中心校验用户信息，创建用户雨SSO认证中心的会话(这时会把信息保存到cookie中)，同时创建授权令牌token

sso认证中心带着令牌跳转到最初的请求地址(应用A)

应用A拿到令牌去SSO认证中心认证是否有效，如果返回有效注册应用A

应用A创建与用户之间的会话，展示资源并维持用户登录态

当用户访问应用B时，发现用户未登录(SSO认证服务器与应用A应用B不是同一个域,不能提供登录态)，跳转到SSO认证中心，并将自己的地址和之前和SSO认证中心会话的cookie信息带入

SSO认证中心发现用户已登录，跳转回应用B地址，并附上令牌token

同样的应用B拿到令牌去SSO认证中心认证是否有效，如果返回有效注册应用B

应用B创建与用户之间的会话，展示资源并维持用户登录态


NodeJS 演示

三个不同的服务

这里我们需要启动三个服务来分别模拟 应用A，SSO认证服务器和应用B


聊聊基于Node实现单点登录（SSO）的方法


这里端口号 8383的服务是SSO认证服务器，其余的 :8686 和 :8787 分别代表应用A与应用B。

其实应用A与应用B的代码几乎一样，如上图所示我们可以通过穿参的方式来设置不同的端口及应用名。

先来看下效果


聊聊基于Node实现单点登录（SSO）的方法


首次访问跳转至登录页

应用A判断登录态，跳转到SSO认证服务器

应用A

  1. const Koa=require('koa');
  2. const Router=require('koa-router')
  3. const views=require('koa-views')
  4. const static=require('koa-static')
  5. const path=require('path');
  6. const app=new Koa();
  7. const router=new Router();
  8. const session=require('koa-session')
  9. const koa2Req=require('koa2-request');
  10.  
  11. //模版引擎相关配置
  12. app.use(views(path.join(__dirname,'./views')),{
  13.     extension:'ejs'
  14.   })
  15. app.keys=['key']
  16.  
  17. const keyMap={
  18.   '8686':'koa:sess8686',
  19.   '8787':'koa:sess8787'
  20. }
  21. const CONFIG={
  22.     key:keyMap[process.env.PORT] || 'koa:sess',
  23.     maxAge:1000*60*60*24,
  24.     httpOnly:true
  25. }
  26. app.use(session(CONFIG,app))
  27.  
  28. const system=process.env.SERVER_NAME
  29. router.get("/",async (ctx)=>{
  30.     //通过 session来判断 应用A的登录状态
  31.     let user=ctx.session.user
  32.     if(user){
  33.      //...
  34.     }
  35.     else //1、当用户登录访问应用A时，应用A发现用户未登录(应为服务器没有保存对应的session)
  36.     {
  37.       let token=ctx.query.token
  38.       //第一次登录url上也不会有令牌
  39.       if(!token)
  40.       {
  41.       //1、跳转到SSO认证服务器
  42.        ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
  43.       }
  44.       else
  45.       {
  46.         //...
  47.       }
  48.     }
  49. })
  50. app.use(router.routes())
  51.  
  52.  
  53. const port=process.env.PORT||8888
  54.  
  55. app.listen(port,()=>{
  56.     console.log(`app ${system} running at ${port}`)
  57.  
  58. })


认证服务器判断登录态，渲染登录页

认证服务器SSO

认证服务器的目录结构如下 主要处理两个功能，一是登录逻辑，二是之后验证令牌的有效性，分别有路由 login.js 和 check-token.js 处理


聊聊基于Node实现单点登录（SSO）的方法


Auth/index.js

  1. const Koa=require('koa');
  2. const Router=require('koa-router')
  3. const views=require('koa-views')
  4. const path=require('path');
  5. const app=new Koa();
  6. const router=new Router();
  7. const login=require("./routes/login")
  8. const checkToken=require('./routes/check-token')
  9. const bodyparser=require('koa-bodyparser')
  10.  
  11. app.use(views(path.join(__dirname,'./views')),{
  12.     extension:'ejs'
  13.   })
  14. app.use(bodyparser())
  15. //处理登录相关的逻辑
  16. router.use('/login',login.routes())
  17. //处理令牌验证的逻辑
  18. router.use('/check_token',checkToken.routes())
  19. app.use(router.routes())
  20.  
  21. app.listen(8383,()=>{
  22.     console.log(`app listen at 8383`)
  23. })

刚才我们从应用A跳转到  http://localhost:8383/login?redirectUrl=localhost:8686  

来看login中的逻辑 Auth/routes/login.js

  1. const service = require("../service");
  2. const router=require("koa-router")()
  3.  
  4.  
  5. router.get('/',async (ctx)=>{
  6.   const cookies=ctx.cookies;
  7.   const token=cookies.get('token');
  8.   //从cookie中判断应用A的登录态
  9.   if(token && service.isTokenVailid(token)){
  10.     //。。。如果有登录过
  11.   }else{
  12.     //2、SSO认证中心发现用户没有登录过，于是渲染登录页面登录页面;
  13.     await ctx.render('login.ejs',{
  14.         extension:'ejs'
  15.      })
  16.   }
  17. })
  18.  
  19. //。。。
  20. module.exports=router

登录页面

Auth/views/login.ejs

  1. <html>
  2. <head>
  3.     <meta charset="UTF-8">
  4.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6.     <title>统一登录</title>
  7. </head>
  8. <body>
  9.     <h1>统一登录</h1>
  10.     <form method="post">
  11.        <div>用户名: <input type="text" name="name"/></div>
  12.        <div>密码  <input type="text" name="password" /></div>
  13.        <div><input type="submit" value='登录'></div>
  14.     </form>
  15. </body>
  16. </html>

校验用户信息，创建令牌

Auth/routes/login.js

  1. router.post('/',async (ctx)=>{
  2. //2、用户填写用户名密码提交登录申请;
  3.    const body=ctx.request.body;
  4.    const {name,password}=body;
  5.     //2、SSO认证中心校验用户信息，
  6.    if(name==="admin" && password==="123456"){
  7.     //2、创建用户雨SSO认证中心的会话(这时会把信息保存到cookie中)，同时创建授权令牌token
  8.        const token="passport";
  9.        await ctx.cookies.set('token',token,{
  10.            maxAge:1000*60*60*24*30,
  11.            httpOnly:true
  12.        })
  13.        if(ctx.query.redirectUrl){
  14.        //3、sso认证中心带着令牌跳转到最初的请求地址(应用A)
  15.            ctx.redirect(`${ctx.protocol}://${ctx.query.redirectUrl}?token=${token}`)
  16.            //回跳地址是 http://localhost:8686/?token=passport
  17.        }else{
  18.            ctx.body="<h1>登录成功！</h1>"
  19.        }
  20.    }else{
  21.        ctx.response.body={
  22.            error:1,
  23.            msg:'用户名或密码错误'
  24.        }
  25.    }
  26. })


从认证服务器携带令牌跳转回应用A

令牌校验 返回资源

应用A

  1. app.use(views(path.join(__dirname,'./views')),{
  2.     extension:'ejs'
  3.   })
  4.  
  5. //...
  6.  
  7. const system=process.env.SERVER_NAME
  8. router.get("/",async (ctx)=>{
  9.     let user=ctx.session.user
  10.     if(user){
  11.       //...
  12.     }
  13.     else
  14.     //这时应用A依旧没有登录态 但url上有了令牌 http://localhost:8686/?token=passport
  15.    {
  16.       let token=ctx.query.token
  17.       if(!token)
  18.       {
  19.         //...跳转去SSO登录页面
  20.       }
  21.       else
  22.       //跳回应用A时走这里的逻辑
  23.       {
  24.         //ajax请求 4. 应用A拿到令牌去SSO认证中心认证是否有效，如果返回有效注册应用A
  25.         const url=`://localhost:8383/check_token?token=${token}&t=${new Date().getTime()}`
  26.         let data = await koa2Req(ctx.protocol + url);
  27.         if(data && data.body){
  28.             try {
  29.                 const body=JSON.parse(data.body)
  30.                 const {error,userId}=body;
  31.                 // console.log(error,userId) 0,admin
  32.                 if(error==0){
  33.                     if(!userId){
  34.                         ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
  35.                         return
  36.                     }
  37.                     //验证通过后注册session，渲染页面
  38.                     //5. 应用A创建与用户之间的会话，展示资源并维持用户登录态
  39.                     ctx.session.user=userId;
  40.                     await ctx.render('index.ejs',{
  41.                         user:userId,
  42.                         system
  43.                     })
  44.                 }else{
  45.                     ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
  46.                 }
  47.             } catch (error) {console.log(error)}
  48.  
  49.              
  50.         }
  51.       }
  52.     }
  53. })
  54. app.use(router.routes())
  55.  
  56. const port=process.env.PORT||8888
  57.  
  58. app.listen(port,()=>{
  59.     console.log(`app ${system} running at ${port}`)
  60.  
  61. })

与之对应的 SSO中处理验证令牌的逻辑

Auth/routes/check-token

  1. const router=require("koa-router")()
  2. const service=require("../service")
  3.  
  4. router.get('/',async (ctx)=>{
  5.   const token=ctx.query.token;
  6.   const result={
  7.       error:1
  8.   }
  9.   //当token 是 password时
  10.   if(service.isTokenVailid(token)){
  11.     result.error=0;
  12.     result.userId='admin'
  13.   }
  14.   ctx.body=result
  15.   
  16.  
  17. })
  18.  
  19.  
  20. module.exports=router

Auth/service/index.js

  1. module.exports={
  2.     isTokenVailid: function(token){
  3.       if(token && token==='passport'){
  4.           return true
  5.       }
  6.       return false
  7.     }
  8. }

至此用户已经能正常访问应用A，SSO服务器和应用A服务器上都有了用户登录过的信息。


访问应用B

带cookie跳转至SSO认证服务器

应用B

  1. //...
  2.  
  3. router.get("/",async (ctx)=>{
  4.     let user=ctx.session.user
  5.     if(user){
  6.       //...
  7.     }else{
  8.       let token=ctx.query.token
  9.       //...
  10.       if(!token)
  11.       {
  12.       //同样既没有session也没有令牌，跳转到SSO认证服务器
  13.       //6、当用户访问应用B时，发现用户未登录(SSO认证服务器与应用A应用B不是同一个域,不能提供登录态)，跳转到SSO认证中心，并将自己的地址和之前和SSO认证中心会话的cookie信息带入
  14.           ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
  15.       }
  16.       else
  17.       {
  18.         //。。。验证令牌的部分
  19.       }
  20.     }
  21. })
  22. app.use(router.routes())
  23.  
  24. const port=process.env.PORT||8888
  25.  
  26. app.listen(port,()=>{
  27.     console.log(`app ${system} running at ${port}`)
  28.  
  29. })


从认证服务器携带令牌跳转回应用B

SSO认证服务器 ,再次登录时携带了cookie，因此不会再请求登录页面 Auth/routes/login

  1. //...
  2. router.get('/',async (ctx)=>{
  3.   const cookies=ctx.cookies;
  4.   const token=cookies.get('token');
  5.   //7. SSO认证中心发现用户已登录，跳转回应用B地址，并附上令牌token
  6.   if(token && service.isTokenVailid(token)){
  7.     const redirectUrl=ctx.query.redirectUrl;
  8.     if(redirectUrl){
  9.        //带着令牌跳转回应用B
  10.         ctx.redirect(`${ctx.protocol}://${redirectUrl}?token=${token}`)
  11.     }else{
  12.         ctx.body="<h1>登录成功！</h1>"
  13.     }
  14.   }else{
  15.     //...渲染登录页面
  16.   }
  17. })
  18. //..


令牌校验 返回资源

这里的逻辑和5，6两步一样，因为token容易伪造，所以要检验真伪。 应用B

  1. app.use(views(path.join(__dirname,'./views')),{
  2.     extension:'ejs'
  3.   })
  4.  
  5. //...
  6.  
  7. const system=process.env.SERVER_NAME
  8. router.get("/",async (ctx)=>{
  9.     let user=ctx.session.user
  10.     if(user){
  11.       //...
  12.     }
  13.     else
  14.     //这时应用B依旧没有登录态 但url上有了令牌 http://localhost:8787/?token=passport
  15.    {
  16.       let token=ctx.query.token
  17.       if(!token)
  18.       {
  19.         //...跳转去SSO登录页面
  20.       }
  21.       else
  22.       //跳回应用B时走这里的逻辑
  23.       {
  24.         //ajax请求 8. 同样的应用B拿到令牌去SSO认证中心认证是否有效，如果返回有效注册应用B
  25.         const url=`://localhost:8383/check_token?token=${token}&t=${new Date().getTime()}`
  26.         let data = await koa2Req(ctx.protocol + url);
  27.         if(data && data.body){
  28.             try {
  29.                 const body=JSON.parse(data.body)
  30.                 const {error,userId}=body;
  31.                 // console.log(error,userId) 0,admin
  32.                 if(error==0){
  33.                     if(!userId){
  34.                         ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
  35.                         return
  36.                     }
  37.                     //验证通过后注册session，渲染页面
  38.                     //9. 应用B创建与用户之间的会话，展示资源并维持用户登录态
  39.                     ctx.session.user=userId;
  40.                     await ctx.render('index.ejs',{
  41.                         user:userId,
  42.                         system
  43.                     })
  44.                 }else{
  45.                     ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
  46.                 }
  47.             } catch (error) {console.log(error)}
  48.  
  49.              
  50.         }
  51.       }
  52.     }
  53. })
  54. app.use(router.routes())
  55.  
  56. const port=process.env.PORT||8888
  57.  
  58. app.listen(port,()=>{
  59.     console.log(`app ${system} running at ${port}`)
  60.  
  61. })

至此单点登录的大部分逻辑都已经完成，之后再session有效期内再访问页面，就不需要再登录，直接返回资源

  1. router.get("/",async (ctx)=>{
  2. //如果session中有用户信息，说明已经登录过，直接返回请求资源
  3.     let user=ctx.session.user
  4.     if(user){
  5.         await ctx.render('index.ejs',{
  6.               user,
  7.               system
  8.         })
  9.     }
  10.     //...
  11.  })


原文地址：https://juejin.cn/post/7088343138905325582

作者：YoYo君


TAG标签：
本文网址：https://www.zztuku.com/index.php/detail-13511.html
站长图库 - 聊聊基于Node实现单点登录（SSO）的方法
申明：本文转载于《掘金社区》，如有侵犯，请 联系我们 删除。

评论（0）条

您还没有登录，请 登录 后发表评论！

提示：请勿发布广告垃圾评论，否则封号处理！！

    编辑推荐