web框架详解之 tornado 四 模板引擎、session、验证码、xss

一、模板引擎

基本使用
继承,extends 页面整体布局用继承
导入,include 如果是小组件等重复的那么就用导入

下面是目录

web框架详解之 tornado 四 模板引擎、session、验证码、xss

首先在controllers里面创建一个文件,文件里面是页面类

#/usr/bin/env python
#-*-coding:utf- -*-
import tornado.web class IndexHandler(tornado.web.RequestHandler):
def get(self,*args,**kwargs):
self.render("extend/index.html",List_info=[,,])
class FFHandler(tornado.web.RequestHandler):
def get(self, *args, **kwargs):
self.render("extend/ff.html",List_info=[,,])

extend代码

之后在路由系统中配置

#/bin/usr/env python
#-*- coding:utf- -*-
import tornado.ioloop
import tornado.web
from controllers import home
from settings import Setting
from controllers import extend #路由映射,路由系统
application=tornado.web.Application(
[#(r"/index/(?P<page>\d*)",home.IndexHandler),
(r"/index",extend.IndexHandler),
(r"/ff",extend.FFHandler)
],
**Setting.settings
)
# application.add_handlers("www.cnblogs.com",[
# (r"/index/(?P<page>\d*)",)
# ]) if __name__=="__main__":
application.listen()
tornado.ioloop.IOLoop.instance().start()

start.py代码

配置路由系统之后分别创建继承html包和导入HTML包以及母版文件包

创建extend文件包:

{% extends "../master/layout.html "%}
{% block body %}
<h1>ff</h1> <h1>end</h1> <!--这里是导入include目录中form文件中的插件内容,注意这里百分号和括号之间不能有空格
如果要用这个插件很多分,那么多导入几次就行了
-->
{% include '../include/form.html' %}
{% include '../include/form.html' %}
{% include '../include/form.html' %}
{% end %}
{ % block js %}
<script>
console.log("ff")
</script>
{ % end % }

ff文件代码

{% extends '../master/layout.html'%}

<!--表示替换掉了layout母版中的css内容-->
{% block css %}
<style>
div{
border: 1px solid red;
}
</style>
{% end %}
<!--表示替换了母版中和下面相同的内容-->
{% block body % }
<h1>Index</h1>
{% inclue '../include/form.html'%}
{% end %} {% block js %}
<script>
console.log("ss")
</script>
{% end %}

index文件代码

创建木板文件包master

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title></title>
<style>
.pg-header{
height: 48px;
background-color: papayawhip;
}
.pg-footer{
height: 100px;
background-color: cadetblue;
}
</style>
<!--上面是公用样式,下面是自定义样式-->
{% block css %}{% end %}
</head>
<body>
<div class="pg-header"> </div>
<div class="pg-content">
{% block body %}{% end %}
</div>
<div class="pg-footer">adss</div>
<script src="xxxj"></script>
{% block js %}{% end %}
</body>
</html>

layout母版文件

extend就是方便自己定义代码

include导入文件包

<form>
<input type="text"/>
<input type="submit"/>
</form> <ul>
{% for item in List_info %}
<li>{{item}}</li>
{% end %}
</ul>

form文件

这里ff文件导入这个form文件

在导入文件中也可以和后台进行文件渲染,展示给用户,这里List_info就是在index文件中后台返回给前台进行渲染

二、cookie

a)    在浏览器端保存的键值对,特性:每次http请求都会携带
b) 实现:
i. 用户验证
c) 浏览器:
i. tornado,在后台设置
ii. 下面能够用索引取值,是因为tornado在后台进行了分割
. self.cookies 获取所有的cookies
. self.get_cookie(“a”) 获取cookie 中key的值
. self.set_cookie(“key”,”value”) 设置cookie中的值
iii. 在浏览器上使用jacascript来获取cookie
. document.cookie 表示在当前页面中所有的cookie
. 要想获取某一个cookie需要自己设置,因为cookie为字符串,所以要用splite进行分割
d) 如:
e) document.cookie.split(";")
f) ["SRCHD=AF=NOFORM", " SRCHUID=V=2&GUID=6FB4DE80646948698D6D4F6B07F7EFED", " SRCHUSR=DOB=20170405", " MUID=1B4DDEB4557967AE1CDAD4EF54D8662D", " HPBingAppQR=CLOSE=1", " WLS=TS=63627045711", " _SS=SID=2DED841E1D526B202FBB8E421CF36A37&HV=1491448911&bIm=31:152", " SRCHHPGUSR=CW=147&CH=937&DPR=1&UTC=480"] 、document.cookie=”k1=xx;path=/;domin(域名):expires” 在浏览器页面设置cookie,并且带上路径

