单系统登录机制

http无状态协议

Web应用一般都是采用browser/server架构，使用http作为通信协议。http是无状态协议，浏览器的每一次请求，服务器都会独立处理，不与之前或之后的请求产生关联，这个过程用下图说明，三次请求/响应对之间没有任何联系

但这也同时意味着，任何用户都能通过浏览器访问服务器资源，如果想保护服务器的某些资源，必须限制浏览器请求；要限制浏览器请求，必须鉴别浏览器请求，响应合法请求，忽略非法请求；要鉴别浏览器请求，必须清楚浏览器请求状态。既然http协议无状态，那就让服务器和浏览器共同维护一个状态吧！这就是会话机制

会话机制

浏览器第一次请求服务器，服务器创建一个会话，并将会话的id作为响应的一部分发送给浏览器，浏览器存储会话id，并在后续第二次和第三次请求中带上会话id，服务器取得请求中的会话id就知道是不是同一个用户了，这个过程用下图说明，后续请求与第一次请求产生了关联

服务器在内存中保存会话对象，浏览器怎么保存会话id呢？你可能会想到两种方式

• 请求参数
• cookie

将会话id作为每一个请求的参数，服务器接收请求自然能解析参数获得会话id，并借此判断是否来自同一会话，很明显，这种方式不靠谱。那就浏览器自己来维护这个会话id吧，每次发送http请求时浏览器自动发送会话id，cookie机制正好用来做这件事。cookie是浏览器用来存储少量数据的一种机制，数据以”key/value“形式存储，浏览器发送http请求时自动附带cookie信息

tomcat会话机制当然也实现了cookie，访问tomcat服务器时，浏览器中可以看到一个名为“JSESSIONID”的cookie，这就是tomcat会话机制维护的会话id，使用了cookie的请求响应过程如下图

登录状态

有了会话机制，登录状态就好明白了，我们假设浏览器第一次请求服务器需要输入用户名与密码验证身份，服务器拿到用户名密码去数据库比对，正确的话说明当前持有这个会话的用户是合法用户，应该将这个会话标记为“已授权”或者“已登录”等等之类的状态，既然是会话的状态，自然要保存在会话对象中，tomcat在会话对象中设置登录状态如下

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

用户再次访问时，tomcat在会话对象中查看登录状态

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

实现了登录状态的浏览器请求服务器模型如下图描述

每次请求受保护资源时都会检查会话对象中的登录状态，只有 isLogin=true 的会话才能访问，登录机制因此而实现。

多系统的复杂性

web系统早已从久远的单系统发展成为如今由多系统组成的应用群，面对如此众多的系统，用户难道要一个一个登录、然后一个一个注销吗？

web系统由单系统发展成多系统组成的应用群，复杂性应该由系统内部承担，而不是用户。无论web系统内部多么复杂，对用户而言，都是一个统一的整体，也就是说，用户访问web系统的整个应用群与访问单个系统一样，登录/注销只要一次就够了

虽然单系统的登录解决方案很完美，但对于多系统应用群已经不再适用了，为什么呢？

单系统登录解决方案的核心是cookie，cookie携带会话id在浏览器与服务器之间维护会话状态。但cookie是有限制的，这个限制就是cookie的域（通常对应网站的域名），浏览器发送http请求时会自动携带与该域匹配的cookie，而不是所有cookie

既然这样，为什么不将web应用群中所有子系统的域名统一在一个顶级域名下，例如“*.baidu.com”，然后将它们的cookie域设置为“baidu.com”，这种做法理论上是可以的，甚至早期很多多系统登录就采用这种同域名共享cookie的方式。

然而，可行并不代表好，共享cookie的方式存在众多局限。首先，应用群域名得统一；其次，应用群各系统使用的技术（至少是web服务器）要相同，不然cookie的key值（tomcat为JSESSIONID）不同，无法维持会话，共享cookie的方式是无法实现跨语言技术平台登录的，比如java、php、.net系统之间；第三，cookie本身不安全。

因此，我们需要一种全新的登录方式来实现多系统应用群的登录，这就是单点登录

单点登录

什么是单点登录？单点登录全称Single Sign On（以下简称SSO），是指在多系统应用群中登录一个系统，便可在其他所有系统中得到授权而无需再次登录，包括单点登录与单点注销两部分

登录

