Mirrors
/
synapse-old
mirror of https://github.com/matrix-org/synapse.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

make black happy

This commit is contained in:
Hubert Chathi 2019-07-22 12:52:39 -04:00
parent ac4746ac4b
commit 7d6c70fc7a
4 changed files with 141 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
synapse/handlers/e2e_keys.py
View File

@ -635,14 +635,12 @@ class E2eKeysHandler(object):
self_device_ids = list(self_signatures.keys()) self_device_ids = list(self_signatures.keys())
try: try:
# get our self-signing key to verify the signatures # get our self-signing key to verify the signatures
self_signing_key, self_signing_key_id, self_signing_verify_key \ self_signing_key, self_signing_key_id, self_signing_verify_key = yield self._get_e2e_cross_signing_verify_key(
= yield self._get_e2e_cross_signing_verify_key(
user_id, "self_signing" user_id, "self_signing"
) )
# get our master key, since it may be signed # get our master key, since it may be signed
master_key, master_key_id, master_verify_key \ master_key, master_key_id, master_verify_key = yield self._get_e2e_cross_signing_verify_key(
= yield self._get_e2e_cross_signing_verify_key(
user_id, "master" user_id, "master"
) )
@ -652,15 +650,15 @@ class E2eKeysHandler(object):
devices = yield self.store.get_e2e_device_keys([(user_id, None)]) devices = yield self.store.get_e2e_device_keys([(user_id, None)])
if user_id not in devices: if user_id not in devices:
raise SynapseError( raise SynapseError(404, "No device keys found", Codes.NOT_FOUND)
404, "No device keys found", Codes.NOT_FOUND
)
devices = devices[user_id] devices = devices[user_id]
for device_id, device in self_signatures.items(): for device_id, device in self_signatures.items():
try: try:
if ("signatures" not in device or if (
user_id not in device["signatures"]): "signatures" not in device
or user_id not in device["signatures"]
):
# no signature was sent # no signature was sent
raise SynapseError( raise SynapseError(
400, "Invalid signature", Codes.INVALID_SIGNATURE 400, "Invalid signature", Codes.INVALID_SIGNATURE
@ -678,15 +676,21 @@ class E2eKeysHandler(object):
# signature list. (In practice, we're likely to # signature list. (In practice, we're likely to
# only have only one signature anyways.) # only have only one signature anyways.)
master_key_signature_list = [] master_key_signature_list = []
for signing_key_id, signature in device["signatures"][user_id].items(): for signing_key_id, signature in device["signatures"][
user_id
].items():
alg, signing_device_id = signing_key_id.split(":", 1) alg, signing_device_id = signing_key_id.split(":", 1)
if (signing_device_id not in devices or if (
signing_key_id not in signing_device_id not in devices
devices[signing_device_id]["keys"]["keys"]): or signing_key_id
not in devices[signing_device_id]["keys"]["keys"]
):
# signed by an unknown device, or the # signed by an unknown device, or the
# device does not have the key # device does not have the key
raise SynapseError( raise SynapseError(
400, "Invalid signature", Codes.INVALID_SIGNATURE 400,
"Invalid signature",
Codes.INVALID_SIGNATURE,
) )
sigs = device["signatures"] sigs = device["signatures"]
@ -697,12 +701,12 @@ class E2eKeysHandler(object):
master_key.pop("unsigned", None) master_key.pop("unsigned", None)
if master_key != device: if master_key != device:
raise SynapseError( raise SynapseError(400, "Key does not match")
400, "Key does not match"
)
# get the key and check the signature # get the key and check the signature
pubkey = devices[signing_device_id]["keys"]["keys"][signing_key_id] pubkey = devices[signing_device_id]["keys"]["keys"][
signing_key_id
]
verify_key = decode_verify_key_bytes( verify_key = decode_verify_key_bytes(
signing_key_id, decode_base64(pubkey) signing_key_id, decode_base64(pubkey)
) )
@ -711,7 +715,9 @@ class E2eKeysHandler(object):
verify_signed_json(device, user_id, verify_key) verify_signed_json(device, user_id, verify_key)
except SignatureVerifyException: except SignatureVerifyException:
raise SynapseError( raise SynapseError(
400, "Invalid signature", Codes.INVALID_SIGNATURE 400,
"Invalid signature",
Codes.INVALID_SIGNATURE,
) )
master_key_signature_list.append( master_key_signature_list.append(
@ -733,11 +739,10 @@ class E2eKeysHandler(object):
try: try:
stored_device = devices[device_id]["keys"] stored_device = devices[device_id]["keys"]
except KeyError: except KeyError:
raise SynapseError( raise SynapseError(404, "Unknown device", Codes.NOT_FOUND)
404, "Unknown device", Codes.NOT_FOUND if self_signing_key_id in stored_device.get(
) "signatures", {}
if self_signing_key_id in stored_device.get("signatures", {}) \ ).get(user_id, {}):
.get(user_id, {}):
# we already have a signature on this device, so we # we already have a signature on this device, so we
# can skip it, since it should be exactly the same # can skip it, since it should be exactly the same
continue continue
@ -751,8 +756,9 @@ class E2eKeysHandler(object):
(self_signing_key_id, user_id, device_id, signature) (self_signing_key_id, user_id, device_id, signature)
) )
except SynapseError as e: except SynapseError as e:
failures.setdefault(user_id, {})[device_id] \ failures.setdefault(user_id, {})[
= _exception_to_failure(e) device_id
] = _exception_to_failure(e)
except SynapseError as e: except SynapseError as e:
failures[user_id] = { failures[user_id] = {
device: _exception_to_failure(e) device: _exception_to_failure(e)
@ -766,8 +772,7 @@ class E2eKeysHandler(object):
try: try:
# get our user-signing key to verify the signatures # get our user-signing key to verify the signatures
user_signing_key, user_signing_key_id, user_signing_verify_key \ user_signing_key, user_signing_key_id, user_signing_verify_key = yield self._get_e2e_cross_signing_verify_key(
= yield self._get_e2e_cross_signing_verify_key(
user_id, "user_signing" user_id, "user_signing"
) )
@ -776,8 +781,7 @@ class E2eKeysHandler(object):
try: try:
# get the user's master key, to make sure it matches # get the user's master key, to make sure it matches
# what was sent # what was sent
stored_key, stored_key_id, _ \ stored_key, stored_key_id, _ = yield self._get_e2e_cross_signing_verify_key(
= yield self._get_e2e_cross_signing_verify_key(
user, "master", user_id user, "master", user_id
) )
@ -790,26 +794,25 @@ class E2eKeysHandler(object):
device_id = None device_id = None
logger.error( logger.error(
"upload signature: wrong device: %s vs %s", "upload signature: wrong device: %s vs %s",
device, devicemap device,
) devicemap,
raise SynapseError(
404, "Unknown device", Codes.NOT_FOUND
) )
raise SynapseError(404, "Unknown device", Codes.NOT_FOUND)
key = devicemap[device_id] key = devicemap[device_id]
del devicemap[device_id] del devicemap[device_id]
if len(devicemap) > 0: if len(devicemap) > 0:
# other devices were signed -- mark those as failures # other devices were signed -- mark those as failures
logger.error("upload signature: too many devices specified") logger.error("upload signature: too many devices specified")
failure = _exception_to_failure(SynapseError( failure = _exception_to_failure(
404, "Unknown device", Codes.NOT_FOUND SynapseError(404, "Unknown device", Codes.NOT_FOUND)
)) )
failures[user] = { failures[user] = {
device: failure device: failure for device in devicemap.keys()
for device in devicemap.keys()
} }
if user_signing_key_id in stored_key.get("signatures", {}) \ if user_signing_key_id in stored_key.get("signatures", {}).get(
.get(user_id, {}): user_id, {}
):
# we already have the signature, so we can skip it # we already have the signature, so we can skip it
continue continue
@ -826,8 +829,7 @@ class E2eKeysHandler(object):
failure = _exception_to_failure(e) failure = _exception_to_failure(e)
if device_id is None: if device_id is None:
failures[user] = { failures[user] = {
device_id: failure device_id: failure for device_id in devicemap.keys()
for device_id in devicemap.keys()
} }
else: else:
failures.setdefault(user, {})[device_id] = failure failures.setdefault(user, {})[device_id] = failure
@ -835,8 +837,7 @@ class E2eKeysHandler(object):
failure = _exception_to_failure(e) failure = _exception_to_failure(e)
for user, devicemap in signature.items(): for user, devicemap in signature.items():
failures[user] = { failures[user] = {
device_id: failure device_id: failure for device_id in devicemap.keys()
for device_id in devicemap.keys()
} }
# store the signature, and send the appropriate notifications for sync # store the signature, and send the appropriate notifications for sync
@ -846,7 +847,9 @@ class E2eKeysHandler(object):
if len(self_device_ids): if len(self_device_ids):
yield self.device_handler.notify_device_update(user_id, self_device_ids) yield self.device_handler.notify_device_update(user_id, self_device_ids)
if len(signed_users): if len(signed_users):
yield self.device_handler.notify_user_signature_update(user_id, signed_users) yield self.device_handler.notify_user_signature_update(
user_id, signed_users
)
defer.returnValue({"failures": failures}) defer.returnValue({"failures": failures})
@ -858,9 +861,7 @@ class E2eKeysHandler(object):
if key is None: if key is None:
logger.error("no %s key found for %s", key_type, user_id) logger.error("no %s key found for %s", key_type, user_id)
raise SynapseError( raise SynapseError(
404, 404, "No %s key found for %s" % (key_type, user_id), Codes.NOT_FOUND
"No %s key found for %s" % (key_type, user_id),
Codes.NOT_FOUND
) )
key_id, verify_key = get_verify_key_from_cross_signing_key(key) key_id, verify_key = get_verify_key_from_cross_signing_key(key)
return key, key_id, verify_key return key, key_id, verify_key
@ -907,14 +908,13 @@ def _check_device_signature(user_id, verify_key, signed_device, stored_device):
key_id = "%s:%s" % (verify_key.alg, verify_key.version) key_id = "%s:%s" % (verify_key.alg, verify_key.version)
# make sure the device is signed # make sure the device is signed
if ("signatures" not in signed_device or user_id not in signed_device["signatures"] if (
or key_id not in signed_device["signatures"][user_id]): "signatures" not in signed_device
or user_id not in signed_device["signatures"]
or key_id not in signed_device["signatures"][user_id]
):
logger.error("upload signature: user not found in signatures") logger.error("upload signature: user not found in signatures")
raise SynapseError( raise SynapseError(400, "Invalid signature", Codes.INVALID_SIGNATURE)
400,
"Invalid signature",
Codes.INVALID_SIGNATURE
)
signature = signed_device["signatures"][user_id][key_id] signature = signed_device["signatures"][user_id][key_id]
@ -927,28 +927,19 @@ def _check_device_signature(user_id, verify_key, signed_device, stored_device):
if signed_device != stored_device: if signed_device != stored_device:
logger.error( logger.error(
"upload signatures: key does not match %s vs %s", "upload signatures: key does not match %s vs %s",
signed_device, stored_device signed_device,
) stored_device,
raise SynapseError(
400, "Key does not match",
) )
raise SynapseError(400, "Key does not match")
# check the signature # check the signature
signed_device["signatures"] = { signed_device["signatures"] = {user_id: {key_id: signature}}
user_id: {
key_id: signature
}
}
try: try:
verify_signed_json(signed_device, user_id, verify_key) verify_signed_json(signed_device, user_id, verify_key)
except SignatureVerifyException: except SignatureVerifyException:
logger.error("invalid signature on key") logger.error("invalid signature on key")
raise SynapseError( raise SynapseError(400, "Invalid signature", Codes.INVALID_SIGNATURE)
400,
"Invalid signature",
Codes.INVALID_SIGNATURE
)
def _exception_to_failure(e): def _exception_to_failure(e):

1
synapse/rest/client/v2_alpha/keys.py
View File

@ -303,6 +303,7 @@ class SignaturesUploadServlet(RestServlet):
} }
} }
""" """
PATTERNS = client_patterns("/keys/signatures/upload$") PATTERNS = client_patterns("/keys/signatures/upload$")
def __init__(self, hs): def __init__(self, hs):