复习

JavaScript操作Cookie

由于Cookie保存在浏览器端,所以在浏览器端也可以使用JavaScript来操作Cookie。

/*
toUTCString() 方法可根据世界时 (UTC) 把 Date 对象转换为字符串,并返回结果
设置cookie,指定秒数过期
*/
function setCookie(name,value,expires){
var temp = [];
var current_date = new Date(); 获取当前时间
// current_date.getSeconds() 获取当前秒
// current_date.setSeconds 设置秒
//data.setDate(data.getDate()+7),表示获取超过现在7天的时间
// current_date 当前时间+5秒
// toUTCString() 当前统一时间
current_date.setSeconds(current_date.getSeconds() + );
document.cookie = name +"= "+ value +";expires="+ current_date.toUTCString();
}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<h1>adasd</h1>
<script>
/*
设置cookie,指定秒数过期
*/
function setCookie(name,value,expires){
var temp = [];
var current_date = new Date();
current_date.setSeconds(current_date.getSeconds() + );
document.cookie = name + "= "+ value +";expires=" + current_date.toUTCString();
}
</script>
</body>
</html> 然后在浏览器中访问
setCookie("k22=11",) 设置cookie,超时时间为5秒
undefined
document.cookie 查看cookie
"k1=999; k22=11= 5"
document.cookie 5秒后查看
"k1=999"

HTML代码

对于参数

  • domain   指定域名下的cookie
  • path       域名下指定url中的cookie
  • secure    https使用

 jquery中设置cookie

要用需要下载  这里

、    导入jquery
、 导入jQuery Cookie Plugin v1.4.1
注意点:
如果用jquery导入的时候expires这里如果为数字的时候,表示天数
如果不想用天数,那么要用,这里的超时时间必须要用toUTCString()统一时间 current_date.setSeconds(current_date.getSeconds() + ); 用天数,然后用字符串拼接的方式";expires="+ current_date.toUTCString()
等来设置时间,js数组的.join方法是吧数组变成字符串
$.cookie(“k1”,””,{“path”:””,”domin”:””,expires=})
上面的cookie中的数组,在内部用了join方法分割成了字符串

tornado带签名的cookie原理图

tornado支持两种方式

  • 一、简单的方式
  • 二、签名的方式

web框架详解之 tornado 四 模板引擎、session、验证码、xss

首先服务端让浏览器端生成cookie的时候会经过base64加密,首先生成加密串,
注意这里的当前时间是
>>> import time
>>> time.time()
1491471613.5271676 --->生成的这个值就是当前时间
>>>
加密串 =v1(value)+当前时间+内部自定义字符串
之后生成的这个cookie就是k1(key)=v1|加密串|当前时间 如何验证这个cookie有没有被篡改:
客户端向浏览器端发送请求:会把v1和加密串和当前时间发送给浏览器,浏览器内部会经过md5生成一个新的加密串
自定义字符串+发送过来的时间+v1等于新的加密串,然后加密串进行对比,如果一致就能通过
#/usr/bin/env python
#-*- coding:utf--*-
import tornado.ioloop
import tornado.web class IndexHandler(tornado.web.RequestHandler):
#这里判断判断用户登录
def get(self):
if self.get_argument("u",None) in ["aa","eric"]:
self.set_cookie("name",self.get_argument("u"))
# self.set_secure_cookie("name",self.get_argument("u"))
else:
self.write("请登录") class ManagerHandler(tornado.web.RequestHandler):
#如果有cookie的时候就登录
def get(self):
if self.get_cookie("name",None) in ["aa","eric"]:
self.write("欢迎登录:"+self.get_cookie("name"))
else:
self.redirect("/index") settings={
"template_path":"views",
"static_path":"statics"
}
application=tornado.web.Application([
(r"/index",IndexHandler),
(r"/manager",ManagerHandler)
],**settings) if __name__=="__main__":
application.listen()
tornado.ioloop.IOLoop.instance().start() 上面就是用一种简单的模式登录,登录的时候
在浏览器中输入
http://127.0.0.1:8000/index?u=aa
之后就会执行IndexHandler方法中的get方法首先存入用户输入的cookie,对比后台,然后访问manager网站的时候,判断,如果有对应的cookie那么就会出现欢迎登录

基于cookie实现用户验证

