我正在关注这篇cake php acl model文章来创建我自己的acl实现。
我已经理解了ACO ARO和ACO_ARO的概念。我想实现Check方法，它将决定aro是否可以访问aco。由于有ARO树和ACO树，我如何计算aco对aro的最有效权限。
此外，我发现下面的文章已经实现了检查方法但是在php中 acl implementation
简而言之，应该优先考虑帐号或组，aco或者父母。
像这样article更新 直到现在我已到达这里
我已经创建了一个accessControlEntry类，如下所示
public class AccessControlEntry
{
public BsonObjectId AccessControlEntryId { get; set; }
public BsonObjectId AccessRequestObjectId { get; set; }
public BsonObjectId AccessControlObjectId { get; set; }
public bool CanView { get; set; }
public bool CanEdit { get; set; }
public bool CanDelete { get; set; }
public bool CanAdministrate { get; set; }
}
public bool Check(Usercontext usercontext, BsonObjectId acoId, string permission)
{
//aco id is accessControlObjectId like in cakephp acl
Account acc = _usercontextService.GetAccountByUserContext(usercontext);
//getting ACE eg X account has CanRead=true on Y object
AccessControlEntry entry = _accessControlEntryRepository.GetAccessControlEntry(acc.AccountId, acoId);
if (entry != null)
{
bool value = (bool)entry.GetType().GetProperty(permission).GetValue(entry, null);
return value;
}
//account entry not found ...search in groups
bool groupEntryFound = false;
bool effectiveValue = false;
Group[] groups = _usercontextService.GetGroupsForAccount(acc.AccountId);
foreach (Group group in groups)
{
AccessControlEntry entryGroup = _accessControlEntryRepository.GetAccessControlEntry(group.GroupId, acoId);
if (entryGroup != null)
{
groupEntryFound = true;
effectiveValue |= (bool)entryGroup.GetType().GetProperty(permission).GetValue(entryGroup, null);
}
}
//ACE found in group ..return most privilged value
if (groupEntryFound)
return effectiveValue;
//entry not found for account nor for group..return false
return false;
}
我从其他服务中调用check方法
Check(context,44556,"CanRead")
check方法查找帐户的AccessControlEntry，如果找不到帐户的任何条目，则会查找组。
答案 0 :(得分：0)
在实施内容管理系统/文档管理系统模型时，我在.Net中遇到了同样的问题。
我发现，在它最简单的形式中，实际上有2棵树，并且根据继承权限进行“有效权限”计算对于您的应用程序而言在可伸缩性方面是不健康的，但这并不意味着它是不可能的。
这意味着您基本上可以基于当前节点计算有效权限，以简化模型。
例如:(让我们使用“Pages”作为节点）
在复杂模型中，为了弄清楚用户在第4页上的权限，您将有效地获取分配给第1,3和4页的所有权限，然后执行“添加合并”。
在简化模型中，我们只考虑为用户添加的权限
Page 1
Page 2
Page 3
Page 4
为了让我的问题尽可能简单，因此尽可能无错误，我决定选择一个模型，其中只能添加一个角色/组，并在树节点上添加相关的acl条目。
这意味着在权限方面找出我想要的权限我会有效地运行查询（只有你的实现可能会有所不同的seudo代码）：
var allAcls = "Select all ACL where PageId in (pagesToThisPoint) and Role in (userRoles)"
var resultAcl = new aclEntry();
allAcls.Each(acl => {
resultAcl.Delete = (acl.Delete > resultAcl.Delete ? acl.Delete : resultAcl.Delete);
resultAcl.Update = (acl.Update > resultAcl.Update ? acl.Update : resultAcl.Update);
resultAcl.Read = (acl.Read > resultAcl.Read ? acl.Read : resultAcl.Read);
....
});
留下另外一个考虑，拒绝规则，规则是拒绝规则，典型的约定是它覆盖允许规则。
因此，再次绕回循环并评估否认：
allAcls.Each(acl => {
resultAcl.Delete = (acl.Delete == deny ? resultAcl.Delete == deny);
resultAcl.Update = (acl.Update == deny ? resultAcl.Update == deny);
resultAcl.Read = (acl.Read == deny ? resultAcl.Read == deny);
....
});
所以你基本上是说获取用户和页面的所有角色，其中页面有任何角色的acl条目将其添加到结果权限中，然后删除任何明确拒绝定义的权限。
我确信如果您希望重新运行用户特定权限的流程，以匹配当前用户当前用户的所有权限并覆盖基于角色的集，则可以进一步扩展。
作为一般的经验法则，我倾向于遵循这样的逻辑：规则越具体，它就越相关。
所以你可能会说...... 所有经理都可以访问整个网站 管理员被剥夺对网站管理员部分的任何权利 所有销售人员都可以访问销售部分 所有营销都可以访问营销 营销用户“Bob”可以访问销售
上述逻辑将涵盖所有这些并有效地应用访问，如下所示： 用户获得部门的权利（销售用户=销售额等） 经理获得额外的权利和访问所有领域接受管理员（IT可能只？） 鲍勃是我们的例外，虽然他从事营销工作，但我们授予他销售权。
这意味着什么： 1.可以将用户添加到角色中 2.可以将页面添加到角色中，然后将有问题的角色赋予“acl”权限 这意味着我可以这样说： 如果用户处于销售角色，则授予他们“读取，更新”权限 3.根据定义，页面本身不是“在角色中”，而只是知道授予角色的访问权限 4.扩展此模型意味着您可以为特定用户指定acl条目 5.用户acl条目覆盖角色acl条目 6.到目前为止，所考虑的Acl条目是针对整个树的 7.拒绝规则会覆盖允许规则
如果说父母页面上写着“销售用户完全被拒绝访问”，那么会发生什么呢？然后我们所在页面上显示“当前用户bob具有完全访问权限”？
这是基于开发人员/企业对如何处理此类情景的选择......
我的想法是： 用户在角色范围内比角色更本地化 拒绝规则适用于父级，而允许规则适用于页面 我会采用允许规则。
但是，如果父规则是针对用户的，并且该角色的Page规则是针对当前页面的，那么我将使用相同的逻辑来获取该角色的规则。
这些ACL的大部分都是主观的，我倾向于依赖人们习惯的东西，例如：Windows中的文件系统权限，这样应用程序似乎以用户认为“常态”的方式行事，将使你在将来不会得到20个问题。
大多数情况下。
答案 1 :(得分：0)
看到这个url这是cakephp 2.0： -
http://book.cakephp.org/2.0/en/tutorials-and-examples/simple-acl-controlled-application/simple-acl-controlled-application.html
http://book.cakephp.org/2.0/en/tutorials-and-examples/simple-acl-controlled-application/part-two.html
答案 2 :(得分：0)
答案 3 :(得分：0)
鉴于以上信息，我们可以编写一些简单的工具，在我的情况下，我正在使用内容管理系统，所以我的ACL是关于页面访问的。
首先我定义我的ACL条目是什么样的......
using System;
namespace Core.Objects.CMS
{
/// <summary>
/// Represents a record on an access control list
/// </summary>
public class PageACLEntry
{
/// <summary>
/// Gets or sets the access control entry id.
/// </summary>
/// <value>
/// The access control entry id.
/// </value>
public int PageACLEntryId { get; set; }
/// <summary>
/// Gets or sets the page id.
/// </summary>
/// <value>
/// The page id.
/// </value>
public int PageId { get; set; }
/// <summary>
/// Gets or sets the name of the role.
/// </summary>
/// <value>
/// The name of the role.
/// </value>
public string RoleName { get; set; }
/// <summary>
/// Gets or sets the read.
/// </summary>
/// <value>
/// The read.
/// </value>
public bool? Read { get; set; }
/// <summary>
/// Gets or sets the content of the update.
/// </summary>
/// <value>
/// The content of the update.
/// </value>
public bool? UpdateContent { get; set; }
/// <summary>
/// Gets or sets the update meta.
/// </summary>
/// <value>
/// The update meta.
/// </value>
public bool? UpdateMeta { get; set; }
/// <summary>
/// Gets or sets the delete.
/// </summary>
/// <value>
/// The delete.
/// </value>
public bool? Delete { get; set; }
/// <summary>
/// Gets or sets the full control.
/// </summary>
/// <value>
/// The full control.
/// </value>
public bool? FullControl { get; set; }
}
}
然后我创建一个帮助类来处理评估......
using System.Collections.Generic;
using System.Security.Principal;
using Core.Objects.CMS;
namespace Core.Utilities
{
/// <summary>
/// Tools for permission calculation
/// </summary>
public static class PermissionHelper
{
/// <summary>
/// Calculates the page permissions the given user has on the given page.
/// </summary>
/// <param name="page">The page.</param>
/// <param name="user">The user.</param>
/// <returns>the effective permissions</returns>
private static PageACLEntry CalculatePagePermissions(Page page, IPrincipal user)
{
PageACLEntry result = new PageACLEntry();
// start with acl for the current page
List<PageACLEntry> acl = new List<PageACLEntry>(page.AclRules);
// append all the way up the tree until parent == null
acl = AppendTreePermissions(acl, page, user);
// reverse the list so we evaluate root first then work up to here
acl.Reverse();
// because of the order in which these are applied the most local rules overrule the less local
// the wider the scope the less it applies
acl.ForEach(ace =>
{
// only apply rules that apply to roles that our current user is in
if (user.IsInRole(ace.RoleName))
{
result.Read = Eval(result.Read, ace.Read);
result.Delete = Eval(result.Delete, ace.Delete);
result.UpdateMeta = Eval(result.UpdateMeta, ace.UpdateMeta);
result.UpdateContent = Eval(result.UpdateContent, ace.UpdateContent);
result.FullControl = Eval(result.FullControl, ace.FullControl);
}
});
return result;
}
/// <summary>
/// Evaluates the specified permission level.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="suggestion">The suggestion.</param>
/// <returns>evaluation result</returns>
private static bool? Eval(bool? target, bool? suggestion)
{
bool? result = null;
switch (target)
{
case false:
result = false;
break;
case true:
result = true;
break;
case null:
break;
}
return result;
}
/// <summary>
/// Appends the tree acl from the tree root up to this point.
/// </summary>
/// <param name="acl">The acl.</param>
/// <param name="page">The page.</param>
/// <param name="user">The user.</param>
/// <returns>the complete acl</returns>
private static List<PageACLEntry> AppendTreePermissions(List<PageACLEntry> acl, Page page, IPrincipal user)
{
Page currentPage = page.Parent;
while (currentPage != null)
{
acl.AddRange(currentPage.AclRules);
currentPage = page.Parent;
}
return acl;
}
/// <summary>
/// Determines if the current User can read the given page.
/// Unless an explicit deny rule is in place the default is to make everything read only.
/// </summary>
/// <param name="page">The page.</param>
/// <param name="user">The user.</param>
/// <returns>
/// access right indication as bool
/// </returns>
public static bool UserCanRead(Page page, IPrincipal user)
{
PageACLEntry permissions = CalculatePagePermissions(page, user);
if (permissions.Read != false)
{
return true;
}
return false;
}
/// <summary>
/// Determines if the current User can delete the given page.
/// </summary>
/// <param name="page">The page.</param>
/// <param name="user">The user.</param>
/// <returns>
/// access right indication as bool
/// </returns>
public static bool UserCanDelete(Page page, IPrincipal user)
{
PageACLEntry permissions = CalculatePagePermissions(page, user);
if (permissions.FullControl == true || permissions.Delete == true)
{
return true;
}
return false;
}
/// <summary>
/// Determines if the current User can update the given page.
/// </summary>
/// <param name="page">The page.</param>
/// <param name="user">The user.</param>
/// <returns>
/// access right indication as bool
/// </returns>
public static bool UserCanUpdate(Page page, IPrincipal user)
{
PageACLEntry permissions = CalculatePagePermissions(page, user);
if (permissions.FullControl == true || permissions.UpdateMeta == true)
{
return true;
}
return false;
}
public static bool UserCanUpdateContent(Page page, IPrincipal user)
{
PageACLEntry permissions = CalculatePagePermissions(page, user);
if (permissions.FullControl == true || permissions.UpdateContent == true)
{
return true;
}
return false;
}
/// <summary>
/// Determines if the current User can append children to the given page.
/// </summary>
/// <param name="page">The page.</param>
/// <param name="user">The user.</param>
/// <returns>
/// access right indication as bool
/// </returns>
public static bool UserCanAddChildTo(Page page, IPrincipal user)
{
PageACLEntry permissions = CalculatePagePermissions(page, user);
if (permissions.FullControl == true || permissions.UpdateMeta == true)
{
return true;
}
return false;
}
}
}
这现在给了我所有的控制权，我只是传递了一个页面和一个IPrincipal对象，然后我找回了一个代表访问级别的ACLEntry。
我决定通过将Calculation方法设为私有而只公开CanX方法来进一步抽象我的安全实现。
所以现在它就像
一样简单bool result = PermissionsHelper.UserCanRead(page, user);
似乎有很多代码，但如果你拿出格式和注释（以满足编码标准），实际上代码很少，如果你将它复制到Visual Studio中的类文件中，实际上很容易遵循和维护。
您可能还会注意到，我没有一次传入存储库或服务类来获取数据，这是因为我使用它来构建使用代码编写的对象，首先使用EF建模我正在使用延迟加载，因此您的实现可能需要比page.parent.AClEntries更多的东西来爬树。
哦，万一你需要它，这是我的页面课......
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
namespace Core.Objects.CMS
{
/// <summary>
/// Represents a managed CMS page
/// </summary>
[Table("Pages")]
public class Page
{
/// <summary>
/// Gets or sets the page id.
/// </summary>
/// <value>
/// The page id.
/// </value>
public int PageId { get; set; }
/// <summary>
/// Gets or sets the version.
/// </summary>
/// <value>
/// The version.
/// </value>
public int Version { get; set; }
/// <summary>
/// Gets or sets the title.
/// </summary>
/// <value>
/// The title.
/// </value>
public string Title { get; set; }
/// <summary>
/// Gets or sets the template.
/// </summary>
/// <value>
/// The template.
/// </value>
public string Template { get; set; }
/// <summary>
/// Gets or sets the path.
/// </summary>
/// <value>
/// The path.
/// </value>
public string Path { get; set; }
/// <summary>
/// Gets or sets the parent.
/// </summary>
/// <value>
/// The parent.
/// </value>
public virtual Page Parent { get; set; }
/// <summary>
/// Gets or sets the children.
/// </summary>
/// <value>
/// The children.
/// </value>
public virtual List<Page> Children { get; set; }
/// <summary>
/// Gets or sets the content.
/// </summary>
/// <value>
/// The content.
/// </value>
public virtual List<PageContent> Content { get; set; }
/// <summary>
/// Gets or sets the component stacks.
/// </summary>
/// <value>
/// The component stacks.
/// </value>
public virtual List<Stack> ComponentStacks { get; set; }
/// <summary>
/// Gets or sets the acl rules.
/// </summary>
/// <value>
/// The acl rules.
/// </value>
public virtual List<PageACLEntry> AclRules { get; set; }
}
}
非常简单的poco ...使用EF的强大功能来完成我所有的按需SQL爬行。 一个下方...我怀疑如果你有一个深深嵌套在树中的页面，它会特别有效。
我仍然愿意接受改进建议，但这感觉就像是当时实施可管理解决方案的最简洁方法。 现在，我可以全面了解我可以提高效率的问题。
但至少你有一个参考点：）