def test_build_kdb(self):
file = self.raw_kdb_full_path
self.processor.build_kdb(filename=file, password="******")
kdb = PyKeePass(filename=file, password="******")
entries = kdb.entries
groups = kdb.groups
self.assertEqual(len(entries), 0)
self.assertEqual(len(groups), 1)
kdb_io = io.BytesIO()
self.kdb.save(kdb_io)
kdb_io.seek(0)
self.processor.load_from_kdb(kdb_io, self.password)
self.processor.build_kdb(filename=file, password="******")
kdb = PyKeePass(filename=file, password="******")
entries = kdb.entries
groups = kdb.groups
self.assertEqual(3, len(entries))
self.assertEqual(3, len(groups))
# TODO DRY
self.processor.build_kdb(filename=kdb_io, password="******")
kdb = PyKeePass(filename=file, password="******")
entries = kdb.entries
groups = kdb.groups
self.assertEqual(3, len(entries))
self.assertEqual(3, len(groups))
def setUp(self):
shutil.copy(os.path.join(base_dir, self.database),
os.path.join(base_dir, 'change_creds.kdbx'))
self.kp = PyKeePass(os.path.join(base_dir, self.database),
password=self.password,
keyfile=os.path.join(base_dir, self.keyfile))
self.kp_tmp = PyKeePass(os.path.join(base_dir, 'change_creds.kdbx'),
password=self.password,
keyfile=os.path.join(base_dir, self.keyfile))
def setUp(self):
shutil.copy(os.path.join(base_dir, 'test.kdbx'),
os.path.join(base_dir, 'change_creds.kdbx'))
self.kp = PyKeePass(os.path.join(base_dir, 'test.kdbx'),
password='******',
keyfile=os.path.join(base_dir, 'test.key'))
self.kp_tmp = PyKeePass(os.path.join(base_dir, 'change_creds.kdbx'),
password='******',
keyfile=os.path.join(base_dir, 'test.key'))
def setUp(self):
shutil.copy(os.path.join(base_dir, self.database),
os.path.join(base_dir, 'change_creds.kdbx'))
self.kp = PyKeePass(os.path.join(base_dir, self.database),
password=self.password,
keyfile=os.path.join(base_dir, self.keyfile))
# for tests which modify the database, use this
self.kp_tmp = PyKeePass(os.path.join(base_dir, 'change_creds.kdbx'),
password=self.password,
keyfile=os.path.join(base_dir, self.keyfile))
def test_open_error(self):
with self.assertRaises(CredentialsError):
database = 'test4.kdbx'
invalid_password = '******'
keyfile = os.path.join(base_dir, 'test4.key')
PyKeePass(os.path.join(base_dir, database),
password=invalid_password,
keyfile=keyfile)
with self.assertRaises(CredentialsError):
database = 'test4.kdbx'
password = '******'
invalid_keyfile = os.path.join(base_dir, 'test3.key')
PyKeePass(os.path.join(base_dir, database),
password=password,
keyfile=invalid_keyfile)
def init_kpdb(self):
'''
init vars for Keepass
'''
self.listuser = []
self.searchuser = []
nb_user = int(input('Combien de compte à rechercher ? : '))
i = 0
while i < nb_user:
'''
Create a list user
'''
user = input('Renseigner le nom de votre utilisateur : ')
self.searchuser.append(user)
i += 1
try:
'''
Check and add user to list
'''
self.db = PyKeePass(self.path, password=self.password)
for user in self.searchuser:
print(
'Recherche dans la base l\'utilisateur : {0}'.format(user))
if self.db.find_entries(username=user, first=True):
self.listuser.append(user)
print('L\'utilisateur : {0} a été ajouté à la liste !'.
format)
else:
print('L\'utilisateur : {0} n\'a pas été trouvé !'.format(
user))
except FileNotFoundError:
print('Le fichier n\'a pas été trouvé !')
def test_merge(sources):
runner = CliRunner(env={"KEEPASS_PASSWORD": '******'})
result_file = 'merged.kdbx'
files = sources + [result_file]
file_paths = [os.path.join('tests', fname) for fname in files]
try:
result = runner.invoke(main, file_paths)
print(result.stdout)
assert not result.exception, exc_to_str(result.exc_info)
assert result.exit_code == 0, " ".join(file_paths)
assert os.path.exists(file_paths[-1])
dest = PyKeePass(file_paths[-1], 'password')
entries = dest.entries
assert len(entries) == 3
michael = dest.find_entries_by_username('Michael321', first=True)
assert michael.password == 'replaced'
user = dest.find_entries_by_username('User Name', first=True)
assert user.password == 'Password'
orig = dest.find_entries_by_title('OnlyOriginal', first=True)
assert orig is not None
finally:
if os.path.exists(file_paths[-1]):
os.remove(file_paths[-1])
def parse(self, inventory, loader, path, cache=False):
# call base method to ensure properties are available for use with other helper methods
super(InventoryModule, self).parse(inventory, loader, path, cache)
# Populate option defaults
self.set_options()
kp_db = None
for pw in self.get_kp_passwords():
try:
kp_db = PyKeePass(path, password=pw)
if kp_db:
self.display.vvv("Attempt to decrypt the keepass file succeeded")
break
except Exception as ex:
# Assuming we've not reached the correct pw
self.display.vvv("An attempt to decrypt the keepass file failed: "+str(ex))
continue
if kp_db:
# Load config options from kdb file
d = kp_db.tree.find('Meta/DatabaseDescription')
if d is not None and d.text:
options = self.read_notes(d.text)
if options:
self._consume_options(options)
if options:
self.display.warning("Database Description contains unsupported options")
self._parse_kp_db(kp_db)
else:
raise AnsibleParserError("Unable to decrypt keepass file")
def _open(self) -> PyKeePass:
if self.location is None or not os.path.isfile(
os.path.realpath(
os.path.expanduser(os.path.expandvars(self.location)))):
raise AnsibleParserError(u"could not find keepass database - %s" %
self.location)
self._display.v(u"Keepass: database found - %s" % self.location)
if self.keyfile is not None:
if not os.path.isfile(
os.path.realpath(
os.path.expanduser(os.path.expandvars(self.keyfile)))):
raise AnsibleParserError(u"could not find keyfile - %s" %
self.keyfile)
self._display.vvv(u"Keepass: keyfile found - %s" % self.keyfile)
database = PyKeePass(
filename=os.path.realpath(
os.path.expanduser(os.path.expandvars(self.location))),
keyfile=(os.path.realpath(
os.path.expanduser(os.path.expandvars(self.keyfile)))
if self.keyfile is not None else None),
password=self.password,
transformed_key=self.transformed_key)
self._display.v(u"Keepass: database opened - %s" % self.location)
return database
def _load_keepass_data(self):
# aggregate entries
kp = PyKeePass(filename=self._keepass_file_path,
password=self._keepass_password,
keyfile=self._keepass_keyfile_path)
# reset data structures
self._kp_ref_entries = []
self._entries = {}
logging.info(
f"Found {len(kp.entries)} entries in KeePass DB. Parsing now...")
for entry in kp.entries:
# if not entry.password and not entry.username and not entry.notes:
# logging.warn(f"Ignoring entry {entry.title} since it has neither (1) a password, (2) a username, or (3) notes")
# continue
# prevent not iterable errors at "in" checks
username = entry.username if entry.username else ''
password = entry.password if entry.password else ''
# Skip REFs as ID might not be in dict yet
if KP_REF_IDENTIFIER in username or KP_REF_IDENTIFIER in password:
self._kp_ref_entries.append(entry)
continue
# Normal entry
self._add_bw_entry_to_entires_dict(entry)
logging.info(f"Parsed {len(self._entries)} entries")
def __init__(self):
Gtk.Window.__init__(self, title="Database")
self.set_border_width(10)
self.set_default_size(700, 400)
scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
flowbox = Gtk.FlowBox()
flowbox.set_valign(Gtk.Align.START)
flowbox.set_max_children_per_line(3)
flowbox.set_selection_mode(Gtk.SelectionMode.NONE)
kp = PyKeePass(file_path, password=key)
for i in kp.entries:
global entry
entry = i
copyuser = Gtk.Button(label = "Copy Username")
copyuser.connect("clicked", self.CopyUser)
copypass = Gtk.Button(label="Copy Password")
copypass.connect("clicked", self.CopyPass)
label = Gtk.Label()
label.set_text(i.title)
flowbox.add(label)
flowbox.add(copyuser)
flowbox.add(copypass)
scrolled.add(flowbox)
self.add(scrolled)
self.show_all()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-f",
"--file",
action="store",
dest="file",
required=True,
help="Keepass file location")
parser.add_argument("-p",
"--password",
action="store",
dest="password",
required=True,
help="Keepass file password")
parser.add_argument("-s",
"--search",
action="store",
dest="search",
required=True,
help="Search Key")
args = parser.parse_args()
kp = PyKeePass(args.file, password=args.password)
searchTerm = args.search.split(" ")
KeePass.search(kp, searchTerm)
def _load_keepass_data(self):
# aggregate entries
kp = PyKeePass(self._keepass_file_path,
password=self._keepass_password)
# reset data structures
self._kp_ref_entries = []
self._entries = {}
logging.info(
f"Found {len(kp.entries)} entries in KeePass DB. Parsing now...")
for entry in kp.entries:
if not entry.password and not entry.username and not entry.notes:
continue
# prevent not iteratable errors at "in" checks
username = entry.username if entry.username else ''
password = entry.password if entry.password else ''
# Skip REFs as ID might not be in dict yet
if KP_REF_IDENTIFIER in username or KP_REF_IDENTIFIER in password:
self._kp_ref_entries.append(entry)
continue
# Normal entry
self._add_bw_entry_to_entires_dict(entry)
logging.debug(f"Parsed {len(self._entries)} entries")
def run(self, terms, variables, **kwargs):
filename = self.get_filename()
password = self.get_password()
ret = []
kp = PyKeePass(filename, password)
for term in terms:
path, attribute = term.rsplit('.', 1)
found = kp.find_entries_by_path(path, first=True)
if not found:
raise AnsibleError(
"Entry %s not found in keepass-Database %s" % \
(path, filename)
)
if attribute.startswith('attr_'):
dict = found.custom_properties
value = dict[attribute[len('attr_'):]]
else:
value = getattr(found, attribute)
ret.append(value)
return ret
def main(kwargs):
password = (get_password(
kwargs["--password-file"] if kwargs["--askpass"] else None))
logging.info("Opening database, this might take a while...")
kp = PyKeePass(
kwargs["KEEPASSX-DB"],
password=password,
keyfile=kwargs["--keyfile"],
)
logging.info("Database opened.")
#entries = kp.find_entries(
# title=kwargs["--title"],
# username=kwargs["--username"],
# history=kwargs["--history"],
# regex=kwargs["--regex"],
#)
entries = kp.find_entries(username=kwargs["--username"], )
logging.info("# of entries to search for pwnage: {}".format(len(entries)))
for n, entry in enumerate(entries, 1):
print('{}: {}'.format(n, entry.title), end=' ')
ps = pwned_status(PWNED_URL_BASE, entry.password)
if ps:
print('PWNED!! (password: {})'.format(entry.password))
else:
print('OK')
logging.info("Done.")
def establishServerConnection(
hostIpAddress="172.16.128.196",
dbName="corona",
username=None,
password=None,
keepassDB="Q:\\FoodData\\new\\01_technical\\Password Database\\DIL.kdbx",
keepassKey="Q:\\FoodData\\new\\01_technical\\Password Database\\2018-03-09_Schlüssel.key",
keepassTitle="MariaDB c.seebold"):
if username == None and password == None:
# Provide MariaDB account information by accessing the locally stored KeePass file.
keePass = PyKeePass(keepassDB, keyfile=keepassKey)
entry = keePass.find_entries(
title=keepassTitle, first=True) # Find entry 'MariaDB c.seebold'.
username = entry.username
password = entry.password
# Try and except clause checks if connection was successful.
try:
connection = pymysql.connect(
hostIpAddress, username, password, dbName, local_infile=True
) # Requires to add 'loose-local-infile = 1' in the '[client]' section of '/etc(/mysql)/my.cnf'.
print("Connection to database {0} successfully established.".format(
dbName))
return connection
except:
print("ERROR: Connection to database {0} failed.".format(dbName))
import sys
sys.exit()
def _fetch_file(self, kp_dbx, kp_psw, kp_key, entry_path, entry_attr, enable_custom_attr):
if kp_key:
kp_key = os.path.realpath(os.path.expanduser(kp_key))
if os.path.isfile(kp_key):
display.vvv(u"Keepass: database keyfile: %s" % kp_key)
try:
if not LookupModule.keepass:
LookupModule.keepass = PyKeePass(kp_dbx, kp_psw, kp_key)
entry = LookupModule.keepass.\
find_entries_by_path(entry_path, first=True)
if entry is None:
raise AnsibleError(u"Entry '%s' is not found" % entry_path)
display.vv(
u"KeePass: attr: %s in path: %s" % (entry_attr, entry_path))
entry_val = None
if enable_custom_attr:
entry_val = entry.get_custom_property(entry_attr)
if entry_val is not None:
return [entry_val]
else:
raise AnsibleError(AttributeError(u"'No custom field property '%s'" % (entry_attr)))
else:
return [getattr(entry, entry_attr)]
except ChecksumError:
raise AnsibleError("Wrong password/keyfile {}".format(kp_dbx))
except (AttributeError, FileNotFoundError) as e:
raise AnsibleError(e)
def test_open_save(self):
"""try to open all databases, save them, then open the result"""
databases = [
'test3.kdbx', # KDBX v3 test
'test4.kdbx', # KDBX v4 test
'test4_aes.kdbx', # KDBX v4 AES test
'test4_chacha20.kdbx', # KDBX v4 ChaCha test
'test4_twofish.kdbx', # KDBX v4 Twofish test
'test4_hex.kdbx' # legacy 64 byte hexadecimal keyfile test
]
passwords = [
'password',
'password',
'password',
'password',
'password',
'password',
]
keyfiles = [
'test3.key',
'test4.key',
'test4.key',
'test4.key',
'test4.key',
'test4_hex.key',
]
encryption_algorithms = [
'aes256',
'chacha20',
'aes256',
'chacha20',
'twofish',
'chacha20',
]
kdf_algorithms = [
'aeskdf',
'argon2',
'argon2',
'argon2',
'argon2',
'argon2',
]
for database, password, keyfile, encryption_algorithm, kdf_algorithm in zip(
databases, passwords, keyfiles, encryption_algorithms,
kdf_algorithms):
kp = PyKeePass(os.path.join(base_dir, database), password,
os.path.join(base_dir, keyfile))
self.assertEqual(kp.encryption_algorithm, encryption_algorithm)
self.assertEqual(kp.kdf_algorithm, kdf_algorithm)
KDBX.parse(KDBX.build(kp.kdbx,
password=password,
keyfile=None if keyfile is None else
os.path.join(base_dir, keyfile)),
password=password,
keyfile=None if keyfile is None else os.path.join(
base_dir, keyfile))
def _get_keepass(self):
if not self.exists:
return None
if not self._keepass:
password = getpass(
prompt='Password for {0}: '.format(self.basename))
self._keepass = PyKeePass(self._path, password=password)
return self._keepass
def opendatabase(database, password, keyfile):
keepassargs = dict()
if password:
keepassargs["password"] = ask_password(f"Enter {os.path.basename(database)} Password")[1]
if keyfile:
keepassargs["keyfile"] = keyfile
kp = PyKeePass(database, **keepassargs)
return kp
def test_set_credentials(self):
self.kp_tmp.password = '******'
self.kp_tmp.keyfile = os.path.join(base_dir, 'change.key')
self.kp_tmp.save()
self.kp_tmp = PyKeePass(self.kp_tmp.filename, 'f00bar',
self.kp_tmp.keyfile)
results = self.kp.find_entries_by_username('foobar_user', first=True)
self.assertEqual('foobar_user', results.username)
def init_connection(self):
try:
kp = PyKeePass(self.kp_db_path, password=self.password)
except IOError:
raise
except Exception as e:
raise
else:
return kp
def skattefunn(request):
encoded = request.user.first_name.encode()
f = Fernet(key)
decrypted = f.decrypt(encoded)
decoded = decrypted.decode()
if request.method == 'POST' and 'run_script' in request.POST:
from djangoweb.library.Main import Publish
Publish(decoded)
messages.success(request, 'Data has been updated')
return redirect('skattefunn')
if request.method == 'POST' and 'update_schedule' in request.POST:
form = UpdateScheduleForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.save()
create_periodic = PeriodicTask.objects.create(crontab=post, interval=None, name=datetime.now(),task='webscrap.tasks.runscript')
messages.success(request, 'Scheduler has been updated')
return redirect('skattefunn')
else:
form = UpdateScheduleForm()
task_list = CrontabSchedule.objects.all()
data_schedule = []
for task in task_list:
cron_data = str(task.minute)+' '+str(task.hour)+' '+str(task.day_of_week)+' '+str(task.day_of_month)+' '+str(task.month_of_year)
base = datetime.now()
iterate = croniter(cron_data, base)
next_schedule = iterate.get_next(datetime)
data_schedule.append(next_schedule)
home = os.getcwd()
archive_path = os.path.join(home, 'djangoweb', 'archive')
if request.method == 'POST' and 'import_user' in request.POST:
with PyKeePass(os.path.join(archive_path, 'userdb.kdbx'), password=decoded) as kp:
entries = kp.find_entries(title='SkatteFunn')
for entry in entries:
if User.objects.filter(username=entry.username).exists():
print('already exist')
else:
new_user = User.objects.create_user(entry.username, password=entry.password)
new_user.is_staff = True
new_user.save()
messages.success(request, 'Users have been imported')
return redirect('skattefunn')
user_list = User.objects.all()
return render(request, 'skattefunn.html', {
'task_list': task_list,
'user_list': user_list,
'data_schedule': data_schedule,
'form': form,
})
def test_password(self, file, password):
filename = self.get_filename()
try:
kp = PyKeePass(filename, password)
except IOError:
return False
return True
def __init__(self,
database_path,
password=None,
keyfile=None,
logging_manager=None):
self.logging_manager = logging_manager
self.db = PyKeePass(database_path, password, keyfile)
self.database_path = database_path
self.database_file_descriptor = Gio.File.new_for_path(database_path)
self.password = password
def merge_two_databases(self, file_database1,
file_database2,
file_output_database,
master_password,
debug=False):
try:
kp1 = PyKeePass(file_database1, password=master_password)
except CredentialsError:
raise DB1WrongPasswordError
try:
kp2 = PyKeePass(file_database2, password=master_password)
except CredentialsError:
raise DB2WrongPasswordError
self.sync_groups(kp2,kp1, debug=debug)
self.sync_entries(kp2,kp1, debug=debug)
self.sync_custom_properties(kp2,kp1, debug=debug)
kp1.save(filename=file_output_database)
def on_event(self, event, extension):
reload(config)
try:
if config.database_path == "" or config.master_key == "":
raise ValueError("您尚未配置数据库路径或密码，请按回车配置")
try:
extension.db = PyKeePass(config.database_path,
password=config.master_key)
except:
raise IOError("数据库或密码错误,回车后请重新配置")
arg = event.get_argument()
args_list = None
try:
args_list = arg.split(" ")
except:
pass
if len(args_list) >= 1:
arg = args_list[0]
if arg == "add":
return RenderResultListAction([
ExtensionResultItem(icon='images/icon.png',
name='%s' % "添加密码到数据库",
on_enter=ExtensionCustomAction(
args_list, keep_app_open=True))
])
else:
if len(args_list) > 1:
raise AttributeError("参数填写错误")
# 执行密码查询
items = []
for e in extension.db.entries:
title = e.title
name = e.username
if title is None:
title = ""
if name is None:
name = ""
if arg in title or arg in name:
items.append(
ExtensionResultItem(
icon='images/icon.png',
name='%s' % title,
description='%s' % name,
on_enter=CopyToClipboardAction(
e.password)))
return RenderResultListAction(items)
except (ValueError, IOError, AttributeError), e:
print type(e)
return RenderResultListAction([
ExtensionResultItem(icon='images/icon.png',
name='%s' % e.message,
on_enter=ExtensionCustomAction(
e, keep_app_open=True))
])
def _build_from_blank(self, filename, password):
if self._blank_kdb_file and os.path.isfile(self._blank_kdb_file):
kdb = PyKeePass(self._blank_kdb_file,
self._blank_kdb_file_password)
kdb.filename = filename
kdb.password = password
kdb.keyfile = None
else:
kdb = create_database(filename, password)
self.__tmd_kdb = kdb
def open(self):
"""Open the keepass repository."""
if not PYKEEPASS:
raise ImportError(name='pykeepass')
try:
self.keepass = PyKeePass(self.prefix,
password=getpassword(self.prefix),
keyfile=self.keyfile)
except CredentialsIntegrityError as error:
raise PMError(error)
def db_pwd(path, password):
db = DatabaseManager(path)
# Hack around async methods
# TODO Provide a sync method which tests unlock_async
with pytest.raises(Exception):
py_db = PyKeePass(path, "wrong password")
py_db = PyKeePass(path, password)
db.db = py_db
db.password == password
db.entries.splice(0, 0, [SafeEntry(db, e) for e in db.db.entries])
db.groups.splice(0, 0, [SafeGroup(db, g) for g in db.db.groups])
db._elements_loaded = True
assert db.locked is False
assert db.is_dirty is False
return db