#/usr/bin/env python
#-*- coding:utf--*-
import tornado.ioloop
import tornado.web class IndexHandler(tornado.web.RequestHandler):
#这里判断判断用户登录
def get(self):
if self.get_argument("u",None) in ["alex","eric"]:
这里设置加密的cookie
self.set_secure_cookie("user",self.get_argument("u"))
else:
self.write("请登录") class ManagerHandler(tornado.web.RequestHandler):
#如果有cookie的时候就登录
def get(self):
获取加密的cookie
if str(self.get_secure_cookie("user",None),encoding="utf-8") in ["alex","eric"]:
self.write("欢迎登录:"+str(self.get_secure_cookie("user")))
else:
self.redirect("/index") settings={
"template_path":"views",
"static_path":"statics",
这必须设置配置
"cookie_secret":"hello",
}
application=tornado.web.Application([
(r"/index",IndexHandler),
(r"/manager",ManagerHandler)
],**settings) if __name__=="__main__":
application.listen()
tornado.ioloop.IOLoop.instance().start() 设置加密的cookie用set_secure_cookie()方法,如果获取cookie的时候用get_secure_cookie()
注意这里获取加密cookie
注意:这里获取的cookie是byte类型,所以必须要转换一下类型

下面是带签名的cookie

Cookie 很容易被恶意的客户端伪造。加入你想在 cookie 中保存当前登陆用户的 id 之类的信息,
你需要对 cookie 作签名以防止伪造。Tornado 通过 set_secure_cookie 和 get_secure_cookie
方法直接支持了这种功能。 要使用这些方法,你需要在创建应用时提供一个密钥,名字为 cookie_secret。
你可以把它作为一个关键词参数传入应用的设置中
签名Cookie的本质是:

写cookie过程:

将值进行base64加密
对除值以外的内容进行签名,哈希算法(无法逆向解析)
拼接 签名 + 加密值
读cookie过程: 读取 签名 + 加密值
对签名进行验证
base64解密,获取值内容
注:许多API验证机制和安全cookie的实现机制相同

总结

三、自定义web组件session

 如果一直用加密的cookie一直给浏览器那么会导致不安全,以及流量的增大
用一段cookie来代表账号密码,邮箱等等
tornado里面默认没有session,django里面有session 补充知识:
hashlib.md5.digest()
hashlib.hexdigest()
是生成MD5的两种表现形式,hashlib.md5.digest() 加密后的结果用二进制表示
二进制由0和1组成,一个字节包含8位二进制码,即包含8位0或1, 1byte可用2个16进制的数来表示
电脑中的数据都是按照16进制来保存的
所以这里要用hexdigest来生成随机数
a[aa]={}:表示a为字典。aa为a的key值,后面的{}表示a中aa为key的value的值 container内容可以放到1在内存,2在数据库,3在缓存

web框架详解之 tornado 四 模板引擎、session、验证码、xss

上图:但用户k1访问服务器的时候会生成aa这个字符串,aa这个字符串保存着用户的各种信息,但用户k2访问服务器的时候,在内部生成bb字符串,用来保存用户的各种信息

session其实就是定义在服务器端用于保存用户回话的容器,其必须依赖cookie才能实现。

#/usr/bin/env python
#-*- coding:utf--*-
import tornado.ioloop
import tornado.web #这个字典必须定制成为全局变量用来保存用户的信息,如果是局部变量,
# 那么http请求断开下次用户登录这个用户信息就会消失
container={} class IndexHandler(tornado.web.RequestHandler):
#这里判断判断用户登录
def get(self):
if self.get_argument("u",None) in ["aa","eric"]:
import hashlib
import time
#首先通过md5生成随机数据,电脑中的数据都是16进制保存的
obj=hashlib.md5()
obj.update(bytes(str(time.time()),encoding="utf-8"))
random_str=obj.hexdigest()
container[random_str]={}
container[random_str]["k1"]=
#加上自定义字符串
container[random_str]["k2"]=self.get_argument("u",None)+"parents"
#自己定义的,希望以后is_login来确定用户是否上线登录
container[random_str]["is_login"]=True #把cookie发送给客户端
self.set_cookie("iii",random_str) else:
self.write("请登录") class ManagerHandler(tornado.web.RequestHandler):
def get(self):
random_str=self.get_cookie("iii")
#获取key对应的值,默认为None
current_user_info=container.get(random_str,None)
if not current_user_info:
self.redirect("/index")
else:
if current_user_info.get("is_login",None):
temp="%s-%s"%(current_user_info.get("k1",""),current_user_info.get("k2",""))
self.write(temp)
else:
self.redirect("/index") settings={
"template_path":"views",
"static_path":"statics",
"cookie_secret":"hello",
}
application=tornado.web.Application([
(r"/index",IndexHandler),
(r"/manager",ManagerHandler)
],**settings) if __name__=="__main__":
application.listen()
tornado.ioloop.IOLoop.instance().start()

