Produits Entr'ouvert » Authentic 2

import logging

from django.utils.translation import ugettext as _

from django.views.decorators.csrf import csrf_exempt

from django.views.generic.base import TemplateView

from django.template.loader import render_to_string

from django.contrib import messages

from django.contrib.auth.forms import AuthenticationForm

    # No SSL entries and no user session, redirect account linking page

    if not user and not request.user.is_authenticated():

    # No SSL entries but active user session, perform account linking

    if not user and request.user.is_authenticated():

        return render(request, 'auth/account_linking_ssl.html')

def profile(request, template_name='ssl/profile.html', *args, **kwargs):

    certificates = models.ClientCertificate.objects.filter(user=request.user)

def delete_certificate(request, certificate_pk):

    qs = models.ClientCertificate.objects.filter(pk=certificate_pk)

        return 'password'

    def login(self, request, *args, **kwargs):

        is_post = request.method == 'POST' and self.submit_name in request.POST

        data = request.POST if is_post else None

        form = forms.AuthenticationForm(request=request, data=data)

        if app_settings.A2_USERNAME_LABEL:

            form.fields['username'].label = app_settings.A2_USERNAME_LABEL

        is_secure = request.is_secure

        if is_post:

            utils.csrf_token_check(request, form)

            if form.is_valid():

                return utils.login(request, form.get_user(), how,

                                   service_slug=request.GET.get(constants.SERVICE_FIELD_NAME))

        context['form'] = form

    def profile(self, request, *args, **kwargs):

        return views.login_password_profile(request, *args, **kwargs)

from django.contrib.auth.decorators import login_required

from django.http import HttpResponseRedirect

from authentic2.saml.models import LibertyProvider

    '''On a GET produce a form asking for consentment,

       On a POST handle the form and redirect to next'''

    if request.method == "GET":

            {'provider_id': request.GET.get('provider_id', ''),

             'nonce': request.GET.get('nonce', ''),

    else:

        next = '/'

        if 'next' in request.POST:

            name = request.GET.get('provider_id', '')

            if provider:

                name = provider.name or name

                {'provider_id': name,

                 'attributes': attributes,

                 'allow_selection': request.session['allow_attributes_selection'],

                 'nonce': request.GET.get('nonce', ''),

    elif request.method == "POST":

        if request.session['allow_attributes_selection']:

from django.contrib.auth import get_user_model

from django.forms import CharField, Form

from django.core.urlresolvers import reverse_lazy

from django.http import Http404, HttpResponseBadRequest

from authentic2.utils import (import_module_or_class, redirect, make_url, get_fields_and_labels,

        return redirect(self.request, 'registration_complete')

    def get_context_data(self, **kwargs):

        parameters = {'request': self.request,

        blocks = [utils.get_backend_method(backend, 'registration', parameters)

                  for backend in utils.get_backends('AUTH_FRONTENDS')]

class RegistrationView(cbv.ValidateCSRFMixin, BaseRegistrationView):

import requests

from authentic2.compat_lasso import lasso

from django.conf import settings

from django.http import HttpResponseRedirect, Http404, HttpResponse

from django.core.exceptions import ValidationError

from authentic2.saml.models import (LibertyFederation, LibertyProvider,

def return_saml2(request, profile, field_name, title=''):

    '''Helper to handle SAMLv2 bindings to emit request and responses'''

    logger.debug('profile.msgBody: %r', profile.msgBody)

    logger.debug('profile.msgUrl: %r', profile.msgUrl)

    logger.debug('profile.msgRelayState: %r', profile.msgRelayState)

    logger.debug('field_name: %s', field_name)

    if profile.msgBody:

        if profile.msgUrl:

                'saml/post_form.html',

                {

                    'title': title,

                    'fieldname': field_name,

                    'body': profile.msgBody,

                    'relay_state': profile.msgRelayState

        return HttpResponse(profile.msgBody, content_type='text/xml')

    elif profile.msgUrl:

        return HttpResponseRedirect(profile.msgUrl)

            back = '/'

    redirection_timeout = getattr(settings, 'REDIRECTION_TIMEOUT_AFTER_ERROR',

                                  2000)

def redirect_next(request, next):

from django.conf import settings

from django.shortcuts import render_to_response, render

from django.template.loader import render_to_string, select_template

from django.views.generic.edit import UpdateView, FormView

from django.views.generic import RedirectView, TemplateView

    registration_url = utils.get_registration_url(

        request, service_slug=request.GET.get(constants.SERVICE_FIELD_NAME))

        'cancel': nonce is not None,

        'can_reset_password': app_settings.A2_CAN_RESET_PASSWORD,

        'registration_authorized': getattr(settings, 'REGISTRATION_OPEN', True),

        'registration_url': registration_url,

    # Cancel button

    if request.method == "POST" \

            blocks.append(block)

        else: # New frontends API

            parameters = {'request': request,

            block = utils.get_backend_method(frontend, 'login', parameters)

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

            # this response is returned.

        if not 'form' in block:

            continue

        frontend = block['frontend']

                'submit_name': 'submit-%s' % fid,

                redirect_field_name: redirect_to,

                'form': block['form']

        if hasattr(frontend, 'get_context'):

            context.update(frontend.get_context())

        sub_template_name = frontend.template()

        block['content'] = render_to_string(

                sub_template_name, context,

    request.session.set_test_cookie()

    # legacy context variable

    rendered_forms = [(block['name'], block['content']) for block in blocks]

        'methods': rendered_forms,

        # new definition

        'blocks': collections.OrderedDict((block['id'], block) for block in blocks),

        redirect_field_name: redirect_to,

def service_list(request):

        return super(ProfileView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):

        frontends = utils.get_backends('AUTH_FRONTENDS')

        request = self.request

        if request.method == "POST":

            for frontend in frontends:

                if 'submit-%s' % frontend.id in request.POST:

        # Credentials management

        parameters = {'request': request,

        profiles = [utils.get_backend_method(frontend, 'profile', parameters)

                            for frontend in frontends]

        # Old frontends data structure for templates

            for idp_backend in idp_backends:

                if hasattr(idp_backend, 'federation_management'):

                    federation_management.extend(idp_backend.federation_management(request))

            'frontends_block': blocks,

            'frontends_block_by_id': blocks_by_id,

            'profile': profile,

            'allow_password_change': request.user.can_change_password(),

            'federation_management': federation_management,

        })

profile = login_required(ProfileView.as_view())

def login_password_profile(request, *args, **kwargs):

    can_change_password = app_settings.A2_REGISTRATION_CAN_CHANGE_PASSWORD

    has_usable_password = request.user.has_usable_password()

    return render_to_string(['auth/login_password_profile.html',

                             'authentic2/login_password_profile.html'],

class LoggedInView(View):

        return 'oidc'

    def login(self, request, *args, **kwargs):

from django.utils.translation import gettext_noop

from django.template.loader import render_to_string

from django.shortcuts import render

from mellon.utils import get_idp, get_idps

        return gettext_noop('SAML')

    def login(self, request, *args, **kwargs):

        submit_name = 'login-%s' % self.id

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

            return redirect_to_login(request, login_url='mellon_login')

    def profile(self, request, *args, **kwargs):

        user_saml_identifiers = request.user.saml_identifiers.all()

        if not user_saml_identifiers:

            return ''

        for user_saml_identifier in user_saml_identifiers:

            user_saml_identifier.idp = get_idp(user_saml_identifier.issuer)

        return render_to_string('authentic2_auth_saml/profile.html',