51CTO首页 | 论坛 | 博客 | 技术圈 | 求职 | 读书 | 技术频道 | CIO | 导航
首页 | 网络 | 安全 | 系统 | 数据库 | 开发 | Web应用 | 考试认证 | 职场 | 管理 | 全部文章
您所在的位置： 首页>>读书频道>>安全>>网络安全>>

5.5.1 XACML策略语言模型

http://book.51cto.com  2007-12-21 10:59  马恒太等著  电子工业出版社博文视点  我要评论(0)
  • 摘要：《Web服务安全》第5章详细的介绍了Web服务安全认证和访问控制机制。本文主要介绍的是XACML策略语言模型。
  • 标签：Web  XACML  模型  策略  Web服务安全

5.5  策略描述语言——XACML

随着分布式系统的发展，对分布式系统的资源访问控制由集中管理方式变成了分布式管理方式。

一个大型企业组织内部，相同的安全策略可能在组织内部的多个点执行。一个资源的安全策略可能由多个部门共同完成，如信息系统部门、人力资源部门、法律部门，以及金融部门等。

同一个安全策略可能应用于内部网络防护、邮件系统、远程访问系统，以及一个具体的平台系统。

因此在分布式系统中，策略交互非常必要。需要一种能够相互理解的策略描述语言，XACML（eXtensible Access Control Markup Language）语言就是为了解决策略描述问题而设计的。

5.5.1  XACML策略语言模型

本节介绍XACML语言，并根据一些情况给出一些例子。首先通过策略语言模型图来了解XACML语言的基本要素及其之间的相互关系。

1．XACML策略语言模型

XACML策略语言模型如图5-15所示。
错误！

图5-15 XACML策略语言模型

XACML策略语言模型中各元素的含义及其之间的相互关系将在后面介绍。

2．组合算法

XACML策略语言是一种分布式策略语言，对于同一资源可能由不同的策略管理点（PAP）为其制定不同的策略。这些策略之间有可能存在冲突，如有的规则可能允许访问，有的规则可能不允许，这些冲突必须得到解决。也可能多条策略的执行效用一样，这样的策略只要执行一条即可得到相应的策略效用。通过XACML策略语言模型可以看出，一条策略可能包含多条规则，这些规则同样有可能存在冲突或具有相同的效用。

因此在XACML语言中需要一个组合算法来解决冲突，并且避免不必要的运算。在XACML语言中，规定了4种类型的组合算法，即拒绝优先算法（Deny-overrides）、许可优先算法（Permit-overrides）、首先应用算法（First-applicable）和唯一应用算法（Only-one-applicable）。在这些算法中，除了唯一应用算法只适用于策略组合外，其他适用于规则组合算法和策略组合算法。

（1）拒绝优先算法

拒绝优先算法的基本思想是一旦有一条规则或者策略应用得到一个拒绝的结果，则返回结果为拒绝（Deny）；如果在处理某一规则或者策略过程中出现了错误，并且这个规则或者策略的效用（Effect）是拒绝，同时也没有其他规则或者策略的应用结果是拒绝，则返回结果为不确定（Indeterminate）；如果在处理过程中没有规则或者策略的应用结果为拒绝，并且至少有一条规则或者策略的应用结果是许可，同时在处理过程中效用为拒绝的规则或者策略没有出现错误，则返回结果为许可（Permit）；如果应用所有的规则中没有一条规则或者策略可以应用，则返回结果为不可应用（NotApplicable）。

拒绝优先规则组合算法的伪代码如下：

Decision denyOverridesRuleCombiningAlgorithm(Rule rule[]) 
{ 
    Boolean atLeastOneError = false;
    Boolean potentialDeny = false; 
    Boolean atLeastOnePermit = false; 
    for( i=0 ; i < lengthOf(rules) ; i++ )
    { 
    Decision decision = evaluate(rule[i]); 
    if (decision == Deny) 
    { 
      return Deny; 
    } 
    if (decision == Permit) 
    { 
      atLeastOnePermit = true; 
      continue; 
    } 
    if (decision == NotApplicable) 
    { 
      continue; 
    } 
    if (decision == Indeterminate) 
    { 
      atLeastOneError = true; 
      if (effect(rule[i]) == Deny) 
      { 
        potentialDeny = true; 
      } 
      continue;
    }
  } 
  if (potentialDeny) 
  { 
    return Indeterminate; 
  } 
  if (atLeastOnePermit) 
  { 
    return Permit; 
  } 
  if (atLeastOneError) 
  { 
    return Indeterminate;
  } 
  return NotApplicable; 
}

对应的拒绝优先策略组合算法的伪代码如下： 

Decision denyOverridesPolicyCombiningAlgorithm(Policy policy[])
{ 
  Boolean atLeastOnePermit = false; 
  for( i=0 ; i < lengthOf(policy) ; i++ ) 
  { 
    Decision decision = evaluate(policy[i]); 
    if (decision == Deny) 
    { 
      return Deny; 
    } 
    if (decision == Permit) 
    { 
      atLeastOnePermit = true; 
      continue; 
    } 
    if (decision == NotApplicable) 
    { 
      continue; 
    } 
    if (decision == Indeterminate) 
    { 
      return Deny; 
    } 
  } 
  if (atLeastOnePermit) 
  { 
    return Permit; 
  } 
  return NotApplicable; 
}

在规则或者策略的选择上，如果是有序的，则是有序算法；如果是随机选择，则是无序算法。

（2）许可优先算法

许可优先算法的基本思想是只要有一条规则或者策略的应用结果是许可（Permit），则返回结果是许可；如果在处理某一规则或者策略过程中出现了错误，并且这个规则或者的策略的效用（Effect）是许可，同时没有其他规则或者策略的应用结果是许可，则返回结果为不确定（Indeterminate）；如果在处理过程中没有规则或者策略的应用结果为许可，同时至少有一条规则或者策略的应用结果是拒绝，而且在处理过程中效用为许可的规则或者策略没有出现错误，则返回结果为拒绝（Deny）；如果应用所有的规则中没有一条规则或者策略可以应用，则返回结果为不可应用（NotApplicable）。

许可优先规则组合算法的伪代码如下：

Decision permitOverridesRuleCombiningAlgorithm(Rule rule[])
{ 
  Boolean atLeastOneError = false;
  Boolean potentialPermit = false;
  Boolean atLeastOneDeny = false;
  for( i=0 ; i < lengthOf(rule) ; i++ )
  {
    Decision decision = evaluate(rule[i]);
    if (decision == Deny)
    {
      atLeastOneDeny = true;
      continue;
    }
    if (decision == Permit)
    {
      return Permit;
    }
    if (decision == NotApplicable)
    {
      continue;
    }
    if (decision == Indeterminate)  //出错情况
    {
      atLeastOneError = true;
      if (effect(rule[i]) ==permit)
      {
        potentialPermit = true;
      }
      continue;
    }
  }
  if (potentialPermit)
  {
    return Indeterminate;
  }
  if (atLeastOneDeny)
  {
    return Deny;
  }
  if (atLeastOneError)
  {
    return Indeterminate;
  }
  return NotApplicable;
}

对应的许可优先策略组合算法的伪代码如下： 

Decision permitOverridesPolicyCombiningAlgorithm(Policy policy[])
{
  Boolean atLeastOneError = false; 
  Boolean atLeastOneDeny = false;
  for( i=0 ; i < lengthOf(policy) ; i++ )
  {
    Decision decision = evaluate(policy[i]);
    if (decision == Deny)
    {
      atLeastOneDeny = true;
      continue;
    }
    if (decision == Permit)
    {
      return Permit;
    }
    if (decision == NotApplicable)
    {
      continue;
    }
    if (decision == Indeterminate)
    {
      atLeastOneError = true;
      continue;
    }
  }
  if (atLeastOneDeny)
  {
    return Deny;
  }
  if (atLeastOneError)
  {
    return Indeterminate;
  }
  return NotApplicable;
}

（3）首先应用算法

该算法的基本思想是在应用一组规则或者策略的过程中，如果有一条规则或者策略是可以应用（其结果可以得到许可或者拒绝），则算法立即停止，并返回这一条规则或者策略的应用结果；如果没有任何一条规则或者策略可以应用，则返回结果是不可应用；如果在处理规则或者策略的过程中出错，则返回结果是不确定的。

首先应用规则组合算法的伪代码如下：

Decision firstApplicableEffectRuleCombiningAlgorithm(Rule rule[])
{
  for( i = 0 ; i < lengthOf(rule) ; i++ )
  {
    Decision decision = evaluate(rule[i]);
    if (decision == Deny)
    {
      return Deny;
    }
    if (decision == Permit)
    {
      return Permit;
    }
    if (decision == NotApplicable)
    {
      continue;
    }
    if (decision == Indeterminate)
    {
      return Indeterminate;
    }
  }
  return NotApplicable;
}

对应的首先应用策略组合算法的伪代码如下： 

Decision firstApplicableEffectPolicyCombiningAlgorithm(Policy policy[])
{
  for( i = 0 ; i < lengthOf(policy) ; i++ )
  {
    Decision decision = evaluate(policy[i]);
    if(decision == Deny)
    {
      return Deny;
    }
    if(decision == Permit)
    {
      return Permit;
    }
    if (decision == NotApplicable)
    {
      continue;
    }
    if (decision == Indeterminate)
    {
      return Indeterminate;
    }
  }
  return NotApplicable;
}

（4）唯一应用算法

唯一应用算法只适用于策略组合算法，它要求在策略中有且只有一条可以应用。

该算法的基本思想是如果策略中有且只有一条策略可以应用，则返回这条策略的应用结果；如果没有一条策略可以应用，则返回结果是不可应用；如果有多于一条策略可以应用，则返回结果是不确定的；如果在处理过程中有出错的情况，或者发现策略无效，则返回结果也是不确定的。

唯一应用策略组合算法的伪代码如下：

Decision onlyOneApplicablePolicyPolicyCombiningAlogrithm(Policy policy[])
{
  Boolean atLeastOne = false;
  Policy selectedPolicy = null;
  ApplicableResult appResult;
  for ( i = 0; i < lengthOf(policy) ; i++ )
  {
    appResult = isApplicable(policy[I]);
    if ( appResult == Indeterminate )
    {
      return Indeterminate;
    }
    if( appResult == Applicable )
    {
      if ( atLeastOne )
      {
        return Indeterminate;
      }
      else
      {
        atLeastOne = true;
        selectedPolicy = policy[i];
      }
    }
    if ( appResult == NotApplicable )
    {
      continue;
    }
  }
  if ( atLeastOne )
  {
    return evaluate(selectedPolicy);
  }
  else
  {
    return NotApplicable;
  }
}

3．规则

从XACML策略语言模型图中可以看出，规则（Rule）是策略语言中一个重要的基本元素。为了更好地理解规则的含义，首先需要了解规则的基本组成部分及其之间的相互关系。

规则包括3个组成部分，即目标（Target）、效用（Effect）和条件（Condition）。

目标（Target）表示规则应用的对象，其中包括4个基本元素，即资源（Resource）、主体（Subject）、动作（Actions）和环境（Environment）。一个目标的基本含义是主体对资源执行的某些动作，这些动作是在一定的环境下执行的。在应用规则的时候，根据请求的主体、资源、动作，以及相关的环境因素来查找可以应用的规则。

效用表示规则应用后的结果，包括两个值，即许可（Permit）和拒绝（Deny）。效用的含义是如果某一个决策请求中的要素（包括主体、资源、动作和环境）和规则中的目标相同，并且效用是许可，则决策结果是许可；如果效用是拒绝，则决策结果是拒绝。

同一规则可能有不同的应用环境，这样在决策时还需要一些辅助的额外信息，这些额外信息需要条件（Condition）来描述。条件是一些谓词结构，其结果是True或者False，通过这些条件可以描述主体、动作、资源，以及环境的一些属性和上下文信息（如操作的时间限制要求）。

【例12（规则）】 病人通过自己的一个病人号码标识自身，并且只能够阅读自己的病历信息。下面就是这个策略对应的XACML语言描述。

[a197] <?xml version="1.0" encoding="UTF-8"?>
[a198] <Policy
[a199] xmlns="urn:oasis:names:tc:xacml:2.0:policy:schema:os" xmlns: xacml-context="urn:oasis:names:tc:xacml:2.0:context:schema:os"
[a200] xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi: schemaLocation="urn:oasis:names:tc:xacml:2.0:policy:schema:os http://docs.oasis-open.org/xacml/access_control-xacml-2.0-context-schema-os.xsd"
[a201] xmlns:md="http://www.med.example.com/schemas/record.xsd"
[a202] PolicyId="urn:oasis:names:tc:xacml:2.0:example:policyid:1"
[a203] RuleCombiningAlgId="urn:oasis:names:tc:xacml:1.0:rule-combining-
algorithm:deny-overrides">
[a204] <PolicyDefaults>
[a205] <XPathVersion>http://www.w3.org/TR/1999/Rec-xpath-19991116</XPathVersion>
[a206] </PolicyDefaults>
[a207] <Target/>
[a208] <VariableDefinition VariableId="17590034">
[a209] <Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:string- equal">
[a210] <Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:string- one-and-only">
[a211] <SubjectAttributeDesignator
AttributeId="urn:oasis:names:tc:xacml:2.0:example:attribute:
patient-number"
[a212] DataType="http://www.w3.org/2001/XMLSchema#string"/>
[a213] </Apply>
[a214] <Apply
[a215] FunctionId="urn:oasis:names:tc:xacml:1.0:function:string-one-and- only">
[a216] <AttributeSelector
[a217] RequestContextPath="//xacml-context:Resource/xacml-
context:ResourceContent/md:record/md:patient/md:patient-number/text()"
[a218] DataType="http://www.w3.org/2001/XMLSchema#string"/>
[a219] </Apply>
[a220] </Apply>
[a221] </VariableDefinition>
[a222] <Rule
[a223] RuleId="urn:oasis:names:tc:xacml:2.0:example:ruleid:1"
[a224] Effect="Permit">
[a225] <Description>
[a226] A person may read any medical record in the
[a227] http://www.med.example.com/schemas/record.xsd namespace
[a228] for which he or she is the designated patient
[a229] </Description>
[a230] <Target>
[a231] <Resources>
[a232] <Resource>
[a233] <ResourceMatch MatchId="urn:oasis:names:tc:xacml:1.0:function: string-equal">
[a234] <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">
[a235] urn:example:med:schemas:record
[a236] </AttributeValue>
[a237] <ResourceAttributeDesignator AttributeId=
[a238] "urn:oasis:names:tc:xacml:2.0:resource:target-namespace"
[a239] DataType="http://www.w3.org/2001/XMLSchema#string"/>
[a240] </ResourceMatch>
[a241] <ResourceMatch MatchId="urn:oasis:names:tc:xacml:1.0:function: xpath-node-match">
[a242] <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">
[a243] /md:record
[a244] </AttributeValue>
[a245] <ResourceAttributeDesignator
AttributeId="urn:oasis:names:tc:xacml:1.0:resource:xpath"
[a246] DataType="http://www.w3.org/2001/XMLSchema#string"/>
[a247] </ResourceMatch>
[a248] </Resource>
[a249] </Resources>
[a250] <Actions>
[a251] <Action>
[a252] <ActionMatch
[a253] MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
[a254] <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">
[a255] read
[a256] </AttributeValue>
[a257] <ActionAttributeDesignator
[a258] AttributeId="urn:oasis:names:tc:xacml:1.0:action:action-id"
[a259] DataType="http://www.w3.org/2001/XMLSchema#string"/>
[a260] </ActionMatch>
[a261] </Action>
[a262] </Actions>
[a263] </Target>
[a264] <Condition>
[a265] <VariableReference VariableId="17590034"/>
[a266] </Condition>
[a267] </Rule>

