NodeJS实现单点登录原理解析

目录
  • 什么是单点登录
  • 单点登录原理
  • NodeJS 演示
    • 三个不同的服务
  • 首次访问跳转至登录页
    • 应用A判断登录态,跳转到SSO认证服务器
    • 认证服务器判断登录态,渲染登录页
    • 校验用户信息,创建令牌
  • 从认证服务器携带令牌跳转回应用A
    • 令牌校验 返回资源
  • 访问应用B
    • 带cookie跳转至SSO认证服务器
  • 从认证服务器携带令牌跳转回应用B
    • 令牌校验 返回资源

什么是单点登录

随着公司业务的增多,必然会产生各个不同的系统,如果每个系统都需要单独登录的话就会很不方便。
因此产生了单点登录这样的解决方案,单点登录全称 Single Sign On,简称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

这里端口号 8383的服务是SSO认证服务器,其余的 :8686 和 :8787 分别代表应用A与应用B。
其实应用A与应用B的代码几乎一样,如上图所示我们可以通过穿参的方式来设置不同的端口及应用名。
先来看下效果

首次访问跳转至登录页

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

应用A

const Koa=require('koa');
const Router=require('koa-router')
const views=require('koa-views')
const static=require('koa-static')
const path=require('path');
const app=new Koa();
const router=new Router();
const session=require('koa-session')
const koa2Req=require('koa2-request');
//模版引擎相关配置
app.use(views(path.join(__dirname,'./views')),{
    extension:'ejs'
  })
app.keys=['key']
const keyMap={
  '8686':'koa:sess8686',
  '8787':'koa:sess8787'
}
const CONFIG={
    key:keyMap[process.env.PORT] || 'koa:sess',
    maxAge:1000*60*60*24,
    httpOnly:true
}
app.use(session(CONFIG,app))
const system=process.env.SERVER_NAME
router.get("/",async (ctx)=>{
    //通过 session来判断 应用A的登录状态
    let user=ctx.session.user
    if(user){
     //...
    }
    else //1、当用户登录访问应用A时,应用A发现用户未登录(应为服务器没有保存对应的session)
    {
      let token=ctx.query.token
      //第一次登录url上也不会有令牌
      if(!token)
      {
      //1、跳转到SSO认证服务器
       ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
      }
      else
      {
        //...
      }
    }
})
app.use(router.routes())

const port=process.env.PORT||8888
app.listen(port,()=>{
    console.log(`app ${system} running at ${port}`)
})

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

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

Auth/index.js

const Koa=require('koa');
const Router=require('koa-router')
const views=require('koa-views')
const path=require('path');
const app=new Koa();
const router=new Router();
const login=require("./routes/login")
const checkToken=require('./routes/check-token')
const bodyparser=require('koa-bodyparser')
app.use(views(path.join(__dirname,'./views')),{
    extension:'ejs'
  })
app.use(bodyparser())
//处理登录相关的逻辑
router.use('/login',login.routes())
//处理令牌验证的逻辑
router.use('/check_token',checkToken.routes())
app.use(router.routes())

app.listen(8383,()=>{
    console.log(`app listen at 8383`)
})

刚才我们从应用A跳转到 http://localhost:8383/login?redirectUrl=localhost:8686 来看login中的逻辑
Auth/routes/login.js

const service = require("../service");
const router=require("koa-router")()
router.get('/',async (ctx)=>{
  const cookies=ctx.cookies;
  const token=cookies.get('token');
  //从cookie中判断应用A的登录态
  if(token && service.isTokenVailid(token)){
    //。。。如果有登录过
  }else{
    //2、SSO认证中心发现用户没有登录过,于是渲染登录页面登录页面;
    await ctx.render('login.ejs',{
        extension:'ejs'
     })
  }
})
//。。。
module.exports=router

登录页面
Auth/views/login.ejs

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>统一登录</title>
</head>
<body>
    <h1>统一登录</h1>
    <form method="post">
       <div>用户名: <input type="text" name="name"/></div>
       <div>密码  <input type="text" name="password" /></div>
       <div><input type="submit" value='登录'></div>
    </form>
</body>
</html>

校验用户信息,创建令牌

Auth/routes/login.js

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

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

令牌校验 返回资源

应用A

app.use(views(path.join(__dirname,'./views')),{
    extension:'ejs'
  })
