def openDatabase(db_path, db_pass):
'''
Check if databases file exist and open it as read only
Return the database
'''
if len(db_pass) == 0:
db_pass = input('Enter password for ' + db_path + ' :')
try:
# Check if file exist, raise an exception if not
if not os.path.isfile(db_path):
raise FileNotFoundError(db_path)
db = KPDBv1(db_path, db_pass, read_only=True)
# Execption Handler for the kppy opener
except KPError as err:
print(err)
print('Error while opening ' + db_path)
print('Quitting...')
quit()
except FileNotFoundError:
print('No File found at ' + db_path)
print('Quitting...')
quit()
return db
def empty_kppy_db(request, tmpdir):
assert isinstance(tmpdir, py.path.local)
kdb_path = tmpdir.join('test_db.kdb')
passpie_keepass.prepare_pycrypto_for_import()
from kppy.database import KPDBv1, KPError
db = KPDBv1(str(kdb_path), password='******', new=True)
def cleanup():
db.close()
return db
def load(self):
"""
Load the keepass database into memory for processing
:raise IOError: Fails if the file doesn't exist
"""
if not hasattr(self, 'reader'):
if not os.path.isfile(self.path):
raise IOError('No such keepass file {}'.format(self.path))
self.reader = KPDBv1(filepath=self.path,
read_only=True,
keyfile=self.keyfile,
password=self.password)
self.reader.load()
def main(k_db, k_passphrase):
# open kepass db
try:
db = KPDBv1(k_db, k_passphrase, read_only=True)
db.load()
except KPError as e:
print(e)
sys.exit(1)
items = ''
for entry in db.entries:
if entry.title != 'Meta-Info':
print entry.title
password = entry.password
username = entry.username
if username != 'SYSTEM':
print " \_", username, password
db.close()
def handle(self, filepath):
passphrase = click.prompt('Keepass passphrase', hide_input=True)
try:
# TODO add keyfile support
db = KPDBv1(filepath=str(filepath),
password=str(passphrase),
read_only=True)
db.load()
except KPError as e:
self.log(str(e))
return []
except Exception as e:
self.log(str(e))
return []
else:
try:
credentials = []
for entry in db.entries:
group_names_str = self.compute_group_name(entry)
entry_fullname = make_fullname(entry.username,
group_names_str)
credential_dict = {
'fullname': entry_fullname,
'name': group_names_str,
'login': entry.username,
'password': entry.password,
'comment': (entry.comment or '').strip(),
'modified': entry.creation,
}
credentials.append(credential_dict)
return credentials
finally:
db.close()
def __init__(self,
pidfile,
loglevel,
logfile,
address=None,
port=50002,
db=None,
password=None,
keyfile=None,
tls=False,
tls_dir=None,
tls_port=50003,
tls_req=False):
Daemon.__init__(self, pidfile)
try:
logdir = realpath(expanduser(getenv('XDG_DATA_HOME')))
except:
logdir = realpath(expanduser('~/.local/share'))
finally:
logfile = join(logdir, 'keepassc', logfile)
logging.basicConfig(format='[%(levelname)s] in %(filename)s:'
'%(funcName)s at %(asctime)s\n%(message)s',
level=loglevel,
filename=logfile,
filemode='a')
if db is None:
print('Need a database path')
sys.exit(1)
self.db_path = realpath(expanduser(db))
# To use this idiom only once, I store the keyfile path
# as a class attribute
if keyfile is not None:
keyfile = realpath(expanduser(keyfile))
else:
keyfile = None
chdir("/var/empty")
try:
self.db = KPDBv1(self.db_path, password, keyfile)
self.db.load()
except KPError as err:
print(err)
logging.error(err.__str__())
sys.exit(1)
self.lookup = {
b'FIND': self.find,
b'GET': self.send_db,
b'CHANGESECRET': self.change_password,
b'NEWG': self.create_group,
b'NEWE': self.create_entry,
b'DELG': self.delete_group,
b'DELE': self.delete_entry,
b'MOVG': self.move_group,
b'MOVE': self.move_entry,
b'TITG': self.set_g_title,
b'TITE': self.set_e_title,
b'USER': self.set_e_user,
b'URL': self.set_e_url,
b'COMM': self.set_e_comment,
b'PASS': self.set_e_pass,
b'DATE': self.set_e_exp
}
self.sock = None
self.net_sock = None
self.tls_sock = None
self.tls_req = tls_req
if tls is True or tls_req is True:
self.context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
cert = join(tls_dir, "servercert.pem")
key = join(tls_dir, "serverkey.pem")
self.context.load_cert_chain(certfile=cert, keyfile=key)
else:
self.context = None
try:
# Listen for commands
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.bind(("localhost", 50000))
self.sock.listen(5)
except OSError as err:
print(err)
logging.error(err.__str__())
sys.exit(1)
else:
logging.info('Server socket created on localhost:50000')
if self.tls_req is False and address is not None:
try:
# Listen for commands
self.net_sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
self.net_sock.bind((address, port))
self.net_sock.listen(5)
except OSError as err:
print(err)
logging.error(err.__str__())
sys.exit(1)
else:
logging.info('Server socket created on ' + address + ':' +
str(port))
if self.context is not None and address is not None:
try:
# Listen for commands
self.tls_sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
self.tls_sock.bind((address, tls_port))
self.tls_sock.listen(5)
except OSError as err:
print(err)
logging.error(err.__str__())
sys.exit(1)
else:
logging.info('TLS-Server socket created on ' + address + ':' +
str(tls_port))
#Handle SIGTERM
signal.signal(signal.SIGTERM, self.handle_sigterm)
return Password
check_arg()
t_file = sys.argv[1]
f = open(t_file, 'r')
s_list = []
for i in f.readlines():
i = i.strip('\n')
s_list.append(i)
f.close()
cus = s_list[0]
del s_list[0]
check_kdb_file(cus + '.kdb')
db = KPDBv1(new=True)
db.groups[0].remove_group()
db.create_group(cus)
for i in s_list:
s = i.split('\t')
server = s[0]
ip = s[1]
db.create_group(server, db.groups[0])
G = db.groups[1]
Password = Gen_pass()
db.create_entry(G, 'ncadmin', 0, ip, 'ncadmin', Password, server)
Password = Gen_pass()
db.create_entry(G, 'root', 0, ip, 'root', Password, server)
m = re.search('db\d$', server)
if m:
#### Test
#new_group_list=db1.groups+db2.groups
#print('Print the list of groups')
#for group in new_group_list :
# print(group.title,group.id_,group.db)
# group.db=None
#
#new_group_set=set(new_group_list)
#print('Print the set of groups')
#
#for group in new_group_set :
# print(group.title,group.id_,group.db)
## Creating the new database
dbnew = KPDBv1(filepath=dbnew_path,
password=dbnew_pass,
read_only=False,
new=True)
# Creating the group architecture
dbnew = syncDb(dbnew, db1, db2)
dbnew = cleanDb(dbnew)
dbnew.save()
dbnew.close()
db1.close()
db2.close()
print('\nSync went good :D ')