xacml

在有关XML安全性的系列的最后一篇文章中，我介绍了安全性断言标记语言（SAML）。 关于可扩展访问控制标记语言（XACML）的文章从该文章的开头继续。 尽管SAML提供了一种进行身份验证和授权声明的机制以及一种传达它们的机制，但是XACML提供了一种语言，该语言定义了做出必要的授权决策所需的规则。

例如，考虑一种情况，即主体请求访问目标资源。 在执行决策并将目标资源释放给主体之前，策略执行点（PEP）与策略决策点（PDP）进行检查。 访问目标资源的请求的生成以及随后的授予或拒绝访问的响应属于SAML的范围。 XACML解决了PEP和PDP之间的策略决策交换。

访问控制和XACML

XACML是为访问控制和授权系统开发标准的一项举措。 当前大多数系统以专有方式实现访问控制和授权。

典型的访问控制和授权方案包括三个主要实体- 主题 ， 资源和操作 -及其属性。 主题请求许可以对资源执行操作。 例如，在访问请求“允许财务经理在财务服务器上的发票文件夹中创建文件”中，主题为“财务经理”，目标资源为“财务服务器上的发票文件夹”，并且操作是“创建文件”。

在专有的访问控制系统中，有关这些实体及其属性的信息保存在存储库中。 这些存储库称为访问控制列表（ACL）。 不同的专有系统具有不同的实现ACL的机制，这使得它们之间难以交换和共享信息。

XACML目标

XACML旨在实现以下目标：

• 创建描述访问控制实体及其属性的可移植标准方法。
• 提供一种机制，它提供了比简单地拒绝或授予访问权限更精细的粒度访问控制，即一种可以在“允许”或“拒绝”许可权之前和之后执行某些操作的机制。

XACML和SAML：有何不同和相似之处？

XACML架构与SAML架构紧密相连。 它们都共享许多概念和一个域-身份验证，授权和访问控制的域。 但是，它们在同一域中解决的问题有所不同。 尽管SAML解决了身份验证并提供了在合作实体之间传输身份验证和授权决策的机制，但是XACML专注于用于获得那些授权决策的机制。

SAML标准提供了允许第三方发送其身份验证和授权请求的接口。 XACML标准解决了内部如何处理这些授权请求。 XACML不仅处理授权请求，而且定义了用于创建规则，策略和策略集的完整基础结构以得出授权决策的机制。 我将在XACML中详细讨论这些概念：螺母和螺栓 。

鉴于SAML和XACML都共享同一个域，因此很有可能并希望将这两个规范最终合并为一个。

XACML架构

XACML由图1中描述的许多组件组成。 其中一些组件也与SAML共享。 共享的组件用红色边框标记。

图1. XACML主要组件

授权请求位于策略执行点（PEP） 。 PEP创建一个XACML请求，并将其发送到Policy Decision Point（PDP） ，后者对请求进行评估并发送回响应。 在适当的义务下，响应可以是允许访问或拒绝访问。 我将在本文后面解释义务。

PDP在评估相关政策和其中的规则后做出决定。 可能有许多策略：PDP不会评估所有策略； 根据政策目标，仅选择相关的评估。 策略目标包含有关主题，操作和其他环境属性的信息。 稍后在“ 策略目标创建”中说明如何通过PDP选择策略进行评估的完整过程。

为了获得策略，PDP使用策略访问点（PAP）来编写策略和策略集，并将其提供给PDP。 PDP还可以调用策略信息点（PIP）服务来检索与主题，资源或环境有关的属性值。 PDP得出的授权决定将发送到PEP。 PEP履行义务，并且根据PDP发送的授权决定，允许或拒绝访问。

XACML：螺栓和螺母

为了说明各种XACML组件，我将向您展示如何接受特定的访问请求并创建处理该请求所需的所有XACML组件。 访问请求如下：属于owner组（主题的属性）的主题mverma@secf.com试图对资源file:///D:/Documents/Administrator/Desktop/Project Plan.html执行open操作file:///D:/Documents/Administrator/Desktop/Project Plan.html 。 创建所有必需的XACML组件之后，您应该获得此请求的授权决定。

请记住，XACML具有三个顶级组件：策略，PEP和PDP。 为定义的请求创建XACML基础结构的过程仅围绕这三个组件。 图2中的图说明了这些组件如何相互链接：

图2.策略语言模型

您需要做的第一件事是创建一个处理请求的策略。

XACML政策

策略包括：一组规则，用于规则组合算法的标识符，一组义务和一个目标。 到目前为止，这是XACML的最重要方面。 XACML中的大多数操作都发生在策略中。

我将向您展示如何创建可以处理请求的策略-策略的范围需要比请求的范围更广。 您将创建的策略将如下所示：允许secf.com命名空间中具有电子邮件名称的任何用户对资源file:///D:/Documents/Administrator/Desktop/Project Plan.html执行任何操作file:///D:/Documents/Administrator/Desktop/Project Plan.html 。 请注意，该策略比请求更通用。

策略是几个子组件的组合：目标，规则，规则组合算法和义务。 了解这些子组件是理解策略的必要条件。 让我解释一下每个子组件的重要性：

• 目标：每个策略只有一个目标。 该目标有助于确定策略是否与请求相关。 策略与请求的相关性确定是否要为请求评估策略。 这是通过在目标中定义三个类别的属性（主题，资源和操作）及其值来实现的。 目标中所有三个类别的属性不是强制性的。 将这些属性的值与请求中相同属性的值进行比较； 如果它们匹配（在它们上应用了某些功能之后，您将在本文后面详细介绍），则该策略被认为与请求相关并被评估。
• 规则 -多个规则可以与一个策略相关联。 每个规则都由条件，效果和目标组成。
  • 条件是关于属性的声明，评估后返回True ， False或Indeterminate 。
  • 效果是满意规则的预期结果。 它可以采用Permit或Deny值。
  • 与策略一样， Target有助于确定规则是否与请求相关。 实现此目标的机制也类似于在制定策略目标的情况下的实现方式。
  规则的最终结果取决于条件评估。 如果条件返回Indeterminate ，则规则还将返回Indeterminate 。 如果条件返回False ，则规则返回NotApplicable 。 如果条件返回True ，则返回Effect元素的值，即Permit或Deny 。
• 规则组合算法：正如我在上文中所解释的 ，一个策略可以有多个规则。 不同的规则可能会产生冲突的结果。 规则组合算法负责解决此类冲突，以使每个请求每个策略获得一个结果。 每个策略仅适用一种规则组合算法。 有关更多详细信息，请参见规则组合算法 。
• 义务：请记住，XACML的目标之一是提供比单纯的允许和拒绝决策更为精细的访问控制。 好吧，义务是实现这一目标的机制。 义务是PEP必须与授权决定的执行一起执行的动作。 评估策略后，将特定的义务与授权决定一起发送到PEP。 PEP除了执行授权决定外，还负责执行指定为义务的操作。

政策制定

本节将带您深入了解策略创建代码。 首先，根据需要创建policy对象（请参见清单1）和子组件。 本文的所有编码示例均使用Sun的XACML实现（ 有关实现，请参阅参考资料 ）。

清单1.创建一个策略

// Create policy identifier and policy description
URI policyId = new URI("ProjectPlanAccessPolicy");
String description =
"This AccessPolicy applies to any account at secf.com "
+ "accessing file:///D:/Documents/Administrator/Desktop/Project Plan.html.";

// Rule combining algorithm for the Policy

URI combiningAlgId = new URI(OrderedPermitOverridesRuleAlg.algId);

CombiningAlgFactory factory = CombiningAlgFactory.getInstance();

RuleCombiningAlgorithm combiningAlg =
  (RuleCombiningAlgorithm) (factory.createAlgorithm(combiningAlgId));


// Create the target for the policy
Target policyTarget = createPolicyTarget();

// Create the rules for the policy

List ruleList = createRules();