python代码

、    首先创建session这个容器,让这个容器定义为全局变量
、 之后创建随机数,并且让这个随机数定义为字典
、 在随机数定义的字典里面,分别定义三类,一类是原本的信息,第二类是让数据加上自定义字符串,第三类标志位
、 给客户端发送cookie
、 然后用户连接的时候分别判断,随机数,和标志位
自定义session相当于自己开发httpd三次握手

session优化封装

web框架详解之 tornado 四 模板引擎、session、验证码、xss

上面每一个用户连接都会生成一个随机数,并且随机数(代表字典)里面会保存用户的信息

#/usr/bin/env python
#-*- coding:utf--*-
import tornado.ioloop
import tornado.web #这个字典必须定制成为全局变量用来保存用户的信息,如果是局部变量,
# 那么http请求断开下次用户登录这个用户信息就会消失
container={} #把Sesson封装起来
class Session:
#为了引入IndexHandler的方法,这里的self代表的是s对象
def __init__(self,handler):
self.handler=handler
def __genarate_random_str(self): #创建随机字符串
import hashlib
import time
#首先通过md5生成随机数据,电脑中的数据都是16进制保存的
obj=hashlib.md5()
obj.update(bytes(str(time.time()),encoding="utf-8"))
random_str=obj.hexdigest()
return random_str
def set_value(self,key,value):
#在container中加入随机字符串,之前要创建随机字符串
#定义专属于自己的数据
#在客户端写入随机字符串
#判断,请求的用户是否已经有随机字符串
random_str=self.handler.get_cookie("__kakaka__")
container[random_str]={}
container[random_str][key]=value
#这里是为写超时时间做准备
self.handler.set_cookie("__kakaka__",random_str) def get_value(self,key): #获取值
#首先获取客户端的随机字符串
#从container中获取专属于我的数据
#专属我的数据[key]
random_str=self.handler.get_cookie("__kakaka__")
user_info_dict=container[random_str]
value=user_info_dict[key]
return value
class IndexHandler(tornado.web.RequestHandler):
#这里判断判断用户登录
def get(self):
if self.get_argument("u",None) in ["aa","eric"]:
s=Session(self)
s.set_value("is_login",True)
else:
self.write("请登录") class ManagerHandler(tornado.web.RequestHandler):
def get(self):
s=Session(self)
val=s.get_value("is_login")
if val:
self.write("成功")
else:
self.write("请重新登录") settings={
"template_path":"views",
"static_path":"statics",
"cookie_secret":"hello",
}
application=tornado.web.Application([
(r"/index",IndexHandler),
(r"/manager",ManagerHandler)
],**settings) if __name__=="__main__":
application.listen()
tornado.ioloop.IOLoop.instance().start()

python代码

这段代码是把上面的方法进行了封装,流程:
、 用户访问index这个网站,其实就是访问了IndexHandler这个类,会执行get方法,获取用户输入的内容,如果输入的内容符合条件
、 初始化Session类中的__init__方法,然后执行set_value方法,并且把传入参数is_login
、获取随机数,清空随机数这个字典中的内容,然后把参数传递进去,并且把cookie传递给浏览器

解析

