Produits Entr'ouvert » django-mellon

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from xml.etree import ElementTree as ET

import hashlib

import logging

import os

import threading

        try:

            doc = ET.fromstring(metadata)

        except (TypeError, ET.ParseError):

            return None

        if doc.tag != '{%s}EntityDescriptor' % lasso.SAML2_METADATA_HREF:

            return None

        if 'entityID' not in doc.attrib:

            logger.error(

            return None

        return doc.attrib['entityID']

            username = force_text(username_template).format(

                realm=realm, attributes=saml_attributes, idp=idp)[:30]

        except ValueError:

        except (AttributeError, KeyError, IndexError) as e:

            logger.error(

        except Exception:

        else:

            return username

                    logger.debug('looking for users by attribute %r and user field %r with value %r: not found',

                                 saml_attribute, user_field, value)

                    continue

                            saml_attribute, user_field, value, display_truncated_list(users_found))

                users.update(users_found)

        if len(users) == 1:

            user = list(users)[0]

            return user

        elif len(users) > 1:

                           lookup_by_attributes, len(users))

        return None

            try:

                value = force_text(tpl).format(realm=realm, attributes=saml_attributes, idp=idp)

            except ValueError:

            except (AttributeError, KeyError, IndexError, ValueError) as e:

                logger.warning(

            else:

                model_field = user._meta.get_field(field)

                if hasattr(model_field, 'max_length'):

                    old_value = getattr(user, field)

                    setattr(user, field, value)

                    attribute_set = True

        if attribute_set:

            user.save()

                groups.append(group)

            for group in Group.objects.filter(pk__in=[g.pk for g in groups]).exclude(user=user):

                logger.info(

                User.groups.through.objects.get_or_create(group=group, user=user)

            qs = User.groups.through.objects.exclude(

                group__pk__in=[g.pk for g in groups]).filter(user=user)

            for rel in qs:

            qs.delete()

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from django.contrib.auth.backends import ModelBackend

from . import utils

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from django.utils.http import urlencode

from django.http import HttpResponseRedirect

from django.core.urlresolvers import reverse

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from django.db import models

from django.utils.translation import ugettext_lazy as _

from django.conf import settings

from django.conf.urls import url

import django

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import datetime

import importlib

                try:

                    server.addProviderFromBuffer(lasso.PROVIDER_ROLE_IDP, idp['METADATA'])

                except lasso.Error as e:

        cache[root] = server

        settings._MELLON_SERVER_CACHE = cache

    return settings._MELLON_SERVER_CACHE.get(root)

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

import requests

import lasso

    def show_message_status_is_not_success(self, profile, prefix):

        status_codes, idp_message = utils.get_status_codes_and_message(profile)

        if idp_message:

            args.append(idp_message)

        self.log.warning(*args)

            for at in ats.attribute:

                values = attributes.setdefault(at.name, [])

                for value in at.attributeValue:

        attributes['issuer'] = login.remoteProviderId

        if login.nameIdentifier:

            name_id = login.nameIdentifier

        try:

            login.initRequest(message, method)

        except lasso.ProfileInvalidArtifactError:

        except lasso.ServerProviderNotFoundError:

            self.log.warning('no entity id found for artifact %s', artifact)

            return HttpResponseBadRequest(

                # lasso>2.5.1 introduced a better API

                if hasattr(authn_request.extensions, 'any'):

                    authn_request.extensions.any = (

                else:

                    authn_request.extensions.setOriginalXmlnode(

                                 xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"

                                 xmlns:eo="https://www.entrouvert.com/">

                               <eo:next_url>%s</eo:next_url>

                    )

            self.set_next_url(next_url)

            self.add_login_hints(idp, authn_request, request=request, next_url=next_url)

            self.log.warning('error validating logout request: %r' % e)

        issuer = request.session.get('mellon_session', {}).get('issuer')

        if issuer == logout.remoteProviderId:

            auth.logout(request)

        try:

            logout.buildResponseMsg()

                    # set next_url after local logout, as the session is wiped by auth.logout

                    if logout:

                        self.set_next_url(next_url)

        else:

            self.log.warning('logout refused referer %r is not of the same origin', referer)

        return HttpResponseRedirect(next_url)

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import datetime

import re

import lasso

def test_provision_user_attributes(settings, django_user_model, idp, saml_attributes, caplog):

    settings.MELLON_IDENTITY_PROVIDERS = [idp]

    settings.MELLON_ATTRIBUTE_MAPPING = {

    }

    user = SAMLBackend().authenticate(saml_attributes=saml_attributes)

    assert user.username == 'x' * 30

    assert len(caplog.records) == 4

    assert 'created new user' in caplog.text

    assert 'set field first_name' in caplog.text

    assert 'set field last_name' in caplog.text

    assert 'set field email' in caplog.text

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import re

import base64

import zlib

from django.core.urlresolvers import reverse

from django.utils import six

from django.utils.six.moves.urllib import parse as urlparse

from mellon.utils import create_metadata

            pass

        else:

            login.buildAssertion(lasso.SAML_AUTHENTICATION_METHOD_PASSWORD,

        if not auth_result and msg:

            login.response.status.statusMessage = msg

        if login.protocolProfile == lasso.LOGIN_PROTOCOL_PROFILE_BRWS_ART:

    url, body, relay_state = idp.process_authn_request_redirect(

        response['Location'],

        auth_result=False,

    assert not relay_state

    assert url.endswith(reverse('mellon_login'))

    response = app.post(reverse('mellon_login'), params={'SAMLResponse': body, 'RelayState': relay_state})

    url, body, relay_state = idp.process_authn_request_redirect(

        response['Location'],

        auth_result=False,

    assert not relay_state

    assert body is None

    assert reverse('mellon_login') in url

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import datetime

import mock

import lasso

from mellon.utils import create_metadata, iso8601_to_datetime, flatten_datetime

from xml_utils import assert_xml_constraints

    d = {

        'x': datetime.datetime(2010, 10, 10, 10, 10, 34),

        'y': 1,

    }

    assert set(flatten_datetime(d).keys()) == set(['x', 'y', 'z'])

    assert flatten_datetime(d)['x'] == '2010-10-10T10:10:34'

    assert flatten_datetime(d)['y'] == 1

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import pytest

import mock

import lasso

def test_sp_initiated_login_requested_authn_context(private_settings, client):

    private_settings.MELLON_IDENTITY_PROVIDERS = [{

        'METADATA': open('tests/metadata.xml').read(),

    }]

    response = client.get('/login/')

    assert response.status_code == 302