// Create the policy
Policy policy =
  new Policy(
    policyId,
    combiningAlg,
    description,
    policyTarget,
    ruleList);

// Display the policy on the std out
policy.encode(System.out, new Indenter());

清单1演示了如何创建policy 。 但是真的吗？ policy创建的关键在于其子组件的创建。 此清单仅演示如何将这些子组件放在一起以构成policy对象。 但是，它确实说明了该policy的总体结构。 以下是该策略的组合方式：

1. 选择策略的规则组合算法。 我使用了ordered-permit-override算法，因此按规则在策略中指定的顺序对规则进行评估。
2. 创建策略目标。 目标创建有点复杂-它需要自己的代码清单和说明才能有意义。 清单2演示了该策略的目标创建。
3. 创建要与策略关联的规则。 与目标一样，规则创建是一个涉及的过程，需要它自己的清单。 清单3专门用于解释规则创建。
4. 在创建了所有必需的策略子组件之后，使用它们来创建policy对象。
5. 将policy对象存储在文件中，以便稍后传递给PDP。

接下来的两节演示了该策略的子组件的创建。 我从目标创建开始，并以规则和相关条件的创建结束策略创建的讨论。

制定政策目标

目标创建是创建策略的重要方面。 目标是选择相关策略以评估请求的机制。 要创建策略目标，您需要定义属于以下三个类别之一的属性及其值：主题，资源或操作。 当PDP评估请求时，它将查找目标具有与请求中相同值的属性的策略。

接下来，我将说明如何以编程方式实现这一目标。 XACML提供了一种称为AttributeDesignator的机制，用于比较请求和策略目标中的属性值。

使用AttributeDesignator ，可以通过定义属性的名称和类型来指定它。 此外，您还可以指定属性的值-将在目标中指定的属性值与请求中的属性值进行比较。 要进行此比较，请选择一种预配置功能。 该函数与AttributeDesignator一起用于创建TargetMatch对象。 您可以创建多个TargetMatch对象； 每个属性一个。 属于一个类别的所有TargetMatch对象都放在一个列表中，并传递给Target对象。 该Target对象是您用来创建Policy对象的对象。

该策略应如下所示：“任何在secf.com名称空间中使用电子邮件名称的secf.com都可以对资源file:///D:/Documents/Administrator/Desktop/Project Plan.html执行任何操作。 ” 对于此策略，您可以创建一个具有两个属性的目标-一个用于主题，另一个用于资源。 您不需要为操作创建属性，因为您要创建的策略不会试图限制任何操作。

清单2演示了策略目标的创建。 您想要将请求中主题的电子邮件的域名值与目标中指定的域名进行比较，因此可以为主题指定属性urn:oasis:names:tc:xacml:1.0:data-type:rfc822Name （电子邮件ID）在目标中。 要使其成为目标的一部分，请定义属性类型（ urn:oasis:names:tc:xacml:1.0:data-type:rfc822Name ），属性名称（ urn:oasis:names:tc:xacml:1.0:subject:subject-id ）和比较器函数，在本例中为urn:oasis:names:tc:xacml:1.0:function:rfc822Name-match 。 此函数将目标中指定的属性的值与请求中相同属性的值进行比较。 对于资源类型http://www.w3.org/2001/XMLSchema#anyURI的属性，遵循类似的过程。

清单2.创建一个策略目标

public static Target createPolicyTarget() throws URISyntaxException {
  List subjects = new ArrayList();
  List resources = new ArrayList();

  // Attributes of Subject type
  // Multiple subject attributes can be specified. In this
  // case only one is being defined.

  List subject = new ArrayList();

  URI subjectDesignatorType =
    new URI("urn:oasis:names:tc:xacml:1.0:data-type:rfc822Name");
  URI subjectDesignatorId =
    new URI("urn:oasis:names:tc:xacml:1.0:subject:subject-id");
  // Match function for the subject-id attribute
  String subjectMatchId =
    "urn:oasis:names:tc:xacml:1.0:function:rfc822Name-match";
  AttributeDesignator subjectDesignator =
    new AttributeDesignator(
                  AttributeDesignator.SUBJECT_TARGET,
                  subjectDesignatorType,
                  subjectDesignatorId,
                  false);

  StringAttribute subjectValue = new
    StringAttribute("secf.com");


  // get the factory that handles Target functions
  FunctionFactory factory =
    FunctionFactory.getTargetInstance();

  // get an instance of the right function for matching
  // subject attributes
  Function subjectFunction =
    factory.createFunction(subjectMatchId);

  TargetMatch subjectMatch = new TargetMatch(
                          TargetMatch.SUBJECT,
                  subjectFunction,
                  subjectDesignator,
                  subjectValue);

  subject.add(subjectMatch);


  // Attributes of resource type
  // Multiple resource attributes can be specified. In this
  // case only one is being defined.

  List resource = new ArrayList();

  URI resourceDesignatorType =
    new URI("http://www.w3.org/2001/XMLSchema#anyURI");
  URI resourceDesignatorId =
    new URI("urn:oasis:names:tc:xacml:1.0:resource:resource-id");

  // Match function for the resource-id attribute
  String resourceMatchId =
    "urn:oasis:names:tc:xacml:1.0:function:anyURI-equal";

  AttributeDesignator resourceDesignator =
    new AttributeDesignator(
                  AttributeDesignator.RESOURCE_TARGET,
                  resourceDesignatorType,
                  resourceDesignatorId,
                  false);

  AnyURIAttribute resourceValue =
    new AnyURIAttribute(
      new URI("file:///D:/Documents/Administrator/Desktop/Project Plan.html"));

  // Get an instance of the right function for matching 
  // resource attribute
  Function resourceFunction =
    factory.createFunction(resourceMatchId);

  TargetMatch resourceMatch = new TargetMatch(
                               TargetMatch.RESOURCE,
                         resourceFunction,
                         resourceDesignator,
                         resourceValue);

  resource.add(resourceMatch);

  // Put the subject and resource sections into their lists
  subjects.add(subject);
  resources.add(resource);

  // Create and return the new target. No action type
  // attributes have been specified in the target
  return new Target(subjects, resources, null);
}

规则创建

规则可能是策略中最重要的子组件。 如上所述，规则本质上是评估为Permit ， Deny ， Indeterminate或不NotApplicable 。

要继续创建处理授权请求所需的XACML组件的过程（要查看，请参阅XACML的第一段：螺母和螺栓 ），现在您要创建一个适当的规则。 这实质上可以归结为创造适当的条件。 清单3演示了规则创建。 如果您看一下代码，将会看到三件事：

• 创建规则目标
• 效果的定义
• 条件的创造

这三个中的两个-创建规则目标和定义规则的效果-很简单。 第三个-创建条件-涉及更多，稍后我将对其进行详细描述。

为满足请求而创建的规则应如下所示：“如果属于组owner的主题mverma@secf.com试图打开资源file:///D:/Documents/Administrator/Desktop/Project Plan.html ，然后允许访问。” 要创建这样的规则，请创建目标，以便针对正在处理的请求评估该规则。 创建规则目标类似于为策略创建目标的方式。 然后，将规则的effect定义为Permit 。 要使规则返回effect的值，相关条件必须返回True 。 清单4中的代码说明了条件的创建。

清单3.创建规则

public static List createRules() throws URISyntaxException {
  // Step 1: Define the identifier for the rule
  URI ruleId = new URI("ProjectPlanAccessRule");
  String ruleDescription = “Rule for accessing project plan";

  // Step 2: Define the effect of the rule
  int effect = Result.DECISION_PERMIT;

  // Step 3: Get the target for the rule
  Target target = createRuleTarget();

  // Step 4: Get the condition for the rule
  Apply condition = createRuleCondition();

  // Step 5: Create the rule
  Rule openRule = new Rule(ruleId, effect,ruleDescription, target, condition);

  // Create a list for the rules and add the rule to it

  List ruleList = new ArrayList();
  ruleList.add(openRule);

  return ruleList;

}

