Produits Entr'ouvert » Authentic 2

    AUTH_FRONTENDS=(),

    AUTH_FRONTENDS_KWARGS={},

    @property

    def priority(self):

        return self.order

# authentic2 - versatile identity manager

# Copyright (C) 2010-2019 Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# 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

from .utils.evaluate import evaluate_condition

logger = logging.getLogger(__name__)

class BaseAuthenticator:

    how = ()

    def __init__(self, show_condition=None, **kwargs):

        self.show_condition = show_condition

    def get_show_condition(self, instance_id=None):

        if isinstance(self.show_condition, dict):

            if instance_id and instance_id in self.show_condition:

                return self.show_condition[instance_id]

        else:

            return self.show_condition

    def shown(self, instance_id=None, ctx=()):

        show_condition = self.get_show_condition(instance_id)

        if not show_condition:

            return True

        ctx = dict(ctx, id=instance_id)

        try:

            return evaluate_condition(show_condition, ctx, on_raise=True)

        except Exception as e:

            logger.error(e)

            return False

    def get_identifier(self):

        return self.id

AUTH_FRONTENDS = plugins.register_plugins_authenticators()

def load_backend(path, kwargs):

    backend_kwargs = {}

    if hasattr(cls, 'id'):

        backend_kwargs.update(kwargs.get(cls.id, {}))

    return cls(**backend_kwargs)

def get_backends(setting_name='IDP_BACKENDS'):

    if setting_name == 'AUTH_FRONTENDS':

        from authentic2.apps.authenticators.models import BaseAuthenticator, LoginPasswordAuthenticator

        backends = list(

            BaseAuthenticator.authenticators.filter(enabled=True).exclude(slug='password-authenticator')

        )

        password_backend, dummy = LoginPasswordAuthenticator.objects.get_or_create(

            slug='password-authenticator',

            defaults={'enabled': True},

        )

        if password_backend.enabled:

            backends.append(password_backend)

    for backend_path in getattr(app_settings, setting_name):

        kwargs_settings = getattr(app_settings, setting_name + '_KWARGS', {})

        backend = load_backend(backend_path, kwargs_settings)

        # If no enabled method is defined on the backend, backend enabled by default.

        if hasattr(backend, 'enabled') and not backend.enabled():

            continue

        if backend_path in kwargs_settings:

            kwargs.update(kwargs_settings[backend_path])

        # Clean id and name for legacy support

        if hasattr(backend, 'id'):

            if callable(backend.id):

                backend.id = backend.id()

        else:

            backend.id = None

        if hasattr(backend, 'name'):

            if callable(backend.name):

                backend.name = backend.name()

        else:

            backend.name = None

        if not hasattr(backend, 'priority'):

            backend.priority = 999  # backend with undefined priority go last

        if backend.id and backend.id in kwargs_settings:

            kwargs.update(kwargs_settings[backend.id])

    # Order backends list with backend priority

    backends.sort(key=lambda backend: backend.priority)

    authenticators = utils_misc.get_backends('AUTH_FRONTENDS')

        # Legacy API

        if not hasattr(authenticator, 'login'):

            fid = authenticator.get_identifier()

            name = authenticator.name

            form_class = authenticator.form()

            submit_name = 'submit-%s' % fid

            block = {'id': fid, 'name': name, 'authenticator': authenticator}

            if request.method == 'POST' and submit_name in request.POST:

                form = form_class(data=request.POST)

                if form.is_valid():

                    return authenticator.post(request, form, nonce, redirect_to)

                block['form'] = form

            else:

                block['form'] = form_class()

            blocks.append(block)

        else:  # New frontends API

            auth_blocks = []

            parameters = {'request': request, 'context': context}

            login_hint = set(request.session.get('login-hint', []))

            show_ctx = make_condition_context(request=request, login_hint=login_hint)

            service = get_service(request)

            if service:

                show_ctx['service_ou_slug'] = service.ou and service.ou.slug

                show_ctx['service_slug'] = service.slug

                show_ctx['service'] = service

            else:

                show_ctx['service_ou_slug'] = ''

                show_ctx['service_slug'] = ''

                show_ctx['service'] = None

            # check if the authenticator has multiple instances

            if hasattr(authenticator, 'instances'):

                for instance_id, instance in authenticator.instances(**parameters):

                    parameters['instance'] = instance

                    parameters['instance_id'] = instance_id

                    if not authenticator.shown(instance_id=instance_id, ctx=show_ctx):

                        continue

                    context['block_index'] = len(blocks)

                    block = utils_misc.get_authenticator_method(authenticator, 'login', parameters)

                    # update block id in order to separate instances

                    block['id'] = '%s_%s' % (block['id'], instance_id)

                    auth_blocks.append(block)

            else:

                if authenticator.shown(ctx=show_ctx):

                    context['block_index'] = len(blocks)

                    auth_blocks.append(

                        utils_misc.get_authenticator_method(authenticator, 'login', parameters)

                    )

            # If a login frontend method returns an HttpResponse with a status code != 200

            # this response is returned.

            for block in auth_blocks:

                if block:

                    if block['status_code'] != 200:

                        return block['response']

                    blocks.append(block)

        if hasattr(authenticator, 'get_context'):

            context.update(authenticator.get_context())

        frontends = utils_misc.get_backends('AUTH_FRONTENDS')

            for authenticator in utils_misc.get_backends('AUTH_FRONTENDS')

-