#/usr/bin/env python
#-*- coding:utf--*-
import tornado.ioloop
import tornado.web #这个字典必须定制成为全局变量用来保存用户的信息,如果是局部变量,
# 那么http请求断开下次用户登录这个用户信息就会消失
container={} #把Sesson封装起来
class Session:
def __init__(self,handler):
self.handler=handler
self.random_str=None #用户连接初始化随机数
def __genarate_random_str(self): #创建随机字符串
import hashlib
import time
#首先通过md5生成随机数据,电脑中的数据都是16进制保存的
obj=hashlib.md5()
obj.update(bytes(str(time.time()),encoding="utf-8"))
random_str=obj.hexdigest()
return random_str
def set_value(self,key,value):
#这里判断如果服务端没有随机数
if not self.random_str: #用户连接,首先服务端没有随机数,那么去客户端拿随机数
random_str=self.handler.get_cookie("__kakaka__") #去客户端中拿随机数
if not random_str: #如果客户端也没有随机数,那么服务端就自己创建随机数
random_str=self.__genarate_random_str() #创建随机数
container[random_str]={} #清空随机数字典中的内容
else:
if random_str in container.keys(): #如果客户端有随机数,并且为真那么就直接登录成功
pass
else: #如果客户端到的随机数是伪造的,那么服务端就自己创建随机数
random_str=self.__genarate_random_str()
container[random_str]={}
self.random_str=random_str #最后把上面判断出来的随机数传递给类
container[self.random_str][key]=value
#这里是为写超时时间做准备
self.handler.set_cookie("__kakaka__",self.random_str) #设置cookie给浏览器,这里可以设置超时时间 def get_value(self,key): #获取值
random_str=self.handler.get_cookie("__kakaka__")
if not random_str:#如果客户端没有随机字符串,就结束
return None
user_info_dict=container.get(random_str,None)#客户端有随机字符串,但是内容服务器不匹配,就退出
if not user_info_dict:
return None
value=user_info_dict.get(key,None) #前面如果都满足,有值就拿值,没有就为None
return value class IndexHandler(tornado.web.RequestHandler):
#这里判断判断用户登录
def get(self):
if self.get_argument("u",None) in ["aa","eric"]:
s=Session(self)
s.set_value("is_login",True)
s.set_value("name",self.get_argument("u",None))
else:
self.write("请登录") class ManagerHandler(tornado.web.RequestHandler):
def get(self):
s=Session(self)
val=s.get_value("is_login")
if val:
self.write(s.get_value("name"))
else:
self.write("请重新登录") settings={
"template_path":"views",
"static_path":"statics",
"cookie_secret":"hello",
}
application=tornado.web.Application([
(r"/index",IndexHandler),
(r"/manager",ManagerHandler)
],**settings) if __name__=="__main__":
application.listen()
tornado.ioloop.IOLoop.instance().start()

session优化:

用户如果直接连接manager会提示必须登录,主要原因是浏览器cookie中没有登录信息
、 用户访问index网页的时候就是访问IndexHandler这个类,用户连接,服务器内部就会初始化随机数
、 服务器就会执行set_value方法,并且传入参数is_login参数,首先为了判断用户是否第一次登陆,所以用if not self.random_str,没有就用get_cookie()方法去客户端中拿随机数,这里需要判断,如果客户端也没有随机数,那么服务端就要自己创建随机数,并且把这个随机数传递给服务器这个类;如果客户端有随机数,要判断这个随机数是否是伪造的,如果是伪造的,服务器需要自己创建随机数,并且把这个随机数传递给服务器这个类;之后把is_login参数替代key传递给session这个字典求出来value这个值,并且设置一下这个cookie传递给浏览器;然后设置key为name的cookie
、 用户访问manager这个网站,会执行get方法,并且获取浏览器随机数,如果浏览器中没有随机数或者浏览器的随机数是伪造的,那么就会退出,如果经过了2这个步骤,那么就能登录成功并且得到设置cookie中key为name的值

流程详解:

优化:

在Tornado框架中,默认执行Handler的get/post等方法之前默认会执行 initialize方法,所以可以通过自定义的方式使得所有请求在处理前执行操作

这里的initialize就是钩子函数

优化一

#定义tornado中的钩子函数和反射函数来优化下面的类
class BaseHandler(tornado.web.RequestHandler):
def initialize(self):
self.session=Session(self) class IndexHandler(BaseHandler):
#这里判断判断用户登录,get方法是被反射调用的getattr
def get(self):
if self.get_argument("u",None) in ["aa","eric"]:
self.session.set_value("is_login",True)
self.session.set_value("name",self.get_argument("u",None))
else:
self.write("请登录") class ManagerHandler(BaseHandler):
def get(self):
val=self.session.get_value("is_login")
if val:
self.write(self.session.get_value("name"))
else:
self.write("请重新登录")

让这两个类继承一个共同的父类,利用tornado内置的钩子函数来优化代码

优化二、利用__getitem__   __setitem__方法

