def test_supports_legacy_is_admin_field(alice):
# Manually craft a local user in legacy format
raw_legacy_local_user = {
"organization_addr": alice.organization_addr.to_url(),
"device_id": str(alice.device_id),
"signing_key": alice.signing_key.encode(),
"private_key": alice.private_key.encode(),
"is_admin": True,
"user_manifest_id": UUID(alice.user_manifest_id.hex),
"user_manifest_key": bytes(alice.user_manifest_key.secret),
"local_symkey": bytes(alice.local_symkey.secret),
}
dumped_legacy_local_user = packb(raw_legacy_local_user)
# Make sure the legacy format can be loaded
legacy_local_user = LocalDevice.load(dumped_legacy_local_user)
assert legacy_local_user == alice
# Manually decode new format to check it is compatible with legacy
dumped_local_user = alice.dump()
raw_local_user = unpackb(dumped_local_user)
assert raw_local_user == {
**raw_legacy_local_user,
"profile": alice.profile.value,
"human_handle": None,
"device_label": None,
}
def _on_notification(self, connection, pid, channel, payload):
data = unpackb(b64decode(payload.encode("ascii")))
signal = data.pop("__signal__")
logger.debug("notif received",
pid=pid,
channel=channel,
payload=payload)
self.event_bus.send(signal, **data)
def _on_notification(self, connection, pid, channel, payload):
data = unpackb(b64decode(payload.encode("ascii")))
data.pop("__id__") # Simply discard the notification id
signal = data.pop("__signal__")
logger.debug("notif received", pid=pid, channel=channel, payload=payload)
# Kind of a hack, but fine enough for the moment
if signal == "realm.roles_updated":
data["role"] = STR_TO_REALM_ROLE.get(data.pop("role_str"))
self.event_bus.send(signal, **data)
async def _http_api_anonymous(self, req: HTTPRequest,
**kwargs: str) -> HTTPResponse:
# Check whether the organization exists
try:
organization_id = OrganizationID(kwargs["organization_id"])
await self._organization_component.get(organization_id)
except OrganizationNotFoundError:
organization_exists = False
except ValueError:
return HTTPResponse.build_msgpack(404, {})
else:
organization_exists = True
# Reply to GET
if req.method == "GET":
status = 200 if organization_exists else 404
return HTTPResponse.build_msgpack(status, {})
# Reply early to POST when the organization doesn't exists
if not organization_exists and not self._config.organization_spontaneous_bootstrap:
return HTTPResponse.build_msgpack(404, {})
# Get and unpack the body
body = await req.get_body()
try:
msg = unpackb(body)
except SerdePackingError:
return HTTPResponse.build_msgpack(200,
{"status": "invalid_msg_format"})
# Lazy creation of the organization if necessary
cmd = msg.get("cmd")
if cmd == "organization_bootstrap" and not organization_exists:
assert self._config.organization_spontaneous_bootstrap
try:
await self._organization_component.create(id=organization_id,
bootstrap_token="")
except OrganizationAlreadyExistsError:
pass
# Retreive command
client_ctx = AnonymousClientContext(organization_id)
try:
if not isinstance(cmd, str):
raise KeyError()
cmd_func = self.anonymous_api[cmd]
except KeyError:
return HTTPResponse.build_msgpack(200,
{"status": "unknown_command"})
# Run command
rep = await cmd_func(client_ctx, msg)
return HTTPResponse.build_msgpack(200, rep)
def _on_notification(self, connection, pid, channel, payload):
data = unpackb(b64decode(payload.encode("ascii")))
data.pop("__id__") # Simply discard the notification id
signal = data.pop("__signal__")
logger.debug("notif received",
pid=pid,
channel=channel,
payload=payload)
# Convert strings to enums
signal = STR_TO_BACKEND_EVENTS[signal]
# Kind of a hack, but fine enough for the moment
if signal == BackendEvent.REALM_ROLES_UPDATED:
data["role"] = STR_TO_REALM_ROLE.get(data.pop("role_str"))
elif signal == BackendEvent.INVITE_STATUS_CHANGED:
data["status"] = STR_TO_INVITATION_STATUS.get(
data.pop("status_str"))
self.event_bus.send(signal, **data)
def test_user_certificate_supports_legacy_is_admin_field(alice, bob):
now = pendulum_now()
certif = UserCertificateContent(
author=bob.device_id,
timestamp=now,
user_id=alice.user_id,
human_handle=None,
public_key=alice.public_key,
profile=alice.profile,
)
# Manually craft a certificate in legacy format
raw_legacy_certif = {
"type": "user_certificate",
"author": bob.device_id,
"timestamp": now,
"user_id": alice.user_id,
"public_key": alice.public_key.encode(),
"is_admin": True,
}
dumped_legacy_certif = bob.signing_key.sign(
zlib.compress(packb(raw_legacy_certif)))
# Make sure the legacy format can be loaded
legacy_certif = UserCertificateContent.verify_and_load(
dumped_legacy_certif,
author_verify_key=bob.verify_key,
expected_author=bob.device_id,
expected_user=alice.user_id,
expected_human_handle=None,
)
assert legacy_certif == certif
# Manually decode new format to check it is compatible with legacy
dumped_certif = certif.dump_and_sign(bob.signing_key)
raw_certif = unpackb(zlib.decompress(bob.verify_key.verify(dumped_certif)))
assert raw_certif == {
**raw_legacy_certif, "profile": alice.profile.value,
"human_handle": None
}
def test_pack_uuid():
data = {"uuid": uuid.uuid4()}
packed = packb(data)
unpacked = unpackb(packed)
assert unpacked == data
assert isinstance(unpacked["uuid"], uuid.UUID)
def test_pack_datetime():
data = {"date": pendulum.now()}
packed = packb(data)
unpacked = unpackb(packed)
assert unpacked == data
assert isinstance(unpacked["date"], pendulum.DateTime)