[a208~a221]定义了一个函数，这个函数将请求主体的病人号属性和资源中的病人号进行比较。在后面的规则中通过应用这个函数即可保障只有病人号和病历中的病人号相同的人才能够读取病历信息，即只有自己才能够读取自己的病历信息。

[a222~a267]定义了规则，规则的效用是“Permit”，规则中的资源是“record”，动作是“read”，对动作的限制条件通过应用定义的函数“VariableId="17590034"”来实现。这个函数在上面已经定义，表示只有病人号和记录中的病人号相同的人才能够进行相应的动作。

4．策略

策略是基于XACML语言的访问控制框架中可以交互的最小单元，它由策略管理点产生并维护，策略决策点（PDP）依据相应的策略进行决策判断。

策略包括4个组成部分，即目标、组合算法、规则集和职责集。

一个策略的目标可以由策略管理人员在策略中明确规定，也可以从策略、策略集或者规则集中推导出来。一旦在策略中明确了目标，则所有规则中的目标都要忽略。

组合算法规定了策略中的规则组合算法。

规则集即策略中的一条或者多条规则组合。

职责集在应用规则的过程中由策略决策点（PDP）返回给策略执行点（PEP），除了执行相应的许可或拒绝操作外。策略执行点（PEP）还需要执行的一些职责，如需要记录相应的日志等。

下面给出一个具体策略的例子。

【例13（策略）】 任何拥有“med.example.com”名字空间下邮箱的用户可以对任何资源执行任何动作。
使用XACML语言描述策略如下：

[a02] <?xml version="1.0" encoding="UTF-8"?>
[a03] <Policy
[a04] xmlns="urn:oasis:names:tc:xacml:2.0:policy:schema:os"
[a05] xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
[a06] xsi:schemaLocation="urn:oasis:names:tc:xacml:2.0:policy:schema:os
http://docs.oasis-open.org/xacml/access_control-xacml-2.0-policy-schema-os.xsd"
[a07] PolicyId="urn:oasis:names:tc:example:SimplePolicy1"
[a08] RuleCombiningAlgId= "identifier:rule- combining- algorithm:deny-     overrides">
[a09] <Description>
[a10] Medi Corp access control policy
[a11] </Description>
[a12] <Target/>
[a13] <Rule
[a14] RuleId= "urn:oasis:names:tc:xacml:2.0:example:SimpleRule1"
[a15] Effect="Permit">
[a16] <Description>
[a17] Any subject with an e-mail name in the med.example.com domain
[a18] can perform any action on any resource.
[a19] </Description>
[a20] <Target>
[a21] <Subjects>
[a22] <Subject>
[a23] <SubjectMatch
[a24] MatchId="urn:oasis:names:tc:xacml:1.0:function:rfc822Name-match">
[a25] <AttributeValue
[a26] DataType="http://www.w3.org/2001/XMLSchema#string">
[a27] med.example.com
[a28] </AttributeValue>
[a29] <SubjectAttributeDesignator
[a30] AttributeId="urn:oasis:names:tc:xacml:1.0:subject:subject-id"
[a31] DataType="urn:oasis:names:tc:xacml:1.0:data-type:rfc822Name"/>
[a32] </SubjectMatch>
[a33] </Subject>
[a34] </Subjects>
[a35] </Target>
[a36] </Rule>
[a37] </Policy>

[a08]定义了规则组合算法，选择的算法是“deny-overrides”，即否定优先算法。在PDP利用该策略进行决策时，一旦有一条规则的应用结果是拒绝，则返回结果为拒绝。

[a12]定义了策略的目标，<Target/>表示本策略可以应用于所有的决策请求，即在具体


[a13~a36]定义了一条规则，在该规则中只有一个主体（Subject）元素，表示本规则的限制条件只是检查主体的一些属性（名字空间检查）。只有主体属性检查通过，才可以对任意资源执行任意的动作。

5．策略集

把多个策略组合在一起形成一个策略集，在XACML语言中，策略集用来描述同时引用多条策略的情况。

下面是一个策略集的例子，策略集中通过引用来使用已经规范的策略（或者策略集）和规则。