清单4演示了规则条件的创建。 与为策略目标创建AttributeDesignator方式几乎相同，您可以创建AttributeDesignator对象，以将请求中的属性值与条件中指定的值进行比较。 这里感兴趣的属性是主题所属的group 。 group属性必须具有值owner ，条件才能返回True 。

您需要为该条件做的唯一的另一件事是使用一个函数从AttributeDesignator返回的倍数中提取一个值。 在这种情况下，请使用函数urn:oasis:names:tc:xacml:1.0:function:string-one-and-only 。 有关处理AttributeDesignator多个值的更多信息，请参见AttributeDesignator返回值 。

如清单4所示 ，您将创建AttributeDesignator对象来定义一个属性，该属性的值要与请求中得到的值进行比较。 比较算法用于进行比较。 然后，您定义函数以从AttributeDesignator返回的那些值中选择一个值。 最后，创建Apply对象，该对象类似于您在目标中创建的TargetMatch对象。 Apply对象的目的是将比较函数应用于从包中选取的值（由AttributeDesignator返回），并将其与条件中指定的值进行比较。

清单4.为规则创建条件

public static Apply createRuleCondition() throws URISyntaxException {
  List conditionArgs = new ArrayList();

  // Define the name and type of the attribute
  // to be used in the condition
  URI designatorType = new URI("http://www.w3.org/2001/XMLSchema#string");
  URI designatorId = new URI("group");

  // Pick the function that the condition uses
  FunctionFactory factory = FunctionFactory.getConditionInstance();
  Function conditionFunction = null;
  try {
      conditionFunction =
          factory.createFunction(
              "urn:oasis:names:tc:xacml:1.0:function:" + "string-equal");
  } catch (Exception e) {
      return null;
  }

  // Choose the function to pick one of the
  // multiple values returned by AttributetDesignator

  List applyArgs = new ArrayList();

  factory = FunctionFactory.getGeneralInstance();
  Function applyFunction = null;
  try {
      applyFunction =
          factory.createFunction(
              "urn:oasis:names:tc:xacml:1.0:function:"
                  + "string-one-and-only");
  } catch (Exception e) {
      return null;
  }

  // Create the AttributeDesignator
  AttributeDesignator designator =
      new AttributeDesignator(
           AttributeDesignator.SUBJECT_TARGET,
           designatorType,
           designatorId,
           false
           null);
  applyArgs.add(designator);

  // Create the Apply object and pass it the
  // function and the AttributeDesignator. The function
  // picks up one of the multiple values returned by the
  // AttributeDesignator
  Apply apply = new Apply(applyFunction, applyArgs, false);

  // Add the new apply element to the list of inputs
  // to the condition along with the AttributeValue
  conditionArgs.add(apply);

  StringAttribute value = new StringAttribute("owner");
  conditionArgs.add(value);

  // Finally, create and return the condition
  return new Apply(conditionFunction, conditionArgs, true);
}

这样，策略创建任务就完成了。 让我快速回顾一下策略创建过程中涉及的内容。 首先，创建必要的策略子组件：策略目标，规则和规则组合算法。 您没有为政策创建义务，因为它们是可选的。 规则的创建本质上是指创建规则目标和条件。 这些也将通过自己的代码清单进行演示。 所有这些策略子组件均在此处用于创建策略。

PEP的创建是创建处理授权请求所需的XACML组件的下一步。 PEP会做什么？ 它会创建要为其创建所有这些XACML组件的授权请求 ！

政策执行点（PEP）

PEP基于请求者的属性，相关资源，操作和其他信息来创建请求。 在这里，我演示了用于创建您开始的请求的机制。 为了您的方便，我将重复请求：属于owner组（主题的属性）的主题mverma@secf.com试图对资源file:///D:/Documents/Administrator/Desktop/Project Plan.html执行open操作file:///D:/Documents/Administrator/Desktop/Project Plan.html 。 要创建这样的请求，您需要两个主题属性，一个资源属性和一个动作属性。 两个主题属性是rfc822Name （电子邮件ID）和主题所属的组。 一个资源属性是资源的URI，而一个动作属性是对该资源的打开操作。 清单5展示了具有所有这些属性的PEP的创建。

