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)

    ctx = { 'certificates': certificates }

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)

                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']:

                    url = '{0}?provider_id={1}&nonce={2}'.format(

                        url, urllib.quote(provider_id), nonce)

                    name = name or provider_id

                        'needs_iframe': policy.needs_iframe_logout,

                        'name': name, 'url': url,

                        'iframe_timeout': policy.iframe_logout_timeout})

from authentic2.compat import get_user_model

import authentic2.views as a2_views

from authentic2.saml.models import (LibertyArtifact,

    nameid2kwargs, saml2_urn_to_nidformat,

    nidformat_to_saml2_urn, save_key_values, get_and_delete_key_values,

    LibertyProvider, LibertyServiceProvider, SAMLAttribute, NAME_ID_FORMATS)

                add_url += '?' + urllib.urlencode({ 'entity_id': provider_id })

                return render(request,

                        'idp/saml/unknown_provider.html',

                          'add_url': add_url,

                        })

            else:

    logger.info('return from redirect')

    relay_state = request.GET.get('RelayState')

    if not relay_state:

                default_url=icon_url('ko'))

    logger.debug('relay_state %r', relay_state)

    try:

from django.utils.encoding import force_bytes

from django.utils.html import format_html

from django.core.mail import EmailMultiAlternatives

from django.core.urlresolvers import reverse

from django.contrib.auth import get_user_model

from django.contrib import messages

        """

        Sends a django.core.mail.EmailMultiAlternatives to `to_email`.

        """

        # Email subject *must not* contain newlines

        subject = ''.join(subject.splitlines())

        email_message = EmailMultiAlternatives(subject, body, to=[to_email])

        email_message.send()

        if not some_message:

            return response

        return render(request, 'authentic2/display_message_and_continue.html',

class ServiceAccessControlMiddleware(object):

from django.core.exceptions import ValidationError

from django.utils.translation import ugettext_lazy as _, ugettext

from django.forms import ModelForm, Form, CharField, PasswordInput, EmailField

from django.db.models.fields import FieldDoesNotExist

from django.contrib.auth.models import BaseUserManager, Group

from django.contrib.auth import forms as auth_forms, get_user_model, REDIRECT_FIELD_NAME

from django.core.mail import send_mail

from django.core import signing

from django.core.urlresolvers import reverse

from django.core.validators import RegexValidator

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,

                    'url': profile.msgUrl,

                    '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)

                                  'msg': message,

                                  'back': back,

                                  'redir_timeout': redirection_timeout

def redirect_next(request, next):

                                 HASH_SESSION_KEY, BACKEND_SESSION_KEY, authenticate,

                                 get_user_model)

from django import forms

from django.forms.utils import to_current_timezone

from django.utils import timezone

from django.utils import html, http

from django.utils.formats import localize

from django.contrib import messages

from django.utils.functional import empty

from django.utils.http import urlsafe_base64_encode

from django.utils.encoding import force_bytes

from django.shortcuts import render

        user_or_email = user_or_email.email

    if not request:

        request = middleware.StoreRequestMiddleware().get_request()

    subject_template_names = [template_name + '_subject.txt' for template_name in template_names]

    subject_template_names += legacy_subject_templates or []

    body_template_names = [template_name + '_body.txt' for template_name in template_names]

    body_template_names += legacy_body_templates or []

    html_body = None

    html_body_template_names = [template_name + '_body.html' for template_name in template_names]

    html_body_template_names += legacy_html_body_templates or []

    if with_html:

        try:

        except TemplateDoesNotExist:

            html_body = None

    send_mail(subject, body, from_email or settings.DEFAULT_FROM_EMAIL, [user_or_email],

import django

from django.conf import settings

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

from django.views.generic.base import View

from django.contrib.auth import SESSION_KEY

from django import http, shortcuts

from django.core.urlresolvers import reverse

from django.core.exceptions import ValidationError

from django.contrib import messages

from django.utils.translation import ugettext as _

from django.contrib.auth import logout as auth_logout

from django.contrib.auth import REDIRECT_FIELD_NAME

from django.http import (HttpResponseRedirect, HttpResponseForbidden,

    HttpResponse)

from django.views.decorators.csrf import csrf_exempt, ensure_csrf_cookie

from django.views.decorators.cache import never_cache

from django.contrib.auth.decorators import login_required

    if not next.startswith('http'):

        next = '/%s%s' % (request.get_host(), next)

    logging.info('Redirect to %r' % next)

def server_error(request, template_name='500.html'):

    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,

    if django.VERSION >= (1, 8, 0):

    # 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.

            context.update(frontend.get_context())

        sub_template_name = frontend.template()

        block['content'] = render_to_string(

    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):

        request = self.request

        if django.VERSION >= (1, 8, 0):

        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': app_settings.A2_REGISTRATION_CAN_CHANGE_PASSWORD,

            'federation_management': federation_management,

        })

profile = login_required(ProfileView.as_view())

    local_logout_done = False

    if request.user.is_authenticated():

        if check_referer and not utils.check_referer(request):

        do_local = do_local and 'local' in request.GET

        if not do_local:

            l = logout_list(request)

                ctx['next_url'] = next_url

                ctx['logout_list'] = l

                ctx['message'] = _('Logging out from all your services')

        # Get redirection targets for full logout with redirections

        # (needed before local logout)

        targets = redirect_logout_list(request)

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'],

                             'has_usable_password' : has_usable_password},

class LoggedInView(View):

        return 'oidc'

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

        ctx = {

            'providers': utils.get_providers(shown=True),

        }

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',

                'url': url,

                'iframe_timeout': use_iframe_timeout,

            }

            fragments.append(content)

            fragments.append(

                render_to_string(

                    'authentic2_idp_oidc/logout_fragment.html',

import time

from django.http import HttpResponse, HttpResponseBadRequest, HttpResponseNotAllowed

from django.utils.http import urlencode

from django.shortcuts import render

from django.views.decorators.csrf import csrf_exempt

                                               state=state,

                                               fragment=fragment)

            else:

                              {

                                  'client': client,

                                  'scopes': scopes - set(['openid']),

            client=client, user=request.user, scopes=u' '.join(scopes),

            state=state, nonce=nonce, redirect_uri=redirect_uri,

            expired=start + datetime.timedelta(seconds=30),

            session_key=request.session.session_key)

        logger.info(u'sending code %s for scopes %s for service %s',

                    code.uuid, ' '.join(scopes),

import urlparse

from django.core.urlresolvers import reverse

from django.utils.translation import ugettext as _

try:

    from django.views.decorators.csrf import csrf_exempt

        types = [OPENID_IDP_2_0_TYPE,SREG_TYPE]

        local_ids = []

    endpoints = [request.build_absolute_uri(reverse('openid-provider-root'))]

        'host': request.build_absolute_uri('/'),

        'types': types,

        'endpoints': endpoints,

        'local_ids': local_ids,

class DecideForm(forms.Form):

    def __init__(self, sreg_request=None, *args, **kwargs):

    except DiscoveryFailure:

        trust_root_valid = "DISCOVERY_FAILED"

        'title': _('Trust this site?'),

        'required': sreg_request.required,

        'optional': sreg_request.optional,

        'trust_root_valid': trust_root_valid,

        'form': form,

@openid_enabled

def openid_discovery(request, id):

    '''HTML discovery page'''

    xrds_url = request.build_absolute_uri(

            reverse('openid-provider-identity-xrds', args=[id]))

        'xrds': xrds_url,

    response['X-XRDS-Location'] = xrds_url

    return response