自建装饰器实现权限控制

在上一章 《登陆注册》中，我们为 REST 的 API 设置了新增、更新和删除的操作需要登陆才能完成。细想一下，这样未免太过草率，因为对于一个系统来说，用户肯定是分为不同的级别的，例如普通的用户也就只能查查数据，然后一些用户还能多一个增加数据的权限，再高级一点的还能修改数据，最高级的就是增删改查都能。

对于这些更加丰富的需求，我们目前的登陆可用明显还不能满足需求，因此，按常规本章应该会引入一个新的扩展，而 Flask 确实是有一款叫做 Flask-Principal，的扩展可以满足我们的需求，通过这个扩展，我们希望能够达到更细粒度得控制用户的权限。但是，我嫌弃这个扩展太累赘了，所以本章不准备使用这个扩展，而是自己编写一个权限控制的扩展进行权限的控制。

权限控制设计

我们这里的权限控制采用 RBAC 的方式，首先，我们会创建一个 Role 的 Model，然后给每个 User 分配一个 Role，这样的话，我们就可以限制某个操作需要某种 Role 才能执行，这样的话就实现了更细粒度的权限控制。

这里还有个实现细节需要先说明一下，我们的 Role 的权限是以二进制位来表示的，每一个二进制位表示一种权限：

  • 第一位表示可以读取记录
  • 第二位表示可以新建记录
  • 第三位表示可以更新记录
  • 第四位表示可以删除记录

这样的话，如果一个用户只能读取记录，那么他对应的 Role 的权限应该是 0000 0001b ，换算成十六进制的话就是： 0x01

如果一个用户所有操作都可以执行，那么它的权限应该对应于 0000 1111b，换算成十六进制的话就是：0x0f

那么，假如我们要判断一个用户时候可以进行新建操作，那么应该怎么实现这个逻辑？我这里的实现机制是如果是只有新建操作，那么对应的权限就是：0000 0010b，那如果我要判断一个用户时候有新建的权限，那么我只需要对这个用户的权限和这个操作所需要的权限进行 and 操作，如果得到的结果等于需要的权限的话，那么就表示该用户拥有权限，可能说得有点复杂，上一个简单的例子

  1. 用户 A 的权限：      0000 0001b      只有读取记录的权限
  2. 用户 B 的权限：      0000 1111b      拥有所有权限
  3. 新建记录需要权限：    0000 0010b      需要新建权限
  4. 用户A是否可以新建：   0000 0001b and 0000 0010b = 0000 0000b ！= 新建权限，所以不能新建
  5. 用户B时候可以新建：   0000 1111b and 0000 0010b = 0000 0010b  == 新建权限，所以可以新建

大概就是这样一个场景，大家可以自己动手演练演练，看下是否可行。

创建 Role Model

之前已经在 《集成数据库》 章节中讲解过了如何创建 Model，所以这里直接根据之前的经验创建 Role Model，然后再往 User 中加上一个 Role 字段。

  1. class Permission:
  2.     READ = 0x01  
  3.     CREATE = 0x02
  4.     UPDATE = 0x04     
  5.     DELETE = 0x08
  6.     DEFAULT = READ
  8. class Role(db.Document):
  9.     name = db.StringField()
  10.     permission = db.IntField()
  12. class User(db.Document):
  13.     name = db.StringField()
  14.     password = db.StringField()
  15.     email = db.StringField()
  16.     role = db.ReferenceField('Role'， default=DEFAULT_ROLE)

这里就简单得创建了一个 Role 的 Model，而 Role 只有一个名称，用于标示这个角色，另外一个就是该角色拥有的权限了。然后就是在 User 中添加了一个 ReferenceField，这个在 MongoEngine 里面就表示是外引用的意思，我们可以直接通过这个成员变量访问到用户的 Role 的 permission。

同时，为了保持代码的可维护性，我们将 permission 都写在一个类中，还设置了一个默认的权限，默认为 READ。