24
synapse/storage/end_to_end_keys.py
View File

@ -62,9 +62,9 @@ class EndToEndKeyWorkerStore(SQLBaseStore):
# add cross-signing signatures to the keys # add cross-signing signatures to the keys
if "signatures" in device_info: if "signatures" in device_info:
for sig_user_id, sigs in device_info["signatures"].items(): for sig_user_id, sigs in device_info["signatures"].items():
device_info["keys"].setdefault("signatures", {}) \ device_info["keys"].setdefault("signatures", {}).setdefault(
.setdefault(sig_user_id, {}) \ sig_user_id, {}
.update(sigs) ).update(sigs)
return results return results
@ -131,12 +131,8 @@ class EndToEndKeyWorkerStore(SQLBaseStore):
# get signatures on the device # get signatures on the device
signature_sql = ( signature_sql = (
"SELECT * " "SELECT * " " FROM e2e_cross_signing_signatures " " WHERE %s"
" FROM e2e_cross_signing_signatures " ) % (" OR ".join("(" + q + ")" for q in signature_query_clauses))
" WHERE %s"
) % (
" OR ".join("(" + q + ")" for q in signature_query_clauses)
)
txn.execute(signature_sql, signature_query_params) txn.execute(signature_sql, signature_query_params)
rows = self.cursor_to_dict(txn) rows = self.cursor_to_dict(txn)
@ -144,12 +140,10 @@ class EndToEndKeyWorkerStore(SQLBaseStore):
for row in rows: for row in rows:
target_user_id = row["target_user_id"] target_user_id = row["target_user_id"]
target_device_id = row["target_device_id"] target_device_id = row["target_device_id"]
if target_user_id in result \ if target_user_id in result and target_device_id in result[target_user_id]:
and target_device_id in result[target_user_id]: result[target_user_id][target_device_id].setdefault(
result[target_user_id][target_device_id] \ "signatures", {}
.setdefault("signatures", {}) \ ).setdefault(row["user_id"], {})[row["key_id"]] = row["signature"]
.setdefault(row["user_id"], {})[row["key_id"]] \
= row["signature"]
log_kv(result) log_kv(result)
return result return result

