Changeset 6624 for TI12-security/trunk


Ignore:
Timestamp:
24/02/10 13:29:48 (10 years ago)
Author:
pjkersha
Message:
 
Location:
TI12-security/trunk/NDG_XACML
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/NDG_XACML/.pydevproject

    r6588 r6624  
    88<path>/NDG_XACML</path> 
    99</pydev_pathproperty> 
     10<pydev_pathproperty name="org.python.pydev.PROJECT_EXTERNAL_SOURCE_PATH"> 
     11<path>/home/pjkersha/workspace/ndg_security_python/ndg_security_common</path> 
     12</pydev_pathproperty> 
    1013</pydev_project> 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/__init__.py

    r6586 r6624  
    5050from ndg.security.common.utils.etree import QName 
    5151 
    52 from ndg.security.common.authz.xacml.exceptions import ParsingException, \ 
    53     UnknownIdentifierException 
    54      
    55 from ndg.security.common.authz.xacml.cond.factory import FunctionFactory, \ 
    56     FunctionTypeException 
    57  
    58 from ndg.security.common.authz.xacml.attr import AttributeFactory, \ 
    59     AttributeDesignator 
    60 from ndg.security.common.authz.xacml.ctx import Result 
    61 from ndg.security.common.authz.xacml.cond import Apply 
     52from ndg.xacml.exceptions import ParsingException, UnknownIdentifierException 
     53from ndg.xacml.cond.factory import FunctionFactory, FunctionTypeException 
     54from ndg.xacml.attr import AttributeFactory, AttributeDesignator 
     55from ndg.xacml.ctx import Result 
     56from ndg.xacml.cond import Apply 
     57 
    6258 
    6359class XacmlBase(object): 
    6460    pass 
     61 
    6562 
    6663class Subject(XacmlBase): 
     
    6966        self.attributes = attributes 
    7067 
     68 
    7169class Resource(XacmlBase): 
    7270    '''XACML Resource designator''' 
    7371 
     72 
    7473class Action(XacmlBase): 
    7574    '''XACML Action designator''' 
    7675 
     76 
    7777class Environment(XacmlBase): 
    7878    '''XACML Environment designator''' 
    7979 
     80 
    8081class PolicySet(XacmlBase): 
    8182    def __init__(self): 
    82           self.policies = [] 
    83           self.combiningAlg = None 
     83        self.policies = [] 
     84        self.combiningAlg = None 
     85 
    8486           
    8587class Policy(XacmlBase): 
     
    9294                 rules=[], 
    9395                 obligations=[]): 
    94           self.id = id 
    95           self.description = description 
    96           self.rules = rules 
    97           self.ruleCombiningAlg = ruleCombiningAlg 
    98           self.obligations = obligations 
    99           self.target = target 
     96        self.id = id 
     97        self.description = description 
     98        self.rules = rules 
     99        self.ruleCombiningAlg = ruleCombiningAlg 
     100        self.obligations = obligations 
     101        self.target = target 
    100102 
    101103    def encode(self): 
     
    139141        return policy 
    140142 
     143 
    141144class MatchResult(XacmlBase): 
    142145    pass 
    143146 
     147 
    144148class Target(XacmlBase): 
    145149    '''The target selects policies relevant to a request''' 
    146150 
    147151    def __init__(self, subjects=None, resources=None, actions=None): 
    148           self.subjects = subjects 
    149           self.resources = resources 
    150           self.actions = actions 
    151           self.rules = [] 
     152        self.subjects = subjects 
     153        self.resources = resources 
     154        self.actions = actions 
     155        self.rules = [] 
    152156 
    153157    def Match(self, evaluationCtx): 
    154           return MatchResult() 
     158        return MatchResult() 
    155159         
    156160    @classmethod 
     
    194198    def _getMatches(root, prefix): 
    195199 
    196         list = [] 
     200        _list = [] 
    197201 
    198202        for elem in root: 
     
    200204 
    201205            if localName == prefix + "Match": 
    202                 list.append(TargetMatch.getInstance(elem, prefix)) 
    203  
    204         return tuple(list) 
     206                _list.append(TargetMatch.getInstance(elem, prefix)) 
     207 
     208        return tuple(_list) 
    205209         
    206210     
     
    216220     
    217221    def __init__(self, 
    218                  type, 
     222                 _type, 
    219223                 function, 
    220                  eval, 
     224                 _eval, 
    221225                 attributeValue): 
    222226        '''Create a TargetMatch from components. 
     
    230234        @raise TypeError if the input type isn't a valid value 
    231235        ''' 
    232         if type not in self.__class__.types: 
     236        if _type not in self.__class__.types: 
    233237            raise TypeError("Type is [%d] but it must be one of %r" %  
    234238                            (type, self.__class__.types)) 
    235         self.type = type 
     239        self.type = _type 
    236240        self.function = function 
    237         self.eval = eval 
     241        self.eval = _eval 
    238242        self.attrValue = attributeValue 
    239243 
    240244    def _getType(self): 
    241         return getattr(self, '_type', None) 
     245        return self._type 
    242246     
    243247    def _setType(self, type): 
     
    293297 
    294298            if localName == prefix + "AttributeDesignator": 
    295                 eval = AttributeDesignator.getInstance(elem, type) 
     299                _eval = AttributeDesignator.getInstance(elem, type) 
    296300                 
    297301            elif localName == "AttributeSelector": 
    298                 eval = AttributeSelector.getInstance(elem) 
     302                _eval = AttributeSelector.getInstance(elem) 
    299303                 
    300304            elif localName == "AttributeValue": 
     
    305309 
    306310        # finally, check that the inputs are valid for this function 
    307         inputs = [attributeValue, eval] 
     311        inputs = [attributeValue, _eval] 
    308312        function.checkInputsNoBag(inputs) 
    309313         
    310         return cls(type, function, eval, attributeValue) 
     314        return cls(type, function, _eval, attributeValue) 
    311315     
    312316 
     
    320324        ''' 
    321325         
    322         result = eval.evaluate(context) 
     326        result = self.eval.evaluate(context) 
    323327         
    324328        if result.indeterminate(): 
     
    330334        bag = result.getAttributeValue() 
    331335 
    332         if not bag.isEmpty(): 
     336        if len(bag) > 0: 
    333337             
    334338            # we got back a set of attributes, so we need to iterate through 
    335339            # them, seeing if at least one matches 
    336             it = bag.iterator() 
    337340            atLeastOneError = False 
    338341            firstIndeterminateStatus = None 
    339342 
    340             while it.hasNext(): 
     343            for i in bag: 
    341344                inputs = [] 
    342345 
    343                 inputs.add(attrValue) 
    344                 inputs.add(it.next()) 
     346                inputs.append(attrValue) 
     347                inputs.append(i) 
    345348 
    346349                # do the evaluation 
     
    365368            if atLeastOneError: 
    366369                return MatchResult(MatchResult.INDETERMINATE, 
    367                                        firstIndeterminateStatus) 
     370                                   firstIndeterminateStatus) 
    368371            else: 
    369372                return MatchResult(MatchResult.NO_MATCH) 
     
    411414          "urn:oasis:names:tc:xacml:1.0:status:syntax-error"        
    412415 
     416 
    413417class Effect(XacmlBase): 
    414418    def __str__(self): 
     
    419423    def __str__(self): 
    420424        return 'deny' 
     425 
    421426           
    422427class PermitEffect(Effect): 
     
    424429        return 'permit' 
    425430 
     431 
    426432class PolicyTreeElement(XacmlBase): 
    427433    pass 
     434 
    428435 
    429436class Rule(PolicyTreeElement): 
     
    470477        @raise ParsingException: if the RuleType is invalid 
    471478        ''' 
    472         id = None 
     479        _id = None 
    473480        name = None 
    474481        effect = 0 
     
    477484        condition = None 
    478485 
    479         id = root.attrib.get("RuleId") 
    480         if id is None: 
     486        _id = root.attrib.get("RuleId") 
     487        if _id is None: 
    481488            raise ParsingException("Error parsing required attribute RuleId") 
    482489         
     
    503510                condition = Apply.getConditionInstance(elem) 
    504511             
    505         return Rule(id, effect, description, target, condition) 
     512        return Rule(_id, effect, description, target, condition) 
    506513     
    507514    def getEffect(self):  
     
    532539        return self.target 
    533540 
    534      
    535541    def getChildren(self): 
    536542        '''Since a rule is always a leaf in a policy tree because it can have 
     
    636642        @param indenter: an object that creates indentation strings''' 
    637643        raise NotImplementedError() 
    638      
    639  
    640644 
    641645           
    642646class Attribute(XacmlBase): 
    643     def __init__(self, id, type=None, issuer=None, issueInstant=None,  
     647    def __init__(self, _id, type=None, issuer=None, issueInstant=None,  
    644648                 value=None): 
    645         self.id = id 
     649        self.id = _id 
    646650        self.type = type or value.__class__ 
    647651        self.issuer = issuer 
     
    655659    TODO: refactor from this initial placeholder''' 
    656660    def __init__(self, subject, resource, action=None, environment={}): 
    657           self.subject = subject 
    658           self.resource = resource 
    659           self.action = action 
    660           self.environment = environment 
     661        self.subject = subject 
     662        self.resource = resource 
     663        self.action = action 
     664        self.environment = environment 
    661665 
    662666class Response(XacmlBase): 
     
    691695 
    692696class DenyOverrides(RuleCombiningAlg): 
    693    '''Deny-overrides: If any rule evaluates to Deny, then the final  
    694    authorization decision is also Deny.''' 
    695    id = 'Deny-overrides' 
     697    '''Deny-overrides: If any rule evaluates to Deny, then the final  
     698    authorization decision is also Deny.''' 
     699    id = 'Deny-overrides' 
    696700    
    697701    
     
    724728 
    725729    # The standard URI for listing a resource's id 
    726     RESOURCE_ID ="urn:oasis:names:tc:xacml:1.0:resource:resource-id" 
     730    RESOURCE_ID = "urn:oasis:names:tc:xacml:1.0:resource:resource-id" 
    727731 
    728732    # The standard URI for listing a resource's scope 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/attr.py

    r6069 r6624  
    4848 
    4949from ndg.security.common.utils.etree import QName 
    50 from ndg.security.common.authz.xacml.cond.eval import Evaluatable, \ 
     50from ndg.xacml.cond.eval import Evaluatable, \ 
    5151    EvaluationResult 
    5252 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/cond/__init__.py

    r6557 r6624  
    4747 
    4848from ndg.security.common.utils.etree import QName 
    49 from ndg.security.common.authz.xacml.exceptions import \ 
     49from ndg.xacml.exceptions import \ 
    5050    UnknownIdentifierException, ParsingException 
    51 from ndg.security.common.authz.xacml.cond.eval import Evaluatable, \ 
     51from ndg.xacml.cond.eval import Evaluatable, \ 
    5252    EvaluationResult 
    53 from ndg.security.common.authz.xacml.attr import AnyURIAttribute, \ 
     53from ndg.xacml.attr import AnyURIAttribute, \ 
    5454    Base64BinaryAttribute, BooleanAttribute, DateAttribute, DateTimeAttribute,\ 
    5555    DayTimeDurationAttribute, DoubleAttribute, HexBinaryAttribute, \ 
     
    100100        @param root the DOM root of a ConditionType XML type 
    101101        ''' 
    102         from ndg.security.common.authz.xacml.cond.factory import \ 
     102        from ndg.xacml.cond.factory import \ 
    103103            FunctionFactory 
    104104        cls.__getInstance(root, FunctionFactory.getConditionInstance(), True) 
     
    111111        @raise ParsingException: if this is not a valid ApplyType 
    112112        ''' 
    113         from ndg.security.common.authz.xacml.cond.factory import \ 
     113        from ndg.xacml.cond.factory import \ 
    114114            FunctionFactory 
    115115        cls.__getInstance(root, FunctionFactory.getGeneralInstance(), True) 
     
    166166                    raise ParsingException("Too many FunctionTypes") 
    167167 
    168                 from ndg.security.common.authz.xacml.cond.factory import \ 
     168                from ndg.xacml.cond.factory import \ 
    169169                    FunctionFactory 
    170170                bagFunction = cls.__getFunction(elem,  
     
    189189            # try creating as an abstract function, using a general factory 
    190190            try: 
    191                 from ndg.security.common.authz.xacml.cond.factory import \ 
     191                from ndg.xacml.cond.factory import \ 
    192192                    FunctionFactory 
    193193                functionFactory = FunctionFactory.getGeneralInstance() 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/cond/factory.py

    r6586 r6624  
    4040 
    4141from ndg.security.common.utils import UniqList 
    42 from ndg.security.common.authz.xacml.cond import Function, EqualFunction, \ 
     42from ndg.xacml.cond import Function, EqualFunction, \ 
    4343    LogicalFunction, NOfFunction, NotFunction, ComparisonFunction, \ 
    4444    MatchFunction, ConditionBagFunction, ConditionSetFunction, \ 
     
    4949    MapFunctionProxy, FunctionProxy 
    5050 
    51 from ndg.security.common.authz.xacml.exceptions import ParsingException, \ 
     51from ndg.xacml.exceptions import ParsingException, \ 
    5252    UnknownIdentifierException, FunctionTypeException 
    5353       
  • TI12-security/trunk/NDG_XACML/ndg/xacml/ctx.py

    r6069 r6624  
    4848 
    4949from ndg.security.common.utils.etree import QName 
    50 from ndg.security.common.authz.xacml import ParsingException 
     50from ndg.xacml import ParsingException 
     51 
    5152 
    5253class Result(object): 
     
    6465     DECISION_NOT_APPLICABLE) = validDecisions 
    6566 
    66         # string versions of the 4 Decision types used for encoding 
     67    # string versions of the 4 Decision types used for encoding 
    6768    DECISIONS =  ("Permit", "Deny", "Indeterminate", "NotApplicable") 
    6869 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/test/test_xacml.py

    r6591 r6624  
    1717 
    1818from ndg.security.test.unit import BaseTestCase 
    19 from ndg.security.common.authz.xacml import Policy 
    20 from ndg.security.common.authz.xacml.exceptions import ParsingException 
     19from ndg.xacml import Policy 
     20from ndg.xacml.exceptions import ParsingException 
    2121 
    2222 
Note: See TracChangeset for help on using the changeset viewer.