flask 源码解析：session

这是 flask 源码解析系列文章的其中一篇，本系列全部文章列表：

• flask 源码解析：简介

• flask 源码解析：应用启动流程

• flask 源码解析：路由

• flask 源码解析：上下文

• flask 源码解析：请求

• flask 源码解析：响应

• flask 源码解析：session

session 简介

在解析 session 的实现以前，咱们先介绍一下 session 怎么使用。session 能够看作是在不一样的请求之间保存数据的方法，由于 HTTP 是无状态的协议，可是在业务应用上咱们但愿知道不一样请求是不是同一我的发起的。好比购物网站在用户点击进入购物车的时候，服务器须要知道是哪一个用户执行了这个操做。

在 flask 中使用 session 也很简单，只要使用 from flask import session 导入这个变量，在代码中就能直接经过读写它和 session 交互。

from flask import Flask, session, escape, request

app = Flask(__name__)
app.secret_key = 'please-generate-a-random-secret_key'


@app.route("/")
def index():
    if 'username' in session:
        return 'hello, {}\n'.format(escape(session['username']))
    return 'hello, stranger\n'


@app.route("/login", methods=['POST'])
def login():
    session['username'] = request.form['username']
    return 'login success'


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

上面这段代码模拟了一个很是简单的登录逻辑，用户访问 POST /login 来登录，后面访问页面的时候 GET /，会返回该用户的名字。咱们看一下具体的操做实例（下面的操做都是用 httpie 来执行的，使用 curl 命令也能达到相同的效果）：

直接访问的话，咱们能够看到返回 hello stranger：

➜  ~ http -v http://127.0.0.1:5000/
GET / HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate
Host: 127.0.0.1:5000
User-Agent: HTTPie/0.8.0


HTTP/1.0 200 OK
Content-Length: 14
Content-Type: text/html; charset=utf-8
Date: Wed, 01 Mar 2017 04:22:18 GMT
Server: Werkzeug/0.11.2 Python/2.7.10

hello stranger

而后咱们模拟登录请求，-v 是打印出请求，-f 是告诉服务器这是表单数据，--session=mysession 是把请求的 cookie 等信息保存到这个变量中，后面能够经过变量来指定 session：

➜  ~ http -v -f --session=mysession POST http://127.0.0.1:5000/login username=cizixs
POST /login HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate
Content-Length: 15
Content-Type: application/x-www-form-urlencoded; charset=utf-8
Host: 127.0.0.1:5000
User-Agent: HTTPie/0.8.0

username=cizixs

HTTP/1.0 200 OK
Content-Length: 13
Content-Type: text/html; charset=utf-8
Date: Wed, 01 Mar 2017 04:20:54 GMT
Server: Werkzeug/0.11.2 Python/2.7.10
Set-Cookie: session=eyJ1c2VybmFtZSI6ImNpeml4cyJ9.C5fdpg.fqm3FTv0kYE2TuOyGF1mx2RuYQ4; HttpOnly; Path=/

login success

最重要的是咱们看到 response 中有 Set-Cookie 的头部，cookie 的键是 session，值是一堆看起来随机的字符串。

继续，这个时候咱们用 --session=mysession 参数把此次的请求带上保存在 mysession 中的信息，登录后访问，能够看到登录的用户名：

➜  ~ http -v --session=mysession http://127.0.0.1:5000/
GET / HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate
Cookie: session=eyJ1c2VybmFtZSI6ImNpeml4cyJ9.C5fevg.LE03yEZDWTUMQW-nNkTr1zBEhKk
Host: 127.0.0.1:5000
User-Agent: HTTPie/0.8.0


HTTP/1.0 200 OK
Content-Length: 11
Content-Type: text/html; charset=utf-8
Date: Wed, 01 Mar 2017 04:25:46 GMT
Server: Werkzeug/0.11.2 Python/2.7.10
Set-Cookie: session=eyJ1c2VybmFtZSI6ImNpeml4cyJ9.C5feyg.sfFCDIqfef4i8cvxUClUUGQNcHA; HttpOnly; Path=/

hellocizixs

此次注意在发送的请求中，客户端带了 Cookie 头部，上面的值保存了前一个请求的 response 给咱们设置的值。

总结一下：session 是经过在客户端设置 cookie 实现的，每次客户端发送请求的时候会附带着全部的 cookie，而里面保存着一些重要的信息（好比这里的用户信息），这样服务器端就能知道客户端的信息，而后根据这些数据作出对应的判断，就好像不一样请求之间是有记忆的。

解析

咱们知道 session 是怎么回事了，这部分就分析一下 flask 是怎么实现它的。

请求过程

不难想象，session 的大体解析过程是这样的：

