def test_get_export_data(self):
settings = {
'settings': {
'unit.test': {
'domain': 'unit.test',
'extras': '#!"§$%&/()[]{}=-_+*<>;:.',
'passwordTemplate': 'xnxoaAxxxx',
'iterations': 5000,
'notes': 'Nice note!',
'salt': 'cGVwcGVy',
'cDate': '2011-02-12T11:07:31',
'mDate': '2011-02-12T11:07:32'
},
'some.domain': {
'domain': 'some.domain',
'extras': '6478593021',
'passwordTemplate': 'xnxoaA',
'iterations': 4096,
'salt': 'cGVwcGVy',
'cDate': '2013-06-17T04:03:41',
'mDate': '2014-08-02T10:37:12'
}
},
'synced': []
}
salt = os.urandom(32)
kgk_manager = KgkManager()
kgk_manager.set_preference_manager(self.preference_manager)
kgk_manager.create_new_kgk()
kgk_block = kgk_manager.create_and_save_new_kgk_block(
Crypter(Crypter.createIvKey(b'xyz', salt, iterations=3)))
crypter = PasswordSettingsManager.get_settings_crypter(kgk_manager)
f = open(os.path.expanduser('~/.ctSESAM_test.pws'), 'bw')
f.write(salt + kgk_block + crypter.encrypt(
struct.pack('!I', 0) +
Packer.compress(json.dumps(settings).encode('utf-8'))))
f.close()
self.preference_manager.read_file()
self.manager.load_local_settings(kgk_manager)
data = b64decode(self.manager.get_export_data(kgk_manager))
self.assertEqual(b'\x01', data[:1])
salt = data[1:33]
kgk_crypter = Crypter(Crypter.createIvKey(b'xyz', salt, iterations=3))
kgk_manager2 = KgkManager()
kgk_manager2.set_preference_manager(self.preference_manager)
kgk_manager2.decrypt_kgk(data[33:145], kgk_crypter)
settings_crypter = PasswordSettingsManager.get_settings_crypter(
kgk_manager2)
self.assertEqual(
settings['settings'],
json.loads(
str(Packer.decompress(settings_crypter.decrypt(data[145:])),
encoding='utf-8')))
def sync_clicked(self):
self.masterpassword_entered()
if not self.settings_manager.sync_manager.has_settings():
self.show_sync_settings()
else:
pull_successful, data = self.settings_manager.sync_manager.pull()
if pull_successful and len(data) > 0:
remote_kgk_manager = KgkManager()
remote_kgk_manager.update_from_blob(self.master_password_edit.text().encode('utf-8'), b64decode(data))
if len(self.preference_manager.get_kgk_block()) == 112 and \
remote_kgk_manager.has_kgk() and self.kgk_manager.has_kgk() and \
self.kgk_manager.get_kgk() != remote_kgk_manager.get_kgk():
if len(self.settings_manager.get_domain_list()) > 0:
print("Lokal und auf dem Server gibt es unterschiedliche KGKs. Das ist ein Problem!")
self.migrate_local_domains(remote_kgk_manager)
else:
if len(self.preference_manager.get_kgk_block()) != 112:
self.kgk_manager = remote_kgk_manager
self.kgk_manager.set_preference_manager(self.preference_manager)
self.kgk_manager.store_local_kgk_block()
self.settings_manager.update_from_export_data(remote_kgk_manager, b64decode(data))
self.domain_edit.blockSignals(True)
current_domain = self.domain_edit.lineEdit().text()
for i in reversed(range(self.domain_edit.count())):
self.domain_edit.removeItem(i)
self.domain_edit.insertItems(0, self.settings_manager.get_domain_list())
self.domain_edit.blockSignals(False)
self.domain_edit.setEditText(current_domain)
self.settings_manager.store_settings(self.kgk_manager)
def test_store_local_settings(self):
abc_setting = self.manager.get_setting('abc.de')
abc_setting.set_template('xAxonaxxxx')
self.manager.set_setting(abc_setting)
new_setting = PasswordSetting('hugo.com')
new_setting.set_template('xonxAxxaxxxx')
self.manager.set_setting(new_setting)
kgk_manager = KgkManager()
kgk_manager.set_preference_manager(self.preference_manager)
kgk_manager.create_new_kgk()
salt = os.urandom(32)
kgk_manager.create_and_save_new_kgk_block(
Crypter(Crypter.createIvKey(b'xyz', salt, iterations=3)))
self.manager.store_local_settings(kgk_manager)
with open(os.path.expanduser('~/.ctSESAM_test.pws'), 'br') as f:
data = f.read()
settings_crypter = PasswordSettingsManager.get_settings_crypter(
kgk_manager)
decrypted_settings = settings_crypter.decrypt(data[144:])
sync_settings_len = struct.unpack('!I', decrypted_settings[:4])[0]
data = json.loads(
Packer.decompress(
decrypted_settings[4 + sync_settings_len:]).decode('utf8'))
self.assertEqual('abc.de', data['settings']['abc.de']['domain'])
self.assertEqual('xAxonaxxxx',
data['settings']['abc.de']['passwordTemplate'])
self.assertEqual('hugo.com', data['settings']['hugo.com']['domain'])
self.assertEqual('xonxAxxaxxxx',
data['settings']['hugo.com']['passwordTemplate'])
def test_fresh_salt2(self):
kgkm = KgkManager()
kgkm.salt2 = b"\x3A" * 32
self.assertEqual(b"\x3A" * 32, kgkm.get_salt2())
kgkm.fresh_salt2()
self.assertNotEqual(b"\x3A" * 32, kgkm.get_salt2())
self.assertEqual(32, len(kgkm.get_salt2()))
def test_fresh_iv2(self):
kgkm = KgkManager()
kgkm.iv2 = b"\x02" * 16
self.assertEqual(b"\x02" * 16, kgkm.get_iv2())
kgkm.fresh_iv2()
self.assertNotEqual(b"\x02" * 16, kgkm.get_iv2())
self.assertEqual(16, len(kgkm.get_iv2()))
def load_settings(self, kgk_manager, password, no_sync=False):
"""
Loads settings from local file and from a sync server if possible.
:param kgk_manager: kgk manager
:type kgk_manager: KgkManager
:param password: the masterpassword
:type password: str
:param no_sync: skip the sync update?
:type no_sync: bool
"""
self.load_local_settings(kgk_manager)
if not no_sync:
if self.sync_manager.has_settings():
pull_successful, data = self.sync_manager.pull()
if pull_successful and len(data) > 0:
remote_kgk_manager = KgkManager()
remote_kgk_manager.update_from_blob(
password.encode('utf-8'), b64decode(data))
if remote_kgk_manager.has_kgk() and kgk_manager.get_kgk(
) != remote_kgk_manager.get_kgk():
raise ValueError(
"KGK mismatch! This are not your settings!")
self.update_from_export_data(remote_kgk_manager,
b64decode(data))
else:
print("Sync failed: No connection to the server.")
def test_get_kgk_has_kgk(self):
kgkm = KgkManager()
self.assertEqual(b'', kgkm.get_kgk())
self.assertFalse(kgkm.has_kgk())
kgkm.kgk = b"\xE4" * 64
kgkm.kgk_crypter = Crypter(
Crypter.createIvKey(b'1234', b'pepper', iterations=3))
self.assertEqual(b"\xE4" * 64, kgkm.get_kgk())
self.assertTrue(kgkm.has_kgk())
def decrypt_remote_settings(kgk_mng, settings_mng):
remote_kgk_manager = KgkManager()
remote_kgk_manager.update_from_blob(master_password.encode('utf-8'), b64decode(data))
if kgk_exists and remote_kgk_manager.has_kgk() and kgk_mng.has_kgk() and \
kgk_mng.get_kgk() != remote_kgk_manager.get_kgk():
print("Lokal und auf dem Server gibt es unterschiedliche KGKs. Das ist ein Problem!")
else:
if not kgk_exists:
kgk_mng = remote_kgk_manager
kgk_mng.set_preference_manager(preference_manager)
kgk_mng.store_local_kgk_block()
settings_mng.update_from_export_data(remote_kgk_manager, b64decode(data))
print("Verbindung erfolgreich getestet.")
def test_load_settings_from_file(self):
settings = {
'settings': {
'unit.test': {
'domain': 'unit.test',
'passwordTemplate': 'xxxxxxxxxxo',
'extras': '#OWspx6;3gov0/1',
'iterations': 5000,
'notes': 'Nice note!',
'cDate': '2011-02-12T11:07:31',
'mDate': '2011-02-12T11:07:32'
},
'some.domain': {
'domain': 'some.domain',
'passwordTemplate': 'oxxx',
'extras': '6478593021',
'cDate': '2013-06-17T04:03:41',
'mDate': '2014-08-02T10:37:12'
}
},
'synced': []
}
salt = os.urandom(32)
data = json.dumps(settings).encode('utf-8')
kgk_manager = KgkManager()
kgk_manager.set_preference_manager(self.preference_manager)
kgk_manager.create_new_kgk()
kgk_block = kgk_manager.create_and_save_new_kgk_block(
Crypter(Crypter.createIvKey(b'xyz', salt, iterations=3)))
crypter = PasswordSettingsManager.get_settings_crypter(kgk_manager)
f = open(os.path.expanduser('~/.ctSESAM_test.pws'), 'bw')
f.write(salt + kgk_block +
crypter.encrypt(struct.pack('!I', 0) + Packer.compress(data)))
f.close()
self.preference_manager.read_file()
self.manager.load_local_settings(kgk_manager)
self.assertIn('unit.test', self.manager.get_domain_list())
self.assertIn('some.domain', self.manager.get_domain_list())
self.assertEqual('xxxxxxxxxxo',
self.manager.get_setting('unit.test').get_template())
self.assertEqual(
5000,
self.manager.get_setting('unit.test').get_iterations())
self.assertEqual('Nice note!',
self.manager.get_setting('unit.test').get_notes())
self.assertEqual(
'oxxx',
self.manager.get_setting('some.domain').get_template())
self.assertEqual(
'6478593021',
self.manager.get_setting('some.domain').get_character_set())
def test_get_domain_list(self):
settings = {
'settings': {
'unit.test': {
'domain': 'unit.test',
'extras': '#!"§$%&/()[]{}=-_+*<>;:.',
'passwordTemplate': 'xxxaoxxAxxn',
'iterations': 5000,
'notes': 'Nice note!',
'salt': 'cGVwcGVy',
'cDate': '2011-02-12T11:07:31',
'mDate': '2011-02-12T11:07:32'
},
'some.domain': {
'domain': 'some.domain',
'extras': '#!"§$%&/()[]{}=-_+*<>;:.',
'passwordTemplate': 'xxxo',
'iterations': 4096,
'salt': 'cGVwcGVy',
'cDate': '2013-06-17T04:03:41',
'mDate': '2014-08-02T10:37:12'
}
},
'synced': []
}
salt = os.urandom(32)
f = open(os.path.expanduser('~/.ctSESAM_test.pws'), 'bw')
data = json.dumps(settings).encode('utf-8')
kgk_manager = KgkManager()
kgk_manager.set_preference_manager(self.preference_manager)
kgk_manager.create_new_kgk()
kgk_block = kgk_manager.create_and_save_new_kgk_block(
Crypter(Crypter.createIvKey(b'xyz', salt, iterations=3)))
crypter = PasswordSettingsManager.get_settings_crypter(kgk_manager)
f.write(salt + kgk_block +
crypter.encrypt(struct.pack('!I', 0) + Packer.compress(data)))
f.close()
self.preference_manager.read_file()
self.manager.load_local_settings(kgk_manager)
self.assertIn('settings', self.manager.get_settings_as_dict())
self.assertIn('unit.test',
self.manager.get_settings_as_dict()['settings'])
self.assertEqual(
settings['settings']['unit.test'],
self.manager.get_settings_as_dict()['settings']['unit.test'])
self.assertIn('some.domain',
self.manager.get_settings_as_dict()['settings'])
self.assertEqual(
settings['settings']['some.domain'],
self.manager.get_settings_as_dict()['settings']['some.domain'])
self.assertEqual(settings, self.manager.get_settings_as_dict())
def __init__(self):
super(MainWindow, self).__init__()
self.nam = QNetworkAccessManager()
self.setWindowIcon(QIcon(os.path.join('icons', 'Logo_rendered_edited.png')))
layout = QBoxLayout(QBoxLayout.TopToBottom)
layout.setContentsMargins(0, 0, 0, 0)
self.preference_manager = PreferenceManager()
self.kgk_manager = KgkManager()
self.kgk_manager.set_preference_manager(self.preference_manager)
self.settings_manager = PasswordSettingsManager(self.preference_manager)
self.setting_dirty = True
# Header bar
header_bar = QFrame()
header_bar.setStyleSheet(
"QWidget { background: rgb(40, 40, 40); } " +
"QToolButton { background: rgb(40, 40, 40); }" +
"QToolTip { color: rgb(255, 255, 255); background-color: rgb(20, 20, 20); " +
"border: 1px solid white; }")
header_bar.setAutoFillBackground(True)
header_bar.setFixedHeight(45)
header_bar_layout = QBoxLayout(QBoxLayout.LeftToRight)
header_bar_layout.addStretch()
header_bar.setLayout(header_bar_layout)
layout.addWidget(header_bar)
self.create_header_bar(header_bar_layout)
# Widget area
main_area = QFrame()
main_layout = QBoxLayout(QBoxLayout.TopToBottom)
main_area.setLayout(main_layout)
layout.addWidget(main_area)
self.create_main_area(main_layout)
# Window layout
layout.addStretch()
main_layout.addStretch()
self.setLayout(layout)
settings = QSettings()
size = settings.value("MainWindow/size")
if not size:
size = QSize(350, 450)
self.resize(size)
position = settings.value("MainWindow/pos")
if not position:
position = QPoint(0, 24)
self.move(position)
self.setWindowTitle("c't SESAM")
self.master_password_edit.setFocus()
self.show()
def test_str(self):
kgkm = KgkManager()
self.assertEqual("<KGK: , salt: >", str(kgkm))
kgkm.salt2 = b"\x01" * 32
kgkm.iv2 = b"\x02" * 16
self.assertEqual(
"<KGK: , salt: , iv2: 02020202020202020202020202020202, " +
"salt2: 0101010101010101010101010101010101010101010101010101010101010101>",
str(kgkm))
kgkm.salt = b"\x03" * 32
kgkm.kgk = b"\x04" * 64
self.assertEqual(
"<KGK: 04040404040404040404040404040404040404040404040404040404040404040404040404040404040"
+ "404040404040404040404040404040404040404040404, " +
"salt: 0303030303030303030303030303030303030303030303030303030303030303, "
+ "iv2: 02020202020202020202020202020202, " +
"salt2: 0101010101010101010101010101010101010101010101010101010101010101>",
str(kgkm))
def test_update_from_sync(self):
settings = {
'settings': {
'unit.test': {
'domain':
'unit.test',
'passwordTemplate':
'xxaAnoxxxxx',
'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',
'passwordTemplate': 'oanA',
'iterations': 4096,
'salt': 'cGVwcGVy',
'usedCharacters': '6478593021',
'cDate': '2013-06-17T04:03:41',
'mDate': '2014-08-02T10:37:12'
}
},
'synced': []
}
salt = os.urandom(32)
kgk_manager = KgkManager()
kgk_manager.set_preference_manager(self.preference_manager)
kgk_manager.create_new_kgk()
kgk_block = kgk_manager.create_and_save_new_kgk_block(
Crypter(Crypter.createIvKey('xyz'.encode('utf-8'), salt)))
crypter = PasswordSettingsManager.get_settings_crypter(kgk_manager)
f = open(os.path.expanduser('~/.ctSESAM_test.pws'), 'bw')
f.write(salt + kgk_block + crypter.encrypt(
struct.pack('!I', 0) +
Packer.compress(json.dumps(settings).encode('utf-8'))))
f.close()
self.preference_manager.read_file()
self.manager.sync_manager = MockSyncManager(kgk_manager.get_kgk())
self.manager.load_settings(kgk_manager, 'xyz')
self.assertIn('unit.test', self.manager.get_domain_list())
self.assertIn('some.domain', self.manager.get_domain_list())
self.assertIn('third.domain', self.manager.get_domain_list())
self.assertEqual(
5001,
self.manager.get_setting('unit.test').get_iterations())
self.assertEqual(
4096,
self.manager.get_setting('some.domain').get_iterations())
self.assertEqual(
4098,
self.manager.get_setting('third.domain').get_iterations())
file = os.path.expanduser('~/.ctSESAM_test_extra.pws')
if os.path.isfile(file):
try:
import win32con
import win32api
win32api.SetFileAttributes(file,
win32con.FILE_ATTRIBUTE_NORMAL)
except ImportError:
pass
os.remove(file)
def test_get_salt2(self):
kgkm = KgkManager()
kgkm.salt2 = b"\x3A" * 32
self.assertEqual(b"\x3A" * 32, kgkm.get_salt2())
def __init__(self, kgk):
self.kgk_manager = KgkManager()
self.kgk_manager.set_preference_manager(
PreferenceManager(os.path.expanduser('~/.ctSESAM_test_extra.pws')))
self.kgk_manager.kgk = kgk
help="If not specified it will be prompted.")
parser.add_argument('-d',
'--domain',
help="If not specified it will be prompted.")
parser.add_argument(
'-q',
'--quiet',
action='store_const',
const=True,
help="Display only prompts (if necessary) and the plain password")
args = parser.parse_args()
if args.master_password:
master_password = args.master_password
else:
master_password = getpass.getpass(prompt='Masterpasswort: ')
kgk_manager = KgkManager()
settings_manager, preference_manager = create_settings_manager(kgk_manager)
try:
settings_manager.load_settings(kgk_manager, master_password,
args.no_sync)
if not args.no_sync and (
args.update_sync_settings
or not settings_manager.sync_manager.has_settings()):
settings_manager.sync_manager.ask_for_sync_settings()
print("Teste die Verbindung...")
pull_successful, data = settings_manager.sync_manager.pull()
if pull_successful and len(data) > 0:
kgk_manager, settings_manager = decrypt_remote_settings(
kgk_manager, settings_manager)
else:
print("Es konnte keine Verbindung aufgebaut werden.")
def test_get_iv2(self):
kgkm = KgkManager()
kgkm.iv2 = b"\x02" * 16
self.assertEqual(b"\x02" * 16, kgkm.get_iv2())
