Produits Entr'ouvert » Authentic 2

            return None

    def check_password(self, raw_password):

        if connection:

            try:

                connection.simple_bind_s(self.dn, raw_password)

        # if the verify pass, we have the old password stored in self._current_password

        _current_password = getattr(self, '_current_password', None) or self.get_password_in_session()

        if _current_password != new_password:

            if not conn:

                log.warning('ldap: set_password failed, could not get a connection')

                return

        cache_key = hashlib.md5(

            (force_text(str(self.pk)) + ';' + force_text(self.dn)).encode('utf-8')

        ).hexdigest()

        # prevents blocking on temporary LDAP failures

        if conn is not None:

            attributes = self.ldap_backend.get_ldap_attributes(self.block, conn, self.dn) or {}

        group_to_role_mapping = block.get('group_to_role_mapping')

        if not block.get('group_filter') or not group_to_role_mapping:

            return

            existing_groups = cls.get_groups_dns(conn, block)

            for group_dn, dummy_role_slugs in group_to_role_mapping:

                if group_dn in existing_groups:

                return user

    def authenticate_block(self, request, block, username, password):

            ldap_uri = conn.get_option(ldap.OPT_URI)

            authz_ids = []

            user_basedn = force_text(block.get('user_basedn') or block['basedn'])

    @classmethod

    def get_users_for_block(cls, block):

        log.info('Synchronising users from realm "%s"', block['realm'])

        if conn is None:

            log.warning('unable to synchronize with LDAP servers %s', force_text(block['url']))

            return

        from authentic2.manager.journal_event_types import ManagerUserDeactivation

        for block in cls.get_config():

            if conn is None:

                continue

            ldap_uri = conn.get_option(ldap.OPT_URI)

            conn.set_option(ldap.OPT_REFERRALS, 1 if block['referrals'] else 0)

            # allow TLS options to be applied

            conn.set_option(ldap.OPT_X_TLS_NEWCTX, 0)

            try:

                if not url.startswith('ldaps://') and block['use_tls']:

                    try:

                        conn.start_tls_s()

                    except ldap.CONNECT_ERROR:

            except ldap.TIMEOUT:

            except ldap.CONNECT_ERROR:

                    'connection to %r failed when activating TLS, did you forget to declare the TLS'

            except ldap.SERVER_DOWN:

            user_credentials = block['connect_with_user_credentials'] and credentials

            else:

                else:

    @classmethod

    def bind(cls, block, conn, credentials=()):

    @classmethod

    def get_connection(cls, block, credentials=()):

        '''Try to get at least one connection'''

    @classmethod

    def update_default(cls, block, validate=True):

                if user_external_id.source != force_text(block['realm']):

                    continue

                for external_id_tuple in map_text(block['external_id_tuples']):

                    if not conn:

                        log.warning('ldap: password-lost authenticate failed, could not get a connection')

                        continue

        kwargs['ldap_list'] = []

        for block in backend.get_config():

            config = block.copy()

            if not conn:

                kwargs['error'] = True

            else:

    time.sleep(pwdMaxAge * 3)

    attributes = ldap_backend.LDAPBackend.get_ppolicy_attributes(settings.LDAP_AUTH_SETTINGS[0], conn, DN)

    assert 'pwdchangedtime' in attributes

    assert attributes['pwdmaxage'] == [str(pwdMaxAge)]

        assert opt in ldap_config_text

    # mock a buggy connection

    resp = app.get(reverse('a2-manager-tech-info'))

    ldap_config_text = resp.pyquery('div#a2-manager-tech-info-ldap-list').text()