Zope3的默认安全策略
zope.securitypolic的Python项目详细描述
经典Zope安全策略
此包实现基于角色的安全策略，类似于 在Zope 2中找到策略。安全策略负责 决定交互是否对对象具有权限。这个 安全策略使用授权和拒绝信息执行此操作。管理者 可以授予或拒绝：
< Buff行情>- 负责人的角色，
- 对主体的权限，以及
- 角色权限
授予和拒绝存储为对象上的批注。存储 授予和拒绝，对象必须是可注释的：
< Buff行情>>>> import zope.interface >>> from zope.annotation.interfaces import IAttributeAnnotatable >>> @zope.interface.implementer(IAttributeAnnotatable) ... class Ob: ... pass
>>> ob = Ob()
我们使用对象来表示主体。这些对象实现了 名为 iprincipal 的接口，但安全策略仅使用 id 和组属性：
< Buff行情>>>> class Principal: ... def __init__(self, id): ... self.id = id ... self.groups = []
>>> principal = Principal('bob')
角色和权限也由对象表示，但是 安全策略的目的是，仅使用字符串 ids 。
安全策略提供了创建交互的工厂：
< Buff行情>>>> import zope.securitypolicy.zopepolicy >>> interaction = zope.securitypolicy.zopepolicy.ZopeSecurityPolicy()
交互表示一些 主体（通常是用户）和系统。通常，我们只是 关注一个主体与系统的相互作用，尽管 我们可以有多个主体的交互。多重主体 当不受信任的用户在 以后执行的系统。当执行不受信任的代码时， 代码的作者参与交互。安 只有当 参与交互的主体可以访问对象。
关于交互的checkpermission方法用于测试 交互具有对象的权限。没有 参与者始终拥有所有权限：
< Buff行情>>>> interaction.checkPermission('P1', ob)
True
在本例中，"p1"是一个权限ID。
通常，互动的参与者：
< Buff行情>>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)
如果我们有参与者，除非有 补助金：
< Buff行情>>>> interaction.checkPermission('P1', ob)
False
注意，霍维夫r，我们始终拥有checkerpublic权限：
< Buff行情>>>> from zope.security.checker import CheckerPublic >>> interaction.checkPermission(CheckerPublic, ob) True
我们通过调整对象以适应不同的 授予接口。从改编返回的对象是 对象特定的管理器对象：
< Buff行情>>>> import zope.interface >>> from zope.annotation.interfaces import IAttributeAnnotatable >>> @zope.interface.implementer(IAttributeAnnotatable) ... class Ob: ... pass0
检查权限所涉及的计算可以是 意义重大。为了降低计算成本，使用缓存 广泛的。我们可以在拨款时使缓存失效，但是 用于进行授权的适配器将自动使 当前的交互作用。他们使用安全管理api 这个。为了利用缓存失效，我们需要 安全管理系统管理我们的交互。首先，我们会 将我们的安全策略设置为默认值：
< Buff行情>>>> import zope.interface >>> from zope.annotation.interfaces import IAttributeAnnotatable >>> @zope.interface.implementer(IAttributeAnnotatable) ... class Ob: ... pass1
然后我们将创建一个新的交互：
< Buff行情>>>> import zope.interface >>> from zope.annotation.interfaces import IAttributeAnnotatable >>> @zope.interface.implementer(IAttributeAnnotatable) ... class Ob: ... pass2
我们通常通过授予对象的角色权限来提供访问：
< Buff行情>>>> import zope.interface >>> from zope.annotation.interfaces import IAttributeAnnotatable >>> @zope.interface.implementer(IAttributeAnnotatable) ... class Ob: ... pass3
然后将角色授予对象的主体（本地角色）：
< Buff行情>>>> import zope.interface >>> from zope.annotation.interfaces import IAttributeAnnotatable >>> @zope.interface.implementer(IAttributeAnnotatable) ... class Ob: ... pass4
这些补助金的组合，我们称之为基于角色的补助金， 提供权限：
< Buff行情>>>> interaction.checkPermission('P1', ob)
True
我们还可以直接提供许可：
< Buff行情>>>> import zope.interface >>> from zope.annotation.interfaces import IAttributeAnnotatable >>> @zope.interface.implementer(IAttributeAnnotatable) ... class Ob: ... pass6
权限授予或拒绝将覆盖基于角色的授予或拒绝。所以 如果我们拒绝p1：
< Buff行情>>>> import zope.interface >>> from zope.annotation.interfaces import IAttributeAnnotatable >>> @zope.interface.implementer(IAttributeAnnotatable) ... class Ob: ... pass7
我们导致交互缺乏权限，尽管角色 赠款：
< Buff行情>>>> interaction.checkPermission('P1', ob)
False
同样，即使我们对p2有基于角色的拒绝：
< Buff行情>>>> import zope.interface >>> from zope.annotation.interfaces import IAttributeAnnotatable >>> @zope.interface.implementer(IAttributeAnnotatable) ... class Ob: ... pass9
由于基于权限的授权，我们仍然可以访问：
< Buff行情>>>> ob = Ob()0
基于角色的拒绝实际上并不拒绝权限；相反 阻止授予权限。所以，如果我们既有补助金又有 基于角色的拒绝，我们可以访问：
< Buff行情>>>> ob = Ob()1
>>> ob = Ob()2
全球拨款
对某个对象的补助被称为"本地"。我们也可以 全球资助：
< Buff行情>>>> ob = Ob()3
同样的规则也适用于全球资助和拒绝。
< Buff行情>>>> ob = Ob()4
在这些测试中，我们不需要定义任何角色、权限， 或者委托人，所以我们传递一个额外的参数来告诉 例行程序不检查值的有效性。
< Buff行情>>>> ob = Ob()5
>>> ob = Ob()6
>>> ob = Ob()7
>>> ob = Ob()8
>>> ob = Ob()9
本地与全球拨款
当然，我们默认获得全球赠款：
< Buff行情>>>> class Principal: ... def __init__(self, id): ... self.id = id ... self.groups = []0
本地基于角色的授权不会覆盖全局主体特定的拒绝：
< Buff行情>>>> class Principal: ... def __init__(self, id): ... self.id = id ... self.groups = []1
而本地基于角色的否认并不凌驾于全球 主要补助金：
< Buff行情>>>> class Principal: ... def __init__(self, id): ... self.id = id ... self.groups = []2
本地基于角色的拒绝可以取消全局基于角色的授予：
< Buff行情>>>> class Principal: ... def __init__(self, id): ... self.id = id ... self.groups = []3
本地基于角色的授权可以覆盖全局基于角色的拒绝：
< Buff行情>>>> class Principal: ... def __init__(self, id): ... self.id = id ... self.groups = []4
当然，基于本地权限的授予或拒绝会覆盖任何 全局设置并覆盖基于角色的本地授予或拒绝：
< Buff行情>>>> class Principal: ... def __init__(self, id): ... self.id = id ... self.groups = []5
>>> class Principal: ... def __init__(self, id): ... self.id = id ... self.groups = []6
子定位
我们可以有分地点。位置的子位置是一个对象 其"父"属性是位置：
< Buff行情>>>> class Principal: ... def __init__(self, id): ... self.id = id ... self.groups = []7
默认情况下，子职位从更高的职位获得补助：
< Buff行情>>>> class Principal: ... def __init__(self, id): ... self.id = id ... self.groups = []8
基于角色的子位置授予不会覆盖其父级 主要特定否认：
< Buff行情>>>> class Principal: ... def __init__(self, id): ... self.id = id ... self.groups = []9
>>> principal = Principal('bob')
0
当地基于角色的否认也不会凌驾于父母之上 本金补助：
< Buff行情>>>> principal = Principal('bob')
1
本地角色-基于拒绝可以取消基于父角色的授予：
< Buff行情>>>> principal = Principal('bob')
2
并且本地基于角色的授权可以覆盖父基于角色的拒绝：
< Buff行情>>>> principal = Principal('bob')
3
当然，基于本地权限的授予或拒绝会覆盖任何 全局设置并覆盖基于角色的本地授予或拒绝：
< Buff行情>>>> principal = Principal('bob')
4
>>> principal = Principal('bob')
5
如果一个对象不是可注释的，但是有父对象，它将得到 其母公司的补助金：
< Buff行情>>>> principal = Principal('bob')
6
>>> principal = Principal('bob')
7
>>> principal = Principal('bob')
8
如果存在多个不可注释的 对象：
< Buff行情>>>> principal = Principal('bob')
9
>>> principal = Principal('bob')
8
如果一个对象没有父对象：
< Buff行情>>>> import zope.securitypolicy.zopepolicy >>> interaction = zope.securitypolicy.zopepolicy.ZopeSecurityPolicy()1
它将获得全球范围内的任何资助：
< Buff行情>>>> import zope.securitypolicy.zopepolicy >>> interaction = zope.securitypolicy.zopepolicy.ZopeSecurityPolicy()2
>>> import zope.securitypolicy.zopepolicy >>> interaction = zope.securitypolicy.zopepolicy.ZopeSecurityPolicy()3
如果我们有一个不带 家长：
< Buff行情>>>> import zope.securitypolicy.zopepolicy >>> interaction = zope.securitypolicy.zopepolicy.ZopeSecurityPolicy()4
>>> import zope.securitypolicy.zopepolicy >>> interaction = zope.securitypolicy.zopepolicy.ZopeSecurityPolicy()5
匿名角色
安全策略定义了一个名为"zope.anonymous"的特殊角色。所有 主体具有此角色，该角色不能被夺走。
< Buff行情>>>> import zope.securitypolicy.zopepolicy >>> interaction = zope.securitypolicy.zopepolicy.ZopeSecurityPolicy()6
代理
可以代理对象：
< Buff行情>>>> import zope.securitypolicy.zopepolicy >>> interaction = zope.securitypolicy.zopepolicy.ZopeSecurityPolicy()7
就像他们的父母一样：
< Buff行情>>>> principal = Principal('bob')
7
>>> principal = Principal('bob')
8
组
主体可能有组。团体也是主体（因此， 可能有组）。
如果主体具有组，则组在中可用作组ID 主体的 组属性。交互必须转换 这些组id将对象分组，以便它能够判断 团体有团体。它通过调用getPrincipal方法 在负责的主要身份验证服务上， 其中包括将主体id转换为主体。 对于这里的示例，我们将创建并注册存根主体 认证服务：
< Buff行情>>>> interaction.checkPermission('P1', ob)
True
0
>>> interaction.checkPermission('P1', ob)
True
1
>>> interaction.checkPermission('P1', ob)
True
2
让我们定义一个组：
< Buff行情>>>> interaction.checkPermission('P1', ob)
True
3
让我们把校长安排在我们小组里。我们通过添加组id 新主体组：
< Buff行情>>>> interaction.checkPermission('P1', ob)
True
4
当然，主体没有未授予的权限：
< Buff行情>>>> interaction.checkPermission('P1', ob)
True
5
现在，如果我们授予组权限：
< Buff行情>>>> interaction.checkPermission('P1', ob)
True
6
我们发现我们的校长有权：
< Buff行情>>>> interaction.checkPermission('P1', ob)
True
7
即使组授权是全局的，也可以这样做：
< Buff行情>>>> interaction.checkPermission('P1', ob)
True
8
>>> interaction.checkPermission('P1', ob)
True
9
>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)0
当然，补助金是获得的：
< Buff行情>>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)1
>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)2
内部授权可以覆盖外部授权：
< Buff行情>>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)3
但主要拨款总是胜过集团拨款：
< Buff行情>>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)4
组也可以有组：
< Buff行情>>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)5
如果我们授予新组：
< Buff行情>>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)6
当然，我们也有这个权限：
< Buff行情>>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)7
正如主体授予覆盖组授予一样，组授予可以 覆盖其他组授权：
< Buff行情>>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)8
主体可以在多个组中。让我们定义一个新组：
< Buff行情>>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)9
现在，校长有两个小组。在一个组中，权限"gp2" 被拒绝，但在另一方面，这是允许的。在这种情况下， 允许权限：
< Buff行情>>>> class Participation: ... interaction = None >>> participation = Participation() >>> participation.principal = principal >>> interaction.add(participation)7
如果主体有两个或多个组，则该组拒绝 父母允许的。他们不会阻止校长 从另一个委托人那里获得许可。
授权可以通过多个路径从祖先组继承。 让我们授予g2权限并拒绝g1：
< Buff行情> α-αα81现在，和以前一样，g1中的拒绝阻止g2中的授予：
< Buff行情>>>> interaction.checkPermission('P1', ob)
False
2
让g2成为g3的一组：
< Buff行情>>>> interaction.checkPermission('P1', ob)
False
3
现在，我们通过G3获得G2的授权，并且允许访问：
< Buff行情>>>> interaction.checkPermission('P1', ob)
False
4
我们可以将角色分配给组：
< Buff行情>>>> interaction.checkPermission('P1', ob)
False
5
并通过角色获得权限：
< Buff行情>>>> interaction.checkPermission('P1', ob)
False
6
我们可以通过子组覆盖对组的角色分配：
< Buff行情>>>> interaction.checkPermission('P1', ob)
False
7
并通过委托人：
< Buff行情>>>> interaction.checkPermission('P1', ob)
False
8
我们将清除在以下示例中所做的更改：
< Buff行情>>>> interaction.checkPermission('P1', ob)
False
9
欢迎加入QQ群-->： 979659372
