diff --git a/synapse/federation/federation_server.py b/synapse/federation/federation_server.py
index 0597725ce7..5fbd8b19de 100644
--- a/synapse/federation/federation_server.py
+++ b/synapse/federation/federation_server.py
@@ -21,6 +21,13 @@ from .units import Transaction, Edu
from synapse.util.logutils import log_function
from synapse.util.logcontext import PreserveLoggingContext
from synapse.events import FrozenEvent
+from synapse.events.utils import prune_event
+
+from syutil.jsonutil import encode_canonical_json
+
+from synapse.crypto.event_signing import check_event_content_hash
+
+from synapse.api.errors import FederationError, SynapseError
import logging
@@ -97,8 +104,10 @@ class FederationServer(object):
response = yield self.transaction_actions.have_responded(transaction)
if response:
- logger.debug("[%s] We've already responed to this request",
- transaction.transaction_id)
+ logger.debug(
+ "[%s] We've already responed to this request",
+ transaction.transaction_id
+ )
defer.returnValue(response)
return
@@ -221,6 +230,54 @@ class FederationServer(object):
"auth_chain": [a.get_pdu_json(time_now) for a in auth_pdus],
}))
+ @defer.inlineCallbacks
+ def on_query_auth_request(self, origin, content, event_id):
+ """
+ Content is a dict with keys::
+ auth_chain (list): A list of events that give the auth chain.
+ missing (list): A list of event_ids indicating what the other
+ side (`origin`) think we're missing.
+ rejects (dict): A mapping from event_id to a 2-tuple of reason
+ string and a proof (or None) of why the event was rejected.
+ The keys of this dict give the list of events the `origin` has
+ rejected.
+
+ Args:
+ origin (str)
+ content (dict)
+ event_id (str)
+
+ Returns:
+ Deferred: Results in `dict` with the same format as `content`
+ """
+ auth_chain = [
+ (yield self._check_sigs_and_hash(self.event_from_pdu_json(e)))
+ for e in content["auth_chain"]
+ ]
+
+ missing = [
+ (yield self._check_sigs_and_hash(self.event_from_pdu_json(e)))
+ for e in content.get("missing", [])
+ ]
+
+ ret = yield self.handler.on_query_auth(
+ origin, event_id, auth_chain, content.get("rejects", []), missing
+ )
+
+ time_now = self._clock.time_msec()
+ send_content = {
+ "auth_chain": [
+ e.get_pdu_json(time_now)
+ for e in ret["auth_chain"]
+ ],
+ "rejects": ret.get("rejects", []),
+ "missing": ret.get("missing", []),
+ }
+
+ defer.returnValue(
+ (200, send_content)
+ )
+
@log_function
def _get_persisted_pdu(self, origin, event_id, do_auth=True):
""" Get a PDU from the database with given origin and id.
@@ -253,6 +310,9 @@ class FederationServer(object):
origin, pdu.event_id, do_auth=False
)
+ # FIXME: Currently we fetch an event again when we already have it
+ # if it has been marked as an outlier.
+
already_seen = (
existing and (
not existing.internal_metadata.is_outlier()
@@ -264,14 +324,27 @@ class FederationServer(object):
defer.returnValue({})
return
+ # Check signature.
+ try:
+ pdu = yield self._check_sigs_and_hash(pdu)
+ except SynapseError as e:
+ raise FederationError(
+ "ERROR",
+ e.code,
+ e.msg,
+ affected=pdu.event_id,
+ )
+
state = None
auth_chain = []
have_seen = yield self.store.have_events(
- [e for e, _ in pdu.prev_events]
+ [ev for ev, _ in pdu.prev_events]
)
+ fetch_state = False
+
# Get missing pdus if necessary.
if not pdu.internal_metadata.is_outlier():
# We only backfill backwards to the min depth.
@@ -308,19 +381,29 @@ class FederationServer(object):
logger.debug("Processed pdu %s", event_id)
else:
logger.warn("Failed to get PDU %s", event_id)
+ fetch_state = True
except:
# TODO(erikj): Do some more intelligent retries.
logger.exception("Failed to get PDU")
+ fetch_state = True
else:
- # We need to get the state at this event, since we have reached
- # a backward extremity edge.
- logger.debug(
- "_handle_new_pdu getting state for %s",
- pdu.room_id
- )
- state, auth_chain = yield self.get_state_for_room(
- origin, pdu.room_id, pdu.event_id,
- )
+ prevs = {e_id for e_id, _ in pdu.prev_events}
+ seen = set(have_seen.keys())
+ if prevs - seen:
+ fetch_state = True
+ else:
+ fetch_state = True
+
+ if fetch_state:
+ # We need to get the state at this event, since we haven't
+ # processed all the prev events.
+ logger.debug(
+ "_handle_new_pdu getting state for %s",
+ pdu.room_id
+ )
+ state, auth_chain = yield self.get_state_for_room(
+ origin, pdu.room_id, pdu.event_id,
+ )
ret = yield self.handler.on_receive_pdu(
origin,
@@ -343,3 +426,37 @@ class FederationServer(object):
event.internal_metadata.outlier = outlier
return event
+
+ @defer.inlineCallbacks
+ def _check_sigs_and_hash(self, pdu):
+ """Throws a SynapseError if the PDU does not have the correct
+ signatures.
+
+ Returns:
+ FrozenEvent: Either the given event or it redacted if it failed the
+ content hash check.
+ """
+ # Check signatures are correct.
+ redacted_event = prune_event(pdu)
+ redacted_pdu_json = redacted_event.get_pdu_json()
+
+ try:
+ yield self.keyring.verify_json_for_server(
+ pdu.origin, redacted_pdu_json
+ )
+ except SynapseError:
+ logger.warn(
+ "Signature check failed for %s redacted to %s",
+ encode_canonical_json(pdu.get_pdu_json()),
+ encode_canonical_json(redacted_pdu_json),
+ )
+ raise
+
+ if not check_event_content_hash(pdu):
+ logger.warn(
+ "Event content has been tampered, redacting %s, %s",
+ pdu.event_id, encode_canonical_json(pdu.get_dict())
+ )
+ defer.returnValue(redacted_event)
+
+ defer.returnValue(pdu)
|
