make black happy

4 files changed, 141 insertions, 178 deletions

diff --git a/synapse/handlers/e2e_keys.py b/synapse/handlers/e2e_keys.py
index 1148803c1e..74bceddc46 100644
--- a/synapse/handlers/e2e_keys.py
+++ b/synapse/handlers/e2e_keys.py
@@ -635,16 +635,14 @@ class E2eKeysHandler(object):
             self_device_ids = list(self_signatures.keys())
             try:
                 # get our self-signing key to verify the signatures
-                self_signing_key, self_signing_key_id, self_signing_verify_key \
-                    = yield self._get_e2e_cross_signing_verify_key(
-                        user_id, "self_signing"
-                    )
+                self_signing_key, self_signing_key_id, self_signing_verify_key = yield self._get_e2e_cross_signing_verify_key(
+                    user_id, "self_signing"
+                )
 
                 # get our master key, since it may be signed
-                master_key, master_key_id, master_verify_key \
-                    = yield self._get_e2e_cross_signing_verify_key(
-                        user_id, "master"
-                    )
+                master_key, master_key_id, master_verify_key = yield self._get_e2e_cross_signing_verify_key(
+                    user_id, "master"
+                )
 
                 # fetch our stored devices.  This is used to 1. verify
                 # signatures on the master key, and 2. to can compare with what
@@ -652,15 +650,15 @@ class E2eKeysHandler(object):
                 devices = yield self.store.get_e2e_device_keys([(user_id, None)])
 
                 if user_id not in devices:
-                    raise SynapseError(
-                        404, "No device keys found", Codes.NOT_FOUND
-                    )
+                    raise SynapseError(404, "No device keys found", Codes.NOT_FOUND)
 
                 devices = devices[user_id]
                 for device_id, device in self_signatures.items():
                     try:
-                        if ("signatures" not in device or
-                                user_id not in device["signatures"]):
+                        if (
+                            "signatures" not in device
+                            or user_id not in device["signatures"]
+                        ):
                             # no signature was sent
                             raise SynapseError(
                                 400, "Invalid signature", Codes.INVALID_SIGNATURE
@@ -678,15 +676,21 @@ class E2eKeysHandler(object):
                             # signature list.  (In practice, we're likely to
                             # only have only one signature anyways.)
                             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)
-                                if (signing_device_id not in devices or
-                                        signing_key_id not in
-                                        devices[signing_device_id]["keys"]["keys"]):
+                                if (
+                                    signing_device_id not in devices
+                                    or signing_key_id
+                                    not in devices[signing_device_id]["keys"]["keys"]
+                                ):
                                     # signed by an unknown device, or the
                                     # device does not have the key
                                     raise SynapseError(
-                                        400, "Invalid signature", Codes.INVALID_SIGNATURE
+                                        400,
+                                        "Invalid signature",
+                                        Codes.INVALID_SIGNATURE,
                                     )
 
                                 sigs = device["signatures"]
@@ -697,12 +701,12 @@ class E2eKeysHandler(object):
                                 master_key.pop("unsigned", None)
 
                                 if master_key != device:
-                                    raise SynapseError(
-                                        400, "Key does not match"
-                                    )
+                                    raise SynapseError(400, "Key does not match")
 
                                 # 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(
                                     signing_key_id, decode_base64(pubkey)
                                 )
@@ -711,7 +715,9 @@ class E2eKeysHandler(object):
                                     verify_signed_json(device, user_id, verify_key)
                                 except SignatureVerifyException:
                                     raise SynapseError(
-                                        400, "Invalid signature", Codes.INVALID_SIGNATURE
+                                        400,
+                                        "Invalid signature",
+                                        Codes.INVALID_SIGNATURE,
                                     )
 
                                 master_key_signature_list.append(
@@ -733,11 +739,10 @@ class E2eKeysHandler(object):
                         try:
                             stored_device = devices[device_id]["keys"]
                         except KeyError:
-                            raise SynapseError(
-                                404, "Unknown device", Codes.NOT_FOUND
-                            )
-                        if self_signing_key_id in stored_device.get("signatures", {}) \
-                                                               .get(user_id, {}):
+                            raise SynapseError(404, "Unknown device", Codes.NOT_FOUND)
+                        if self_signing_key_id in stored_device.get(
+                            "signatures", {}
+                        ).get(user_id, {}):
                             # we already have a signature on this device, so we
                             # can skip it, since it should be exactly the same
                             continue
@@ -751,8 +756,9 @@ class E2eKeysHandler(object):
                             (self_signing_key_id, user_id, device_id, signature)
                         )
                     except SynapseError as e:
-                        failures.setdefault(user_id, {})[device_id] \
-                            = _exception_to_failure(e)
+                        failures.setdefault(user_id, {})[
+                            device_id
+                        ] = _exception_to_failure(e)
             except SynapseError as e:
                 failures[user_id] = {
                     device: _exception_to_failure(e)
@@ -766,20 +772,18 @@ class E2eKeysHandler(object):
 
             try:
                 # get our user-signing key to verify the signatures
-                user_signing_key, user_signing_key_id, user_signing_verify_key \
-                    = yield self._get_e2e_cross_signing_verify_key(
-                        user_id, "user_signing"
-                    )
+                user_signing_key, user_signing_key_id, user_signing_verify_key = yield self._get_e2e_cross_signing_verify_key(
+                    user_id, "user_signing"
+                )
 
                 for user, devicemap in signatures.items():
                     device_id = None
                     try:
                         # get the user's master key, to make sure it matches
                         # what was sent
-                        stored_key, stored_key_id, _ \
-                            = yield self._get_e2e_cross_signing_verify_key(
-                                user, "master", user_id
-                            )
+                        stored_key, stored_key_id, _ = yield self._get_e2e_cross_signing_verify_key(
+                            user, "master", user_id
+                        )
 
                         # make sure that the user's master key is the one that
                         # was signed (and no others)
@@ -790,26 +794,25 @@ class E2eKeysHandler(object):
                             device_id = None
                             logger.error(
                                 "upload signature: wrong device: %s vs %s",
-                                device, devicemap
-                            )
-                            raise SynapseError(
-                                404, "Unknown device", Codes.NOT_FOUND
+                                device,
+                                devicemap,
                             )
+                            raise SynapseError(404, "Unknown device", Codes.NOT_FOUND)
                         key = devicemap[device_id]
                         del devicemap[device_id]
                         if len(devicemap) > 0:
                             # other devices were signed -- mark those as failures
                             logger.error("upload signature: too many devices specified")
-                            failure = _exception_to_failure(SynapseError(
-                                404, "Unknown device", Codes.NOT_FOUND
-                            ))
+                            failure = _exception_to_failure(
+                                SynapseError(404, "Unknown device", Codes.NOT_FOUND)
+                            )
                             failures[user] = {
-                                device: failure
-                                for device in devicemap.keys()
+                                device: failure for device in devicemap.keys()
                             }
 
-                        if user_signing_key_id in stored_key.get("signatures", {}) \
-                                                            .get(user_id, {}):
+                        if user_signing_key_id in stored_key.get("signatures", {}).get(
+                            user_id, {}
+                        ):
                             # we already have the signature, so we can skip it
                             continue
 
@@ -826,8 +829,7 @@ class E2eKeysHandler(object):
                         failure = _exception_to_failure(e)
                         if device_id is None:
                             failures[user] = {
-                                device_id: failure
-                                for device_id in devicemap.keys()
+                                device_id: failure for device_id in devicemap.keys()
                             }
                         else:
                             failures.setdefault(user, {})[device_id] = failure
@@ -835,8 +837,7 @@ class E2eKeysHandler(object):
                 failure = _exception_to_failure(e)
                 for user, devicemap in signature.items():
                     failures[user] = {
-                        device_id: failure
-                        for device_id in devicemap.keys()
+                        device_id: failure for device_id in devicemap.keys()
                     }
 
         # store the signature, and send the appropriate notifications for sync
@@ -846,7 +847,9 @@ class E2eKeysHandler(object):
         if len(self_device_ids):
             yield self.device_handler.notify_device_update(user_id, self_device_ids)
         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})
 
@@ -858,9 +861,7 @@ class E2eKeysHandler(object):
         if key is None:
             logger.error("no %s key found for %s", key_type, user_id)
             raise SynapseError(
-                404,
-                "No %s key found for %s" % (key_type, user_id),
-                Codes.NOT_FOUND
+                404, "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)
         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)
 
     # make sure the device is signed
-    if ("signatures" not in signed_device or user_id not in signed_device["signatures"]
-            or key_id not in signed_device["signatures"][user_id]):
+    if (
+        "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")
-        raise SynapseError(
-            400,
-            "Invalid signature",
-            Codes.INVALID_SIGNATURE
-        )
+        raise SynapseError(400, "Invalid signature", Codes.INVALID_SIGNATURE)
 
     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:
         logger.error(
             "upload signatures: key does not match %s vs %s",
-            signed_device, stored_device
-        )
-        raise SynapseError(
-            400, "Key does not match",
+            signed_device,
+            stored_device,
         )
+        raise SynapseError(400, "Key does not match")
 
     # check the signature