//...
const system=process.env.SERVER_NAME
router.get("/",async (ctx)=>{
    let user=ctx.session.user
    if(user){
      //...
    }
    else
    //这时应用A依旧没有登录态 但url上有了令牌 http://localhost:8686/?token=passport
   {
      let token=ctx.query.token
      if(!token)
      {
        //...跳转去SSO登录页面
      }
      else
      //跳回应用A时走这里的逻辑
      {
        //ajax请求 4. 应用A拿到令牌去SSO认证中心认证是否有效,如果返回有效注册应用A
        const url=`://localhost:8383/check_token?token=${token}&t=${new Date().getTime()}`
        let data = await koa2Req(ctx.protocol + url);
        if(data && data.body){
            try {
                const body=JSON.parse(data.body)
                const {error,userId}=body;
                // console.log(error,userId) 0,admin
                if(error==0){
                    if(!userId){
                        ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
                        return
                    }
                    //验证通过后注册session,渲染页面
                    //5. 应用A创建与用户之间的会话,展示资源并维持用户登录态
                    ctx.session.user=userId;
                    await ctx.render('index.ejs',{
                        user:userId,
                        system
                    })
                }else{
                    ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
                }
            } catch (error) {console.log(error)}

        }
      }
    }
})
app.use(router.routes())
const port=process.env.PORT||8888
app.listen(port,()=>{
    console.log(`app ${system} running at ${port}`)
})

与之对应的 SSO中处理验证令牌的逻辑
Auth/routes/check-token

const router=require("koa-router")()
const service=require("../service")
router.get('/',async (ctx)=>{
  const token=ctx.query.token;
  const result={
      error:1
  }
  //当token 是 password时
  if(service.isTokenVailid(token)){
    result.error=0;
    result.userId='admin'
  }
  ctx.body=result
})
module.exports=router

Auth/service/index.js

module.exports={
    isTokenVailid: function(token){
      if(token && token==='passport'){
          return true
      }
      return false
    }
}

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

访问应用B

带cookie跳转至SSO认证服务器

应用B

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

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

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

//...
router.get('/',async (ctx)=>{
  const cookies=ctx.cookies;
  const token=cookies.get('token');
  //7. SSO认证中心发现用户已登录,跳转回应用B地址,并附上令牌token
  if(token && service.isTokenVailid(token)){
    const redirectUrl=ctx.query.redirectUrl;
    if(redirectUrl){
       //带着令牌跳转回应用B
        ctx.redirect(`${ctx.protocol}://${redirectUrl}?token=${token}`)
    }else{
        ctx.body="<h1>登录成功!</h1>"
    }
  }else{
    //...渲染登录页面
  }
})
//..

令牌校验 返回资源

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

app.use(views(path.join(__dirname,'./views')),{
    extension:'ejs'
  })
//...
const system=process.env.SERVER_NAME
router.get("/",async (ctx)=>{
    let user=ctx.session.user
    if(user){
      //...
    }
    else
    //这时应用B依旧没有登录态 但url上有了令牌 http://localhost:8787/?token=passport
   {
      let token=ctx.query.token
      if(!token)
      {
        //...跳转去SSO登录页面
      }
      else
      //跳回应用B时走这里的逻辑
      {
        //ajax请求 8. 同样的应用B拿到令牌去SSO认证中心认证是否有效,如果返回有效注册应用B
        const url=`://localhost:8383/check_token?token=${token}&t=${new Date().getTime()}`
        let data = await koa2Req(ctx.protocol + url);
        if(data && data.body){
            try {
                const body=JSON.parse(data.body)
                const {error,userId}=body;
                // console.log(error,userId) 0,admin
                if(error==0){
                    if(!userId){
                        ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
                        return
                    }
                    //验证通过后注册session,渲染页面
                    //9. 应用B创建与用户之间的会话,展示资源并维持用户登录态
                    ctx.session.user=userId;
                    await ctx.render('index.ejs',{
                        user:userId,
                        system
                    })
                }else{
                    ctx.redirect(`http://localhost:8383/login?redirectUrl=${ctx.host+ctx.originalUrl}`)
                }
            } catch (error) {console.log(error)}

        }
      }
    }
})
app.use(router.routes())
const port=process.env.PORT||8888
app.listen(port,()=>{
    console.log(`app ${system} running at ${port}`)
})

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