相比于单系统登录，sso需要一个独立的认证中心，只有认证中心能接受用户的用户名密码等安全信息，其他系统不提供登录入口，只接受认证中心的间接授权。间接授权通过令牌实现，sso认证中心验证用户的用户名密码没问题，创建授权令牌，在接下来的跳转过程中，授权令牌作为参数发送给各个子系统，子系统拿到令牌，即得到了授权，可以借此创建局部会话，局部会话登录方式与单系统的登录方式相同。这个过程，也就是单点登录的原理，用下图说明

下面对上图简要描述

• 用户访问系统1的受保护资源，系统1发现用户未登录，跳转至sso认证中心，并将自己的地址作为参数
• sso认证中心发现用户未登录，将用户引导至登录页面
• 用户输入用户名密码提交登录申请
• sso认证中心校验用户信息，创建用户与sso认证中心之间的会话，称为全局会话，同时创建授权令牌
• sso认证中心带着令牌跳转会最初的请求地址（系统1）
• 系统1拿到令牌，去sso认证中心校验令牌是否有效
• sso认证中心校验令牌，返回有效，注册系统1
• 系统1使用该令牌创建与用户的会话，称为局部会话，返回受保护资源
• 用户访问系统2的受保护资源
• 系统2发现用户未登录，跳转至sso认证中心，并将自己的地址作为参数
• sso认证中心发现用户已登录，跳转回系统2的地址，并附上令牌
• 系统2拿到令牌，去sso认证中心校验令牌是否有效
• sso认证中心校验令牌，返回有效，注册系统2
• 系统2使用该令牌创建与用户的局部会话，返回受保护资源

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

• 局部会话存在，全局会话一定存在
• 全局会话存在，局部会话不一定存在
• 全局会话销毁，局部会话必须销毁

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

注销

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

实现

Python ，此部分为验证中心

# - * - coding: utf-8 - * -
import json
import jwt
import logging
import datetime
import requests

from backend.constants import SSO_LOGIN_ADDRESS
from django.shortcuts import redirect
from django.utils import timezone
from django.http import HttpResponseRedirect

from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status

from backend.util import decode_jwt, encode_jwt
from backend.models import UserTokenStore, UserProfile

logger = logging.getLogger('dev_logger')


@api_view(['GET'])
def verify_login(request):
    """
    verify user login information
    :param request:
    :return:
    """
    request_web_address = request.GET.get('request_web_address')
    logger.debug('request_web_address:{}'.format(request_web_address))

    token = None
    # the following identity can use sso
    user_types = ['s-jwt', 't-jwt']
    for user_type in user_types:
        token = request.COOKIES.get(user_type)
        if token:
            logger.debug('find token')
            break

    if token:
        # verify pass, store and publish the token
        jwt_json = decode_jwt(token)
        union_id = jwt_json["unionid"]

        logger.debug('cookie:{}'.format(token))
        logger.debug('json:{}'.format(jwt_json))
        logger.debug('unionid:{}'.format(union_id))

        # create new token
        # create_token = create_authorization_token(unionid=union_id)

        tested_user = UserProfile.objects.filter(unionid=union_id).first()
        logger.debug('tested_user:{}'.format(tested_user))
        if tested_user:
            return HttpResponseRedirect(request_web_address+'?token='+token)
        else:
            logger.debug('tested_user is null ')
            data = {'status': False, 'content': 'user not exist'}
            return Response(data)
    else:
        logger.debug('token not find')
        # jump to the login page
        # data = {'status': False, 'content': SSO_LOGIN_ADDRESS}
        data = {'status': False, 'content': 'token not exist'}
        return Response(data)
        # return HttpResponseRedirect(SSO_LOGIN_ADDRESS)
        # return Response(status=status.HTTP_406_NOT_ACCEPTABLE)


@api_view(['POST'])
def verify_authorization_token(request):
    """
    receive and check token
    :return:
    """
    logger.debug('verify_authorization_token is running')

    # clean_expired_token()
    token = request.POST.get('token')
    if not token:
        data = {'status': False, 'content': 'not found token'}
        logger.debug('data:{}'.format(data))
        return Response(data)
    # request_address = get_client_ip(request)

    # logger.debug('request_address:{}'.format(request_address))

    json = decode_jwt(token)
    unionid = json["unionid"]
    logger.debug('unionid:{}'.format(unionid))

    # check token
    tested_user = UserProfile.objects.filter(unionid=unionid).first()
    if not tested_user:
        data = {'status': False, 'content': 'user not exist'}
        logger.debug('data:{}'.format(data))
        return Response(data)
    # get_token = UserTokenStore.objects.filter(no=tested_user, content=token).first()

    # if not get_token:
    #     data = {'status': False, 'content': 'token not exist'}
    #     logger.debug('data:{}'.format(data))
    #     return Response(data)

    data = {'status': True, 'content': 'success'}

    logger.debug('data:{}'.format(data))
    return Response(data)


