Django 进阶篇之 CSRF,COOIKE,SESSION

时间 2019-11-12

标签 django 进阶 csrf cooike session 栏目 Python 繁體版

原文原文链接

1.CSRF（Cross Site Request Forgery, 跨站域请求伪造）

CSRF 背景与介绍

CSRF（Cross Site Request Forgery, 跨站域请求伪造）是一种网络的攻击方式，它在 2007 年曾被列为互联网 20 大安全隐患之一。其余安全隐患，好比 SQL 脚本注入，跨站域脚本攻击等在近年来已经逐渐为众人熟知，不少网站也都针对他们进行了防护。然而，对于大多数人来讲，CSRF 却依然是一个陌生的概念。即使是大名鼎鼎的 Gmail, 在 2007 年末也存在着 CSRF 漏洞，从而被黑客攻击而使 Gmail 的用户形成巨大的损失。javascript

CSRF 攻击实例

CSRF 攻击能够在受害者绝不知情的状况下以受害者名义伪造请求发送给受攻击站点，从而在并未受权的状况下执行在权限保护之下的操做。好比说，受害者 Bob 在银行有一笔存款，经过对银行的网站发送请求 http://bank.example/withdraw?account=bob&amount=1000000&for=bob2 可使 Bob 把 1000000 的存款转到 bob2 的帐号下。一般状况下，该请求发送到网站后，服务器会先验证该请求是否来自一个合法的 session，而且该 session 的用户 Bob 已经成功登录。黑客 Mallory 本身在该银行也有帐户，他知道上文中的 URL 能够把钱进行转账操做。Mallory 能够本身发送一个请求给银行：http://bank.example/withdraw?account=bob&amount=1000000&for=Mallory。可是这个请求来自 Mallory 而非 Bob，他不能经过安全认证，所以该请求不会起做用。这时，Mallory 想到使用 CSRF 的攻击方式，他先本身作一个网站，在网站中放入以下代码： src=”http://bank.example/withdraw?account=bob&amount=1000000&for=Mallory ”，而且经过广告等诱使 Bob 来访问他的网站。当 Bob 访问该网站时，上述 url 就会从 Bob 的浏览器发向银行，而这个请求会附带 Bob 浏览器中的 cookie 一块儿发向银行服务器。大多数状况下，该请求会失败，由于他要求 Bob 的认证信息。可是，若是 Bob 当时恰巧刚访问他的银行后不久，他的浏览器与银行网站之间的 session 还没有过时，浏览器的 cookie 之中含有 Bob 的认证信息。这时，悲剧发生了，这个 url 请求就会获得响应，钱将从 Bob 的帐号转移到 Mallory 的帐号，而 Bob 当时绝不知情。等之后 Bob 发现帐户钱少了，即便他去银行查询日志，他也只能发现确实有一个来自于他本人的合法请求转移了资金，没有任何被攻击的痕迹。而 Mallory 则能够拿到钱后逍遥法外。html

CSRF 攻击的对象

在讨论如何抵御 CSRF 以前，先要明确 CSRF 攻击的对象，也就是要保护的对象。从以上的例子可知，CSRF 攻击是黑客借助受害者的 cookie 骗取服务器的信任，可是黑客并不能拿到 cookie，也看不到 cookie 的内容。另外，对于服务器返回的结果，因为浏览器同源策略的限制，黑客也没法进行解析。所以，黑客没法从返回的结果中获得任何东西，他所能作的就是给服务器发送请求，以执行请求中所描述的命令，在服务器端直接改变数据的值，而非窃取服务器中的数据。因此，咱们要保护的对象是那些能够直接产生数据改变的服务，而对于读取数据的服务，则不须要进行 CSRF 的保护。好比银行系统中转帐的请求会直接改变帐户的金额，会遭到 CSRF 攻击，须要保护。而查询余额是对金额的读取操做，不会改变数据，CSRF 攻击没法解析服务器返回的结果，无需保护。java

防护策略：在请求地址中添加 token 并验证

CSRF 攻击之因此可以成功，是由于黑客能够彻底伪造用户的请求，该请求中全部的用户验证信息都是存在于 cookie 中，所以黑客能够在不知道这些验证信息的状况下直接利用用户本身的 cookie 来经过安全验证。要抵御 CSRF，关键在于在请求中放入黑客所不能伪造的信息，而且该信息不存在于 cookie 之中。能够在 HTTP 请求中以参数的形式加入一个随机产生的 token，并在服务器端创建一个拦截器来验证这个 token，若是请求中没有 token 或者 token 内容不正确，则认为多是 CSRF 攻击而拒绝该请求。jquery

