0
0
Fork 1
mirror of https://mau.dev/maunium/synapse.git synced 2024-12-15 17:03:52 +01:00
synapse/tests/crypto/test_keyring.py

220 lines
8 KiB
Python
Raw Normal View History

# -*- coding: utf-8 -*-
# Copyright 2017 New Vector Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
2017-09-20 02:32:42 +02:00
import time
2018-07-09 08:09:20 +02:00
from mock import Mock
2017-09-20 02:32:42 +02:00
import signedjson.key
import signedjson.sign
2018-07-09 08:09:20 +02:00
from twisted.internet import defer, reactor
from synapse.api.errors import SynapseError
from synapse.crypto import keyring
2018-07-09 08:09:20 +02:00
from synapse.util import Clock, logcontext
from synapse.util.logcontext import LoggingContext
2018-07-09 08:09:20 +02:00
from tests import unittest, utils
2017-09-20 02:32:42 +02:00
class MockPerspectiveServer(object):
def __init__(self):
self.server_name = "mock_server"
self.key = signedjson.key.generate_signing_key(0)
def get_verify_keys(self):
vk = signedjson.key.get_verify_key(self.key)
2018-08-10 15:54:09 +02:00
return {"%s:%s" % (vk.alg, vk.version): vk}
2017-09-20 02:32:42 +02:00
def get_signed_key(self, server_name, verify_key):
key_id = "%s:%s" % (verify_key.alg, verify_key.version)
res = {
"server_name": server_name,
"old_verify_keys": {},
"valid_until_ts": time.time() * 1000 + 3600,
"verify_keys": {
2018-08-10 15:54:09 +02:00
key_id: {"key": signedjson.key.encode_verify_key_base64(verify_key)}
},
2017-09-20 02:32:42 +02:00
}
signedjson.sign.sign_json(res, self.server_name, self.key)
return res
class KeyringTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
2017-09-20 02:32:42 +02:00
self.mock_perspective_server = MockPerspectiveServer()
self.http_client = Mock()
self.hs = yield utils.setup_test_homeserver(
2018-08-13 08:47:46 +02:00
self.addCleanup, handlers=None, http_client=self.http_client
)
2018-08-10 16:01:43 +02:00
keys = self.mock_perspective_server.get_verify_keys()
2018-08-13 08:47:46 +02:00
self.hs.config.perspectives = {self.mock_perspective_server.server_name: keys}
2017-09-20 02:32:42 +02:00
def check_context(self, _, expected):
self.assertEquals(
2018-08-10 15:54:09 +02:00
getattr(LoggingContext.current_context(), "request", None), expected
2017-09-20 02:32:42 +02:00
)
@defer.inlineCallbacks
def test_wait_for_previous_lookups(self):
sentinel_context = LoggingContext.current_context()
kr = keyring.Keyring(self.hs)
lookup_1_deferred = defer.Deferred()
lookup_2_deferred = defer.Deferred()
with LoggingContext("one") as context_one:
context_one.request = "one"
wait_1_deferred = kr.wait_for_previous_lookups(
2018-08-10 15:54:09 +02:00
["server1"], {"server1": lookup_1_deferred}
)
# there were no previous lookups, so the deferred should be ready
self.assertTrue(wait_1_deferred.called)
# ... so we should have preserved the LoggingContext.
self.assertIs(LoggingContext.current_context(), context_one)
2017-09-20 02:32:42 +02:00
wait_1_deferred.addBoth(self.check_context, "one")
with LoggingContext("two") as context_two:
context_two.request = "two"
# set off another wait. It should block because the first lookup
# hasn't yet completed.
wait_2_deferred = kr.wait_for_previous_lookups(
2018-08-10 15:54:09 +02:00
["server1"], {"server1": lookup_2_deferred}
)
self.assertFalse(wait_2_deferred.called)
# ... so we should have reset the LoggingContext.
self.assertIs(LoggingContext.current_context(), sentinel_context)
2017-09-20 02:32:42 +02:00
wait_2_deferred.addBoth(self.check_context, "two")
# let the first lookup complete (in the sentinel context)
lookup_1_deferred.callback(None)
# now the second wait should complete and restore our
# loggingcontext.
yield wait_2_deferred
@defer.inlineCallbacks
def test_verify_json_objects_for_server_awaits_previous_requests(self):
clock = Clock(reactor)
key1 = signedjson.key.generate_signing_key(1)
kr = keyring.Keyring(self.hs)
json1 = {}
2017-09-20 02:32:42 +02:00
signedjson.sign.sign_json(json1, "server10", key1)
persp_resp = {
"server_keys": [
self.mock_perspective_server.get_signed_key(
2018-08-10 15:54:09 +02:00
"server10", signedjson.key.get_verify_key(key1)
)
2017-09-20 02:32:42 +02:00
]
}
persp_deferred = defer.Deferred()
2017-09-20 02:32:42 +02:00
@defer.inlineCallbacks
def get_perspectives(**kwargs):
2018-08-10 15:54:09 +02:00
self.assertEquals(LoggingContext.current_context().request, "11")
2017-09-20 02:32:42 +02:00
with logcontext.PreserveLoggingContext():
yield persp_deferred
defer.returnValue(persp_resp)
2018-08-10 15:54:09 +02:00
2017-09-20 02:32:42 +02:00
self.http_client.post_json.side_effect = get_perspectives
with LoggingContext("11") as context_11:
context_11.request = "11"
2017-09-20 02:32:42 +02:00
# start off a first set of lookups
res_deferreds = kr.verify_json_objects_for_server(
2018-08-10 15:54:09 +02:00
[("server10", json1), ("server11", {})]
2017-09-20 02:32:42 +02:00
)
# the unsigned json should be rejected pretty quickly
self.assertTrue(res_deferreds[1].called)
try:
yield res_deferreds[1]
self.assertFalse("unsigned json didn't cause a failure")
except SynapseError:
pass
self.assertFalse(res_deferreds[0].called)
res_deferreds[0].addBoth(self.check_context, None)
# wait a tick for it to send the request to the perspectives server
# (it first tries the datastore)
2018-08-10 15:54:09 +02:00
yield clock.sleep(1) # XXX find out why this takes so long!
2017-09-20 02:32:42 +02:00
self.http_client.post_json.assert_called_once()
self.assertIs(LoggingContext.current_context(), context_11)
context_12 = LoggingContext("12")
context_12.request = "12"
2017-09-20 02:32:42 +02:00
with logcontext.PreserveLoggingContext(context_12):
# a second request for a server with outstanding requests
# should block rather than start a second call
self.http_client.post_json.reset_mock()
self.http_client.post_json.return_value = defer.Deferred()
res_deferreds_2 = kr.verify_json_objects_for_server(
2018-08-10 15:54:09 +02:00
[("server10", json1)]
2017-09-20 02:32:42 +02:00
)
yield clock.sleep(1)
2017-09-20 02:32:42 +02:00
self.http_client.post_json.assert_not_called()
res_deferreds_2[0].addBoth(self.check_context, None)
# complete the first request
with logcontext.PreserveLoggingContext():
persp_deferred.callback(persp_resp)
self.assertIs(LoggingContext.current_context(), context_11)
with logcontext.PreserveLoggingContext():
yield res_deferreds[0]
yield res_deferreds_2[0]
2017-09-20 02:32:42 +02:00
@defer.inlineCallbacks
def test_verify_json_for_server(self):
kr = keyring.Keyring(self.hs)
key1 = signedjson.key.generate_signing_key(1)
yield self.hs.datastore.store_server_verify_key(
2018-08-10 15:54:09 +02:00
"server9", "", time.time() * 1000, signedjson.key.get_verify_key(key1)
)
2017-09-20 02:32:42 +02:00
json1 = {}
signedjson.sign.sign_json(json1, "server9", key1)
2017-09-20 02:32:42 +02:00
sentinel_context = LoggingContext.current_context()
2017-09-20 02:32:42 +02:00
with LoggingContext("one") as context_one:
context_one.request = "one"
2017-09-20 02:32:42 +02:00
defer = kr.verify_json_for_server("server9", {})
try:
yield defer
self.fail("should fail on unsigned json")
except SynapseError:
pass
self.assertIs(LoggingContext.current_context(), context_one)
2017-09-20 02:32:42 +02:00
defer = kr.verify_json_for_server("server9", json1)
self.assertFalse(defer.called)
self.assertIs(LoggingContext.current_context(), sentinel_context)
yield defer
2017-09-20 02:32:42 +02:00
self.assertIs(LoggingContext.current_context(), context_one)