source: TI12-security/trunk/NDG_XACML/ndg/xacml/core/policy.py @ 6771

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI12-security/trunk/NDG_XACML/ndg/xacml/core/policy.py@6771
Revision 6771, 6.8 KB checked in by pjkersha, 10 years ago (diff)

Added request subject, resource, action and environment types

Line 
1"""NDG Security Policy type definition
2
3NERC DataGrid Project
4"""
5__author__ = "P J Kershaw"
6__date__ = "24/02/10"
7__copyright__ = "(C) 2010 Science and Technology Facilities Council"
8__contact__ = "Philip.Kershaw@stfc.ac.uk"
9__license__ = "BSD - see LICENSE file in top-level directory"
10__contact__ = "Philip.Kershaw@stfc.ac.uk"
11__revision__ = "$Id: $"
12from ndg.xacml.utils import TypedList
13from ndg.xacml.core import XacmlCoreBase
14from ndg.xacml.core.policydefaults import PolicyDefaults
15from ndg.xacml.core.target import Target
16from ndg.xacml.core.rule import Rule
17from ndg.xacml.core.obligation import Obligation
18
19
20class PolicyParseError(Exception):
21    """Error reading policy attributes from file"""
22
23
24class InvalidPolicyXmlNsError(PolicyParseError):
25    """Invalid XML namespace for policy document"""
26
27
28class Policy(XacmlCoreBase):
29    """NDG MSI Policy.""" 
30    DEFAULT_XACML_VERSION = "1.0"
31    ELEMENT_LOCAL_NAME = "Policy"
32    POLICY_ID_ATTRIB_NAME = "PolicyId"
33    RULE_COMBINING_ALG_ID_ATTRIB_NAME = "RuleCombiningAlgId"
34    VERSION_ATTRIB_NAME = "Version"
35
36    DESCRIPTION_LOCAL_NAME = "Description"
37    POLICY_DEFAULTS_LOCAL_NAME = "PolicyDefaults"
38    COMBINER_PARAMETERS_LOCAL_NAME = "CombinerParameters"
39    RULE_COMBINER_PARAMETERS_LOCAL_NAME = "RuleCombinerParameters"
40    OBLIGATIONS_LOCAL_NAME = "Obligations"
41   
42    # Plan to support permit overrides in a future release
43    RULE_COMBINING_ALG_IDS = (
44    "urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:permit-overrides",
45    "urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:deny-overrides",
46    )
47    __slots__ = (
48        '__policyId',
49        '__version',
50        '__ruleCombiningAlgId',
51        '__description',
52        '__policyDefaults',
53        '__target',
54        '__attr',
55        '__obligations'
56    )
57   
58    def __init__(self):
59        super(Policy, self).__init__()
60        self.__policyId = None
61        self.__version = None
62        self.__ruleCombiningAlgId = None
63        self.__description = None
64        self.__target = None
65       
66        # Attr should eventually allow a choice of Rule, CombinerParameter,
67        # RuleCombinerParameter and VariableDefinition but only Rule type is
68        # currently supported
69        self.__attr = TypedList(Rule)
70       
71        self.__obligations = TypedList(Obligation)
72
73    def _getPolicyId(self):
74        return self.__policyId
75
76    def _setPolicyId(self, value):
77        if not isinstance(value, basestring):
78            raise TypeError('Expecting string type for "policyId" '
79                            'attribute; got %r' % type(value))
80           
81        self.__policyId = value
82
83    policyId = property(_getPolicyId, _setPolicyId, None, "Policy Id")
84
85    def _getVersion(self):
86        return self.__version
87
88    def _setVersion(self, value):
89        if not isinstance(value, basestring):
90            raise TypeError('Expecting string type for "version" '
91                            'attribute; got %r' % type(value))
92           
93        self.__version = value
94
95    version = property(_getVersion, _setVersion, None, "Policy Version")
96
97    def _getRuleCombiningAlgId(self):
98        return self.__ruleCombiningAlgId
99
100    def _setRuleCombiningAlgId(self, value):
101        if not isinstance(value, basestring):
102            raise TypeError('Expecting string type for "ruleCombiningAlgId" '
103                            'attribute; got %r' % type(value))
104           
105        if value not in Policy.RULE_COMBINING_ALG_IDS:
106            raise AttributeError('%r rule combining algorithm is invalid.  '
107                                 'Only these algorithms are currently '
108                                 'supported %r' % 
109                                 (value, Policy.RULE_COMBINING_ALG_IDS))
110        self.__ruleCombiningAlgId = value
111
112    ruleCombiningAlgId = property(_getRuleCombiningAlgId, 
113                                  _setRuleCombiningAlgId, None, 
114                                  doc="Rule Combining Algorithm Id")
115
116
117    @property
118    def combinerParameters(self):
119        raise NotImplementedError()
120   
121    @property
122    def ruleCombinerParameters(self):
123        raise NotImplementedError()
124   
125    @property
126    def variableDefinitions(self):
127        raise NotImplementedError()
128   
129    @property
130    def rules(self):
131        return self.__attr
132   
133    @property
134    def obligations(self):
135        return self.__obligations
136
137    def _getTarget(self):
138        return self.__target
139
140    def _setTarget(self, value):
141        if not isinstance(value, Target):
142            raise TypeError('Expecting Target for "target" '
143                            'attribute; got %r' % type(value))
144        self.__target = value
145
146    target = property(_getTarget, _setTarget, doc="list of Policy targets")
147
148    def _getDescription(self):
149        return self.__description
150
151    def _setDescription(self, value):
152        if not isinstance(value, basestring):
153            raise TypeError('Expecting string type for "description" '
154                            'attribute; got %r' % type(value))
155        self.__description = value
156
157    description = property(_getDescription, _setDescription, 
158                           doc="Policy Description text")
159
160    def _getPolicyDefaults(self):
161        return self.__policyDefaults
162
163    def _setPolicyDefaults(self, value):
164        if not isinstance(value, PolicyDefaults):
165            raise TypeError('Expecting string type for "policyDefaults" '
166                            'attribute; got %r' % type(value))
167           
168        self.__policyDefaults = value
169
170    policyDefaults = property(_getPolicyDefaults, 
171                              _setPolicyDefaults, 
172                              None, 
173                              "Policy PolicyDefaults element")   
174    def parse(self):
175        """Parse the policy file set in policyFilePath attribute
176        """
177        elem = ElementTree.parse(self.policyFilePath)
178        root = elem.getroot()
179       
180        self.xmlns = QName.getNs(root.tag)
181        if not self.isValidXmlns:
182            raise InvalidPolicyXmlNsError("Namespace %r is recognised; valid "
183                                          "namespaces are: %r" %
184                                          (self.xmlns, Policy.XMLNS))
185           
186        for elem in root:
187            localName = QName.getLocalPart(elem.tag)
188            if localName == Policy.DESCRIPTION_LOCALNAME:
189                self.description = elem.text.strip()
190               
191            elif localName == Policy.TARGET_LOCALNAME:
192                self.targets.append(Target.Parse(elem))
193               
194            else:
195                raise PolicyParseError("Invalid policy attribute: %s" % 
196                                        localName)
197               
198    @classmethod
199    def Parse(cls, policyFilePath):
200        policy = cls(policyFilePath=policyFilePath)
201        policy.parse()
202        return policy
Note: See TracBrowser for help on using the repository browser.