def test_load_from_json(self):
json_str = "{\"domain\": \"unit.test\", \"username\": \"testilinius\", " +\
"\"notes\": \"interesting note\", \"legacyPassword\": \"rtSr?bS,mi\", " +\
"\"usedCharacters\": \"AEIOUaeiou\", \"iterations\": 5341, " +\
"\"length\": 16, \"salt\": \"ZmFzY2luYXRpbmc=\", " +\
"\"cDate\": \"2001-01-01T02:14:12\", \"mDate\": \"2005-01-01T01:14:12\"}"
s = PasswordSetting(json.loads(json_str)["domain"])
s.load_from_dict(json.loads(json_str))
self.assertEquals("unit.test", s.get_domain())
self.assertEquals("testilinius", s.get_username())
self.assertEquals("interesting note", s.get_notes())
self.assertEquals("rtSr?bS,mi", s.get_legacy_password())
self.assertFalse(s.use_lower_case())
self.assertFalse(s.use_upper_case())
self.assertFalse(s.use_digits())
self.assertFalse(s.use_extra())
self.assertTrue(s.use_custom_character_set())
self.assertEquals("AEIOUaeiou", s.get_character_set())
self.assertEquals(5341, s.get_iterations())
self.assertEquals(16, s.get_length())
expected_salt = "fascinating".encode('utf-8')
self.assertEqual(len(expected_salt), len(s.get_salt()))
for i in range(len(expected_salt)):
self.assertEqual(expected_salt[i], s.get_salt()[i])
self.assertEquals("2001-01-01T02:14:12", s.get_creation_date())
self.assertEquals("2005-01-01T01:14:12", s.get_modification_date())
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 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_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 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.")