router.get("/",async (ctx)=>{
//如果session中有用户信息,说明已经登录过,直接返回请求资源
    let user=ctx.session.user
    if(user){
        await ctx.render('index.ejs',{
              user,
              system
        })
    }
    //...
 })

到此这篇关于NodeJS实现单点登录的文章就介绍到这了,更多相关nodejs单点登录内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • nodejs实现用户登录路由功能

    经过前面几次的学习,已经可以做下小功能,今天要实现的事用户登录路由. 一.users_model.js  功能:定义用户对象模型 var mongoose=require('mongoose'), Schema=mongoose.Schema; var UserSchema=new Schema({ username:{type:String,unique:true}, email:String, color:String, hashed_password:String }); mongoose

  • nodejs微信开发之授权登录+获取用户信息

    上一篇:获取access_token+自定义菜单 这部分代码是之前就已经完成了,但是考虑篇幅的问题就和上篇分开了,这部分相较前面的方式较为复杂一点,但是也是很容易理解的. 这里简单介绍一下微信网页授权. 微信网页授权配置回调域名: 注:下面引自官方文档 1.在微信公众号请求用户网页授权之前,开发者需要先到公众平台官网中的"开发 - 接口权限 - 网页服务 - 网页帐号 - 网页授权获取用户基本信息"的配置选项中,修改授权回调域名.请注意,这里填写的是域名(是一个字符串),而不是URL,

  • 图解NodeJS实现登录注册功能

    该Demo根据菜鸟教程的练手项目,请提前到菜鸟教程的官网查看nodejs的相关教程,根据教程实际操作一遍,然后自己动手去实现登录.注册功能,此Demo只作参考,不符合前端相关规范. 使用的技术栈 node+express+mongodb 项目目录结构 node_modules: 第三方模块目录 public: 公共文件目录(js.css.image) login.html:登录页面 register.html:注册页面 main.html:主页面 db.js:数据库相关封装(数据库添加.查询)

  • 通过Nodejs搭建网站简单实现注册登录流程

    1. 使用Backbone实现前端hash路由 初步设想将注册和登录作为两个不同的url实现,但登录和注册功能的差距只有form表单部分,用两个url实现显然开销过大,所以最终方案为使用hash作为前端路由,根据url的hash值切换相应的表单显示. 很多致力于SPA开发的前端框架都具备hash路由功能,考虑到嗨猫本身是一个类博客.偏重静态展示的网站,所以最后选择了轻量级的Backbone最为前端框架. Backbone实现hash路由的代码很简单: let $formBox = $('.box

  • NodeJS实现单点登录原理解析

    目录 什么是单点登录 单点登录原理 NodeJS 演示 三个不同的服务 首次访问跳转至登录页 应用A判断登录态,跳转到SSO认证服务器 认证服务器判断登录态,渲染登录页 校验用户信息,创建令牌 从认证服务器携带令牌跳转回应用A 令牌校验 返回资源 访问应用B 带cookie跳转至SSO认证服务器 从认证服务器携带令牌跳转回应用B 令牌校验 返回资源 什么是单点登录 随着公司业务的增多,必然会产生各个不同的系统,如果每个系统都需要单独登录的话就会很不方便.因此产生了单点登录这样的解决方案,单点登录

  • 入门到精通Java SSO单点登录原理详解

    目录 1. 基础概念 2. 单点登录 3. CAS 流程 4. OAuth 流程 5. CAS和OAuth的区别 1. 基础概念 SSO单点登录(Single sign-on) 所谓单点登录就是在多个应用系统中,用户只需登录一次就可以访问所有相互信任的系统. CAS 中央认证服务(Central Authentication Service) CAS是由美国耶鲁大学发起的一个企业级开源项目,旨在为WEB应用系统提供一种可靠的单点登录解决方案(WEB SSO). OAuth2.0 开放授权(Ope

  • springcloud微服务基于redis集群的单点登录实现解析

    简介 本文介绍微服务架构中如何实现单点登录功能 创建三个服务: 操作redis集群的服务,用于多个服务之间共享数据 统一认证中心服务,用于整个系统的统一登录认证 服务消费者,用于测试单点登录 大体思路:每个服务都设置一个拦截器检查cookie中是否有token,若有token,则放行,若没有token,重定向到统一认证中心服务进行登录,登录成功后返回到被拦截的服务. 搭建redis集群服务 搭建redis集群参考文档 搭建统一认证中心 主函数添加注解 /** * 单点登录既要注册到服务注册中心,

  • spring session同域下单点登录实现解析

    Session会话管理 在Web项目开发中,Session会话管理是一个很重要的部分,用于存储与记录用户的状态或相关的数据:通常情况下session交由容器(tomcat)来负责存储和管理,但是如果项目部署在多台tomcat中,则session管理存在很大的问题: 1.多台tomcat之间无法共享session,比如用户在tomcat A服务器上已经登录了,但当负载均衡跳转到tomcat B时,由于tomcat B服务器并没有用户的登录信息,session就失效了,用户就退出了登录: 2.一旦t

  • 基于JWT实现SSO单点登录流程图解

    一.基于JWT实现SSO单点登录原理 1.什么是单点登录 所谓单点登录就是有多个应用部署在不同的服务器上,只需登录一次就可以互相访问不同服务器上的资源. 2.单点登录流程 当一个访问请求发给应用A,如果这个请求需要登录以后才能访问,那么应用A就会向认证服务器请求授权,这时候就把用户引导到认证服务器上.用户在认证服务器上完成认证并授权.认证授权完成后,认证服务器返回给应用A一个授权码,应用A携带授权码到认证服务器请求令牌,认证服务器返回应用A一个JWT,应用A解析JWT里面的信息,完成登录.这是一

  • 浅析微信扫码登录原理(小结)

    微信扫码登录原理解析 扫码登录是现在流行的登录方式,使用这种方式及其方便,而且安全 扫码登录流程 原理 获取唯一的uuid, 以及包含uid信息的二维码 // 获取uuid getUUID: function() { var e = t.defer(); return window.QRLogin = {}, $.ajax({ url: i.API_jsLogin, dataType: "script" }).done(function() { 200 == window.QRLogi

  • SSO单点登录系统实现原理及流程图解

    一.准备 1.了解http请求及特点 2.了解cookie和session 3.了解用户登录和注销流程 二.单机用户登录流程 总体流程图实现: 1.http无状态协议 web应用采用browser/server架构,http作为通信协议.http是无状态协议,浏览器的每一次请求,服务器会独立处理,不与之前或之后的请求产生关联,这个过程用下图说明,三次请求/响应对之间没有任何联系 但这也同时意味着,任何用户都能通过浏览器访问服务器资源,如果想保护服务器的某些资源,必须限制浏览器请求:要限制浏览器请

  • 深入浅析C#中单点登录的原理和使用

    什么是单点登录? 我想肯定有一部分人"望文生义"的认为单点登录就是一个用户只能在一处登录,其实这是错误的理解(我记得我第一次也是这么理解的). 单点登录指的是多个子系统只需要登录一个,其他系统不需要登录了(一个浏览器内).一个子系统退出,其他子系统也全部是退出状态. 如果你还是不明白,我们举个实际的例子把.比如我们首页:https://www.jb51.ne ,和我们的搜索http://so.jb51.net .这就是两个系统(不同的域名).如果你登录其中一个,另一个也是登录状态.如果

  • Spring session实现共享单点登录案例过程解析

    一.项目构建 1.案例说明 本文主要演示单点登录功能,会贴出主要配置和代码以及必要解释,全部代码请参考git地址.session共享一个基本原则是将session存储在某个地方,所有的应用都可以访问,这里使用redis存储session.当应用需要认证时,先从redis读取用户信息. 2.基本配置 1)pom.xml <dependency> <groupId>org.springframework.session</groupId> <artifactId>

  • SpringSecurity OAuth2单点登录和登出的实现

    目录 1. 单点登录 1.1 使用内存保存客户端和用户信息 1.2 使用数据库保存客户端和用户信息 1.3 单点登录流程 1.3 JWT Token 2. 单点登出 3. 总结 参考: Spring Security OAuth 最新官方已经不再维护,以下内容只用于学习记录. GitHub:shpunishment/spring-security-oauth2-demo 1. 单点登录 单点登录即有多个子系统,有一个认证中心.当访问其中任意一个子系统时,如果发现未登录,就跳到认证中心进行登录,登

随机推荐