#/usr/bin/env python
#-*- coding:utf--*-
import tornado.ioloop
import tornado.web #这个字典必须定制成为全局变量用来保存用户的信息,如果是局部变量,
# 那么http请求断开下次用户登录这个用户信息就会消失
container={} #把Sesson封装起来
class Session:
def __init__(self,handler):
self.handler=handler
self.random_str=None #用户连接初始化随机数
def __genarate_random_str(self): #创建随机字符串
import hashlib
import time
#首先通过md5生成随机数据,电脑中的数据都是16进制保存的
obj=hashlib.md5()
obj.update(bytes(str(time.time()),encoding="utf-8"))
random_str=obj.hexdigest()
return random_str
def __setitem__(self,key,value):
#这里判断如果服务端没有随机数
if not self.random_str: #用户连接,首先服务端没有随机数,那么去客户端拿随机数
random_str=self.handler.get_cookie("__kakaka__") #去客户端中拿随机数
if not random_str: #如果客户端也没有随机数,那么服务端就自己创建随机数
random_str=self.__genarate_random_str() #创建随机数
container[random_str]={} #清空随机数字典中的内容
else:
if random_str in container.keys(): #如果客户端有随机数,并且为真那么就直接登录成功
pass
else: #如果客户端到的随机数是伪造的,那么服务端就自己创建随机数
random_str=self.__genarate_random_str()
container[random_str]={}
self.random_str=random_str #最后把上面判断出来的随机数传递给类
container[self.random_str][key]=value
#这里是为写超时时间做准备
self.handler.set_cookie("__kakaka__",self.random_str) #设置cookie给浏览器,这里可以设置超时时间 def __getitem__(self,key): #获取值
random_str=self.handler.get_cookie("__kakaka__")
if not random_str:#如果客户端没有随机字符串,就结束
return None
user_info_dict=container.get(random_str,None)#客户端有随机字符串,但是内容服务器不匹配,就退出
if not user_info_dict:
return None
value=user_info_dict.get(key,None) #前面如果都满足,有值就拿值,没有就为None
return value #定义tornado中的钩子函数和反射函数来优化下面的类
class BaseHandler(tornado.web.RequestHandler):
def initialize(self):
self.session=Session(self) class IndexHandler(BaseHandler):
#这里判断判断用户登录,get方法是被反射调用的getattr
def get(self):
if self.get_argument("u",None) in ["aa","eric"]:
self.session["is_login"]=True
self.session["name"]=self.get_argument("u",None)
# self.session.set_value("is_login",True)
# self.session.set_value("name",self.get_argument("u",None))
else:
self.write("请登录") class ManagerHandler(BaseHandler):
def get(self):
val=self.session["is_login"]
if val:
self.write(self.session["name"])
else:
self.write("请重新登录") settings={
"template_path":"views",
"static_path":"statics",
"cookie_secret":"hello",
}
application=tornado.web.Application([
(r"/index",IndexHandler),
(r"/manager",ManagerHandler)
],**settings) if __name__=="__main__":
application.listen()
tornado.ioloop.IOLoop.instance().start()

所有的web框架都是session[key]=value的方法实现的

这里只需要改一下名字就可以


placeholder 属性提供可描述输入字段预期值的提示信息(hint)。
该提示会在输入字段为空时显示,并会在字段获得焦点时消失。

open打开一个文件的时候里面要加上r表示不用转义了
open(r”路径”)

补充知识:

四、验证码

验证码原理在于后台自动创建一张带有随机内容的图片,然后将内容通过img标签输出到页面。
这个验证码是放在tornado的session里面的
验证码机制:服务器首先创建验证码,并且把验证码放入到随机数这个字典里面,用户通过get方法接收到验证码,然后用户输入验证码和账户信息发送给服务器,服务器通过对比用户发来的验证码和自己产生的验证码,(这里要创建不分辨大小写,可以让用户输入的和自己产生的转成全部大写或者全部小写)对比,如果一样那么就显示登录成功,如果没有一样,那么就显示输入的验证码错误。并且在前端添加一个点击事件,只要用户一点击那么验证码就会刷新

说明

安装图像处理模块:

1

pip3 install pillow

下载下面源码之后,需要把check_code.py和Monaco.ttf导入到这个代码目录中(仅仅限制与python3.5)

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8">
<title></title>
<style>
.aa{
cursor: pointer;
}
</style>
</head>
<body>
<h1>请输入登录信息</h1>
<form action="/login" method="post">
<p><input name="user" type="text" placeholder="用户名" /></p>
<p><input name="pwd" type="password" placeholder="密码" /></p>
<p>
<input name='code' type="text" placeholder="验证码" />
<img class="aa" src="/check_code" onclick='ChangeCode();' id='imgCode'>
</p>
<input type="submit" value="提交"/><span style="color: red">{{status}}</span>
</form>
<script type="text/javascript"> function ChangeCode() {
var code = document.getElementById('imgCode');
//url后面只能添加问号,添加问号就是改变地址
code.src += '?';
}
</script>
</body>
</html>

login.html