-    signed_device["signatures"] = {
-        user_id: {
-            key_id: signature
-        }
-    }
+    signed_device["signatures"] = {user_id: {key_id: signature}}
 
     try:
         verify_signed_json(signed_device, user_id, verify_key)
     except SignatureVerifyException:
         logger.error("invalid signature on key")
-        raise SynapseError(
-            400,
-            "Invalid signature",
-            Codes.INVALID_SIGNATURE
-        )
+        raise SynapseError(400, "Invalid signature", Codes.INVALID_SIGNATURE)
 
 
 def _exception_to_failure(e):
diff --git a/synapse/rest/client/v2_alpha/keys.py b/synapse/rest/client/v2_alpha/keys.py
index cb3c52cb8e..a205281830 100644
--- a/synapse/rest/client/v2_alpha/keys.py
+++ b/synapse/rest/client/v2_alpha/keys.py
@@ -303,6 +303,7 @@ class SignaturesUploadServlet(RestServlet):
       }
     }
     """
+
     PATTERNS = client_patterns("/keys/signatures/upload$")
 
     def __init__(self, hs):
diff --git a/synapse/storage/end_to_end_keys.py b/synapse/storage/end_to_end_keys.py
index e68ce318af..258e8dcb47 100644
--- a/synapse/storage/end_to_end_keys.py
+++ b/synapse/storage/end_to_end_keys.py
@@ -62,9 +62,9 @@ class EndToEndKeyWorkerStore(SQLBaseStore):
                 # add cross-signing signatures to the keys
                 if "signatures" in device_info:
                     for sig_user_id, sigs in device_info["signatures"].items():
-                        device_info["keys"].setdefault("signatures", {}) \
-                                           .setdefault(sig_user_id, {}) \
-                                           .update(sigs)
+                        device_info["keys"].setdefault("signatures", {}).setdefault(
+                            sig_user_id, {}
+                        ).update(sigs)
 
         return results
 
@@ -131,12 +131,8 @@ class EndToEndKeyWorkerStore(SQLBaseStore):
 
         # get signatures on the device
         signature_sql = (
-            "SELECT * "
-            "  FROM e2e_cross_signing_signatures "
-            " WHERE %s"
-        ) % (
-            " OR ".join("(" + q + ")" for q in signature_query_clauses)
-        )
+            "SELECT * " "  FROM e2e_cross_signing_signatures " " WHERE %s"
+        ) % (" OR ".join("(" + q + ")" for q in signature_query_clauses))
 
         txn.execute(signature_sql, signature_query_params)
         rows = self.cursor_to_dict(txn)
@@ -144,12 +140,10 @@ class EndToEndKeyWorkerStore(SQLBaseStore):
         for row in rows:
             target_user_id = row["target_user_id"]
             target_device_id = row["target_device_id"]
-            if target_user_id in result \
-               and target_device_id in result[target_user_id]:
-                result[target_user_id][target_device_id] \
-                    .setdefault("signatures", {}) \
-                    .setdefault(row["user_id"], {})[row["key_id"]] \
-                    = row["signature"]
+            if target_user_id in result and target_device_id in result[target_user_id]:
+                result[target_user_id][target_device_id].setdefault(
+                    "signatures", {}
+                ).setdefault(row["user_id"], {})[row["key_id"]] = row["signature"]
 
         log_kv(result)
         return result
diff --git a/tests/handlers/test_e2e_keys.py b/tests/handlers/test_e2e_keys.py
index b1d3a4cfae..8c0ee3f7d3 100644
--- a/tests/handlers/test_e2e_keys.py
+++ b/tests/handlers/test_e2e_keys.py
@@ -225,20 +225,11 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
             "user_id": local_user,
             "device_id": device_id,
             "algorithms": ["m.olm.curve25519-aes-sha256", "m.megolm.v1.aes-sha"],
-            "keys": {
-                "curve25519:xyz": "curve25519+key",
-                "ed25519:xyz": device_pubkey
-            },
-            "signatures": {
-                local_user: {
-                    "ed25519:xyz": "something"
-                }
-            }
+            "keys": {"curve25519:xyz": "curve25519+key", "ed25519:xyz": device_pubkey},
+            "signatures": {local_user: {"ed25519:xyz": "something"}},
         }
         device_signing_key = key.decode_signing_key_base64(
-            "ed25519",
-            "xyz",
-            "OMkooTr76ega06xNvXIGPbgvvxAOzmQncN8VObS7aBA"
+            "ed25519", "xyz", "OMkooTr76ega06xNvXIGPbgvvxAOzmQncN8VObS7aBA"
         )
 
         yield self.handler.upload_keys_for_user(
@@ -250,26 +241,20 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
         master_key = {
             "user_id": local_user,
             "usage": ["master"],
-            "keys": {
-                "ed25519:" + master_pubkey: master_pubkey
-            }
+            "keys": {"ed25519:" + master_pubkey: master_pubkey},
         }
         master_signing_key = key.decode_signing_key_base64(
-            "ed25519", master_pubkey,
-            "2lonYOM6xYKdEsO+6KrC766xBcHnYnim1x/4LFGF8B0"
+            "ed25519", master_pubkey, "2lonYOM6xYKdEsO+6KrC766xBcHnYnim1x/4LFGF8B0"
         )
         usersigning_pubkey = "Hq6gL+utB4ET+UvD5ci0kgAwsX6qP/zvf8v6OInU5iw"
         usersigning_key = {
             # private key: 4TL4AjRYwDVwD3pqQzcor+ez/euOB1/q78aTJ+czDNs
             "user_id": local_user,
             "usage": ["user_signing"],
-            "keys": {
-                "ed25519:" + usersigning_pubkey: usersigning_pubkey,
-            }
+            "keys": {"ed25519:" + usersigning_pubkey: usersigning_pubkey},
         }
         usersigning_signing_key = key.decode_signing_key_base64(
-            "ed25519", usersigning_pubkey,
-            "4TL4AjRYwDVwD3pqQzcor+ez/euOB1/q78aTJ+czDNs"
+            "ed25519", usersigning_pubkey, "4TL4AjRYwDVwD3pqQzcor+ez/euOB1/q78aTJ+czDNs"
         )
         sign.sign_json(usersigning_key, local_user, master_signing_key)
         # private key: HvQBbU+hc2Zr+JP1sE0XwBe1pfZZEYtJNPJLZJtS+F8
@@ -277,13 +262,10 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
         selfsigning_key = {
             "user_id": local_user,
             "usage": ["self_signing"],
-            "keys": {
-                "ed25519:" + selfsigning_pubkey: selfsigning_pubkey,
-            }
+            "keys": {"ed25519:" + selfsigning_pubkey: selfsigning_pubkey},
         }
         selfsigning_signing_key = key.decode_signing_key_base64(
-            "ed25519", selfsigning_pubkey,
-            "HvQBbU+hc2Zr+JP1sE0XwBe1pfZZEYtJNPJLZJtS+F8"
+            "ed25519", selfsigning_pubkey, "HvQBbU+hc2Zr+JP1sE0XwBe1pfZZEYtJNPJLZJtS+F8"
         )
         sign.sign_json(selfsigning_key, local_user, master_signing_key)
         cross_signing_keys = {
@@ -301,13 +283,11 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
             # private key: oyw2ZUx0O4GifbfFYM0nQvj9CL0b8B7cyN4FprtK8OI
             "user_id": other_user,
             "usage": ["master"],
-            "keys": {
-                "ed25519:" + other_master_pubkey: other_master_pubkey
-            }
+            "keys": {"ed25519:" + other_master_pubkey: other_master_pubkey},
         }
-        yield self.handler.upload_signing_keys_for_user(other_user, {
-            "master_key": other_master_key
-        })
+        yield self.handler.upload_signing_keys_for_user(
+            other_user, {"master_key": other_master_key}
+        )
 
         # test various signature failures (see below)
         ret = yield self.handler.upload_signatures_for_device_keys(
@@ -319,17 +299,18 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
                     device_id: {
                         "user_id": local_user,
                         "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": {
                             "curve25519:xyz": "curve25519+key",
                             # private key: OMkooTr76ega06xNvXIGPbgvvxAOzmQncN8VObS7aBA
-                            "ed25519:xyz": device_pubkey
+                            "ed25519:xyz": device_pubkey,
                         },
                         "signatures": {
-                            local_user: {
-                                "ed25519:" + selfsigning_pubkey: "something",
-                            }
-                        }
+                            local_user: {"ed25519:" + selfsigning_pubkey: "something"}
+                        },
                     },
                     # fails because device is unknown
                     # should fail with NOT_FOUND
@@ -337,25 +318,19 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
                         "user_id": local_user,
                         "device_id": "unknown",
                         "signatures": {
-                            local_user: {
-                                "ed25519:" + selfsigning_pubkey: "something",
-                            }
-                        }
+                            local_user: {"ed25519:" + selfsigning_pubkey: "something"}
+                        },
                     },
                     # fails because the signature is invalid
                     # should fail with INVALID_SIGNATURE
                     master_pubkey: {
                         "user_id": local_user,
                         "usage": ["master"],
-                        "keys": {
-                            "ed25519:" + master_pubkey: master_pubkey
-                        },
+                        "keys": {"ed25519:" + master_pubkey: master_pubkey},
                         "signatures": {
-                            local_user: {
-                                "ed25519:" + device_pubkey: "something",
-                            }
-                        }
-                    }
+                            local_user: {"ed25519:" + device_pubkey: "something"}
+                        },
+                    },
                 },
                 other_user: {
                     # fails because the device is not the user's master-signing key
@@ -364,38 +339,40 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
                         "user_id": other_user,
                         "device_id": "unknown",
                         "signatures": {
-                            local_user: {
-                                "ed25519:" + usersigning_pubkey: "something",
-                            }
-                        }
+                            local_user: {"ed25519:" + usersigning_pubkey: "something"}
+                        },
                     },
                     other_master_pubkey: {
                         # fails because the key doesn't match what the server has
                         # should fail with UNKNOWN
                         "user_id": other_user,
                         "usage": ["master"],
-                        "keys": {
-                            "ed25519:" + other_master_pubkey: other_master_pubkey
-                        },
+                        "keys": {"ed25519:" + other_master_pubkey: other_master_pubkey},
                         "something": "random",
                         "signatures": {
-                            local_user: {
-                                "ed25519:" + usersigning_pubkey: "something",
-                            }
-                        }
-                    }
-                }
-            }
+                            local_user: {"ed25519:" + usersigning_pubkey: "something"}
+                        },
+                    },
+                },
+            },
         )
 
         user_failures = ret["failures"][local_user]
-        self.assertEqual(user_failures[device_id]["errcode"], errors.Codes.INVALID_SIGNATURE)
-        self.assertEqual(user_failures[master_pubkey]["errcode"], errors.Codes.INVALID_SIGNATURE)
+        self.assertEqual(
+            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)
 
         other_user_failures = ret["failures"][other_user]
-        self.assertEqual(other_user_failures["unknown"]["errcode"], errors.Codes.NOT_FOUND)
-        self.assertEqual(other_user_failures[other_master_pubkey]["errcode"], errors.Codes.UNKNOWN)
+        self.assertEqual(
+            other_user_failures["unknown"]["errcode"], errors.Codes.NOT_FOUND
+        )
+        self.assertEqual(
+            other_user_failures[other_master_pubkey]["errcode"], errors.Codes.UNKNOWN
+        )
 
         # test successful signatures
         del device_key["signatures"]
@@ -405,33 +382,33 @@ class E2eKeysHandlerTestCase(unittest.TestCase):
         ret = yield self.handler.upload_signatures_for_device_keys(
             local_user,
             {
-                local_user: {
-                    device_id: device_key,
-                    master_pubkey: master_key
-                },
-                other_user: {
-                    other_master_pubkey: other_master_key
-                }
-            }
+                local_user: {device_id: device_key, master_pubkey: master_key},
+                other_user: {other_master_pubkey: other_master_key},
+            },
         )
 
         self.assertEqual(ret["failures"], {})
 
         # fetch the signed keys/devices and make sure that the signatures are there
         ret = yield self.handler.query_devices(
-            {"device_keys": {local_user: [], other_user: []}},
-            0, local_user
+            {"device_keys": {local_user: [], other_user: []}}, 0, local_user
         )
 
         self.assertEqual(
-            ret["device_keys"][local_user]["xyz"]["signatures"][local_user]["ed25519:" + selfsigning_pubkey],
-            device_key["signatures"][local_user]["ed25519:" + selfsigning_pubkey]
+            ret["device_keys"][local_user]["xyz"]["signatures"][local_user][
+                "ed25519:" + selfsigning_pubkey
+            ],
+            device_key["signatures"][local_user]["ed25519:" + selfsigning_pubkey],
         )
         self.assertEqual(
-            ret["master_keys"][local_user]["signatures"][local_user]["ed25519:" + device_id],
-            master_key["signatures"][local_user]["ed25519:" + device_id]
+            ret["master_keys"][local_user]["signatures"][local_user][
+                "ed25519:" + device_id
+            ],
+            master_key["signatures"][local_user]["ed25519:" + device_id],
         )
         self.assertEqual(
-            ret["master_keys"][other_user]["signatures"][local_user]["ed25519:" + usersigning_pubkey],
-            other_master_key["signatures"][local_user]["ed25519:" + usersigning_pubkey]
+            ret["master_keys"][other_user]["signatures"][local_user][
+                "ed25519:" + usersigning_pubkey
+            ],
+            other_master_key["signatures"][local_user]["ed25519:" + usersigning_pubkey],
         )