Exemple #1
0
    def process(self):
        kpconf = Conf()
        new_client_id = kpconf.get_selected_ui().RequireAssociationDecision.require_client_name()
        if new_client_id:
            kpconf.backend.create_config_key(new_client_id, self.request_dict["Key"])
            self.response_dict.update({"Id": new_client_id,
                                       "Success": True})

            self.set_verifier(new_client_id)
def main():
    # avoid: UnboundLocalError: local variable '__doc__' referenced before assignment
    doc_ = __doc__
    kpconf = Conf()

    if has_gui_support():
        doc_ += "  --gui".ljust(28) + "Use QT (PySide) for a graphical interface"

    # handle arguments
    arguments = docopt.docopt(doc_)

    is_daemon = arguments["--daemon"]
    database_path = arguments["<database_path>"]
    host = arguments["--host"]
    port = arguments["--port"]
    assert port.isdigit()
    loglevel = arguments["--loglevel"]

    gui = arguments.get("--gui", False)
    if gui:
        ui = Conf.UI.GUI
    else:
        ui = Conf.UI.CLI

    kpconf.select_ui(ui)
    kpconf.set_loglevel(loglevel)

    if not has_gui_support():
        log.debug("\nIt seems that you don't have GUI support installed. Install it with:\n"
                  "  $ pip install -e '.[GUI]'\n"
                  "or\n"
                  "  $ pip install keepass_http[GUI]\n")

    # backend
    backend = backends.BaseBackend.get_by_filepath(database_path)
    kpconf.set_backend(backend)

    success = kpconf.get_selected_ui().RequireDatabasePassphraseUi.do(MAX_TRY_COUNT)
    if success is False:
        sys.exit("Wrong or no passphrase")

    # config daemon
    run_server = partial(app.run, debug=False, host=host, port=int(port))
    if is_daemon:
        pid_file = os.path.join(kpconf.confdir, "process.pid")
        log.info("Server started as daemon on %s:%s" % (host, port))
        daemon = daemonize.Daemonize(app=APP_NAME,
                                     pid=pid_file,
                                     action=run_server,
                                     keep_fds=get_logging_filehandlers_streams_to_keep())
        daemon.start()

    else:
        log.info("Server started on %s:%s" % (host, port))
        run_server()
Exemple #3
0
 def __init__(self):
     Tkinter.Tk.__init__(self)
     self.kpconf = Conf()
     self._success = False
     self.setup_frame_1()
     self.title("Enter the passphrase for %s" %
                self.kpconf.backend.database_path)
def main():
    # avoid: UnboundLocalError: local variable '__doc__' referenced before assignment
    doc_ = __doc__
    kpconf = Conf()

    if has_gui_support():
        doc_ += "  --gui                     Use TKinter for a graphical interface"

    # handle arguments
    arguments = docopt.docopt(doc_)

    is_daemon = arguments["--daemon"]
    database_path = arguments["<database_path>"]
    host = arguments["--host"]
    port = arguments["--port"]
    assert port.isdigit()
    loglevel = arguments["--loglevel"]

    gui = arguments.get("--gui", False)
    if gui:
        ui = Conf.UI.GUI
    else:
        ui = Conf.UI.CLI

    kpconf.select_ui(ui)
    kpconf.set_loglevel(loglevel)

    # backend
    backend = backends.BaseBackend.get_by_filepath(database_path)
    kpconf.set_backend(backend)

    success = kpconf.get_selected_ui().OpenDatabase.open(MAX_TRY_COUNT)
    if success is False:
        sys.exit("Wrong passphrase after %d attempts" % MAX_TRY_COUNT)

    # config daemon
    run_server = partial(app.run, debug=False, host=host, port=int(port))
    if is_daemon:
        pid_file = os.path.join(kpconf.confdir, "process.pid")
        log.info("Server started as daemon on %s:%s" % (host, port))
        daemon = daemonize.Daemonize(
            app=APP_NAME,
            pid=pid_file,
            action=run_server,
            keep_fds=get_logging_filehandlers_streams_to_keep())
        daemon.start()

    else:
        log.info("Server started on %s:%s" % (host, port))
        run_server()
Exemple #5
0
    def process(self):
        try:
            self.authenticate()
        except AuthenticationError as unused_e:
            return
        url = self.kpc.decrypt(self.request_dict['Url'])
        url = url.decode("utf-8")

        entries = Conf().backend.search_entries("url", url)

        self.response_dict.update({"Success": True, "Count": len(entries)})
Exemple #6
0
 def try_authenticate(self, *args):
     passphrase = self.ui.passphrase.text()
     try:
         Conf().backend.open_database(passphrase)
     except WrongPassword:
         statusbar = self.ui.statusBar()
         msg = "Wrong passphrase, try again please."
         statusbar.showMessage(msg)
         log.warning(msg)
     else:
         log.info("Passphrase %s accepted" % ("*" * len(passphrase)))
         self._exit(True)
Exemple #7
0
    def process(self):
        try:
            self.authenticate()
        except AuthenticationError as unused_e:
            return

        url = self.kpc.decrypt(self.request_dict['SubmitUrl'])
        login = self.kpc.decrypt(self.request_dict['Login'])
        password = self.kpc.decrypt(self.request_dict['Password'])

        Conf().backend.create_login(self.get_client_id(), login, password, url)

        self.response_dict.update({"Success": True})
def main():
    # avoid: UnboundLocalError: local variable '__doc__' referenced before assignment
    doc_ = __doc__
    kpconf = Conf()

    if has_gui_support():
        doc_ += "  --gui                     Use TKinter for a graphical interface"

    # handle arguments
    arguments = docopt.docopt(doc_)

    is_daemon = arguments["--daemon"]
    database_path = arguments["<database_path>"]
    host = arguments["--host"]
    port = arguments["--port"]
    assert port.isdigit()
    loglevel = arguments["--loglevel"]

    gui = arguments.get("--gui", False)
    if gui:
        ui = Conf.UI.GUI
    else:
        ui = Conf.UI.CLI

    kpconf.select_ui(ui)
    kpconf.set_loglevel(loglevel)

    # backend
    backend = backends.BaseBackend.get_by_filepath(database_path)
    kpconf.set_backend(backend)

    success = kpconf.get_selected_ui().OpenDatabase.open(MAX_TRY_COUNT)
    if success is False:
        sys.exit("Wrong passphrase after %d attempts" % MAX_TRY_COUNT)

    # config daemon
    run_server = partial(app.run, debug=False, host=host, port=int(port))
    if is_daemon:
        pid_file = os.path.join(kpconf.confdir, "process.pid")
        log.info("Server started as daemon on %s:%s" % (host, port))
        daemon = daemonize.Daemonize(app=APP_NAME,
                                     pid=pid_file,
                                     action=run_server,
                                     keep_fds=get_logging_filehandlers_streams_to_keep())
        daemon.start()

    else:
        log.info("Server started on %s:%s" % (host, port))
        run_server()
def test_get_backend_by_mimetype():
    Conf()

    assert isinstance(BaseBackend.get_by_filepath("foo.kdb"),
                      python_keepass_backend.Backend)
    assert isinstance(BaseBackend.get_by_filepath("foo.kdbx"),
                      libkeepass_backend.Backend)

    with pytest.raises(NoBackendError):
        BaseBackend.get_by_filepath("eggs.kdbfx")

    with pytest.raises(NoBackendError):
        BaseBackend.get_by_filepath("/tmp/foo.gif")
Exemple #10
0
    def set_verifier(self, new_client_id=None):
        if new_client_id:
            client_id = new_client_id
            key = Conf().backend.get_key_for_client(client_id)
            if not key:
                raise AuthenticationError()
        else:
            client_id = self.get_client_id()
            key = self.kpc.get_key()

        nonce = AESCipher.generate_nonce()
        response_kpc = AESCipher(key, nonce)

        self.response_dict.update({"Nonce": nonce, "Verifier": response_kpc.encrypt(nonce)})
        self.set_response_kpc = response_kpc
