Change capabilities sedes according to #6503

This changes the (de-)serialization of capabilities that are broadcast
via synapse `avatar_url` to be `base64` wrapped `json`.

Changes in detail:
- hand rolled serialization is removed
- truncation of falsy entries is dropped / all entries are explicit
- unknown capabilities will be preserved
- `parse_capabilities` is renamed to `deserialize_capabilities`
- deserialization errors are treated as empty capabilities
- adjusted unit tests

Author: konradkonrad

raiden/network/transport/matrix/utils.py

@@ -56,7 +56,7 @@
 )
 from raiden.network.utils import get_average_http_response_time
 from raiden.storage.serialization.serializer import MessageSerializer
-from raiden.utils.capabilities import parse_capabilities, serialize_capabilities
+from raiden.utils.capabilities import deserialize_capabilities, serialize_capabilities
 from raiden.utils.gevent import spawn_named
 from raiden.utils.signer import Signer, recover
 from raiden.utils.typing import Address, ChainID, MessageID, PeerCapabilities, Signature
@@ -346,7 +346,7 @@ def query_capabilities_for_user_id(self, user_id: str) -> PeerCapabilities:
             return PeerCapabilities({})
         avatar_url = user.get_avatar_url()
         if avatar_url is not None:
-            return PeerCapabilities(parse_capabilities(avatar_url))
+            return PeerCapabilities(deserialize_capabilities(avatar_url))
         else:
             return PeerCapabilities({})
 

raiden/tests/integration/network/transport/test_matrix_transport.py

@@ -56,7 +56,7 @@
 from raiden.transfer.identifiers import CANONICAL_IDENTIFIER_UNORDERED_QUEUE, QueueIdentifier
 from raiden.transfer.state import NetworkState
 from raiden.transfer.state_change import ActionChannelClose
-from raiden.utils.capabilities import capconfig_to_dict, parse_capabilities
+from raiden.utils.capabilities import capconfig_to_dict, deserialize_capabilities
 from raiden.utils.formatting import to_checksum_address
 from raiden.utils.typing import Address, Dict, List, PeerCapabilities, TokenNetworkAddress, cast
 from raiden.waiting import wait_for_network_state
@@ -1354,7 +1354,7 @@ def test_transport_capabilities(raiden_network: List[RaidenService], capabilitie
     app1_avatar_url = app1_user.get_avatar_url()
     assert "adhoc_capability" in app1_avatar_url, "avatar_url not set for app1"
     msg = "capabilities could not be parsed"
-    assert parse_capabilities(app1_avatar_url) == expected_capabilities, msg
+    assert deserialize_capabilities(app1_avatar_url) == expected_capabilities, msg
 
     msg = "capabilities were not collected in transport client"
     collected_capabilities = app0.transport._address_mgr.get_address_capabilities(app1.address)

raiden/tests/unit/test_utils.py

@@ -11,7 +11,7 @@
 from raiden.utils.capabilities import (
     capconfig_to_dict,
     capdict_to_config,
-    parse_capabilities,
+    deserialize_capabilities,
     serialize_capabilities,
 )
 from raiden.utils.keys import privatekey_to_publickey
@@ -97,26 +97,23 @@ def test_get_http_rtt_ignore_failing(requests_responses):
     assert get_average_http_response_time(url="http://url3", method="get") is None
 
 
-def test_parse_capabilities():
-    capstring = 'foo,toad,bar="max",form,agar'
-    parsed = parse_capabilities(capstring)
+def test_deserialize_capabilities():
+    capstring = "eyJmb28iOiB0cnVlLCAidG9hZCI6IHRydWUsICJiYXIiOiAibWF4IiwgImFnYXIiOiB0cnVlfQ==\n"
+    parsed = deserialize_capabilities(capstring)
     assert parsed.get("foo") is True
     assert parsed.get("toad") is True
     assert parsed.get("bar") == "max"
-    assert parsed.get("form") is True
     assert parsed.get("agar") is True
     assert not parsed.get("nothing")
 
     assert serialize_capabilities(parsed) == f"mxc://{capstring}"
 
     parsed["false"] = False
 
-    assert serialize_capabilities(parsed) == f"mxc://{capstring}"
-
-    parsed["nothing"] = None
-    assert 'nothing="None"' in serialize_capabilities(parsed)
+    # Explicit new value changes the serialization format
+    assert serialize_capabilities(parsed) != f"mxc://{capstring}"
 
-    assert parse_capabilities("") == dict()
+    assert deserialize_capabilities("") == dict()
 
     assert serialize_capabilities({}) == "mxc://"
 

raiden/utils/capabilities.py

@@ -1,44 +1,42 @@
+import binascii
+import json
+from base64 import decodebytes, encodebytes
 from typing import Any, Dict, Optional
 
+import structlog
+
 from raiden.constants import Capabilities
 from raiden.settings import CapabilitiesConfig
 
+log = structlog.get_logger(__name__)
+
+
+def _serialize(capdict: Optional[Dict[str, Any]]) -> str:
+    if capdict is None:
+        capdict = {}
+    return encodebytes(json.dumps(capdict).encode("utf-8")).decode("utf-8")
 
-def parse_capabilities(capstring: str) -> Dict[str, Any]:
-    if capstring.startswith("mxc://"):
-        capstring = capstring[6:]
-    elif "/" in capstring:
-        capstring = capstring[capstring.rindex("/") + 1 :]
-    result: Dict[str, Any] = {}
-    if len(capstring) == 0:
-        return result
-    for token in capstring.split(","):
-        if "=" in token:
-            key, value = token.split("=")
-            value = value.strip('"')
-            result[key] = value
-        else:
-            result[token] = True
-    return result
+
+def _deserialize(b64capabilites: bytes) -> Dict[str, Any]:
+    try:
+        return json.loads(decodebytes(b64capabilites))
+    except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
+        log.error(f'Malformed capabilities "{b64capabilites!r}"')
+        return {}
 
 
 def serialize_capabilities(capdict: Optional[Dict[str, Any]]) -> str:
     if not capdict:
         return "mxc://"
-    for key in capdict.keys():
-        if "/" in str(key):
-            raise ValueError(f"Key {key} is malformed, '/' not allowed")
+    return f"mxc://{_serialize(capdict)}"
+
 
-    entries = []
-    for key, value in capdict.items():
-        if isinstance(value, bool):
-            if value:
-                entries.append(key)
-        else:
-            entries.append(f'{key}="{value}"')
-    if len(entries):
-        return f"mxc://{','.join(entries)}"
-    return "mxc://"
+def deserialize_capabilities(capstring: str) -> Dict[str, Any]:
+    if capstring.startswith("mxc://"):
+        capstring = capstring[6:]
+    if "/" in capstring:
+        capstring = capstring[capstring.rindex("/") + 1 :]
+    return _deserialize(capstring.encode("utf-8"))
 
 
 def capdict_to_config(capdict: Dict[str, Any]) -> CapabilitiesConfig: