def load_settings_from_file(self, password):
"""
This loads the saved settings. It is a good idea to call this method the minute you have a password.
:param str password:
"""
if os.path.isfile(self.settings_file):
file = open(self.settings_file, 'br')
data = file.read()
crypter = Crypter(data[:32], password)
saved_settings = json.loads(str(Packer.decompress(crypter.decrypt(data[32:])), encoding='utf-8'))
for domain_name in saved_settings['settings'].keys():
data_set = saved_settings['settings'][domain_name]
found = False
i = 0
while i < len(self.settings):
setting = self.settings[i]
if setting.get_domain() == domain_name:
found = True
if datetime.strptime(data_set['mDate'], "%Y-%m-%dT%H:%M:%S") > setting.get_m_date():
setting.load_from_dict(data_set)
setting.set_synced(setting.get_domain() in saved_settings['synced'])
i += 1
if not found:
new_setting = PasswordSetting(domain_name)
new_setting.load_from_dict(data_set)
new_setting.set_synced(new_setting.get_domain() in saved_settings['synced'])
self.settings.append(new_setting)
file.close()
def load_settings_from_file(self, password):
"""
This loads the saved settings. It is a good idea to call this method the minute you have a password.
:param str password:
"""
if os.path.isfile(self.settings_file):
file = open(self.settings_file, 'br')
data = file.read()
crypter = Crypter(data[:32], password)
saved_settings = json.loads(
str(Packer.decompress(crypter.decrypt(data[32:])),
encoding='utf-8'))
for domain_name in saved_settings['settings'].keys():
data_set = saved_settings['settings'][domain_name]
found = False
i = 0
while i < len(self.settings):
setting = self.settings[i]
if setting.get_domain() == domain_name:
found = True
if datetime.strptime(
data_set['mDate'],
"%Y-%m-%dT%H:%M:%S") > setting.get_m_date():
setting.load_from_dict(data_set)
setting.set_synced(setting.get_domain() in
saved_settings['synced'])
i += 1
if not found:
new_setting = PasswordSetting(domain_name)
new_setting.load_from_dict(data_set)
new_setting.set_synced(
new_setting.get_domain() in saved_settings['synced'])
self.settings.append(new_setting)
file.close()
def update_from_sync(self, password):
"""
Call this method to pull settings from the sync server.
:param password: the masterpassword
:type password: str
"""
pull_successful, data = self.sync_manager.pull()
if not pull_successful:
print("Sync failed: No connection to the server.")
return False
if not len(data) > 0:
return False
binary_data = b64decode(data)
data_version = binary_data[:1]
if data_version == b'\x00':
encryption_salt = binary_data[1:33]
encrypted_data = binary_data[33:]
crypter = Crypter(encryption_salt, password)
self.remote_data = json.loads(
str(Packer.decompress(crypter.decrypt(encrypted_data)), encoding='utf-8'))
self.update_remote = False
for domain_name in self.remote_data.keys():
data_set = self.remote_data[domain_name]
found = False
i = 0
while i < len(self.settings):
setting = self.settings[i]
if setting.get_domain() == domain_name:
found = True
if datetime.strptime(data_set['mDate'], "%Y-%m-%dT%H:%M:%S") > setting.get_m_date():
if 'deleted' in data_set and data_set['deleted']:
self.settings.pop(i)
else:
setting.load_from_dict(data_set)
setting.set_synced(True)
self.update_remote = True
i += 1
else:
i += 1
else:
i += 1
if not found:
new_setting = PasswordSetting(domain_name)
new_setting.load_from_dict(data_set)
new_setting.set_synced(True)
self.settings.append(new_setting)
for setting in self.settings:
found = False
for domain_name in self.remote_data.keys():
data_set = self.remote_data[domain_name]
if setting.get_domain() == domain_name:
found = True
if setting.get_m_date() >= datetime.strptime(data_set['mDate'], "%Y-%m-%dT%H:%M:%S"):
self.update_remote = True
if not found:
self.update_remote = True
else:
print("Unknown data format version! Could not update.")
def update_from_export_data(self, password, data):
"""
This takes a base64 encoded string of encrypted settings (a blob) and updates the internal list of settings.
:param str password: the masterpassword
:param str data: base64 encoded data
"""
binary_data = b64decode(data)
data_version = binary_data[:1]
if data_version == b'\x00':
encryption_salt = binary_data[1:33]
encrypted_data = binary_data[:33]
crypter = Crypter(encryption_salt, password)
self.remote_data = json.loads(
str(Packer.decompress(crypter.decrypt(encrypted_data)),
encoding='utf-8'))
update_remote = False
for domain_name in self.remote_data.keys():
data_set = self.remote_data[domain_name]
found = False
i = 0
while i < len(self.settings):
setting = self.settings[i]
if setting.get_domain() == domain_name:
found = True
if datetime.strptime(
data_set['mDate'],
"%Y-%m-%dT%H:%M:%S") > setting.get_m_date():
if 'deleted' in data_set and data_set['deleted']:
self.settings.pop(i)
else:
setting.load_from_dict(data_set)
setting.set_synced(True)
i += 1
else:
i += 1
update_remote = True
else:
i += 1
if not found:
new_setting = PasswordSetting(domain_name)
new_setting.load_from_dict(data_set)
new_setting.set_synced(True)
self.settings.append(new_setting)
for setting in self.settings:
found = False
for domain_name in self.remote_data.keys():
data_set = self.remote_data[domain_name]
if setting.get_domain() == domain_name:
found = True
if setting.get_m_date() >= datetime.strptime(
data_set['mDate'], "%Y-%m-%dT%H:%M:%S"):
update_remote = True
if not found:
update_remote = True
return update_remote
else:
print("Unknown data format version! Could not update.")
return False
def update_from_export_data(self, password, data):
"""
This takes a base64 encoded string of encrypted settings (a blob) and updates the internal list of settings.
:param str password: the masterpassword
:param str data: base64 encoded data
"""
binary_data = b64decode(data)
data_version = binary_data[:1]
if data_version == b'\x00':
encryption_salt = binary_data[1:33]
encrypted_data = binary_data[:33]
crypter = Crypter(encryption_salt, password)
self.remote_data = json.loads(str(Packer.decompress(crypter.decrypt(encrypted_data)), encoding='utf-8'))
update_remote = False
for domain_name in self.remote_data.keys():
data_set = self.remote_data[domain_name]
found = False
i = 0
while i < len(self.settings):
setting = self.settings[i]
if setting.get_domain() == domain_name:
found = True
if datetime.strptime(data_set['mDate'], "%Y-%m-%dT%H:%M:%S") > setting.get_m_date():
if 'deleted' in data_set and data_set['deleted']:
self.settings.pop(i)
else:
setting.load_from_dict(data_set)
setting.set_synced(True)
i += 1
else:
i += 1
update_remote = True
else:
i += 1
if not found:
new_setting = PasswordSetting(domain_name)
new_setting.load_from_dict(data_set)
new_setting.set_synced(True)
self.settings.append(new_setting)
for setting in self.settings:
found = False
for domain_name in self.remote_data.keys():
data_set = self.remote_data[domain_name]
if setting.get_domain() == domain_name:
found = True
if setting.get_m_date() >= datetime.strptime(data_set['mDate'], "%Y-%m-%dT%H:%M:%S"):
update_remote = True
if not found:
update_remote = True
return update_remote
else:
print("Unknown data format version! Could not update.")
return False
def test_save_settings_to_file(self):
self.manager.get_setting('abc.de')
new_setting = PasswordSetting('hugo.com')
new_setting.set_length(12)
self.manager.save_setting(new_setting)
self.manager.save_settings_to_file('xyz')
f = open(os.path.expanduser('~/.ctSESAM_test.pws'), 'br')
crypter = Crypter('xyz')
data = json.loads(Packer.decompress(crypter.decrypt(f.read())).decode('utf8'))
f.close()
self.assertEqual('abc.de', data['settings']['abc.de']['domain'])
self.assertEqual(10, data['settings']['abc.de']['length'])
self.assertEqual('hugo.com', data['settings']['hugo.com']['domain'])
self.assertEqual(12, data['settings']['hugo.com']['length'])
def test_save_settings_to_file(self):
self.manager.get_setting('abc.de')
new_setting = PasswordSetting('hugo.com')
new_setting.set_length(12)
self.manager.set_setting(new_setting)
self.manager.save_settings_to_file('xyz')
with open(os.path.expanduser('~/.ctSESAM_test.pws'), 'br') as f:
data = f.read()
crypter = Crypter(data[:32], 'xyz')
sync_settings_len = struct.unpack('!I', data[32:36])[0]
data = json.loads(Packer.decompress(crypter.decrypt(data[36+sync_settings_len:])).decode('utf8'))
self.assertEqual('abc.de', data['settings']['abc.de']['domain'])
self.assertEqual(10, data['settings']['abc.de']['length'])
self.assertEqual('hugo.com', data['settings']['hugo.com']['domain'])
self.assertEqual(12, data['settings']['hugo.com']['length'])
def test_save_settings_to_file(self):
self.manager.get_setting('abc.de')
new_setting = PasswordSetting('hugo.com')
new_setting.set_length(12)
self.manager.save_setting(new_setting)
self.manager.save_settings_to_file('xyz')
f = open(os.path.expanduser('~/.ctSESAM_test.pws'), 'br')
crypter = Crypter('xyz')
data = json.loads(
Packer.decompress(crypter.decrypt(f.read())).decode('utf8'))
f.close()
self.assertEqual('abc.de', data['settings']['abc.de']['domain'])
self.assertEqual(10, data['settings']['abc.de']['length'])
self.assertEqual('hugo.com', data['settings']['hugo.com']['domain'])
self.assertEqual(12, data['settings']['hugo.com']['length'])
def load_settings_from_file(self,
password,
omit_sync_settings_questions=False):
"""
This loads the saved settings. It is a good idea to call this method the minute you have a password.
:param str password: masterpassword
:param bool omit_sync_settings_questions: do not ask for questions? (Defalut: False)
:type password: str
"""
if os.path.isfile(self.settings_file):
file = open(self.settings_file, 'br')
data = file.read()
crypter = Crypter(data[:32], password)
sync_settings_len = struct.unpack('!I', data[32:36])[0]
if sync_settings_len > 0:
self.sync_manager.load_binary_sync_settings(
crypter.decrypt(data[36:36 + sync_settings_len]))
saved_settings = json.loads(
str(Packer.decompress(
crypter.decrypt(data[36 + sync_settings_len:])),
encoding='utf-8'))
for domain_name in saved_settings['settings'].keys():
data_set = saved_settings['settings'][domain_name]
found = False
i = 0
while i < len(self.settings):
setting = self.settings[i]
if setting.get_domain() == domain_name:
found = True
if datetime.strptime(
data_set['mDate'],
"%Y-%m-%dT%H:%M:%S") > setting.get_m_date():
setting.load_from_dict(data_set)
setting.set_synced(setting.get_domain() in
saved_settings['synced'])
i += 1
if not found:
new_setting = PasswordSetting(domain_name)
new_setting.load_from_dict(data_set)
new_setting.set_synced(
new_setting.get_domain() in saved_settings['synced'])
self.settings.append(new_setting)
file.close()
else:
if not omit_sync_settings_questions:
self.sync_manager.ask_for_sync_settings()
def test_get_export_data(self):
settings = {
'settings': {
'unit.test': {
'domain': 'unit.test',
'length': 11,
'iterations': 5000,
'notes': 'Nice note!',
'salt': 'cGVwcGVy',
'usedCharacters': 'abcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNPQRTUVWXYZ0123456789' +
'#!"§$%&/()[]{}=-_+*<>;:.',
'cDate': '2011-02-12T11:07:31',
'mDate': '2011-02-12T11:07:32'
},
'some.domain': {
'domain': 'some.domain',
'length': 4,
'iterations': 4096,
'salt': 'cGVwcGVy',
'usedCharacters': '6478593021',
'cDate': '2013-06-17T04:03:41',
'mDate': '2014-08-02T10:37:12'
}
},
'synced': []
}
salt = os.urandom(32)
crypter = Crypter(salt, 'xyz')
f = open(os.path.expanduser('~/.ctSESAM_test.pws'), 'bw')
f.write(salt + struct.pack('!I', 0) + crypter.encrypt(
Packer.compress(json.dumps(settings).encode('utf-8'))))
f.close()
self.manager.load_settings_from_file('xyz')
data = b64decode(self.manager.get_export_data('xyz'))
salt = data[1:33]
crypter = Crypter(salt, 'xyz')
self.assertEqual(
settings['settings'],
json.loads(str(Packer.decompress(crypter.decrypt(data[33:])), encoding='utf-8')))
def load_settings_from_file(self, password, omit_sync_settings_questions=False):
"""
This loads the saved settings. It is a good idea to call this method the minute you have a password.
:param str password: masterpassword
:param bool omit_sync_settings_questions: do not ask for questions? (Defalut: False)
:type password: str
"""
if os.path.isfile(self.settings_file):
file = open(self.settings_file, 'br')
data = file.read()
crypter = Crypter(data[:32], password)
sync_settings_len = struct.unpack('!I', data[32:36])[0]
if sync_settings_len > 0:
self.sync_manager.load_binary_sync_settings(crypter.decrypt(data[36:36+sync_settings_len]))
saved_settings = json.loads(str(Packer.decompress(crypter.decrypt(data[36+sync_settings_len:])),
encoding='utf-8'))
for domain_name in saved_settings['settings'].keys():
data_set = saved_settings['settings'][domain_name]
found = False
i = 0
while i < len(self.settings):
setting = self.settings[i]
if setting.get_domain() == domain_name:
found = True
if datetime.strptime(data_set['mDate'], "%Y-%m-%dT%H:%M:%S") > setting.get_m_date():
setting.load_from_dict(data_set)
setting.set_synced(setting.get_domain() in saved_settings['synced'])
i += 1
if not found:
new_setting = PasswordSetting(domain_name)
new_setting.load_from_dict(data_set)
new_setting.set_synced(new_setting.get_domain() in saved_settings['synced'])
self.settings.append(new_setting)
file.close()
else:
if not omit_sync_settings_questions:
self.sync_manager.ask_for_sync_settings()
def load_binary_sync_settings(self, data):
"""
loads sync settings
:param bytes data: packed json data of sync settings
"""
settings_dict = json.loads(str(Packer.decompress(data), encoding='utf-8'))
if "server-address" in settings_dict and \
"username" in settings_dict and \
"password" in settings_dict and \
"certificate" in settings_dict:
self.server_address = settings_dict["server-address"]
self.username = settings_dict["username"]
self.password = settings_dict["password"]
self.certificate = settings_dict["certificate"]
if self.certificate_file:
self.certificate_file.close()
self.certificate_file = NamedTemporaryFile()
self.certificate_file.write(self.certificate.encode('utf-8'))
self.certificate_file.seek(0)
self.create_sync()
else:
print("Sync settings konnten nicht geladen werden.")
def update_from_sync(self, password):
"""
Call this method to pull settings from the sync server.
:param password: the masterpassword
:type password: str
"""
pull_successful, data = self.sync_manager.pull()
if not pull_successful:
print("Sync failed: No connection to the server.")
return False
if not len(data) > 0:
return False
binary_data = b64decode(data)
data_version = binary_data[:1]
if data_version == b'\x00':
encryption_salt = binary_data[1:33]
encrypted_data = binary_data[33:]
crypter = Crypter(encryption_salt, password)
self.remote_data = json.loads(
str(Packer.decompress(crypter.decrypt(encrypted_data)),
encoding='utf-8'))
self.update_remote = False
for domain_name in self.remote_data.keys():
data_set = self.remote_data[domain_name]
found = False
i = 0
while i < len(self.settings):
setting = self.settings[i]
if setting.get_domain() == domain_name:
found = True
if datetime.strptime(
data_set['mDate'],
"%Y-%m-%dT%H:%M:%S") > setting.get_m_date():
if 'deleted' in data_set and data_set['deleted']:
self.settings.pop(i)
else:
setting.load_from_dict(data_set)
setting.set_synced(True)
self.update_remote = True
i += 1
else:
i += 1
else:
i += 1
if not found:
new_setting = PasswordSetting(domain_name)
new_setting.load_from_dict(data_set)
new_setting.set_synced(True)
self.settings.append(new_setting)
for setting in self.settings:
found = False
for domain_name in self.remote_data.keys():
data_set = self.remote_data[domain_name]
if setting.get_domain() == domain_name:
found = True
if setting.get_m_date() >= datetime.strptime(
data_set['mDate'], "%Y-%m-%dT%H:%M:%S"):
self.update_remote = True
if not found:
self.update_remote = True
else:
print("Unknown data format version! Could not update.")
def test_decompress(self):
self.assertEqual(
b'Some packable information',
Packer.decompress(b64decode("AAAAGXjaC87PTVUoSEzOTkzKSVXIzEvLL8pNLMnMzwMAedUJrg==")))