[a558] <?xml version="1.0" encoding="UTF-8"?>
[a559] <PolicySet
[a560] xmlns="urn:oasis:names:tc:xacml:2.0:policy:schema:os"
[a561] xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="urn:oasis:names:tc:xacml:2.0:policy:schema:os
http://docs.oasis-open.org/xacml/access_control-xacml-2.0-
policy-schema-os.xsd"
[a562] PolicySetId=
[a563] "urn:oasis:names:tc:xacml:2.0:example:policysetid:1"
[a564] PolicyCombiningAlgId="urn:oasis:names:tc:xacml:1.0:
[a565] policy-combining-algorithm:deny-overrides">
[a566] <Description>
[a567] Example policy set.
[a568] </Description>
[a569] <Target>
[a570] <Resources>
[a571] <Resource>
[a572] <ResourceMatch
[a573] MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
[a574] <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">
[a575] urn:example:med:schema:records
[a576] </AttributeValue>
[a577] <ResourceAttributeDesignator AttributeId=
[a578] "urn:oasis:names:tc:xacml:1.0:resource:target-namespace"
[a579] DataType="http://www.w3.org/2001/XMLSchema#string"/>
[a580] </ResourceMatch>
[a581] </Resource>
[a582] </Resources>
[a583] </Target>
[a584] <PolicyIdReference>
[a585] urn:oasis:names:tc:xacml:2.0:example:policyid:3
[a586] </PolicyIdReference>
[a587] <Policy
[a588] PolicyId="urn:oasis:names:tc:xacml:2.0:example:policyid:2"
[a589] RuleCombiningAlgId=
[a590] "urn: oasis: names: tc:xacml:1.0:rule-combining-algorithm:deny- overrides">
[a591] <Target/>
[a592] <Rule RuleId="urn:oasis:names:tc:xacml:2.0:example:ruleid:1"
[a593] Effect="Permit">
[a594] </Rule>
[a595] <Rule RuleId="urn:oasis:names:tc:xacml:2.0:example:ruleid:2"
[a596] Effect="Permit">
[a597] </Rule>
[a598] <Rule RuleId="urn:oasis:names:tc:xacml:2.0:example:ruleid:4"
[a599] Effect="Deny">
[a600] </Rule>
[a601] </Policy>
[a602] </PolicySet>

在该策略集中包括两条策略信息，第1条策略通过引用已有策略实现[a584~a587]，引用的策略通过ID“urn: oasis :names :tc: xacml: 2.0: example: policyid :3”来标识。

第2条策略在策略集中描述，其目标 [a591]和策略集相同。规则组合算法[a589~a590]是拒绝优先算法，规则是通过引用得到的。规则1[a592~a594]引用的规则是“urn: oasis: names: tc: xacml: 2.0: example: ruleid: 1”，规则2[a595~a597]引用的规则是“urn: oasis: names: tc: xacml: 2.0: example: ruleid: 2”，规则3[a598~a600]引用的是“urn: oasis: names: tc: xacml: 2.0: example: ruleid: 4”。

【责任编辑：董书 TEL：（010）68476606】

回书目   上一节   下一节
上一篇： Web服务安全 下一篇： 5.5.2 XACML上下文
企业级Web2.0 你准备好了么？
WebSphere 实现SOA的利器
Web安全云时代
安全防范与策略
企业Web安全威胁在线评估系统
查看所有评论(0 )
 
 验证码： (点击刷新验证码)   匿名发表

频道推荐

更多>>

全站热点

更多>>
ARP攻击防范与解决方案
ARP攻击防范与..
SOA 面向服务架构
SOA 面向服务..

技术人

更多>>
Google十周年：..
求职必杀技 决战..

读书

更多>>

  • 野蛮生长

  • 作者：冯仑著
  • “地产界的思想家”冯仑纵横生意江湖20年来，第一次系统梳理出书。　　三十年来中国民营企业从前公司时代发展到公司时代，21..

优秀博文

更多>>

最新热帖

更多>>

技术快讯

查看样刊
Copyright©2005-2008 51CTO.COM 版权所有