def test_build_key_from_dict(self):
kdict = {
'address': [ADDRESS],
'key_id': KEY_FINGERPRINT[-16:],
'fingerprint': KEY_FINGERPRINT,
'key_data': PUBLIC_KEY,
'private': False,
'length': 4096,
'expiry_date': 0,
'last_audited_at': 0,
'refreshed_at': 1311239602,
'validation': str(ValidationLevels.Weak_Chain),
'encr_used': False,
'sign_used': True,
}
key = build_key_from_dict(OpenPGPKey, kdict)
self.assertEqual(kdict['address'], key.address, 'Wrong data in key.')
self.assertEqual(kdict['key_id'], key.key_id, '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(ValidationLevels.get(kdict['validation']),
key.validation, 'Wrong data in key.')
self.assertEqual(kdict['encr_used'], key.encr_used,
'Wrong data in key.')
self.assertEqual(kdict['sign_used'], key.sign_used,
'Wrong data in key.')
def build_key(doc):
if doc is None:
raise errors.KeyNotFound(address)
leap_assert(address in doc.content[KEY_ADDRESS_KEY],
'Wrong address in key data.')
key = build_key_from_dict(OpenPGPKey, doc.content)
key._gpgbinary = self._gpgbinary
return key
def build_key(doc):
if doc is None:
raise errors.KeyNotFound(address)
leap_assert(
address in doc.content[KEY_ADDRESS_KEY],
'Wrong address in key data.')
key = build_key_from_dict(OpenPGPKey, doc.content)
key._gpgbinary = self._gpgbinary
return key
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(OpenPGPKey, 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.')
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(OpenPGPKey, keydoc.content,
activedoc.content)
key._gpgbinary = self._gpgbinary
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(OpenPGPKey, 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 get_all_keys_in_local_db(self, private=False):
"""
Return all keys stored in local database.
:return: A list with all keys in local db.
:rtype: list
"""
return map(
lambda doc: build_key_from_dict(
self._key_class_from_type(doc.content['type']),
doc.content['address'],
doc.content),
self._soledad.get_from_index(
TAGS_PRIVATE_INDEX,
KEYMANAGER_KEY_TAG,
'1' if private else '0'))
def get_key(self, address, private=False):
"""
Get key bound to C{address} from local storage.
:param address: The address bound to the key.
:type address: str
:param private: Look for a private key instead of a public one?
:type private: bool
:return: The key bound to C{address}.
:rtype: OpenPGPKey
@raise KeyNotFound: If the key was not found on local storage.
"""
leap_assert(is_address(address), 'Not an user address: %s' % address)
doc = self._get_key_doc(address, private)
if doc is None:
raise errors.KeyNotFound(address)
return build_key_from_dict(OpenPGPKey, address, doc.content)
def test_build_key_from_dict(self):
kdict = {
'address': ADDRESS,
'key_id': 'key_id',
'fingerprint': 'fingerprint',
'key_data': 'key_data',
'private': 'private',
'length': 'length',
'expiry_date': 'expiry_date',
'first_seen_at': 'first_seen_at',
'last_audited_at': 'last_audited_at',
'validation': 'validation',
}
key = build_key_from_dict(OpenPGPKey, ADDRESS, kdict)
self.assertEqual(
kdict['address'], key.address,
'Wrong data in key.')
self.assertEqual(
kdict['key_id'], key.key_id,
'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(
kdict['expiry_date'], key.expiry_date,
'Wrong data in key.')
self.assertEqual(
kdict['first_seen_at'], key.first_seen_at,
'Wrong data in key.')
self.assertEqual(
kdict['last_audited_at'], key.last_audited_at,
'Wrong data in key.')
self.assertEqual(
kdict['validation'], key.validation,
'Wrong data in key.')
def get_key(self, address, private=False):
"""
Get key bound to C{address} from local storage.
:param address: The address bound to the key.
:type address: str
:param private: Look for a private key instead of a public one?
:type private: bool
:return: The key bound to C{address}.
:rtype: OpenPGPKey
@raise KeyNotFound: If the key was not found on local storage.
"""
# Remove the identity suffix after the '+' until the '@'
# e.g.: [email protected] becomes [email protected]
# since the key belongs to the identity without the '+' suffix.
address = re.sub(r'\+.*\@', '@', address)
doc = self._get_key_doc(address, private)
if doc is None:
raise errors.KeyNotFound(address)
return build_key_from_dict(OpenPGPKey, address, doc.content)
def check_and_put(docs, key):
if len(docs) == 1:
doc = docs.pop()
oldkey = build_key_from_dict(OpenPGPKey, doc.content)
if key.fingerprint == oldkey.fingerprint:
# in case of an update of the key merge them with gnupg
with self._temporary_gpgwrapper() as gpg:
gpg.import_keys(oldkey.key_data)
gpg.import_keys(key.key_data)
gpgkey = gpg.list_keys(secret=key.private).pop()
mergedkey = self._build_key_from_gpg(
gpgkey,
gpg.export_keys(gpgkey['fingerprint'],
secret=key.private))
mergedkey.validation = max(
[key.validation, oldkey.validation])
mergedkey.last_audited_at = oldkey.last_audited_at
mergedkey.refreshed_at = key.refreshed_at
mergedkey.encr_used = key.encr_used or oldkey.encr_used
mergedkey.sign_used = key.sign_used or oldkey.sign_used
doc.set_json(mergedkey.get_json())
d = self._soledad.put_doc(doc)
else:
logger.critical(
"Can't put a key whith the same key_id and different "
"fingerprint: %s, %s"
% (key.fingerprint, oldkey.fingerprint))
d = defer.fail(
errors.KeyFingerprintMismatch(key.fingerprint))
elif len(docs) > 1:
logger.critical(
"There is more than one key with the same key_id %s"
% (key.key_id,))
d = defer.fail(errors.KeyAttributesDiffer(key.key_id))
else:
d = self._soledad.create_doc_from_json(key.get_json())
return d
def check_and_put(docs, key):
if len(docs) == 1:
doc = docs.pop()
oldkey = build_key_from_dict(OpenPGPKey, doc.content)
if key.fingerprint == oldkey.fingerprint:
# in case of an update of the key merge them with gnupg
with self._temporary_gpgwrapper() as gpg:
gpg.import_keys(oldkey.key_data)
gpg.import_keys(key.key_data)
gpgkey = gpg.list_keys(secret=key.private).pop()
mergedkey = self._build_key_from_gpg(
gpgkey,
gpg.export_keys(gpgkey['fingerprint'],
secret=key.private))
mergedkey.validation = max(
[key.validation, oldkey.validation])
mergedkey.last_audited_at = oldkey.last_audited_at
mergedkey.refreshed_at = key.refreshed_at
mergedkey.encr_used = key.encr_used or oldkey.encr_used
mergedkey.sign_used = key.sign_used or oldkey.sign_used
doc.set_json(mergedkey.get_json())
d = self._soledad.put_doc(doc)
else:
logger.critical(
"Can't put a key whith the same key_id and different "
"fingerprint: %s, %s" %
(key.fingerprint, oldkey.fingerprint))
d = defer.fail(
errors.KeyFingerprintMismatch(key.fingerprint))
elif len(docs) > 1:
logger.critical(
"There is more than one key with the same key_id %s" %
(key.key_id, ))
d = defer.fail(errors.KeyAttributesDiffer(key.key_id))
else:
d = self._soledad.create_doc_from_json(key.get_json())
return d
def build_keys(docs):
return map(
lambda doc: build_key_from_dict(
self._key_class_from_type(doc.content['type']),
doc.content),
docs)
def build_keys(docs):
return map(
lambda doc: build_key_from_dict(
self._key_class_from_type(doc.content['type']), doc.content
), docs)