• 请求过来的时候，flask 会根据 cookie 信息建立出 session 变量（若是 cookie 不存在，这个变量有可能为空），保存在该请求的上下文中

• 视图函数能够获取 session 中的信息，实现本身的逻辑处理

• flask 会在发送 response 的时候，根据 session 的值，把它写回到 cookie 中

注意：session 和 cookie 的转化过程当中，应该考虑到安全性，否则直接使用伪造的 cookie 会是个很大的安全隐患。

在 flask 上下文那篇文章中，咱们知道，每次请求过来的时候，咱们访问的 request 和 session 变量都是 RequestContext 实例的变量。在 RequestContext.Push() 方法的最后有这么一段代码：

self.session = self.app.open_session(self.request)
if self.session is None:
    self.session = self.app.make_null_session()

它初始化了 session 变量，保存在 RequestContext 上，这样后面就能直接经过 from flask import session 来使用它。若是没有设置 secret_key 变量， open_session 就会返回 None，这个时候会调用 make_null_session 来生成一个空的 session，这个特殊的 session 不能进行任何读写操做，否则会报异常给用户。

咱们来看看 open_session 方法：

def open_session(self, request):
    return self.session_interface.open_session(self, request)

在 Flask 中，全部和 session 有关的调用，都是转发到 self.session_interface 的方法调用上（这样用户就能用自定义的 session_interface 来控制 session 的使用）。而默认的 session_inerface 有默认值：

session_interface = SecureCookieSessionInterface()

后面遇到 session 有关方法解释，咱们会直接讲解 SecureCookieSessionInterface 的代码实现，跳过中间的这个转发说明。

null_session_class = NullSession

def make_null_session(self, app):
    return self.null_session_class()

def open_session(self, app, request):
    # 获取 session 签名的算法
    s = self.get_signing_serializer(app)
    if s is None:
        return None

    # 从 cookie 中获取 session 变量的值
    val = request.cookies.get(app.session_cookie_name)
    if not val:
        return self.session_class()

    # 由于 cookie 的数据须要验证是否有篡改，因此须要签名算法来读取里面的值
    max_age = total_seconds(app.permanent_session_lifetime)
    try:
        data = s.loads(val, max_age=max_age)
        return self.session_class(data)
    except BadSignature:
        return self.session_class()

open_session 根据请求中的 cookie 来获取对应的 session 对象。之因此有 app 参数，是由于根据 app 中的安全设置（好比签名算法、secret_key）对 cookie 进行验证。

这里有两点须要特殊说明的：签名算法是怎么工做的？session 对象究竟是怎么定义的？

session 对象

默认的 session 对象是 SecureCookieSession，这个类就是一个基本的字典，外加一些特殊的属性，好比 permanent（flask 插件会用到这个变量）、modified（代表实例是否被更新过，若是更新过就要从新计算并设置 cookie，由于计算过程比较贵，因此若是对象没有被修改，就直接跳过）。

class SessionMixin(object):
    def _get_permanent(self):
        return self.get('_permanent', False)

    def _set_permanent(self, value):
        self['_permanent'] = bool(value)

    #: this reflects the ``'_permanent'`` key in the dict.
    permanent = property(_get_permanent, _set_permanent)
    del _get_permanent, _set_permanent

    modified = True

class SecureCookieSession(CallbackDict, SessionMixin):
    """Base class for sessions based on signed cookies."""

    def __init__(self, initial=None):
        def on_update(self):
            self.modified = True
        CallbackDict.__init__(self, initial, on_update)
        self.modified = False

怎么知道实例的数据被更新过呢？ SecureCookieSession 是基于 werkzeug/datastructures:CallbackDict 实现的，这个类能够指定一个函数做为 on_update 参数，每次有字典操做的时候（__setitem__、__delitem__、clear、popitem、update、pop、setdefault）会调用这个函数。

NOTE：CallbackDict 的实现很巧妙，可是并不复杂，感兴趣的能够本身参考代码。主要思路就是重载字典的一些更新操做，让它们在作原来事情的同时，额外调用一下实现保存的某个函数。

对于开发者来讲，能够把 session 简单地当作字典，全部的操做都是和字典一致的。

签名算法

都获取 cookie 数据的过程当中，最核心的几句话是：

s = self.get_signing_serializer(app)
val = request.cookies.get(app.session_cookie_name)
data = s.loads(val, max_age=max_age)

return self.session_class(data)

其中两句都和 s 有关，signing_serializer 保证了 cookie 和 session 的转换过程当中的安全问题。若是 flask 发现请求的 cookie 被篡改了，它会直接放弃使用。

咱们继续看 get_signing_serializer 方法：

def get_signing_serializer(self, app):
    if not app.secret_key:
        return None
    signer_kwargs = dict(
        key_derivation=self.key_derivation,
        digest_method=self.digest_method
    )
    return URLSafeTimedSerializer(app.secret_key,
        salt=self.salt,
        serializer=self.serializer,
        signer_kwargs=signer_kwargs)

咱们看到这里须要用到不少参数：

• secret_key：密钥。这个是必须的，若是没有配置 secret_key 就直接使用 session 会报错

• salt：为了加强安全性而设置一个 salt 字符串（能够自行搜索“安全加盐”了解对应的原理）

• serializer：序列算法

• signer_kwargs：其余参数，包括摘要/hash算法（默认是 sha1）和 签名算法（默认是 hmac）

URLSafeTimedSerializer 是 itsdangerous 库的类，主要用来进行数据验证，增长网络中数据的安全性。itsdangerours 提供了多种 Serializer，能够方便地进行相似 json 处理的数据序列化和反序列的操做。至于具体的实现，由于篇幅限制，就不解释了。

应答过程

flask 会在请求过来的时候自动解析 cookie 的值，把它变成 session 变量。开发在视图函数中可使用它的值，也能够对它进行更新。最后再返回的 response 中，flask 也会自动把 session 写回到 cookie。咱们来看看这部分是怎么实现的！

以前的文章讲解了应答的过程，其中 finalize_response 方法在根据视图函数的返回生成 response 对象以后，会调用 process_response 方法进行处理。process_response 方法的最后有这样两句话：

def process_response(self, response):
    ...
    if not self.session_interface.is_null_session(ctx.session):
        self.save_session(ctx.session, response)
    return response

这里就是 session 在应答中出现的地方，思路也很简单，若是须要就调用 save_sessoin，把当前上下文中的 session 对象保存到 response 。

save_session 的代码和 open_session 对应：

def save_session(self, app, session, response):
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)

        # 若是 session 变成了空字典，flask 会直接删除对应的 cookie
        if not session:
            if session.modified:
                response.delete_cookie(app.session_cookie_name,
                                       domain=domain, path=path)
            return

        # 是否须要设置 cookie。若是 session 发生了变化，就必定要更新 cookie，不然用户能够 `SESSION_REFRESH_EACH_REQUEST` 变量控制是否要设置 cookie
        if not self.should_set_cookie(app, session):
            return

        httponly = self.get_cookie_httponly(app)
        secure = self.get_cookie_secure(app)
        expires = self.get_expiration_time(app, session)
        val = self.get_signing_serializer(app).dumps(dict(session))
        response.set_cookie(app.session_cookie_name, val,
                            expires=expires,
                            httponly=httponly,
                            domain=domain, path=path, secure=secure)

这段代码也很容易理解，就是从 app 和 session 变量中获取全部须要的信息，而后调用 response.set_cookie 设置最后的 cookie。这样客户端就能在 cookie 中保存 session 有关的信息，之后访问的时候再次发送给服务器端，以此来实现有状态的交互。

解密 session

有时候在开发或者调试的过程当中，须要了解 cookie 中保存的究竟是什么值，能够经过手动解析它的值。session 在 cookie 中的值，是一个字符串，由句号分割成三个部分。第一部分是 base64 加密的数据，第二部分是时间戳，第三部分是校验信息。

前面两部分的内容能够经过下面的方式获取，代码也可直观，就不给出解释了：

In [1]: from itsdangerous import *

In [2]: s = 'eyJ1c2VybmFtZSI6ImNpeml4cyJ9.C5fdpg.fqm3FTv0kYE2TuOyGF1mx2RuYQ4'

In [3]: data, timstamp, secret = s.split('.')

In [4]: base64_decode(data)
Out[4]: '{"username":"cizixs"}'

In [5]: bytes_to_int(base64_decode(timstamp))
Out[5]: 194502054

In [7]: time.strftime('%Y-%m-%d %H:%I%S', time.localtime(194502054+EPOCH))
Out[7]: '2017-03-01 12:1254'

总结

flask 默认提供的 session 功能仍是很简单的，知足了基本的功能。可是咱们看到 flask 把 session 的数据都保存在客户端的 cookie 中，这里只有用户名还好，若是有一些私密的数据（好比密码，帐户余额等等），就会形成严重的安全问题。能够考虑使用 flask-session 这个三方的库，它把数据保存在服务器端（本地文件、redis、memcached），客户端只拿到一个 sessionid。

session 主要是用来在不一样的请求之间保存信息，最多见的应用就是登录功能。虽然直接经过 session 本身也能够写出来不错的登录功能，可是在实际的项目中能够考虑 flask-login 这个三方的插件，方便咱们的开发

参考资料

• flask-session github page

• Flask 源码阅读笔记