#/usr/bin/env python
#-*- coding:utf--*-
import tornado.ioloop
import tornado.web
import tornado.httpserver
import tornado.ioloop
import tornado.process
import tornado.web
# #这个字典必须定制成为全局变量用来保存用户的信息,如果是局部变量,
# 那么http请求断开下次用户登录这个用户信息就会消失
container={} #把Sesson封装起来
class Session:
def __init__(self,handler):
self.handler=handler
self.random_str=None #用户连接初始化随机数
def __genarate_random_str(self): #创建随机字符串
import hashlib
import time
#首先通过md5生成随机数据,电脑中的数据都是16进制保存的
obj=hashlib.md5()
obj.update(bytes(str(time.time()),encoding="utf-8"))
random_str=obj.hexdigest()
return random_str
def __setitem__(self,key,value):
#这里判断如果服务端没有随机数
if not self.random_str: #用户连接,首先服务端没有随机数,那么去客户端拿随机数
random_str=self.handler.get_cookie("__kakaka__") #去客户端中拿随机数
if not random_str: #如果客户端也没有随机数,那么服务端就自己创建随机数
random_str=self.__genarate_random_str() #创建随机数
container[random_str]={} #清空随机数字典中的内容
else:
if random_str in container.keys(): #如果客户端有随机数,并且为真那么就直接登录成功
pass
else: #如果客户端到的随机数是伪造的,那么服务端就自己创建随机数
random_str=self.__genarate_random_str()
container[random_str]={}
self.random_str=random_str #最后把上面判断出来的随机数传递给类
container[self.random_str][key]=value
#这里是为写超时时间做准备
self.handler.set_cookie("__kakaka__",self.random_str) #设置cookie给浏览器,这里可以设置超时时间 def __getitem__(self,key): #获取值
random_str=self.handler.get_cookie("__kakaka__")
if not random_str:#如果客户端没有随机字符串,就结束
return None
user_info_dict=container.get(random_str,None)#客户端有随机字符串,但是内容服务器不匹配,就退出
if not user_info_dict:
return None
value=user_info_dict.get(key,None) #前面如果都满足,有值就拿值,没有就为None
return value #定义tornado中的钩子函数和反射函数来优化下面的类
class BaseHandler(tornado.web.RequestHandler):
def initialize(self):
self.session=Session(self) class IndexHandler(BaseHandler):
#这里判断判断用户登录,get方法是被反射调用的getattr
def get(self):
if self.get_argument("u",None) in ["aa","eric"]:
self.session["is_login"]=True
self.session["name"]=self.get_argument("u",None)
# self.session.set_value("is_login",True)
# self.session.set_value("name",self.get_argument("u",None))
else:
self.write("请登录") class ManagerHandler(BaseHandler):
def get(self):
val=self.session["is_login"]
if val:
self.write(self.session["name"])
else:
self.write("请重新登录")
# class CheckCodeHandler(BaseHandler):
# def get(self):
# import io
# import check_code
#
# mstream = io.BytesIO()
# img, code = check_code.create_validate_code()
# img.save(mstream, "GIF")
# # self.session["CheckCode"] = code
# self.write(mstream.getvalue())
class MainHandler(BaseHandler):
def get(self):
self.render('login.html',status="")
def post(self, *args, **kwargs):
user=self.get_argument("user",None)
pwd=self.get_argument("pwd",None)
code=self.get_argument("code",None)
#比较用户输入的验证码和服务器给出的验证码的值
check_code=self.session["CheckCode"]
if code.upper()==check_code.upper():
self.write("验证码正确")
else:
# self.redirect("/login")
self.render("login.html",status="验证码错误") class CheckCodeHandler(BaseHandler):
def get(self, *args, **kwargs):
#生成图片并且返回
import io
import check_code
#建立内存级别文件,相当于一个容器
mstream = io.BytesIO()
#创建图片并且写入验证码
img, code = check_code.create_validate_code()
#将图片内容写入到IO中mstream
img.save(mstream, "GIF")
#为每个用户保存其对应的验证码
self.session["CheckCode"] = code
self.write(mstream.getvalue()) settings={
'template_path': 'views',
'static_path': 'static',
"static_url_prefix":"/statics/",
"cookie_secret":"hello",
# "xsrf_cookies":True,
} application=tornado.web.Application([
(r"/index",IndexHandler),
(r"/manager",ManagerHandler),
# (r"/login",LoginHandler),
(r"/login",MainHandler),
(r"/check_code",CheckCodeHandler), ],**settings) if __name__=="__main__":
application.listen()
tornado.ioloop.IOLoop.instance().start()

python代码

验证码Demo源码下载:猛击这里

web框架详解之 tornado 四 模板引擎、session、验证码、xss

