:param passwd: plaintext password

        :param settings: plugin settings

        """

        return None

            raise Exception('returned value from auth must be a dict')

        for k in self.auth_func_attrs:

                raise Exception('Missing %s attribute from returned data' % k)

class KallitheaExternalAuthPlugin(KallitheaAuthPluginBase):

        raise NotImplementedError("Not implemented in base class")

    def _authenticate(self, userobj, username, passwd, settings, **kwargs):

            userobj, username, passwd, settings, **kwargs)

            # maybe plugin will clean the username ?

            # we should use the return value

            # if user is not active from our extern type we should fail to auth

            # this can prevent from creating users in Kallithea when using

            # external authentication, but if it's inactive user we shouldn't

            # create that user anyway

                log.warning("User %s authenticated against %s, but is inactive"

                            % (username, self.__module__))

                return None

            user = UserModel().create_or_update(

                username=username,

                password=passwd,

                extern_type=self.name

            )

            Session().flush()

            # enforce user is just in given groups, all of them has to be ones

            # created from plugins. We store this info in _group_data JSON field

            UserGroupModel().enforce_groups(user, groups, self.name)

            Session().commit()

def importplugin(plugin):

    :param username: username can be empty for container auth

    :param password: password can be empty for container auth

    :param environ: environ headers passed for container auth

    """

    auth_plugins = Setting.get_auth_plugins()

        # it also maps users to Database and maps the attributes returned

        # from .auth() to Kallithea database. If this function returns data

        # then auth is correct.

                                           plugin_settings,

                                           environ=environ or {})

            log.debug('Plugin returned proper authentication data')

        # we failed to Auth because .auth() method didn't return the user

        if username:

        lastname = getattr(userobj, 'lastname', '')

        extern_type = getattr(userobj, 'extern_type', '')

            'username': username,

            'firstname': safe_unicode(firstname or username),

            'lastname': safe_unicode(lastname or ''),

            'extern_type': extern_type,

        }

        lastname = getattr(userobj, 'lastname', '')

        extern_type = getattr(userobj, 'extern_type', '')

            'username': username,

            'firstname': crowd_user["first-name"] or firstname,

            'lastname': crowd_user["last-name"] or lastname,

        # set an admin if we're in admin_groups of crowd

        for group in settings["admin_groups"].split(","):

                     % (userobj, userobj.extern_type, self.name))

            return None

            "username": userobj.username,

            "firstname": userobj.firstname,

            "lastname": userobj.lastname,

            'extern_type': userobj.extern_type,

        }

        if userobj.active:

            from kallithea.lib import auth

            password_match = auth.KallitheaCrypto.hash_check(password, userobj.password)

            if userobj.username == User.DEFAULT_USER and userobj.active:

                log.info('user %s authenticated correctly as anonymous user' %

                         username)

            elif userobj.username == username and password_match:

            log.error("user %s had a bad password" % username)

            return None

        else:

            lastname = getattr(userobj, 'lastname', '')

            extern_type = getattr(userobj, 'extern_type', '')

                'username': username,

                'firstname': safe_unicode(get_ldap_attr('attr_firstname') or firstname),

                'lastname': safe_unicode(get_ldap_attr('attr_lastname') or lastname),

                'extern_name': user_dn,

                'extern_type': extern_type,

            }

        except (LdapUsernameError, LdapPasswordError, LdapImportError):

            log.error(traceback.format_exc())

        lastname = getattr(userobj, 'lastname', '')

        extern_type = getattr(userobj, 'extern_type', '')

            'username': username,

            'firstname': firstname,

            'lastname': lastname,

            regex = settings["gecos"]

            match = re.search(regex, user_data.pw_gecos)

            if match:

        except Exception:

            log.warning("Cannot extract additional info for PAM user %s", username)

            pass

            for name in Setting.get_auth_plugins()

        ):

            try:

            except UserCreationError as e:

                from kallithea.lib import helpers as h

                h.flash(e, 'error', logf=log.error)

            else:

                    user = User.get_by_username(username, case_insensitive=True)

                    return log_in_user(user, remember=False,

                                       is_external_auth=True)