Produits Entr'ouvert » Authentic 2

    if 'LDAP_AUTH_SETTINGS' in os.environ:

        try:

            LDAP_AUTH_SETTINGS = json.loads(os.environ['LDAP_AUTH_SETTINGS'])

            raise ImproperlyConfigured('LDAP_AUTH_SETTINGS is not a JSON document', e)

    if 'CACHE_BACKEND' in os.environ:

    if 'LDAP_AUTH_SETTINGS' in os.environ:

        try:

            LDAP_AUTH_SETTINGS = json.loads(os.environ['LDAP_AUTH_SETTINGS'])

            raise ImproperlyConfigured('LDAP_AUTH_SETTINGS is not a JSON document', e)

    if 'CACHE_BACKEND' in os.environ:

        elif name == 'ModPythonRequest':

            env = request._req.subprocess_env

        else:

        self.read_env(env);

        pass

        if attr in self.__dict__:

            return self.__dict__[attr]

        else:

    def __setattr__(self, attr, value):

    def __repr__(self):

        return '<SSLInfo %s>' % self.__dict__

            connection.simple_bind_s(self.dn, raw_password)

        except ldap.INVALID_CREDENTIALS:

            return False

            log.error('LDAPUser.check_password() failed: %s', e)

            return False

        self._current_password = raw_password

                            n = len(user_filter.split('%s')) - 1

                            try:

                                query = filter_format(user_filter, (username,) * n)

                                log.error('user_filter syntax error %r: %s', block['user_filter'],

                                          e)

                                return

                        if block['replicas']:

                            break

                        continue

                        log.error('user lookup failed: with query %r got error %s: %s', username,

                                  query, e)

                        continue