token 能够在用户登录后产生并放于 session 之中，而后在每次请求时把 token 从 session 中拿出，与请求中的 token 进行比对，但这种方法的难点在于如何把 token 以参数的形式加入请求。对于 GET 请求，token 将附在请求地址以后，这样 URL 就变成 http://url?csrftoken=tokenvalue。而对于 POST 请求来讲，要在 form 的最后加上 <input type=”hidden” name=”csrftoken” value=”tokenvalue”/>，这样就把 token 以参数的形式加入请求了。可是，在一个网站中，能够接受请求的地方很是多，要对于每个请求都加上 token 是很麻烦的，而且很容易漏掉，一般使用的方法就是在每次页面加载时，使用 javascript 遍历整个 dom 树，对于 dom 中全部的 a 和 form 标签后加入 token。这样能够解决大部分的请求，可是对于在页面加载以后动态生成的 html 代码，这种方法就没有做用，还须要程序员在编码时手动添加 token。git

Django 中使用CSRF

method:

To take advantage of CSRF protection in your views, follow these steps:

The CSRF middleware is activated by default in the MIDDLEWARE_CLASSES setting. If you override that setting, remember that 'django.middleware.csrf.CsrfViewMiddleware' should come before any view middleware that assume that CSRF attacks have been dealt with.

If you disabled it, which is not recommended, you can use csrf_protect() on particular views you want to protect (see below).

In any template that uses a POST form, use the csrf_token tag inside the <form> element if the form is for an internal URL, e.g.:

<form action="" method="post">{% csrf_token %}
This should not be done for POST forms that target external URLs, since that would cause the CSRF token to be leaked, leading to a vulnerability.

In the corresponding view functions, ensure that RequestContext is used to render the response so that {%csrf_token %} will work properly. If you’re using the render() function, generic views, or contrib apps, you are covered already since these all use RequestContext.

CSRF with AJAX

While the above method can be used for AJAX POST requests, it has some inconveniences: you have to remember to pass the CSRF token in as POST data with every POST request. For this reason, there is an alternative method: on each XMLHttpRequest, set a custom X-CSRFToken header to the value of the CSRF token. This is often easier, because many JavaScript frameworks provide hooks that allow headers to be set on every request.

As a first step, you must get the CSRF token itself. The recommended source for the token is the csrftokencookie, which will be set if you’ve enabled CSRF protection for your views as outlined above.

Acquiring the token is straightforward:程序员

// using jQuery
function getCookie(name) {
    var cookieValue = null;
    if (document.cookie && document.cookie != '') {
        var cookies = document.cookie.split(';');
        for (var i = 0; i < cookies.length; i++) {
            var cookie = jQuery.trim(cookies[i]);
            // Does this cookie string begin with the name we want?
            if (cookie.substring(0, name.length + 1) == (name + '=')) {
                cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
                break;
            }
        }
    }
    return cookieValue;
}
var csrftoken = getCookie('csrftoken');

The above code could be simplified by using the JavaScript Cookie library to replace getCookie:github

var csrftoken = Cookies.get('csrftoken');

Finally, you’ll have to actually set the header on your AJAX request, while protecting the CSRF token from being sent to other domains using settings.crossDomain in jQuery 1.5.1 and newer:ajax

function csrfSafeMethod(method) {
    // these HTTP methods do not require CSRF protection
    return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
}
$.ajaxSetup({
    beforeSend: function(xhr, settings) {
        if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
            xhr.setRequestHeader("X-CSRFToken", csrftoken);
        }
    }
});

下面来看下实例：数据库

此前咱们将settings的csrf注释掉，如今打开django

MIDDLEWARE_CLASSES = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

views:

def csrf(request):

    return render(request,'csrf.html')