Exemple #11
0
    def process(self):
        try:
            self.authenticate()
        except AuthenticationError as unused_e:
            return

        url = str(self.kpc.decrypt(self.request_dict['Url']))
        url = urlparse(url).netloc
        url = url.decode("utf-8")

        entries = []
        for entry in Conf().backend.search_entries("url", url):
            json_entry = entry.to_json_dict(self.response_kpc)
            entries.append(json_entry)

        self.response_dict.update({"Success": True, "Id": self.get_client_id(), "Entries": entries})
Exemple #12
0
    def open(max_try_count):
        kpconf = Conf()
        try_count = 1
        success = False
        while try_count <= max_try_count:
            passphrase = getpass.getpass("Please enter the passphrase for database %s: \n" %
                                         kpconf.backend.database_path)
            try:
                kpconf.backend.open_database(passphrase)
            except backends.WrongPassword:
                log.info("Wrong passphrase, please try again. (attempt [%s/%s]" % (try_count,
                                                                                   max_try_count))
                try_count += 1
            else:
                success = True
                log.info("Passphrase accepted")
                break

        return success
Exemple #13
0
    def authenticate(self):
        client_id = self.get_client_id()

        log.info("Authenticate client %s" % client_id)

        key = Conf().backend.get_key_for_client(client_id)
        # FIXME: Fix unit tests
        # Special case when methods used in unit test are not mocked correctly.
        # <TestAES name='AESCipher().key' id='25131856'> is not None :S
        if key is None or not isinstance(key, basestring):
            raise AuthenticationError()

        nonce = self.request_dict['Nonce']
        verifier = self.request_dict['Verifier']

        kpc = AESCipher(key, nonce)

        # wrong saved key in database -> force associate
        if not kpc.is_valid(nonce, verifier):
            raise InvalidAuthentication()

        self.set_kpc = kpc
        self.set_verifier()
def main():
    # avoid: UnboundLocalError: local variable '__doc__' referenced before assignment
    doc_ = __doc__
    kpconf = Conf()

    if has_gui_support():
        doc_ += "  --gui                     Use TKinter for a graphical interface"

    # handle arguments
    arguments = docopt.docopt(doc_)

    is_daemon = arguments["--daemon"]
    database_path = arguments["<database_path>"]
    host = arguments["--host"]
    port = arguments["--port"]
    assert port.isdigit()
    loglevel = arguments["--loglevel"]

    gui = arguments.get("--gui", False)
    if gui:
        ui = Conf.UI.GUI
    else:
        ui = Conf.UI.CLI

    kpconf.select_ui(ui)
    kpconf.set_loglevel(loglevel)

    # server
    #server = KeepassHTTPServer(host, int(port))

    # backend
    backend_class = backends.get_backend_by_file(database_path)

    try_count = 1
    max_try_count = 3
    success = False
    while try_count <= max_try_count:
        passphrase = getpass.getpass(
            "Please enter the passphrase for database %s: \n" %
            database_path)
        try:
            backend = backend_class(database_path, passphrase)
        except backends.WrongPassword:
            log.info(
                "Wrong passphrase, please try again. (attempt [%s/%s]" %
                (try_count, max_try_count))
            try_count += 1
        else:
            success = True
            log.info("Passphrase accepted")
            break

    if success is False:
        sys.exit("Wrong passphrase after %d attempts" % max_try_count)

    kpconf.set_backend(backend)

    # config daemon
    run_server = partial(app.run, debug=False, host=host, port=int(port))
    if is_daemon:
        pid_file = os.path.join(kpconf.confdir, "process.pid")
        log.info("Server started as daemon on %s:%s" % (host, port))
        daemon = daemonize.Daemonize(app=APP_NAME,
                                     pid=pid_file,
                                     action=run_server,
                                     keep_fds=get_logging_filehandlers_streams_to_keep())
        daemon.start()

    else:
        log.info("Server started on %s:%s" % (host, port))
        run_server()