因为我们现在的数据库中还没有 Role 相关的记录，所以我们需要在启动应用的时候进行插入数据，所以我做了这样的一个操作：

  1. # init roles     
  2. if Role.objects.count() <= 0:  
  3.     READ_ROLE = Role('READER', Permission.READ)
  4.     CREATE_ROLE = Role('CREATER', Permission.CREATE)
  5.     UPDATE_ROLE = Role('UPDATER', Permission.UPDATE)
  6.     DELETE_ROLE = Role('DELETER', Permission.DELETE)
  7.     DEFAULT_ROLE = Role('DEFAULT', Permission.DEFAULT)
  9.     READ_ROLE.save()
  10.     CREATE_ROLE.save()
  11.     UPDATE_ROLE.save()
  12.     DELETE_ROLE.save()
  13.     DEFAULT_ROLE.save()
  14. else:            
  15.     READ_ROLE = Role.objects(permission=Permission.READ).first()
  16.     CREATE_ROLE = Role.objects(permission=Permission.CREATE).first()
  17.     UPDATE_ROLE = Role.objects(permission=Permission.UPDATE).first()
  18.     DELETE_ROLE = Role.objects(permission=Permission.DELETE).first()
  19.     DEFAULT_ROLE = Role.objects(permission=Permission.DEFAULT).first()

虽然这段代码有不严谨的地方，但是作为讲解的话无关大雅，通过这段代码，我们可以保证在下面的代码中我们有五种 Role 的对象，分别对应着增删改查，还有一个默认的角色，他为读取权限。同时，我们也应该修改一下我们的 API，让他能够增加用户的默认权限。

  1. @app.route('/', methods=['POST'])
  2. @login_required 
  3. def create_record():
  4.     record = json.loads(request.data)
  5.     user = User(name=record['name'],
  6.                 password=record['password'],
  7.                 email=record['email'],
  8.                 role=DEFAULT_ROLE)
  9.     user.save() 
  10.     return jsonify(user.to_json())

这段代码只增加了一行，就是：

  1. role=DEFAULT_ROLE

权限控制

好，到这里算是完成了一半了，我们的角色已经算是有了，然后就是怎么进行权限控制了，我希望权限控制代码能够竟可能得简单，最好是能用装饰器实现，对于一些默认权限就能访问的，我希望不用加权限控制的代码就好了。没有不能实现的需求，只是实现得好坏而已，所以，既然我们都能描述出需求，那么就能够写出满足需求的代码。

首先，我们是需要编写一个权限控制的装饰器的，我们希望这个装饰器可以很方便得进行权限控制，最好是可以这样：

  1. @creater_required()
  2. def create_model():
  3.     ... ...

或者这样也可以接受：

  1. @permission_required(CREATE_PERMISSION):
  2. def create_model():
  3.     ... ...

那么，就先写一个较为简单的版本试试先：

  1. def permission_required(permission):
  2.     def decorator(func):           
  3.         @wraps(func)               
  4.         def decorated_function(*args, **kwargs):
  5.             if not current_user.is_authenticated:
  6.                 abort(401) 
  7.             user_permission = current_user.role.permission
  8.             if user_permission & permission == permission:
  9.                 return func(*args, **kwargs)
  10.             else:                  
  11.                 abort(403)         
  12.         return decorated_function
  13.     return decorator

这一版本我们可以简单得看这几句关键的代码：

  1. if not current_user.is_authenticated:
  2.     abort(401) 
  3. user_permission = current_user.role.permission
  4. if user_permission & permission == permission:
  5.     return func(*args, **kwargs)
  6. else:                  
  7.     abort(403)

首先用户没有登陆肯定是没有权限的了，所以返回 401 未授权错误，如果用户没有权限（权限设计中的描述），那么就返回 403 禁止访问。

接着我们就在我们的 REST API 中尝试一下这个权限，这里相对新增用户进行尝试：

  1. @app.route('/', methods=['POST'])
  2. @permission_required(Permission.CREATE)   
  3. def create_record():               
  4.     record = json.loads(request.data) 
  5.     user = User(name=record['name'],  
  6.                 password=record['password'],
  7.                 email=record['email'],
  8.                 role=DEFAULT_ROLE)  
  9.     user.save()                     
  10.     return jsonify(user.to_json()

这里只将 @login_required 的装饰器换成了

  1. @permission_required(Permission.CREATE)

然后我们尝试一下新建记录：

  1. POST http://localhost:8080
  3. {
  4.   "email": "liqianglau@outlook.com",
  5.   "name": "tyrael",
  6.   "password": "password"
  7. }

然后发现响应是：

Image-2016-05-26-020312001.png

说明我们的权限控制生效啦。