html：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title></title>
</head>
<body>
        {#        form提交,能够比喻为衣服的外兜#}
        <form action="/csrf/" method="post">
            {% csrf_token %}
            <input type="text" name="v" />
            <input type="submit" value="提交" />
        </form>
        {#Ajax提交,能够比喻为衣服的内兜#}
        <input type="button"  value="Ajax提交" onclick="DoAjax();" />
        <script src="/static/jquery-2.1.4.min.js"></script>
        <script src="/static/jquery.cookie.js"></script> ##在引用$.cooike前要导入jquery.cooike.js这个插件
    <script>
        // 去cookie中获取值
        var csrftoken = $.cookie('csrftoken');

        function csrfSafeMethod(method) {
            // these HTTP methods do not require CSRF protection
            return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
        }
        {#        为每一个jquery函数注册csrf方法,不用每次都从新注册#}
        $.ajaxSetup({
            beforeSend: function(xhr, settings) {
                if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                    xhr.setRequestHeader("X-CSRFToken", csrftoken);
                }
            }
        });
        function DoAjax(){
            $.ajax({
                url: '/csrf/',
                type: 'POST',
                data: {'k1': 'v1'},
                success: function (data) {
                    console.log(data);
                }
            })
        }
    </script>

</body>
</html>

开发模式下打开在input标签下django会自动添加带有token的input标签

全局：

　　中间件 django.middleware.csrf.CsrfViewMiddleware

局部：

@csrf_protect，为当前函数强制设置防跨站请求伪造功能，即使settings中没有设置全局中间件。
@csrf_exempt，取消当前函数防跨站请求伪造功能，即使settings中设置了全局中间件。

注：from django.views.decorators.csrf import csrf_exempt,csrf_protect

取消csrftoken验证

from django.views.decorators.csrf import csrf_exempt

@csrf_exempt
def post_data(request):
    pass

在urlconf当中用

from django.views.decorators.csrf import csrf_exempt
urlpatterns = [
    url(r'^post/get_data/$', csrf_exempt(post_data), name='post_data'),

]

只对特定的url作csrf保护，能够用csrf_protect装饰器

缘由是在视图函数中少了一个装饰方法@csrf_protect
装饰方法：
而不是增长CsrfViewMiddleware就全面保护,您可使用csrfprotect装饰,具备彻底相同的功能,在特定的视图,须要保护。注意必须经过POST形式和{% csrftoken %}令牌才能对此有用。

from django.views.decorators.csrf import csrf_protect

@csrf_protect
def post_data(request):
    pass

更多：https://docs.djangoproject.com/en/dev/ref/csrf/#ajax

2.cookie&&session

Cookie就是一段字符串，保存于本机电脑上。

session 保存于服务器,用来保存用户的会话信息，依赖于Cookies.

一、流程

举个例子，我们在登陆一个网站后，拿JD，淘宝举例，若是我登陆进去以后，在想点击订单的时候。server断怎么判断我是“我”，而不是其余人呢？

Http是短链接，那么Server端确定有一个保存我登陆状态的地方（session），那server怎么判断是我发送过来的请求呢?就是经过Cookie！

当客户端访问过来后，server端会在IE里生成一个Cookie，当访问过来的时候就能够经过Cookie进行判断

二、结构

一、自动生成一段字符串

二、将字符串发送到客户端的浏览器，同时把字符串当作key放在session里。（能够理解为session就是一个字典）

三、在用户的session对应的value里设置任意值

3.Session和Cookie的好处及用途

使用Session和Cookie的好处：Cookie能够理解为一个身份证ID，你只能拿着他去和Server端进行通讯，若是你没有这个ID那么server端也不知道你是谁！

实例：（0 0 ！）

我在写博客的时候在作Cookie和Session的实验，把Cookie删掉了！当我保存的时候直接给我提出来了，为何呢？就是由于，server端不知道我是谁了，我已经没有密钥了。

因此，只要Session和Cookie任意一方失效，就能够理解为：

Cookie失效就至关于身份证ID过时，须要从新认证才能够继续使用。Session失效就至关于银行里的数据标识此ID无效，也须要从新申请。

4.操做与配置

Cooike:

一、获取Cookie：

request.COOKIES['key']
request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
    参数：
        default: 默认值
           salt: 加密盐
        max_age: 后台控制过时时间

二、设置Cookie：

rep = HttpResponse(...) 或 rep ＝ render(request, ...)
 
rep.set_cookie(key,value,...)
rep.set_signed_cookie(key,value,salt='加密盐',...)
    参数：
        key,              键
        value='',         值
        max_age=None,     超时时间
        expires=None,     超时时间(IE requires expires, so set it if hasn't been already.)
        path='/',         Cookie生效的路径，/ 表示根路径，特殊的：跟路径的cookie能够被任何url的页面访问
        domain=None,      Cookie生效的域名
        secure=False,     https传输
        httponly=False    只能http协议传输，没法被JavaScript获取（不是绝对，底层抓包能够获取到也能够被覆盖）

因为cookie保存在客户端的电脑上，因此，JavaScript和jquery也能够操做cookie。

<script src='/static/js/jquery.cookie.js'></script>
$.cookie("list_pager_num", 30,{ path: '/' });

实例：

views:

def cookie(request):
    print(request.COOKIES)
    obj = render(request, 'cookie.html')
    obj.set_cookie('k3','v3',path='/cookie/')
    return obj

def cookie1(request):
    print(request.COOKIES)
    obj = render(request, 'cookie.html')
    return obj

session:

Django中默认支持Session，其内部提供了5种类型的Session供开发者使用：

数据库（默认）
缓存
文件
缓存+数据库
加密cookie

一、数据库Session

Django默认支持Session，而且默认是将Session数据存储在数据库中，即：django_session 表中。
 
a. 配置 settings.py
 
    SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）
     
    SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
    SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
    SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
    SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
    SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
    SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期（2周）（默认）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过时（默认）
    SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改以后才保存（默认）
 
 
 
b. 使用
 
    def index(request):
        # 获取、设置、删除Session中数据
        request.session['k1']
        request.session.get('k1',None)
        request.session['k1'] = 123
        request.session.setdefault('k1',123) # 存在则不设置
        del request.session['k1']
 
        # 全部 键、值、键值对
        request.session.keys()
        request.session.values()
        request.session.items()
        request.session.iterkeys()
        request.session.itervalues()
        request.session.iteritems()
 
 
        # 用户session的随机字符串
        request.session.session_key
 
        # 将全部Session失效日期小于当前日期的数据删除
        request.session.clear_expired()
 
        # 检查 用户session的随机字符串 在数据库中是否
        request.session.exists("session_key")
 
        # 删除当前用户的全部Session数据
        request.session.delete("session_key")

　　　　　request.session.set_expiry(value)
　　　　　* 若是value是个整数，session会在些秒数后失效。
　　　　　* 若是value是个datatime或timedelta，session就会在这个时间后失效。
　　　　　* 若是value是0,用户关闭浏览器session就会失效。
　　　　　* 若是value是None,session会依赖全局session失效策略。

...

二、缓存Session

 
    SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
    SESSION_CACHE_ALIAS = 'default'                            # 使用的缓存别名（默认内存缓存，也能够是memcache），此处别名依赖缓存的设置
 
 
    SESSION_COOKIE_NAME ＝ "sessionid"                        # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
    SESSION_COOKIE_PATH ＝ "/"                                # Session的cookie保存的路径
    SESSION_COOKIE_DOMAIN = None                              # Session的cookie保存的域名
    SESSION_COOKIE_SECURE = False                             # 是否Https传输cookie
    SESSION_COOKIE_HTTPONLY = True                            # 是否Session的cookie只支持http传输
    SESSION_COOKIE_AGE = 1209600                              # Session的cookie失效日期（2周）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                   # 是否关闭浏览器使得Session过时
    SESSION_SAVE_EVERY_REQUEST = False                        # 是否每次请求都保存Session，默认修改以后才保存
 
 
 
b. 使用
 
    同上

三、文件Session

a. 配置 settings.py
 
    SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎
    SESSION_FILE_PATH = None                                    # 缓存文件路径，若是为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()                                                            # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T
 
 
    SESSION_COOKIE_NAME ＝ "sessionid"                          # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
    SESSION_COOKIE_PATH ＝ "/"                                  # Session的cookie保存的路径
    SESSION_COOKIE_DOMAIN = None                                # Session的cookie保存的域名
    SESSION_COOKIE_SECURE = False                               # 是否Https传输cookie
    SESSION_COOKIE_HTTPONLY = True                              # 是否Session的cookie只支持http传输
    SESSION_COOKIE_AGE = 1209600                                # Session的cookie失效日期（2周）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                     # 是否关闭浏览器使得Session过时
    SESSION_SAVE_EVERY_REQUEST = False                          # 是否每次请求都保存Session，默认修改以后才保存
 
b. 使用
 
    同上

四、缓存+数据库Session

数据库用于作持久化，缓存用于提升效率
 
a. 配置 settings.py
 
    SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎
 
b. 使用
 
    同上

五、加密cookie Session

a. 配置 settings.py
     
    SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎
 
b. 使用
 
    同上

更多参考：猛击这里和猛击这里

扩展：Session用户验证

def login(func):
    def wrap(request, *args, **kwargs):
        # 若是未登录，跳转到指定页面
        if request.path == '/test/':
            return redirect('http://www.baidu.com')
        return func(request, *args, **kwargs)
    return wrap

实例：

USER_LIST = ['alex','eric','wangminglong', 'hu']

def session_login(request):
    if request.method == 'POST':
        u = request.POST.get('user')
        p = request.POST.get('pwd')
        if p == '123' and u in USER_LIST:
            request.session['user'] = u
            return redirect('/session_index/')
    return render(request,'session_login.html')

##定义验证装饰器def auth(func):    def inner(request, *args,**kwargs):        # print(request,args,kwargs)        ##判断用户是否登陆        user = request.session.get('user', None)        if not user:            return redirect('/session_login/')        return func(request, *args,**kwargs)    return inner@authdef session_index(request):    user = request.session.get('user', None)    return render(request,'session_index.html',{'user': user})@authdef session_logout(request):    del request.session['user']    return redirect('/session_login/')