def errorcollector(error_dict):

    try:

        yield

        e.update_error_dict(error_dict)

            store = engine.SessionStore(key)

            logging.debug('Killing session %s', key)

            store.delete()

        logging.error(e)

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

        try:

            return func(request, *args, **kwargs)

            return error_redirect(request, e.message or repr(e))

    return f

            request.session['saml:authnRequest'] = login.request.getOriginalXmlnode()

            break

        except (lasso.ProfileInvalidMsgError,

            logger.warning('invalid message for WebSSO profile with '

                          'HTTP-Redirect binding: %r exception: %s' \

                          % (message, e),

            logger.warning("the request cannot be answered because no "

                "valid protocol binding could be found")

            return HttpResponseBadRequest(message, content_type='text/plain')

            log_info_authn_request_details(login)

            logger.warning('no public key found: %s', e)

            login.response.status.statusMessage = 'The public key is unknown'

            return return_login_response(request, login)

            log_info_authn_request_details(login)

            logger.warning('digital signature treatment error: %s', e)

            login.response.status.statusMessage = 'Signature validation failed'

            logger.error('provider loading failure')

        try:

            login.processRequestMsg(soap_message)

            logger.error('signature error for %s: %s'

                    % (e, login.remoteProviderId))

        else:

        # SP sent us a logout request but we do not know its Response endpoint, just continue to the

        # homepage

        return redirect('auth_homepage')

        logger.warning('logout.buildResponseMsg() failed: %s', e)

        return redirect('auth_homepage')

    if all_sessions.exists():

            '''

            logger.error('one provider does \

                not support SOAP %s' % [s.provider_id for s in lib_sessions])

            logger.exception('slo, unknown error %s' % str(e))

            logout.buildResponseMsg()

            provider = LibertyProvider.objects.get(entity_id=logout.remoteProviderId)

            load_provider(request, logout.remoteProviderId,

                    server=logout.server)

            logout.processRequestMsg(message)

        logger.exception('signature error %s' % e)

        logout.buildResponseMsg()

        provider = LibertyProvider.objects.get(entity_id=logout.remoteProviderId)

        return return_saml2_response(request, logout,

            title=_('You are being redirected to "%s"') % provider.name)

    except (lasso.ProfileInvalidMsgError,

        return error_page(request, _('Invalid logout request'), logger=logger, warning=True)

    session_indexes = logout.request.sessionIndexes

    if len(session_indexes) == 0:

    set_session_dump_from_liberty_sessions(logout, [last_session])

    try:

        logout.validateRequest()

        logger.warning('logout request validation failed: %s', e)

        return return_logout_error(request, logout,

                AUTHENTIC_STATUS_CODE_INTERNAL_SERVER_ERROR)

        logger.info('slo by SOAP')

        try:

            soap_response = send_soap_request(request, logout)

            logger.exception('slo SOAP failure due to %s' % str(e))

            return redirect_next(request, next) or ko_icon(request)

        return process_logout_response(request, logout, soap_response, next)

def unlink_if_exists(path):

    try:

        os.unlink(path)

        if e.errno != errno.ENOENT:

            raise

    # test if the file exists

    try:

        stat = os.stat(file_path)

        # test if it doesnt exit or if another error happened

        if e.errno != errno.ENOENT:

            raise

        raise

    try:

        os.link(temp_file.name, file_path)

        if e.errno == errno.EEXIST:

            unlink_if_exists(temp_file.name)

        return False

        now_time = timegm(now.utctimetuple())

        try:

            stat = os.stat(nonce_path)

            if e.errno == errno.ENOENT:

                continue

            raise

        if stat.st_mtime < now_time:

            try:

                os.unlink(nonce_path)

                if e.errno == errno.ENOENT:

                    continue

                raise

    for entrypoint in pkg_resources.iter_entry_points(group_name):

        try:

            plugin_callable = entrypoint.load()

            logger.exception('unable to load entrypoint %s', entrypoint)

            raise PluginError('unable to load entrypoint %s' % entrypoint, e)

        plugins.append(plugin_callable(*args, **kwargs))

    for provider in qs:

        try:

            provider.update_metadata()

            params = {

                    'name': provider,

                    'error_msg': u', '.join(e.messages)

    # Try the WKL

    try:

        metadata = get_url(provider_id)

        logging.error('SAML metadata autoload: failure to retrieve metadata '

                      'for entity id %s: %s', provider_id, e)

        return None

    p = LibertyProvider(metadata=metadata)

    try:

        p.full_clean(exclude=['entity_id', 'protocol_conformance'])

        logging.error('SAML metadata autoload: retrieved metadata for entity '

                      'id %s are invalid, %s', provider_id, e.args)

        return None

        logger.debug('SOAP call to %r with data %r', url, msg[:10000])

        response = requests.post(url, data=msg, headers={'Content-Type': 'text/xml'})

        response.raise_for_status()

        logging.error('SOAP call to %r error %s with data %r', url, e, msg[:10000])

        raise SOAPException(url, e)

    logger.debug('SOAP call response %r', response.content[:10000])

                response = requests.get(url)

                response.raise_for_status()

                content = response.content

                raise ValidationError(_('Retrieval of %(url)s failed: %(exception)s') % {

                    'url': url,

                    'exception': e

        try:

            doc = etree.parse(metadata_file)

            raise CommandError('XML parsing error: %s' % str(e))

        if doc.getroot().tag == ENTITY_DESCRIPTOR_TN:

            load_one_entity(doc.getroot(), options)

                        sp_policy=sp_policy,

                        afp=afp)

                    loaded.append(entity_descriptor.get(ENTITY_ID))

                    if not options['ignore-errors']:

                        raise

                    if verbosity > 0:

            if not self.metadata_url:

                raise ValidationError(_('No metadata URL'))

            response = requests.get(self.metadata_url)

            raise ValidationError(_('Retrieval of metadata failed: %s') % e)

        else:

            self.metadata = response.content

                        format = attribute.nameFormat.decode('ascii')

                    if attribute.friendlyName:

                        nickname = attribute.friendlyName

                    message = 'get_attributes_from_assertion: name or format of an \

                        attribute failed to decode as ascii: %s due to %s'

                    logger.warning(message % (attribute.dump(), str(e)))

                        content = ''.join(content)

                        attributes[(name, format)].append(content.\

                            decode('utf8'))

                    message = 'get_attributes_from_assertion: value of an \

                        attribute failed to decode as ascii: %s due to %s'

                    logger.warning(message % (attribute.dump(), str(e)))

    module, attr = path[:i], path[i + 1:]

    try:

        mod = import_module(module)

        raise ImproperlyConfigured('Error importing idp backend %s: "%s"' % (module, e))

        raise ImproperlyConfigured('Error importing idp backends. Is IDP_BACKENDS a correctly '

                                   'defined list or tuple?')

    try:

            try:

                value = saml_attributes[saml_attribute]

                self.set_user_attribute(user, attribute, value)

                log.error(u'failed to set attribute %r from saml attribute %r with value %r: %s',

                          attribute, saml_attribute, value, e,

                          extra={'attributes': repr(saml_attributes)})