def build_key((keydoc, activedoc)):
if keydoc is None:
raise errors.KeyNotFound(address)
leap_assert(
address in keydoc.content[KEY_UIDS_KEY],
'Wrong address in key %s. Expected %s, found %s.' %
(keydoc.content[KEY_FINGERPRINT_KEY], address,
keydoc.content[KEY_UIDS_KEY]))
key = build_key_from_dict(keydoc.content, activedoc.content)
key._gpgbinary = self._gpgbinary
return key
def get_all_keys(self, private=False):
"""
Return all keys stored in local database.
:param private: Include private keys
:type private: bool
:return: A Deferred which fires with a list of all keys in local db.
:rtype: Deferred
"""
HAS_ACTIVE = "has_active"
active_docs = yield self._soledad.get_from_index(
TAGS_PRIVATE_INDEX, KEYMANAGER_ACTIVE_TAG, '1' if private else '0')
key_docs = yield self._soledad.get_from_index(TAGS_PRIVATE_INDEX,
KEYMANAGER_KEY_TAG,
'1' if private else '0')
keys = []
fp = lambda doc: doc.content[KEY_FINGERPRINT_KEY]
for active in active_docs:
fp_keys = filter(lambda k: fp(k) == fp(active), key_docs)
if len(fp_keys) == 0:
yield self._soledad.delete_doc(active)
continue
elif len(fp_keys) == 1:
key = fp_keys[0]
else:
key = yield self._repair_key_docs(fp_keys)
key.content[HAS_ACTIVE] = True
keys.append(
build_key_from_dict(key.content,
active.content,
gpgbinary=self._gpgbinary))
unactive_keys = filter(lambda k: HAS_ACTIVE not in k.content, key_docs)
keys += map(
lambda k: build_key_from_dict(k.content, gpgbinary=self._gpgbinary
), unactive_keys)
defer.returnValue(keys)
def _get_key(address, key_fingerprint, key_data, private):
kdict = {
'uids': [address],
'fingerprint': key_fingerprint,
'key_data': key_data,
'private': private,
'length': 4096,
'expiry_date': 0,
'refreshed_at': 1311239602,
}
key = build_key_from_dict(kdict)
return key
def merge_and_put((keydoc, activedoc)):
if not keydoc:
return put_new_key(activedoc)
active_content = None
if activedoc:
active_content = activedoc.content
oldkey = build_key_from_dict(keydoc.content, active_content)
key.merge(oldkey)
keydoc.set_json(key.get_json())
d = self._soledad.put_doc(keydoc)
d.addCallback(put_active, activedoc)
return d
def test_build_key_from_dict(self):
kdict = {
'uids': [ADDRESS],
'fingerprint': KEY_FINGERPRINT,
'key_data': PUBLIC_KEY,
'private': False,
'length': 4096,
'expiry_date': 0,
'refreshed_at': 1311239602,
}
adict = {
'address': ADDRESS,
'private': False,
'last_audited_at': 0,
'validation': str(ValidationLevels.Weak_Chain),
'encr_used': False,
'sign_used': True,
}
key = build_key_from_dict(kdict, adict)
self.assertEqual(kdict['uids'], key.uids, 'Wrong data in key.')
self.assertEqual(kdict['fingerprint'], key.fingerprint,
'Wrong data in key.')
self.assertEqual(kdict['key_data'], key.key_data, 'Wrong data in key.')
self.assertEqual(kdict['private'], key.private, 'Wrong data in key.')
self.assertEqual(kdict['length'], key.length, 'Wrong data in key.')
self.assertEqual(None, key.expiry_date, 'Wrong data in key.')
self.assertEqual(None, key.last_audited_at, 'Wrong data in key.')
self.assertEqual(datetime.fromtimestamp(kdict['refreshed_at']),
key.refreshed_at, 'Wrong data in key.')
self.assertEqual(adict['address'], key.address, 'Wrong data in key.')
self.assertEqual(ValidationLevels.get(adict['validation']),
key.validation, 'Wrong data in key.')
self.assertEqual(adict['encr_used'], key.encr_used,
'Wrong data in key.')
self.assertEqual(adict['sign_used'], key.sign_used,
'Wrong data in key.')
