ini = '/srv/kallithea/my.ini'

      from logging.config import fileConfig

      from paste.deploy import loadapp

      application = loadapp('config:' + ini)

      ini = '/srv/kallithea/kallithea.ini'

      from logging.config import fileConfig

      from paste.deploy import loadapp

      application = loadapp('config:' + ini)

# stamping during "kallithea-cli db-create"), config_file_name is not available,

# and loggers are assumed to already have been configured.

if config.config_file_name:

def include_in_autogeneration(object, name, type, reflected, compare_to):

def upgrade():

def downgrade():

                path_to_ini_file = os.path.realpath(config_file)

                kallithea.CONFIG = paste.deploy.appconfig('config:' + path_to_ini_file)

                config_bytes = read_config(path_to_ini_file, strip_section_prefix=annotated.__name__)

                if config_file_initialize_app:

                    kallithea.config.middleware.make_app_without_logging(kallithea.CONFIG.global_conf, **kallithea.CONFIG.local_conf)

                    kallithea.lib.utils.setup_cache_regions(kallithea.CONFIG)

def __ExtensionFactory__():

    from paste.deploy import loadapp

    from logging.config import fileConfig

    application = loadapp('config:%(inifile)s')

    def app(environ, start_response):

    with open(dispatchfile, 'w') as f:

        f.write(dispath_py_template % {

            'inifile': config_file_abs.replace('\\', '\\\\'),

            'virtualdir': virtualdir,

            })

from kallithea.lib.utils2 import str2bool

from kallithea.lib.vcs.backends.git.ssh import GitSshHandler

from kallithea.lib.vcs.backends.hg.ssh import MercurialSshHandler

log = logging.getLogger(__name__)

    The file is usually maintained automatically, but this command will also re-write it.

    """

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""WSGI middleware initialization for the Kallithea application."""

from kallithea.config.app_cfg import base_config

from kallithea.config.environment import load_environment

    ``app_conf`` contains all the application-specific settings (those defined

    under ``[app:main]``.

    """

    return make_app_without_logging(global_conf, full_stack=full_stack, **app_conf)

    @IfSshEnabled

    def my_account_ssh_keys_delete(self):

        try:

            Session().commit()

            SshKeyModel().write_authorized_keys()

            h.flash(_("SSH key successfully deleted"), category='success')

    def ssh_keys_delete(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        try:

            Session().commit()

            SshKeyModel().write_authorized_keys()

            h.flash(_("SSH key successfully deleted"), category='success')

            return htmlfill.render(

                render('/password_reset_confirmation.html'),

                defaults=dict(request.params),

                encoding='UTF-8')

        form = PasswordResetConfirmationForm()()

import hashlib

import itertools

import logging

import os

import ipaddr

from kallithea.model.meta import Session

from kallithea.model.user import UserModel

log = logging.getLogger(__name__)

    :param password: password to hash

    """

        return hashlib.sha256(password).hexdigest()

    elif is_unix:

        return bcrypt.hashpw(safe_str(password), bcrypt.gensalt(10))

    else:

        raise Exception('Unknown or unsupported platform %s'

    :param hashed: password in hashed form

    """

        return hashlib.sha256(password).hexdigest() == hashed

        try:

            return bcrypt.checkpw(safe_str(password), safe_str(hashed))

        except ValueError as e:

            # bcrypt will throw ValueError 'Invalid hashed_password salt' on all password errors

            log.error('error from bcrypt checking password: %s', e)

            return False

def _cached_perms_data(user_id, user_is_admin):

import binascii

import os

import time

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import action_logger, make_ui, setup_cache_regions

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.utils.hgcompat import revrange

from kallithea.model.db import Repository, User

def handle_git_post_receive(repo_path, git_stdin_lines):

    """Called from Git post-receive hook"""

    # the post push hook should never use the cached instance

    scm_repo = repo.scm_instance_no_cache()

    >>> parse_pub_key('''AAAAB3NzaC1yc2EAAAALVGhpcyBpcyBmYWtlIQ''')

    Traceback (most recent call last):

    ...

    >>> parse_pub_key('''abc AAAAB3NzaC1yc2EAAAALVGhpcyBpcyBmYWtlIQ''')

    Traceback (most recent call last):

    ...

    parts = ssh_key.split(None, 2)

    if len(parts) < 2:

    keytype, keyvalue, comment = (parts + [''])[:3]

    if keytype not in ('ssh-rsa', 'ssh-dss', 'ssh-ed25519'):

SSH_OPTIONS = 'no-pty,no-port-forwarding,no-X11-forwarding,no-agent-forwarding'

def authorized_keys_line(kallithea_cli_path, config_file, key):

    """

    Return a line as it would appear in .authorized_keys

    except SshKeyParseError:

        return '# Invalid Kallithea SSH key: %s %s\n' % (key.user.user_id, key.user_ssh_key_id)

    mimekey = decoded.encode('base64').replace('\n', '')

    return '%s,command="%s ssh-serve -c %s %s %s" %s %s\n' % (

        SSH_OPTIONS, kallithea_cli_path, config_file,

        key.user.user_id, key.user_ssh_key_id,

    return str(_url)

def get_hook_environment():

    """

    Get hook context by deserializing the global KALLITHEA_EXTRAS environment

    """

    try:

    except KeyError:

    try:

            extras[k]

    except KeyError:

    return AttributeDict(extras)

class UserSshKeys(Base, BaseDbModel):

    __tablename__ = 'user_ssh_keys'

    __table_args__ = (

        Index('usk_fingerprint_idx', 'fingerprint'),

        UniqueConstraint('fingerprint'),

        _table_args_default_dict

from kallithea.lib import ssh

from kallithea.lib.utils2 import safe_str, str2bool

from kallithea.model.db import User, UserSshKeys

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

    """Exception raised by SshKeyModel methods to report errors"""

        return new_ssh_key

        """

        Will raise SshKeyModelException on errors

        """

        ssh_key = ssh_key.scalar()

        if ssh_key is None:

        Session().delete(ssh_key)

    def get_ssh_keys(self, user):

        # Now, test that the directory is or was created in a readable way by previous.

        if not (os.path.isdir(authorized_keys_dir) and

                os.access(authorized_keys_dir, os.W_OK)):

        # Make sure we don't overwrite a key file with important content

        if os.path.exists(authorized_keys):

                    elif ssh.SSH_OPTIONS in l and ' ssh-serve ' in l:

                        pass # Kallithea entries are ok to overwrite

                    else:

        fh, tmp_authorized_keys = tempfile.mkstemp('.authorized_keys', dir=os.path.dirname(authorized_keys))

        with os.fdopen(fh, 'w') as f:

            for key in UserSshKeys.query().join(UserSshKeys.user).filter(User.active == True):

                f.write(ssh.authorized_keys_line(kallithea_cli_path, config['__file__'], key))

        os.chmod(tmp_authorized_keys, stat.S_IRUSR | stat.S_IWUSR)

            </td>

            <td>

                ${h.form(url('my_account_ssh_keys_delete'))}

                    <button class="btn btn-danger btn-xs" type="submit"

                            onclick="return confirm('${_('Confirm to remove this SSH key: %s') % ssh_key.fingerprint}');">

                        <i class="icon-trashcan"></i>

            </td>

            <td>

                ${h.form(url('edit_user_ssh_keys_delete', id=c.user.user_id))}

                    <button class="btn btn-danger btn-xs" type="submit"

                            onclick="return confirm('${_('Confirm to remove this SSH key: %s') % ssh_key.fingerprint}');">

                        <i class="icon-trashcan"></i>

        assert ssh_key.description == u'me@localhost'

        response = self.app.post(url('edit_user_ssh_keys_delete', id=user_id),

                                  '_session_csrf_secret_token': self.session_csrf_secret_token()})

        self.checkSessionFlash(response, 'SSH key successfully deleted')

        keys = UserSshKeys.query().all()

        assert ssh_key.description == u'me@localhost'

        response = self.app.post(url('my_account_ssh_keys_delete'),

                                  '_session_csrf_secret_token': self.session_csrf_secret_token()})

        self.checkSessionFlash(response, 'SSH key successfully deleted')

        keys = UserSshKeys.query().all()