到目前为止，您已经看到策略的创建和PEP的请求生成。 现在剩下的唯一要创建的XACML组件是PDP。

政策决策点（PDP）

PDP根据策略评估请求并返回响应。

由于XACML规范没有定义任何用于将策略和请求传递到PDP以评估请求的特定机制，因此可以选择任何方便的机制。 在这种情况下，策略和请求将作为命令行参数传递到PDP。

请注意，PDP不会根据需要服务的请求类型而改变。 它是一个通用组件，它接受任何请求以及一组策略，并根据适用的策略评估该请求。 清单6演示了如何创建PDP，以及如何使用它来评估来自PEP的请求。 清单6之后将详细描述PDP创建和请求评估过程。

清单6.创建一个PDP

public static void main(String[] args) throws Exception {
  if (args.length < 2) {
      System.out.println("Usage: <request> <AccessPolicy> [policies]");
      System.exit(1);
  }
 
  // Step 1: Get the request and policy file from the command line
  String requestFile = null;

  requestFile = args[0];
  String[] policyFiles = new String[args.length - 1];

  for (int i = 1; i < args.length; i++)
      policyFiles[i - 1] = args[i];
 
  // Step 2: Create a PolicyFinderModule and initialize it
  // Use the sample FilePolicyModule, which
  // is configured using the policies from the command line
	
  FilePolicyModule filePolicyModule = new FilePolicyModule();
  for (int i = 0; i < policyFiles.length; i++)
      filePolicyModule.addPolicy(policyFiles[i]);

  // Step 3: Set up the PolicyFinder that this PDP will use
  // 
  PolicyFinder policyFinder = new PolicyFinder();
  Set policyModules = new HashSet();
  policyModules.add(filePolicyModule);
  policyFinder.setModules(policyModules);

  // Step 4: Create the PDP
  PDP pdp = new PDP(new PDPConfig(null, policyFinder, null));

 //  Get the request send by the PEP
  RequestCtx request =
      RequestCtx.getInstance(new FileInputStream(requestFile));

  // Step 5: Evaluate the request. Generate the response.
  ResponseCtx response = pdp.evaluate(request);

  // Display the output on std out
  response.encode(System.out, new Indenter());
}

以下分步说明详细介绍了PDP创建和请求评估：

1. 从命令行参数获取请求和策略文件。
2. 创建一个PolicyFinderModule并使用FilePolicyModule对象对其进行初始化。 FilePolicyModule是使用命令行中的策略配置的。 PolicyFinderModule是三个查找器模块之一：
   • PolicyFinderModule
   • AttributeFinderModule
   • ResourceFinderModule
   这些模块是Sun XACML的实现使用的机制，用于查找属性，策略和资源。
3. 设置PDP将使用的策略查找器。
4. 创建PDP通过初始化PDP类。 的PDPConfig对象，这是使用配置的FilepolicyModule ，被提供给PDP的构造。
5. 通过调用PDP上的evaluate方法， evaluate来自PEP的请求。 这将返回授权决定。 如果按照本文所述创建了所有XACML组件，则PDP将做出“ Permit授权决定。

授权决定被传送回PEP 。 您可以选择将决策发送回PEP的机制。

这样就完成了对创建请求所需的三个主要XACML组件（策略，PEP和PDP）的说明和演示。

结论

访问控制是几乎所有大型和小型应用程序都使用的领域。 XACML试图将标准化引入这一领域。 尽管XACML是一种冗长的语言，但是一旦掌握了该语言的基本概念和流程，就很容易构建访问控制机制。

在本文中，我带您完成了创建基本XACML组件的过程：

• 政策，包括规则和政策目标
• PEP
• PDP

有了这些知识，您就可以采用XACML来处理当前和将来所有应用程序中的访问控制。

翻译自: https://www.ibm.com/developerworks/xml/library/x-xacml/index.html

xacml