743 lines
25 KiB
Python
743 lines
25 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
#
|
|
# Copyright (C) 2010-2011 Umeå University
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
import importlib
|
|
import logging
|
|
|
|
import re
|
|
from saml2.saml import NAME_FORMAT_URI
|
|
import xmlenc
|
|
|
|
from saml2 import saml
|
|
|
|
from saml2.time_util import instant, in_a_while
|
|
from saml2.attribute_converter import from_local, get_local_name
|
|
from saml2.s_utils import sid, MissingValue
|
|
from saml2.s_utils import factory
|
|
from saml2.s_utils import assertion_factory
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _filter_values(vals, vlist=None, must=False):
|
|
""" Removes values from *vals* that does not appear in vlist
|
|
|
|
:param vals: The values that are to be filtered
|
|
:param vlist: required or optional value
|
|
:param must: Whether the allowed values must appear
|
|
:return: The set of values after filtering
|
|
"""
|
|
|
|
if not vlist: # No value specified equals any value
|
|
return vals
|
|
|
|
if isinstance(vlist, basestring):
|
|
vlist = [vlist]
|
|
|
|
res = []
|
|
|
|
for val in vlist:
|
|
if val in vals:
|
|
res.append(val)
|
|
|
|
if must:
|
|
if res:
|
|
return res
|
|
else:
|
|
raise MissingValue("Required attribute value missing")
|
|
else:
|
|
return res
|
|
|
|
|
|
def _match(attr, ava):
|
|
if attr in ava:
|
|
return attr
|
|
|
|
_la = attr.lower()
|
|
if _la in ava:
|
|
return _la
|
|
|
|
for _at in ava.keys():
|
|
if _at.lower() == _la:
|
|
return _at
|
|
|
|
return None
|
|
|
|
|
|
def filter_on_attributes(ava, required=None, optional=None, acs=None):
|
|
""" Filter
|
|
|
|
:param ava: An attribute value assertion as a dictionary
|
|
:param required: list of RequestedAttribute instances defined to be
|
|
required
|
|
:param optional: list of RequestedAttribute instances defined to be
|
|
optional
|
|
:return: The modified attribute value assertion
|
|
"""
|
|
res = {}
|
|
|
|
if required is None:
|
|
required = []
|
|
|
|
nform = "friendly_name"
|
|
for attr in required:
|
|
try:
|
|
_name = attr[nform]
|
|
except KeyError:
|
|
if nform == "friendly_name":
|
|
_name = get_local_name(acs, attr["name"],
|
|
attr["name_format"])
|
|
else:
|
|
continue
|
|
|
|
_fn = _match(_name, ava)
|
|
if not _fn: # In the unlikely case that someone has provided us
|
|
# with URIs as attribute names
|
|
_fn = _match(attr["name"], ava)
|
|
|
|
if _fn:
|
|
try:
|
|
values = [av["text"] for av in attr["attribute_value"]]
|
|
except KeyError:
|
|
values = []
|
|
res[_fn] = _filter_values(ava[_fn], values, True)
|
|
continue
|
|
else:
|
|
desc = "Required attribute missing: '%s' (%s)" % (attr["name"],
|
|
_name)
|
|
raise MissingValue(desc)
|
|
|
|
if optional is None:
|
|
optional = []
|
|
|
|
for attr in optional:
|
|
for nform in ["friendly_name", "name"]:
|
|
if nform in attr:
|
|
_fn = _match(attr[nform], ava)
|
|
if _fn:
|
|
try:
|
|
values = [av["text"] for av in attr["attribute_value"]]
|
|
except KeyError:
|
|
values = []
|
|
try:
|
|
res[_fn].extend(_filter_values(ava[_fn], values))
|
|
except KeyError:
|
|
res[_fn] = _filter_values(ava[_fn], values)
|
|
|
|
return res
|
|
|
|
|
|
def filter_on_demands(ava, required=None, optional=None):
|
|
""" Never return more than is needed. Filters out everything
|
|
the server is prepared to return but the receiver doesn't ask for
|
|
|
|
:param ava: Attribute value assertion as a dictionary
|
|
:param required: Required attributes
|
|
:param optional: Optional attributes
|
|
:return: The possibly reduced assertion
|
|
"""
|
|
|
|
# Is all what's required there:
|
|
if required is None:
|
|
required = {}
|
|
|
|
lava = dict([(k.lower(), k) for k in ava.keys()])
|
|
|
|
for attr, vals in required.items():
|
|
attr = attr.lower()
|
|
if attr in lava:
|
|
if vals:
|
|
for val in vals:
|
|
if val not in ava[lava[attr]]:
|
|
raise MissingValue(
|
|
"Required attribute value missing: %s,%s" % (attr,
|
|
val))
|
|
else:
|
|
raise MissingValue("Required attribute missing: %s" % (attr,))
|
|
|
|
if optional is None:
|
|
optional = {}
|
|
|
|
oka = [k.lower() for k in required.keys()]
|
|
oka.extend([k.lower() for k in optional.keys()])
|
|
|
|
# OK, so I can imaging releasing values that are not absolutely necessary
|
|
# but not attributes that are not asked for.
|
|
for attr in lava.keys():
|
|
if attr not in oka:
|
|
del ava[lava[attr]]
|
|
|
|
return ava
|
|
|
|
|
|
def filter_on_wire_representation(ava, acs, required=None, optional=None):
|
|
"""
|
|
:param ava: A dictionary with attributes and values
|
|
:param acs: List of tuples (Attribute Converter name,
|
|
Attribute Converter instance)
|
|
:param required: A list of saml.Attributes
|
|
:param optional: A list of saml.Attributes
|
|
:return: Dictionary of expected/wanted attributes and values
|
|
"""
|
|
acsdic = dict([(ac.name_format, ac) for ac in acs])
|
|
|
|
if required is None:
|
|
required = []
|
|
if optional is None:
|
|
optional = []
|
|
|
|
res = {}
|
|
for attr, val in ava.items():
|
|
done = False
|
|
for req in required:
|
|
try:
|
|
_name = acsdic[req.name_format]._to[attr]
|
|
if _name == req.name:
|
|
res[attr] = val
|
|
done = True
|
|
except KeyError:
|
|
pass
|
|
if done:
|
|
continue
|
|
for opt in optional:
|
|
try:
|
|
_name = acsdic[opt.name_format]._to[attr]
|
|
if _name == opt.name:
|
|
res[attr] = val
|
|
break
|
|
except KeyError:
|
|
pass
|
|
|
|
return res
|
|
|
|
|
|
def filter_attribute_value_assertions(ava, attribute_restrictions=None):
|
|
""" Will weed out attribute values and values according to the
|
|
rules defined in the attribute restrictions. If filtering results in
|
|
an attribute without values, then the attribute is removed from the
|
|
assertion.
|
|
|
|
:param ava: The incoming attribute value assertion (dictionary)
|
|
:param attribute_restrictions: The rules that govern which attributes
|
|
and values that are allowed. (dictionary)
|
|
:return: The modified attribute value assertion
|
|
"""
|
|
if not attribute_restrictions:
|
|
return ava
|
|
|
|
for attr, vals in ava.items():
|
|
_attr = attr.lower()
|
|
try:
|
|
_rests = attribute_restrictions[_attr]
|
|
except KeyError:
|
|
del ava[attr]
|
|
else:
|
|
if _rests is None:
|
|
continue
|
|
if isinstance(vals, basestring):
|
|
vals = [vals]
|
|
rvals = []
|
|
for restr in _rests:
|
|
for val in vals:
|
|
if restr.match(val):
|
|
rvals.append(val)
|
|
|
|
if rvals:
|
|
ava[attr] = list(set(rvals))
|
|
else:
|
|
del ava[attr]
|
|
return ava
|
|
|
|
|
|
def restriction_from_attribute_spec(attributes):
|
|
restr = {}
|
|
for attribute in attributes:
|
|
restr[attribute.name] = {}
|
|
for val in attribute.attribute_value:
|
|
if not val.text:
|
|
restr[attribute.name] = None
|
|
break
|
|
else:
|
|
restr[attribute.name] = re.compile(val.text)
|
|
return restr
|
|
|
|
|
|
def post_entity_categories(maps, **kwargs):
|
|
restrictions = {}
|
|
if kwargs["mds"]:
|
|
try:
|
|
ecs = kwargs["mds"].entity_categories(kwargs["sp_entity_id"])
|
|
except KeyError:
|
|
for ec_map in maps:
|
|
for attr in ec_map[""]:
|
|
restrictions[attr] = None
|
|
else:
|
|
for ec_map in maps:
|
|
for key, val in ec_map.items():
|
|
if key == "": # always released
|
|
attrs = val
|
|
elif isinstance(key, tuple):
|
|
attrs = val
|
|
for _key in key:
|
|
try:
|
|
assert _key in ecs
|
|
except AssertionError:
|
|
attrs = []
|
|
break
|
|
elif key in ecs:
|
|
attrs = val
|
|
else:
|
|
attrs = []
|
|
|
|
for attr in attrs:
|
|
restrictions[attr] = None
|
|
|
|
return restrictions
|
|
|
|
|
|
class Policy(object):
|
|
""" handles restrictions on assertions """
|
|
|
|
def __init__(self, restrictions=None):
|
|
if restrictions:
|
|
self.compile(restrictions)
|
|
else:
|
|
self._restrictions = None
|
|
self.acs = []
|
|
|
|
def compile(self, restrictions):
|
|
""" This is only for IdPs or AAs, and it's about limiting what
|
|
is returned to the SP.
|
|
In the configuration file, restrictions on which values that
|
|
can be returned are specified with the help of regular expressions.
|
|
This function goes through and pre-compiles the regular expressions.
|
|
|
|
:param restrictions:
|
|
:return: The assertion with the string specification replaced with
|
|
a compiled regular expression.
|
|
"""
|
|
|
|
self._restrictions = restrictions.copy()
|
|
|
|
for who, spec in self._restrictions.items():
|
|
if spec is None:
|
|
continue
|
|
try:
|
|
items = spec["entity_categories"]
|
|
except KeyError:
|
|
pass
|
|
else:
|
|
ecs = []
|
|
for cat in items:
|
|
_mod = importlib.import_module(
|
|
"saml2.entity_category.%s" % cat)
|
|
_ec = {}
|
|
for key, items in _mod.RELEASE.items():
|
|
_ec[key] = [k.lower() for k in items]
|
|
ecs.append(_ec)
|
|
spec["entity_categories"] = ecs
|
|
try:
|
|
restr = spec["attribute_restrictions"]
|
|
except KeyError:
|
|
continue
|
|
|
|
if restr is None:
|
|
continue
|
|
|
|
_are = {}
|
|
for key, values in restr.items():
|
|
if not values:
|
|
_are[key.lower()] = None
|
|
continue
|
|
|
|
_are[key.lower()] = [re.compile(value) for value in values]
|
|
spec["attribute_restrictions"] = _are
|
|
logger.debug("policy restrictions: %s" % self._restrictions)
|
|
|
|
return self._restrictions
|
|
|
|
def get(self, attribute, sp_entity_id, default=None, post_func=None,
|
|
**kwargs):
|
|
"""
|
|
|
|
:param attribute:
|
|
:param sp_entity_id:
|
|
:param default:
|
|
:param post_func:
|
|
:return:
|
|
"""
|
|
if not self._restrictions:
|
|
return default
|
|
|
|
try:
|
|
try:
|
|
val = self._restrictions[sp_entity_id][attribute]
|
|
except KeyError:
|
|
try:
|
|
val = self._restrictions["default"][attribute]
|
|
except KeyError:
|
|
val = None
|
|
except KeyError:
|
|
val = None
|
|
|
|
if val is None:
|
|
return default
|
|
elif post_func:
|
|
return post_func(val, sp_entity_id=sp_entity_id, **kwargs)
|
|
else:
|
|
return val
|
|
|
|
def get_nameid_format(self, sp_entity_id):
|
|
""" Get the NameIDFormat to used for the entity id
|
|
:param: The SP entity ID
|
|
:retur: The format
|
|
"""
|
|
return self.get("nameid_format", sp_entity_id,
|
|
saml.NAMEID_FORMAT_TRANSIENT)
|
|
|
|
def get_name_form(self, sp_entity_id):
|
|
""" Get the NameFormat to used for the entity id
|
|
:param: The SP entity ID
|
|
:retur: The format
|
|
"""
|
|
|
|
return self.get("name_format", sp_entity_id, NAME_FORMAT_URI)
|
|
|
|
def get_lifetime(self, sp_entity_id):
|
|
""" The lifetime of the assertion
|
|
:param sp_entity_id: The SP entity ID
|
|
:param: lifetime as a dictionary
|
|
"""
|
|
# default is a hour
|
|
return self.get("lifetime", sp_entity_id, {"hours": 1})
|
|
|
|
def get_attribute_restrictions(self, sp_entity_id):
|
|
""" Return the attribute restriction for SP that want the information
|
|
|
|
:param sp_entity_id: The SP entity ID
|
|
:return: The restrictions
|
|
"""
|
|
|
|
return self.get("attribute_restrictions", sp_entity_id)
|
|
|
|
def entity_category_attributes(self, ec):
|
|
if not self._restrictions:
|
|
return None
|
|
|
|
ec_maps = self._restrictions["default"]["entity_categories"]
|
|
for ec_map in ec_maps:
|
|
try:
|
|
return ec_map[ec]
|
|
except KeyError:
|
|
pass
|
|
return []
|
|
|
|
def get_entity_categories(self, sp_entity_id, mds):
|
|
"""
|
|
|
|
:param sp_entity_id:
|
|
:param mds: MetadataStore instance
|
|
:return: A dictionary with restrictions
|
|
"""
|
|
|
|
kwargs = {"mds": mds}
|
|
|
|
return self.get("entity_categories", sp_entity_id, default={},
|
|
post_func=post_entity_categories, **kwargs)
|
|
|
|
def not_on_or_after(self, sp_entity_id):
|
|
""" When the assertion stops being valid, should not be
|
|
used after this time.
|
|
|
|
:param sp_entity_id: The SP entity ID
|
|
:return: String representation of the time
|
|
"""
|
|
|
|
return in_a_while(**self.get_lifetime(sp_entity_id))
|
|
|
|
def filter(self, ava, sp_entity_id, mdstore, required=None, optional=None):
|
|
""" What attribute and attribute values returns depends on what
|
|
the SP has said it wants in the request or in the metadata file and
|
|
what the IdP/AA wants to release. An assumption is that what the SP
|
|
asks for overrides whatever is in the metadata. But of course the
|
|
IdP never releases anything it doesn't want to.
|
|
|
|
:param ava: The information about the subject as a dictionary
|
|
:param sp_entity_id: The entity ID of the SP
|
|
:param mdstore: A Metadata store
|
|
:param required: Attributes that the SP requires in the assertion
|
|
:param optional: Attributes that the SP regards as optional
|
|
:return: A possibly modified AVA
|
|
"""
|
|
|
|
_rest = self.get_attribute_restrictions(sp_entity_id)
|
|
if _rest is None:
|
|
_rest = self.get_entity_categories(sp_entity_id, mdstore)
|
|
logger.debug("filter based on: %s" % _rest)
|
|
ava = filter_attribute_value_assertions(ava, _rest)
|
|
|
|
if required or optional:
|
|
logger.debug("required: %s, optional: %s" % (required, optional))
|
|
ava = filter_on_attributes(ava, required, optional, self.acs)
|
|
|
|
return ava
|
|
|
|
def restrict(self, ava, sp_entity_id, metadata=None):
|
|
""" Identity attribute names are expected to be expressed in
|
|
the local lingo (== friendlyName)
|
|
|
|
:return: A filtered ava according to the IdPs/AAs rules and
|
|
the list of required/optional attributes according to the SP.
|
|
If the requirements can't be met an exception is raised.
|
|
"""
|
|
if metadata:
|
|
spec = metadata.attribute_requirement(sp_entity_id)
|
|
if spec:
|
|
ava = self.filter(ava, sp_entity_id, metadata,
|
|
spec["required"], spec["optional"])
|
|
|
|
return self.filter(ava, sp_entity_id, metadata, [], [])
|
|
|
|
def conditions(self, sp_entity_id):
|
|
""" Return a saml.Condition instance
|
|
|
|
:param sp_entity_id: The SP entity ID
|
|
:return: A saml.Condition instance
|
|
"""
|
|
return factory(saml.Conditions,
|
|
not_before=instant(),
|
|
# How long might depend on who's getting it
|
|
not_on_or_after=self.not_on_or_after(sp_entity_id),
|
|
audience_restriction=[factory(
|
|
saml.AudienceRestriction,
|
|
audience=[factory(saml.Audience,
|
|
text=sp_entity_id)])])
|
|
|
|
def get_sign(self, sp_entity_id):
|
|
"""
|
|
Possible choices
|
|
"sign": ["response", "assertion", "on_demand"]
|
|
|
|
:param sp_entity_id:
|
|
:return:
|
|
"""
|
|
|
|
return self.get("sign", sp_entity_id, [])
|
|
|
|
|
|
class EntityCategories(object):
|
|
pass
|
|
|
|
|
|
class Assertion(dict):
|
|
""" Handles assertions about subjects """
|
|
|
|
def __init__(self, dic=None):
|
|
dict.__init__(self, dic)
|
|
self.acs = []
|
|
|
|
@staticmethod
|
|
def _authn_context_decl(decl, authn_auth=None):
|
|
"""
|
|
Construct the authn context with a authn context declaration
|
|
:param decl: The authn context declaration
|
|
:param authn_auth: Authenticating Authority
|
|
:return: An AuthnContext instance
|
|
"""
|
|
return factory(saml.AuthnContext,
|
|
authn_context_decl=decl,
|
|
authenticating_authority=factory(
|
|
saml.AuthenticatingAuthority, text=authn_auth))
|
|
|
|
def _authn_context_decl_ref(self, decl_ref, authn_auth=None):
|
|
"""
|
|
Construct the authn context with a authn context declaration reference
|
|
:param decl_ref: The authn context declaration reference
|
|
:param authn_auth: Authenticating Authority
|
|
:return: An AuthnContext instance
|
|
"""
|
|
return factory(saml.AuthnContext,
|
|
authn_context_decl_ref=decl_ref,
|
|
authenticating_authority=factory(
|
|
saml.AuthenticatingAuthority, text=authn_auth))
|
|
|
|
@staticmethod
|
|
def _authn_context_class_ref(authn_class, authn_auth=None):
|
|
"""
|
|
Construct the authn context with a authn context class reference
|
|
:param authn_class: The authn context class reference
|
|
:param authn_auth: Authenticating Authority
|
|
:return: An AuthnContext instance
|
|
"""
|
|
cntx_class = factory(saml.AuthnContextClassRef, text=authn_class)
|
|
if authn_auth:
|
|
return factory(saml.AuthnContext,
|
|
authn_context_class_ref=cntx_class,
|
|
authenticating_authority=factory(
|
|
saml.AuthenticatingAuthority, text=authn_auth))
|
|
else:
|
|
return factory(saml.AuthnContext,
|
|
authn_context_class_ref=cntx_class)
|
|
|
|
def _authn_statement(self, authn_class=None, authn_auth=None,
|
|
authn_decl=None, authn_decl_ref=None, authn_instant="",
|
|
subject_locality=""):
|
|
"""
|
|
Construct the AuthnStatement
|
|
:param authn_class: Authentication Context Class reference
|
|
:param authn_auth: Authenticating Authority
|
|
:param authn_decl: Authentication Context Declaration
|
|
:param authn_decl_ref: Authentication Context Declaration reference
|
|
:param authn_instant: When the Authentication was performed.
|
|
Assumed to be seconds since the Epoch.
|
|
:param subject_locality: Specifies the DNS domain name and IP address
|
|
for the system from which the assertion subject was apparently
|
|
authenticated.
|
|
:return: An AuthnContext instance
|
|
"""
|
|
if authn_instant:
|
|
_instant = instant(time_stamp=authn_instant)
|
|
else:
|
|
_instant = instant()
|
|
|
|
if authn_class:
|
|
res = factory(
|
|
saml.AuthnStatement,
|
|
authn_instant=_instant,
|
|
session_index=sid(),
|
|
authn_context=self._authn_context_class_ref(
|
|
authn_class, authn_auth))
|
|
elif authn_decl:
|
|
res = factory(
|
|
saml.AuthnStatement,
|
|
authn_instant=_instant,
|
|
session_index=sid(),
|
|
authn_context=self._authn_context_decl(authn_decl, authn_auth))
|
|
elif authn_decl_ref:
|
|
res = factory(
|
|
saml.AuthnStatement,
|
|
authn_instant=_instant,
|
|
session_index=sid(),
|
|
authn_context=self._authn_context_decl_ref(authn_decl_ref,
|
|
authn_auth))
|
|
else:
|
|
res = factory(
|
|
saml.AuthnStatement,
|
|
authn_instant=_instant,
|
|
session_index=sid())
|
|
|
|
if subject_locality:
|
|
res.subject_locality = saml.SubjectLocality(text=subject_locality)
|
|
|
|
return res
|
|
|
|
def construct(self, sp_entity_id, in_response_to, consumer_url,
|
|
name_id, attrconvs, policy, issuer, authn_class=None,
|
|
authn_auth=None, authn_decl=None, encrypt=None,
|
|
sec_context=None, authn_decl_ref=None, authn_instant="",
|
|
subject_locality=""):
|
|
""" Construct the Assertion
|
|
|
|
:param sp_entity_id: The entityid of the SP
|
|
:param in_response_to: An identifier of the message, this message is
|
|
a response to
|
|
:param consumer_url: The intended consumer of the assertion
|
|
:param name_id: An NameID instance
|
|
:param attrconvs: AttributeConverters
|
|
:param policy: The policy that should be adhered to when replying
|
|
:param issuer: Who is issuing the statement
|
|
:param authn_class: The authentication class
|
|
:param authn_auth: The authentication instance
|
|
:param authn_decl: An Authentication Context declaration
|
|
:param encrypt: Whether to encrypt parts or all of the Assertion
|
|
:param sec_context: The security context used when encrypting
|
|
:param authn_decl_ref: An Authentication Context declaration reference
|
|
:param authn_instant: When the Authentication was performed
|
|
:param subject_locality: Specifies the DNS domain name and IP address
|
|
for the system from which the assertion subject was apparently
|
|
authenticated.
|
|
:return: An Assertion instance
|
|
"""
|
|
|
|
if policy:
|
|
_name_format = policy.get_name_form(sp_entity_id)
|
|
else:
|
|
_name_format = NAME_FORMAT_URI
|
|
|
|
attr_statement = saml.AttributeStatement(attribute=from_local(
|
|
attrconvs, self, _name_format))
|
|
|
|
if encrypt == "attributes":
|
|
for attr in attr_statement.attribute:
|
|
enc = sec_context.encrypt(text="%s" % attr)
|
|
|
|
encd = xmlenc.encrypted_data_from_string(enc)
|
|
encattr = saml.EncryptedAttribute(encrypted_data=encd)
|
|
attr_statement.encrypted_attribute.append(encattr)
|
|
|
|
attr_statement.attribute = []
|
|
|
|
# start using now and for some time
|
|
conds = policy.conditions(sp_entity_id)
|
|
|
|
if authn_auth or authn_class or authn_decl or authn_decl_ref:
|
|
_authn_statement = self._authn_statement(authn_class, authn_auth,
|
|
authn_decl, authn_decl_ref,
|
|
authn_instant,
|
|
subject_locality)
|
|
else:
|
|
_authn_statement = None
|
|
|
|
|
|
_ass = assertion_factory(
|
|
issuer=issuer,
|
|
conditions=conds,
|
|
subject=factory(
|
|
saml.Subject,
|
|
name_id=name_id,
|
|
subject_confirmation=[factory(
|
|
saml.SubjectConfirmation,
|
|
method=saml.SCM_BEARER,
|
|
subject_confirmation_data=factory(
|
|
saml.SubjectConfirmationData,
|
|
in_response_to=in_response_to,
|
|
recipient=consumer_url,
|
|
not_on_or_after=policy.not_on_or_after(sp_entity_id)))]
|
|
),
|
|
)
|
|
|
|
if _authn_statement:
|
|
_ass.authn_statement = [_authn_statement]
|
|
|
|
if not attr_statement.empty():
|
|
_ass.attribute_statement=[attr_statement]
|
|
|
|
return _ass
|
|
|
|
def apply_policy(self, sp_entity_id, policy, metadata=None):
|
|
""" Apply policy to the assertion I'm representing
|
|
|
|
:param sp_entity_id: The SP entity ID
|
|
:param policy: The policy
|
|
:param metadata: Metadata to use
|
|
:return: The resulting AVA after the policy is applied
|
|
"""
|
|
|
|
policy.acs = self.acs
|
|
ava = policy.restrict(self, sp_entity_id, metadata)
|
|
self.update(ava)
|
|
return ava |