def create_authorization_token(**kwargs):
    """
    if you need to encrypt information in Token, you should create it here
    :param kwargs:
    :return:
    """
    # kwargs = {"unionid": "unionid"}
    token = jwt.encode(kwargs, 'WELCOME_EMBARKCHINA', algorithm="HS256")

    return token


def get_client_ip(request):
    """
    get user ip address
    :param request:
    :return:
    """
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0]
    else:
        ip = request.META.get('REMOTE_ADDR')
    return ip


def global_logout(request):
    """
    global logout
    :return:
    """
    pass


def verify(sso_server_verify_url, token):
    """
    authentication procedure
    :param sso_server_verify_url:
    :param token:
    :return:
    """
    return True


def clean_expired_token():
    uts = UserTokenStore.objects.filter(dead_time__lt=timezone.now()).delete()
    logger.debug('clean_token:{}'.format(uts))

Java部分代码

private void ossLogin(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String ssoToken = request.getParameter("token");

        if (Strings.isNullOrEmpty(ssoToken)) {

            // 先在本地验证是否登录
            OdeAuthFilter.UserInfo userInfo = OdeAuthFilter.getUserInfo(request);
            if (userInfo != null) {
                responseUtil.responseWithStatus(response, 0, true, "user login");
                return;
            }
            // 已登录就是返回true,未登录就到sso认证中心进行认证
            String certificationAddress = Flag.createFlag("sso.certification.authority.address", "localhost").get();
            String getToken = Flag.createFlag("accept.token.address", "localhost").get();
            //String getTokenAddress = Flag.createFlag("accept.token.address", "localhost").get();
            //LOG.info("tokenAddress = " + getTokenAddress);
            LOG.info("certificationAddress = " + certificationAddress);

            response.sendRedirect(certificationAddress + "?request_web_address=" + getToken);

        } else {
            LOG.info("token = " + ssoToken);
            // 验证token
            String params = "token=" + ssoToken;
            String verifyTokenAddress = Flag.createFlag("verify.token.address", "localhost").get();
            String result = URLConnectionHelper.sendPost(verifyTokenAddress, params);
            SSOResult objResult = new Gson().fromJson(result, SSOResult.class);
            if (objResult !=null) {
                LOG.info("SSOResult = " + objResult.toString());
                if (objResult.isStatus()) {
                    // 进行登录
                    LOG.info("get token = " + ssoToken);

                    Key KEY = new SecretKeySpec("WELCOME_EMBARKCHINA".getBytes(), SignatureAlgorithm.HS256.getJcaName());
                    Jws<Claims> claimsJws = Jwts.parser().setSigningKey(KEY).parseClaimsJws(ssoToken);
                    JwsHeader header = claimsJws.getHeader();
                    Claims body = claimsJws.getBody();

                    String unionid = body.get("unionid", String.class);
                    LOG.info("jwt header:" + header);
                    LOG.info("jwt body:" + body);
                    LOG.info("jwt body unionid:" + unionid);

                    LOG.info("token pass second verification");
                    // unionid = "anna";
                    User user = storageIo.findUserByEmail(unionid);
                    if (user == null) {
                        LOG.info("cant found user by unionid:" + unionid);
                        responseUtil.responseWithStatus(response, 1005, false, "用户名不存在！");
                    } else {
                        OdeAuthFilter.UserInfo userInfo = new OdeAuthFilter.UserInfo();
                        userInfo.setUserId(user.getUserId());
                        userInfo.setIsAdmin(user.getIsAdmin());
                        addUserCookie(response, userInfo);
                        LOG.info("find user");
                        LOG.info("user login" + userInfo.getUserId());
                        responseUtil.responseWithStatus(response, 0, true, "user login");
                    }
                }else{
                    responseUtil.responseWithStatus(response, 0, true, "token 认证失败,请到官网登录");
                }
            }else{
                responseUtil.responseWithStatus(response, 0, true, "token 认证接口请求异常");
            }
        }
    }