五、CSRF

会集群要会:分布式哈希haxi redis
CSRF限制post请求的
用户访问是先请求服务器调用get请求,然后发送post请求,之后服务器会给用户一个随机字符串,当用户离开后,下次再访问会带着这个随机字符串访问服务器,如果用户没有这个随机字符串,那么CSRF会阻止这个用户请求,这样可以使服务器免遭受恶意攻击造成服务器宕机

要加上CSRF:

1、在配置文件中加上配置文件”xsrf_cookies”:True

2、在前台代码中加上{% raw xsrf__form_html %}

class CsrfHandler(BaseHandler):
def get(self, *args, **kwargs):
self.render("csrf.html")
def post(self, *args, **kwargs):
self.write("csrf.post")
settings={
'template_path': 'views',
'static_path': 'static',
"static_url_prefix":"/statics/",
"cookie_secret":"hello",
"xsrf_cookies":True, 这里加上配置文件
} application=tornado.web.Application([
(r"/index",IndexHandler),
(r"/manager",ManagerHandler),
# (r"/login",LoginHandler),
(r"/login",MainHandler),
(r"/check_code",CheckCodeHandler),
(r"/csrf",CsrfHandler) ],**settings)

html代码上面加上

<form action="/csrf" method="post">
{% raw xsrf_form_html() %}
<p><input type="text" placeholder="用户"/></p>
<p><input type="text" placeholder="密码"/></p>
<p>
<input name="code" type="text" placeholder="验证码"/>
<!--<img src="/check_code">-->
</p>
<input type="submit" value="Submit"/>

提交的是AJAX的post请求

如果你提交的是 AJAX 的 POST 请求,你还是需要在每一个请求中通过脚本添加上 _xsrf 这个值。下面是在 FriendFeed 中的 AJAX 的 POST 请求,使用了 jQuery 函数来为所有请求组东添加 _xsrf 值:

function getCookie(name) {
var r = document.cookie.match("\\b" + name + "=([^;]*)\\b");
return r ? r[1] : undefined;
} jQuery.postJSON = function(url, args, callback) {
args._xsrf = getCookie("_xsrf");
$.ajax({url: url, data: $.param(args), dataType: "text", type: "POST",
success: function(response) {
callback(eval("(" + response + ")"));
}});
};

对于 PUT 和 DELETE 请求(以及不使用将 form 内容作为参数的 POST 请求) 来说,你也可以在 HTTP 头中以 X-XSRFToken这个参数传递 XSRF token。

如果你需要针对每一个请求处理器定制 XSRF 行为,你可以重写 RequestHandler.check_xsrf_cookie()。例如你需要使用一个不支持 cookie 的 API, 你可以通过将 check_xsrf_cookie() 函数设空来禁用 XSRF 保护机制。然而如果 你需要同时支持 cookie 和非 cookie 认证方式,那么只要当前请求是通过 cookie 进行认证的,你就应该对其使用 XSRF 保护机制,这一点至关重要。

六、总结

、cookie和session的区别
)cookie是保存在客户端的,session是保存在服务端的,因为服务器端,表示可能在内存中,可能在数据库端,可能在缓存中统称为服务器端
、session和cookie有什么联系?:
答:有。session是通过cookie人为构建起来的,在web开发里面本身没有session这个东西的。在服务器端可以高层一个数据库,可以在内存中搞成一个字典,每一次用户来访问的时候,给用户发一对token,下一次,用户访问再带着这一对token来,服务器端就知道你是不是上一次的你。如果再问就来画一张图 、分页 XSS 跨站脚本攻击
、csrf 工作方式:
答:跨站请求伪造
验证:第一次请求的时候是get方式请求,防止没有经过验证就来post请求,造成大并发机器宕机
、 Ajax
为什么要有Ajax
答:防止页面批量刷新
利用:
iframe 忽略
XMLHttpRequest
自己写
xhr
xhr.open()
xhr.onreadystatechange
xhr.send()
jQuery
会用下面的就会jquery,ajax
$.ajax({
url:
type
data
dataType
success
error
})
、 验证码、
、 上传文件
form标签
form标签 enctype=““form标签里面必须要有这个才能进行上传文件
通过Ajax上传文件
利用formDate()
XMLHttpRequest
jQuery
iframe+form标签为了兼容性设计,ifram就相当于设置一个通道,form把数据提交到这个通道,然后不刷页面上传文件

重点总结

上一篇:第8.13节 Python类中内置方法__repr__详解


下一篇:减小ipa体积之删除frameWork中无用mach-O文件