145
tests/handlers/test_e2e_keys.py
View File

@ -225,20 +225,11 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
"user_id": local_user, "user_id": local_user,
"device_id": device_id, "device_id": device_id,
"algorithms": ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"], "algorithms": ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"],
"keys": { "keys": {"curve25519:xyz": "curve25519+key", "ed25519:xyz": device_pubkey},
"curve25519:xyz": "curve25519+key", "signatures": {local_user: {"ed25519:xyz": "something"}},
"ed25519:xyz": device_pubkey
},
"signatures": {
local_user: {
"ed25519:xyz": "something"
}
}
} }
device_signing_key = key.decode_signing_key_base64( device_signing_key = key.decode_signing_key_base64(
"ed25519", "ed25519", "xyz", "OMkooTr76ega06xNvXIGPbgvvxAOzmQncN8VObS7aBA"
"xyz",
"OMkooTr76ega06xNvXIGPbgvvxAOzmQncN8VObS7aBA"
) )
yield self.handler.upload_keys_for_user( yield self.handler.upload_keys_for_user(
@ -250,26 +241,20 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
master_key = { master_key = {
"user_id": local_user, "user_id": local_user,
"usage": ["master"], "usage": ["master"],
"keys": { "keys": {"ed25519:" + master_pubkey: master_pubkey},
"ed25519:" + master_pubkey: master_pubkey
}
} }
master_signing_key = key.decode_signing_key_base64( master_signing_key = key.decode_signing_key_base64(
"ed25519", master_pubkey, "ed25519", master_pubkey, "2lonYOM6xYKdEsO+6KrC766xBcHnYnim1x/4LFGF8B0"
"2lonYOM6xYKdEsO+6KrC766xBcHnYnim1x/4LFGF8B0"
) )
usersigning_pubkey = "Hq6gL+utB4ET+UvD5ci0kgAwsX6qP/zvf8v6OInU5iw" usersigning_pubkey = "Hq6gL+utB4ET+UvD5ci0kgAwsX6qP/zvf8v6OInU5iw"
usersigning_key = { usersigning_key = {
# private key: 4TL4AjRYwDVwD3pqQzcor+ez/euOB1/q78aTJ+czDNs # private key: 4TL4AjRYwDVwD3pqQzcor+ez/euOB1/q78aTJ+czDNs
"user_id": local_user, "user_id": local_user,
"usage": ["user_signing"], "usage": ["user_signing"],
"keys": { "keys": {"ed25519:" + usersigning_pubkey: usersigning_pubkey},
"ed25519:" + usersigning_pubkey: usersigning_pubkey,
}
} }
usersigning_signing_key = key.decode_signing_key_base64( usersigning_signing_key = key.decode_signing_key_base64(
"ed25519", usersigning_pubkey, "ed25519", usersigning_pubkey, "4TL4AjRYwDVwD3pqQzcor+ez/euOB1/q78aTJ+czDNs"
"4TL4AjRYwDVwD3pqQzcor+ez/euOB1/q78aTJ+czDNs"
) )
sign.sign_json(usersigning_key, local_user, master_signing_key) sign.sign_json(usersigning_key, local_user, master_signing_key)
# private key: HvQBbU+hc2Zr+JP1sE0XwBe1pfZZEYtJNPJLZJtS+F8 # private key: HvQBbU+hc2Zr+JP1sE0XwBe1pfZZEYtJNPJLZJtS+F8
@ -277,13 +262,10 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
selfsigning_key = { selfsigning_key = {
"user_id": local_user, "user_id": local_user,
"usage": ["self_signing"], "usage": ["self_signing"],
"keys": { "keys": {"ed25519:" + selfsigning_pubkey: selfsigning_pubkey},
"ed25519:" + selfsigning_pubkey: selfsigning_pubkey,
}
} }
selfsigning_signing_key = key.decode_signing_key_base64( selfsigning_signing_key = key.decode_signing_key_base64(
"ed25519", selfsigning_pubkey, "ed25519", selfsigning_pubkey, "HvQBbU+hc2Zr+JP1sE0XwBe1pfZZEYtJNPJLZJtS+F8"
"HvQBbU+hc2Zr+JP1sE0XwBe1pfZZEYtJNPJLZJtS+F8"
) )
sign.sign_json(selfsigning_key, local_user, master_signing_key) sign.sign_json(selfsigning_key, local_user, master_signing_key)
cross_signing_keys = { cross_signing_keys = {
@ -301,13 +283,11 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
# private key: oyw2ZUx0O4GifbfFYM0nQvj9CL0b8B7cyN4FprtK8OI # private key: oyw2ZUx0O4GifbfFYM0nQvj9CL0b8B7cyN4FprtK8OI
"user_id": other_user, "user_id": other_user,
"usage": ["master"], "usage": ["master"],
"keys": { "keys": {"ed25519:" + other_master_pubkey: other_master_pubkey},
"ed25519:" + other_master_pubkey: other_master_pubkey
} }
} yield self.handler.upload_signing_keys_for_user(
yield self.handler.upload_signing_keys_for_user(other_user, { other_user, {"master_key": other_master_key}
"master_key": other_master_key )
})
# test various signature failures (see below) # test various signature failures (see below)
ret = yield self.handler.upload_signatures_for_device_keys( ret = yield self.handler.upload_signatures_for_device_keys(
@ -319,17 +299,18 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
device_id: { device_id: {
"user_id": local_user, "user_id": local_user,
"device_id": device_id, "device_id": device_id,
"algorithms": ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"], "algorithms": [
"m.olm.curve25519-aes-sha256",
"m.megolm.v1.aes-sha",
],
"keys": { "keys": {
"curve25519:xyz": "curve25519+key", "curve25519:xyz": "curve25519+key",
# private key: OMkooTr76ega06xNvXIGPbgvvxAOzmQncN8VObS7aBA # private key: OMkooTr76ega06xNvXIGPbgvvxAOzmQncN8VObS7aBA
"ed25519:xyz": device_pubkey "ed25519:xyz": device_pubkey,
}, },
"signatures": { "signatures": {
local_user: { local_user: {"ed25519:" + selfsigning_pubkey: "something"}
"ed25519:" + selfsigning_pubkey: "something", },
}
}
}, },
# fails because device is unknown # fails because device is unknown
# should fail with NOT_FOUND # should fail with NOT_FOUND
@ -337,25 +318,19 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
"user_id": local_user, "user_id": local_user,
"device_id": "unknown", "device_id": "unknown",
"signatures": { "signatures": {
local_user: { local_user: {"ed25519:" + selfsigning_pubkey: "something"}
"ed25519:" + selfsigning_pubkey: "something", },
}
}
}, },
# fails because the signature is invalid # fails because the signature is invalid
# should fail with INVALID_SIGNATURE # should fail with INVALID_SIGNATURE
master_pubkey: { master_pubkey: {
"user_id": local_user, "user_id": local_user,
"usage": ["master"], "usage": ["master"],
"keys": { "keys": {"ed25519:" + master_pubkey: master_pubkey},
"ed25519:" + master_pubkey: master_pubkey
},
"signatures": { "signatures": {
local_user: { local_user: {"ed25519:" + device_pubkey: "something"}
"ed25519:" + device_pubkey: "something", },
} },
}
}
}, },
other_user: { other_user: {
# fails because the device is not the user's master-signing key # fails because the device is not the user's master-signing key
@ -364,38 +339,40 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
"user_id": other_user, "user_id": other_user,
"device_id": "unknown", "device_id": "unknown",
"signatures": { "signatures": {
local_user: { local_user: {"ed25519:" + usersigning_pubkey: "something"}
"ed25519:" + usersigning_pubkey: "something", },
}
}
}, },
other_master_pubkey: { other_master_pubkey: {
# fails because the key doesn't match what the server has # fails because the key doesn't match what the server has
# should fail with UNKNOWN # should fail with UNKNOWN
"user_id": other_user, "user_id": other_user,
"usage": ["master"], "usage": ["master"],
"keys": { "keys": {"ed25519:" + other_master_pubkey: other_master_pubkey},
"ed25519:" + other_master_pubkey: other_master_pubkey
},
"something": "random", "something": "random",
"signatures": { "signatures": {
local_user: { local_user: {"ed25519:" + usersigning_pubkey: "something"}
"ed25519:" + usersigning_pubkey: "something", },
} },
} },
} },
}
}
) )
user_failures = ret["failures"][local_user] user_failures = ret["failures"][local_user]
self.assertEqual(user_failures[device_id]["errcode"], errors.Codes.INVALID_SIGNATURE) self.assertEqual(
self.assertEqual(user_failures[master_pubkey]["errcode"], errors.Codes.INVALID_SIGNATURE) user_failures[device_id]["errcode"], errors.Codes.INVALID_SIGNATURE
)
self.assertEqual(
user_failures[master_pubkey]["errcode"], errors.Codes.INVALID_SIGNATURE
)
self.assertEqual(user_failures["unknown"]["errcode"], errors.Codes.NOT_FOUND) self.assertEqual(user_failures["unknown"]["errcode"], errors.Codes.NOT_FOUND)
other_user_failures = ret["failures"][other_user] other_user_failures = ret["failures"][other_user]
self.assertEqual(other_user_failures["unknown"]["errcode"], errors.Codes.NOT_FOUND) self.assertEqual(
self.assertEqual(other_user_failures[other_master_pubkey]["errcode"], errors.Codes.UNKNOWN) other_user_failures["unknown"]["errcode"], errors.Codes.NOT_FOUND
)
self.assertEqual(
other_user_failures[other_master_pubkey]["errcode"], errors.Codes.UNKNOWN
)
# test successful signatures # test successful signatures
del device_key["signatures"] del device_key["signatures"]
@ -405,33 +382,33 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
ret = yield self.handler.upload_signatures_for_device_keys( ret = yield self.handler.upload_signatures_for_device_keys(
local_user, local_user,
{ {
local_user: { local_user: {device_id: device_key, master_pubkey: master_key},
device_id: device_key, other_user: {other_master_pubkey: other_master_key},
master_pubkey: master_key
}, },
other_user: {
other_master_pubkey: other_master_key
}
}
) )
self.assertEqual(ret["failures"], {}) self.assertEqual(ret["failures"], {})
# fetch the signed keys/devices and make sure that the signatures are there # fetch the signed keys/devices and make sure that the signatures are there
ret = yield self.handler.query_devices( ret = yield self.handler.query_devices(
{"device_keys": {local_user: [], other_user: []}}, {"device_keys": {local_user: [], other_user: []}}, 0, local_user
0, local_user
) )
self.assertEqual( self.assertEqual(
ret["device_keys"][local_user]["xyz"]["signatures"][local_user]["ed25519:" + selfsigning_pubkey], ret["device_keys"][local_user]["xyz"]["signatures"][local_user][
device_key["signatures"][local_user]["ed25519:" + selfsigning_pubkey] "ed25519:" + selfsigning_pubkey
],
device_key["signatures"][local_user]["ed25519:" + selfsigning_pubkey],
) )
self.assertEqual( self.assertEqual(
ret["master_keys"][local_user]["signatures"][local_user]["ed25519:" + device_id], ret["master_keys"][local_user]["signatures"][local_user][
master_key["signatures"][local_user]["ed25519:" + device_id] "ed25519:" + device_id
],
master_key["signatures"][local_user]["ed25519:" + device_id],
) )
self.assertEqual( self.assertEqual(
ret["master_keys"][other_user]["signatures"][local_user]["ed25519:" + usersigning_pubkey], ret["master_keys"][other_user]["signatures"][local_user][
other_master_key["signatures"][local_user]["ed25519:" + usersigning_pubkey] "ed25519:" + usersigning_pubkey
],
other_master_key["signatures"][local_user]["ed25519:" + usersigning_pubkey],
) )