def render_POST(self, request):
"""
Bulk-lookup for threepids.
** DEPRECATED **
Use /bulk_lookup which returns the result encapsulated in a dict
Params: 'threepids': list of threepids, each of which is a list of medium, address
Returns: List of results where each result is a 3 item list of medium, address, mxid
Threepids for which no mapping is found are omitted.
"""
send_cors(request)
authIfV2(self.sydent, request)
args = get_args(request, ('threepids',))
threepids = args['threepids']
if not isinstance(threepids, list):
request.setResponseCode(400)
return {'errcode': 'M_INVALID_PARAM', 'error': 'threepids must be a list'}, None
logger.info("Bulk lookup of %d threepids (deprecated endpoint)", len(threepids))
globalAssocStore = GlobalAssociationStore(self.sydent)
results = globalAssocStore.getMxids(threepids)
return json.dumps(results)
def render_POST(self, request):
"""
Bulk-lookup for threepids.
Params: 'threepids': list of threepids, each of which is a list of medium, address
Returns: Object with key 'threepids', which is a list of results where each result
is a 3 item list of medium, address, mxid
Note that results are not streamed to the client.
Threepids for which no mapping is found are omitted.
"""
send_cors(request)
authIfV2(self.sydent, request)
args = get_args(request, ('threepids', ))
threepids = args['threepids']
if not isinstance(threepids, list):
raise MatrixRestError(400, 'M_INVALID_PARAM',
'threepids must be a list')
logger.info("Bulk lookup of %d threepids", len(threepids))
globalAssocStore = GlobalAssociationStore(self.sydent)
results = globalAssocStore.getMxids(threepids)
return {'threepids': results}
def render_POST(self, request):
"""
Bulk-lookup for threepids.
** DEPRECATED **
Use /bulk_lookup which returns the result encapsulated in a dict
Params: 'threepids': list of threepids, each of which is a list of medium, address
Returns: List of results where each result is a 3 item list of medium, address, mxid
Threepids for which no mapping is found are omitted.
"""
send_cors(request)
err, args = get_args(request, ('threepids',))
if err:
return json.dumps(err)
threepids = args['threepids']
if not isinstance(threepids, list):
request.setResponseCode(400)
return {'errcode': 'M_INVALID_PARAM', 'error': 'threepids must be a list'}, None
logger.info("Bulk lookup of %d threepids (deprecated endpoint)", len(threepids))
globalAssocStore = GlobalAssociationStore(self.sydent)
results = globalAssocStore.getMxids(threepids)
return json.dumps(results)
def render_POST(self, request):
"""
Bulk-lookup for threepids.
Params: 'threepids': list of threepids, each of which is a list of medium, address
Returns: Object with key 'threepids', which is a list of results where each result
is a 3 item list of medium, address, mxid
Note that results are not streamed to the client.
Threepids for which no mapping is found are omitted.
"""
send_cors(request)
err, args = get_args(request, ('threepids',))
if err:
return json.dumps(err)
threepids = args['threepids']
if not isinstance(threepids, list):
request.setResponseCode(400)
return {'errcode': 'M_INVALID_PARAM', 'error': 'threepids must be a list'}, None
logger.info("Bulk lookup of %d threepids", len(threepids))
globalAssocStore = GlobalAssociationStore(self.sydent)
results = globalAssocStore.getMxids(threepids)
return json.dumps({ 'threepids': results })
def __init__(self, sydent):
super(LocalPeer, self).__init__(sydent.server_name, {})
self.sydent = sydent
globalAssocStore = GlobalAssociationStore(self.sydent)
self.lastId = globalAssocStore.lastIdFromServer(self.servername)
if self.lastId is None:
self.lastId = -1
def __init__(self, sydent):
super(LocalPeer, self).__init__(sydent.server_name, {})
self.sydent = sydent
globalAssocStore = GlobalAssociationStore(self.sydent)
self.lastId = globalAssocStore.lastIdFromServer(self.servername)
if self.lastId is None:
self.lastId = -1
def __init__(self, sydent: "Sydent") -> None:
super().__init__(sydent.config.general.server_name, {})
self.sydent = sydent
self.hashing_store = HashingMetadataStore(sydent)
globalAssocStore = GlobalAssociationStore(self.sydent)
lastId = globalAssocStore.lastIdFromServer(self.servername)
self.lastId = lastId if lastId is not None else -1
def pushUpdates(self, sgAssocs):
globalAssocStore = GlobalAssociationStore(self.sydent)
for localId in sgAssocs:
if localId > self.lastId:
assocObj = threePidAssocFromDict(sgAssocs[localId])
# We can probably skip verification for the local peer (although it could be good as a sanity check)
globalAssocStore.addAssociation(assocObj, json.dumps(sgAssocs[localId]),
self.sydent.server_name, localId)
d = twisted.internet.defer.succeed(True)
return d
def render_GET(self, request: Request) -> JsonDict:
"""
Look up an individual threepid.
** DEPRECATED **
Params: 'medium': the medium of the threepid
'address': the address of the threepid
Returns: A signed association if the threepid has a corresponding mxid, otherwise the empty object.
"""
send_cors(request)
args = get_args(request, ("medium", "address"))
medium = args["medium"]
address = args["address"]
globalAssocStore = GlobalAssociationStore(self.sydent)
sgassoc_raw = globalAssocStore.signedAssociationStringForThreepid(
medium, address)
if not sgassoc_raw:
return {}
# TODO validate this really is a dict
sgassoc: JsonDict = json_decoder.decode(sgassoc_raw)
if self.sydent.config.general.server_name not in sgassoc["signatures"]:
# We have not yet worked out what the proper trust model should be.
#
# Maybe clients implicitly trust a server they talk to (and so we
# should sign every assoc we return as ourselves, so they can
# verify this).
#
# Maybe clients really want to know what server did the original
# verification, and want to only know exactly who signed the assoc.
#
# Until we work out what we should do, sign all assocs we return as
# ourself. This is vaguely ok because there actually is only one
# identity server, but it happens to have two names (matrix.org and
# vector.im), and so we're not really lying too much.
#
# We do this when we return assocs, not when we receive them over
# replication, so that we can undo this decision in the future if
# we wish, without having destroyed the raw underlying data.
sgassoc = signedjson.sign.sign_json(
sgassoc,
self.sydent.config.general.server_name,
self.sydent.keyring.ed25519,
)
return sgassoc
def pushUpdates(self, sgAssocs):
globalAssocStore = GlobalAssociationStore(self.sydent)
for localId in sgAssocs:
if localId > self.lastId:
assocObj = threePidAssocFromDict(sgAssocs[localId])
# We can probably skip verification for the local peer (although it could be good as a sanity check)
globalAssocStore.addAssociation(assocObj,
json.dumps(sgAssocs[localId]),
self.sydent.server_name,
localId)
d = twisted.internet.defer.succeed(True)
return d
def pushUpdates(self, sgAssocs):
globalAssocStore = GlobalAssociationStore(self.sydent)
for localId in sgAssocs:
if localId > self.lastId:
assocObj = threePidAssocFromDict(sgAssocs[localId])
if assocObj.mxid is not None:
# We can probably skip verification for the local peer (although it could be good as a sanity check)
globalAssocStore.addAssociation(assocObj, json.dumps(sgAssocs[localId]),
self.sydent.server_name, localId)
else:
globalAssocStore.removeAssociation(assocObj.medium, assocObj.address)
d = defer.succeed(True)
return d
def render_GET(self, request):
"""
Look up an individual threepid.
Params: 'medium': the medium of the threepid
'address': the address of the threepid
Returns: A signed association if the threepid has a corresponding mxid, otherwise the empty object.
"""
send_cors(request)
err, args = get_args(request, ('medium', 'address'))
if err:
return json.dumps(err)
medium = args['medium']
address = args['address']
globalAssocStore = GlobalAssociationStore(self.sydent)
sgassoc = globalAssocStore.signedAssociationStringForThreepid(medium, address)
if not sgassoc:
return json.dumps({})
sgassoc = json.loads(sgassoc.encode('utf8'))
if not self.sydent.server_name in sgassoc['signatures']:
# We have not yet worked out what the proper trust model should be.
#
# Maybe clients implicitly trust a server they talk to (and so we
# should sign every assoc we return as ourselves, so they can
# verify this).
#
# Maybe clients really want to know what server did the original
# verification, and want to only know exactly who signed the assoc.
#
# Until we work out what we should do, sign all assocs we return as
# ourself. This is vaguely ok because there actually is only one
# identity server, but it happens to have two names (matrix.org and
# vector.im), and so we're not really lying too much.
#
# We do this when we return assocs, not when we receive them over
# replication, so that we can undo this decision in the future if
# we wish, without having destroyed the raw underlying data.
sgassoc = signedjson.sign.sign_json(
sgassoc,
self.sydent.server_name,
self.sydent.keyring.ed25519
)
return json.dumps(sgassoc)
def render_GET(self, request):
"""
Look up an individual threepid.
Params: 'medium': the medium of the threepid
'address': the address of the threepid
Returns: A signed association if the threepid has a corresponding mxid, otherwise the empty object.
"""
send_cors(request)
err, args = get_args(request, ('medium', 'address'))
if err:
return json.dumps(err)
medium = args['medium']
address = args['address']
globalAssocStore = GlobalAssociationStore(self.sydent)
sgassoc = globalAssocStore.signedAssociationStringForThreepid(
medium, address)
if not sgassoc:
return json.dumps({})
sgassoc = json.loads(sgassoc.encode('utf8'))
if not self.sydent.server_name in sgassoc['signatures']:
# We have not yet worked out what the proper trust model should be.
#
# Maybe clients implicitly trust a server they talk to (and so we
# should sign every assoc we return as ourselves, so they can
# verify this).
#
# Maybe clients really want to know what server did the original
# verification, and want to only know exactly who signed the assoc.
#
# Until we work out what we should do, sign all assocs we return as
# ourself. This is vaguely ok because there actually is only one
# identity server, but it happens to have two names (matrix.org and
# vector.im), and so we're not really lying too much.
#
# We do this when we return assocs, not when we receive them over
# replication, so that we can undo this decision in the future if
# we wish, without having destroyed the raw underlying data.
sgassoc = signedjson.sign.sign_json(sgassoc,
self.sydent.server_name,
self.sydent.keyring.ed25519)
return json.dumps(sgassoc)
def render_GET(self, request):
send_cors(request)
err = require_args(request, ('medium', 'address'))
if err:
return err
medium = request.args['medium'][0]
address = request.args['address'][0]
globalAssocStore = GlobalAssociationStore(self.sydent)
sgassoc = globalAssocStore.signedAssociationStringForThreepid(medium, address)
if not sgassoc:
return json.dumps({})
return sgassoc.encode('utf8')
def pushUpdates(self, sgAssocs):
globalAssocStore = GlobalAssociationStore(self.sydent)
for localId in sgAssocs:
if localId > self.lastId:
assocObj = threePidAssocFromDict(sgAssocs[localId])
if assocObj.mxid is not None:
# Assign a lookup_hash to this association
str_to_hash = ' '.join([
assocObj.address, assocObj.medium,
self.hashing_store.get_lookup_pepper()
], )
assocObj.lookup_hash = sha256_and_url_safe_base64(
str_to_hash)
# We can probably skip verification for the local peer (although it could
# be good as a sanity check)
globalAssocStore.addAssociation(
assocObj, json.dumps(sgAssocs[localId]),
self.sydent.server_name, localId)
else:
globalAssocStore.removeAssociation(assocObj.medium,
assocObj.address)
d = defer.succeed(True)
return d
def pushUpdates(self, sgAssocs):
globalAssocStore = GlobalAssociationStore(self.sydent)
for localId in sgAssocs:
if localId > self.lastId:
assocObj = threePidAssocFromDict(sgAssocs[localId])
if assocObj.mxid is not None:
# We can probably skip verification for the local peer (although it could be good as a sanity check)
globalAssocStore.addAssociation(
assocObj, json.dumps(sgAssocs[localId]),
self.sydent.server_name, localId)
else:
globalAssocStore.removeAssociation(assocObj.medium,
assocObj.address)
d = defer.succeed(True)
return d
def pushUpdates(self, sgAssocs: SignedAssociations) -> "Deferred[bool]":
"""
Saves the given associations in the global associations store. Only stores an
association if its ID is greater than the last seen ID.
:param sgAssocs: The associations to save.
:return: A deferred that succeeds with the value `True`.
"""
globalAssocStore = GlobalAssociationStore(self.sydent)
for localId in sgAssocs:
if localId > self.lastId:
assocObj = threePidAssocFromDict(sgAssocs[localId])
# ensure we are casefolding email addresses
assocObj.address = normalise_address(assocObj.address,
assocObj.medium)
if assocObj.mxid is not None:
# Assign a lookup_hash to this association
pepper = self.hashing_store.get_lookup_pepper()
if not pepper:
raise RuntimeError("No lookup_pepper in the database.")
str_to_hash = " ".join([
assocObj.address,
assocObj.medium,
pepper,
], )
assocObj.lookup_hash = sha256_and_url_safe_base64(
str_to_hash)
# We can probably skip verification for the local peer (although it could
# be good as a sanity check)
globalAssocStore.addAssociation(
assocObj,
json.dumps(sgAssocs[localId]),
self.sydent.config.general.server_name,
localId,
)
else:
globalAssocStore.removeAssociation(assocObj.medium,
assocObj.address)
d = defer.succeed(True)
return d
def pushUpdates(self, sgAssocs):
"""
Saves the given associations in the global associations store. Only stores an
association if its ID is greater than the last seen ID.
:param sgAssocs: The associations to save.
:type sgAssocs: dict[int, dict[str, any]]
:return: True
:rtype: twisted.internet.defer.Deferred[bool]
"""
globalAssocStore = GlobalAssociationStore(self.sydent)
for localId in sgAssocs:
if localId > self.lastId:
assocObj = threePidAssocFromDict(sgAssocs[localId])
if assocObj.mxid is not None:
# Assign a lookup_hash to this association
str_to_hash = u' '.join([
assocObj.address, assocObj.medium,
self.hashing_store.get_lookup_pepper()
], )
assocObj.lookup_hash = sha256_and_url_safe_base64(
str_to_hash)
# We can probably skip verification for the local peer (although it could
# be good as a sanity check)
globalAssocStore.addAssociation(
assocObj, json.dumps(sgAssocs[localId]),
self.sydent.server_name, localId)
else:
globalAssocStore.removeAssociation(assocObj.medium,
assocObj.address)
d = defer.succeed(True)
return d
def render_POST(self, request):
peerCert = request.transport.getPeerCertificate()
peerCertCn = peerCert.get_subject().commonName
peerStore = PeerStore(self.sydent)
peer = peerStore.getPeerByName(peerCertCn)
if not peer:
logger.warn("Got connection from %s but no peer found by that name", peerCertCn)
request.setResponseCode(403)
return {'errcode': 'M_UNKNOWN_PEER', 'error': 'This peer is not known to this server'}
logger.info("Push connection made from peer %s", peer.servername)
if not request.requestHeaders.hasHeader('Content-Type') or \
request.requestHeaders.getRawHeaders('Content-Type')[0] != 'application/json':
logger.warn("Peer %s made push connection with non-JSON content (type: %s)",
peer.servername, request.requestHeaders.getRawHeaders('Content-Type')[0])
return {'errcode': 'M_NOT_JSON', 'error': 'This endpoint expects JSON'}
try:
inJson = json.load(request.content)
except ValueError:
logger.warn("Peer %s made push connection with malformed JSON", peer.servername)
return {'errcode': 'M_BAD_JSON', 'error': 'Malformed JSON'}
if 'sgAssocs' not in inJson:
logger.warn("Peer %s made push connection with no 'sgAssocs' key in JSON", peer.servername)
return {'errcode': 'M_BAD_JSON', 'error': 'No "sgAssocs" key in JSON'}
failedIds = []
globalAssocsStore = GlobalAssociationStore(self.sydent)
for originId,sgAssoc in inJson['sgAssocs'].items():
try:
peer.verifySignedAssociation(sgAssoc)
logger.debug("Signed association from %s with origin ID %s verified", peer.servername, originId)
# Don't bother adding if one has already failed: we add all of them or none so we're only going to
# roll back the transaction anyway (but we continue to try & verify the rest so we can give a
# complete list of the ones that don't verify)
if len(failedIds) > 0:
continue
assocObj = threePidAssocFromDict(sgAssoc)
if assocObj.mxid is not None:
globalAssocsStore.addAssociation(assocObj, json.dumps(sgAssoc), peer.servername, originId, commit=False)
else:
logger.info("Incoming deletion: removing associations for %s / %s", assocObj.medium, assocObj.address)
globalAssocsStore.removeAssociation(assocObj.medium, assocObj.address)
logger.info("Stored association origin ID %s from %s", originId, peer.servername)
except:
failedIds.append(originId)
logger.warn("Failed to verify signed association from %s with origin ID %s",
peer.servername, originId)
twisted.python.log.err()
if len(failedIds) > 0:
self.sydent.db.rollback()
request.setResponseCode(400)
return {'errcode': 'M_VERIFICATION_FAILED', 'error': 'Verification failed for one or more associations',
'failed_ids':failedIds}
else:
self.sydent.db.commit()
return {'success':True}
def render_POST(self, request: Request) -> JsonDict:
# Cast safety: This request has an ISSLTransport because this servlet
# is a resource under the ReplicationHttpsServer and nowhere else.
request.transport = cast(ISSLTransport, request.transport)
peerCert = cast(X509, request.transport.getPeerCertificate())
peerCertCn = peerCert.get_subject().commonName
peerStore = PeerStore(self.sydent)
peer = peerStore.getPeerByName(peerCertCn)
if not peer:
logger.warning(
"Got connection from %s but no peer found by that name",
peerCertCn)
raise MatrixRestError(403, "M_UNKNOWN_PEER",
"This peer is not known to this server")
logger.info("Push connection made from peer %s", peer.servername)
if (not request.requestHeaders.hasHeader("Content-Type")
# Type safety: the hasHeader call returned True, so getRawHeaders()
# returns a nonempty list.
or request.requestHeaders.getRawHeaders("Content-Type")[
0] # type: ignore[index]
!= "application/json"):
logger.warning(
"Peer %s made push connection with non-JSON content (type: %s)",
peer.servername,
# Type safety: the hasHeader call returned True, so getRawHeaders()
# returns a nonempty list.
request.requestHeaders.getRawHeaders("Content-Type")
[0], # type: ignore[index]
)
raise MatrixRestError(400, "M_NOT_JSON",
"This endpoint expects JSON")
try:
# json.loads doesn't allow bytes in Python 3.5
inJson = json_decoder.decode(
request.content.read().decode("UTF-8"))
except ValueError:
logger.warning("Peer %s made push connection with malformed JSON",
peer.servername)
raise MatrixRestError(400, "M_BAD_JSON", "Malformed JSON")
if "sgAssocs" not in inJson:
logger.warning(
"Peer %s made push connection with no 'sgAssocs' key in JSON",
peer.servername,
)
raise MatrixRestError(400, "M_BAD_JSON",
'No "sgAssocs" key in JSON')
failedIds: List[int] = []
globalAssocsStore = GlobalAssociationStore(self.sydent)
# Ensure items are pulled out of the dictionary in order of origin_id.
sg_assocs_raw: SignedAssociations = inJson.get("sgAssocs", {})
sg_assocs = sorted(sg_assocs_raw.items(), key=lambda k: int(k[0]))
for originId, sgAssoc in sg_assocs:
try:
peer.verifySignedAssociation(sgAssoc)
logger.debug(
"Signed association from %s with origin ID %s verified",
peer.servername,
originId,
)
# Don't bother adding if one has already failed: we add all of them or none so
# we're only going to roll back the transaction anyway (but we continue to try
# & verify the rest so we can give a complete list of the ones that don't
# verify)
if len(failedIds) > 0:
continue
assocObj = threePidAssocFromDict(sgAssoc)
# ensure we are casefolding email addresses before hashing/storing
assocObj.address = normalise_address(assocObj.address,
assocObj.medium)
if assocObj.mxid is not None:
# Calculate the lookup hash with our own pepper for this association
pepper = self.hashing_store.get_lookup_pepper()
assert pepper is not None
str_to_hash = " ".join(
[assocObj.address, assocObj.medium, pepper], )
assocObj.lookup_hash = sha256_and_url_safe_base64(
str_to_hash)
# Add this association
globalAssocsStore.addAssociation(
assocObj,
json.dumps(sgAssoc),
peer.servername,
originId,
commit=False,
)
else:
logger.info(
"Incoming deletion: removing associations for %s / %s",
assocObj.medium,
assocObj.address,
)
globalAssocsStore.removeAssociation(
assocObj.medium, assocObj.address)
logger.info("Stored association origin ID %s from %s",
originId, peer.servername)
except Exception:
failedIds.append(originId)
logger.warning(
"Failed to verify signed association from %s with origin ID %s",
peer.servername,
originId,
)
twisted.python.log.err()
if len(failedIds) > 0:
self.sydent.db.rollback()
request.setResponseCode(400)
return {
"errcode": "M_VERIFICATION_FAILED",
"error": "Verification failed for one or more associations",
"failed_ids": failedIds,
}
else:
self.sydent.db.commit()
return {"success": True}
def render_POST(self, request):
send_cors(request)
err = require_args(request, ("medium", "address", "room_id", "sender",))
if err:
return json.dumps(err)
medium = request.args["medium"][0]
address = request.args["address"][0]
roomId = request.args["room_id"][0]
sender = request.args["sender"][0]
globalAssocStore = GlobalAssociationStore(self.sydent)
mxid = globalAssocStore.getMxid(medium, address)
if mxid:
request.setResponseCode(400)
return json.dumps({
"errcode": "THREEPID_IN_USE",
"error": "Binding already known",
"mxid": mxid,
})
if medium != "email":
request.setResponseCode(400)
return json.dumps({
"errcode": "M_UNRECOGNIZED",
"error": "Didn't understand medium '%s'" % (medium,),
})
token = self._randomString(128)
tokenStore = JoinTokenStore(self.sydent)
ephemeralPrivateKey = nacl.signing.SigningKey.generate()
ephemeralPublicKey = ephemeralPrivateKey.verify_key
ephemeralPrivateKeyBase64 = encode_base64(ephemeralPrivateKey.encode(), True)
ephemeralPublicKeyBase64 = encode_base64(ephemeralPublicKey.encode(), True)
tokenStore.storeEphemeralPublicKey(ephemeralPublicKeyBase64)
tokenStore.storeToken(medium, address, roomId, sender, token)
substitutions = {}
for key, values in request.args.items():
if len(values) == 1 and type(values[0]) == str:
substitutions[key] = values[0]
substitutions["token"] = token
required = [
'sender_display_name',
'token',
'room_name',
'bracketed_room_name',
'room_avatar_url',
'sender_display_name',
'guest_user_id',
'guest_access_token',
]
for k in required:
substitutions.setdefault(k, '')
substitutions["ephemeral_private_key"] = ephemeralPrivateKeyBase64
if substitutions["room_name"] != '':
substitutions["bracketed_room_name"] = "(%s)" % substitutions["room_name"]
subject_header = Header(self.sydent.cfg.get('email', 'email.invite.subject', raw=True) % substitutions, 'utf8')
substitutions["subject_header_value"] = subject_header.encode()
sendEmail(self.sydent, "email.invite_template", address, substitutions)
pubKey = self.sydent.keyring.ed25519.verify_key
pubKeyBase64 = encode_base64(pubKey.encode())
baseUrl = "%s/_matrix/identity/api/v1" % (self.sydent.cfg.get('http', 'client_http_base'),)
keysToReturn = []
keysToReturn.append({
"public_key": pubKeyBase64,
"key_validity_url": baseUrl + "/pubkey/isvalid",
})
keysToReturn.append({
"public_key": ephemeralPublicKeyBase64,
"key_validity_url": baseUrl + "/pubkey/ephemeral/isvalid",
})
resp = {
"token": token,
"public_key": pubKeyBase64,
"public_keys": keysToReturn,
"display_name": self.redact(address),
}
return json.dumps(resp)
def __init__(self, syd: "Sydent", lookup_pepper: str) -> None:
self.sydent = syd
self.globalAssociationStore = GlobalAssociationStore(self.sydent)
self.lookup_pepper = lookup_pepper
def render_POST(self, request):
peerCert = request.transport.getPeerCertificate()
peerCertCn = peerCert.get_subject().commonName
peerStore = PeerStore(self.sydent)
peer = peerStore.getPeerByName(peerCertCn)
if not peer:
logger.warn(
"Got connection from %s but no peer found by that name",
peerCertCn)
request.setResponseCode(403)
return {
'errcode': 'M_UNKNOWN_PEER',
'error': 'This peer is not known to this server'
}
logger.info("Push connection made from peer %s", peer.servername)
if not request.requestHeaders.hasHeader('Content-Type') or \
request.requestHeaders.getRawHeaders('Content-Type')[0] != 'application/json':
logger.warn(
"Peer %s made push connection with non-JSON content (type: %s)",
peer.servername,
request.requestHeaders.getRawHeaders('Content-Type')[0])
return {
'errcode': 'M_NOT_JSON',
'error': 'This endpoint expects JSON'
}
try:
inJson = json.load(request.content)
except ValueError:
logger.warn("Peer %s made push connection with malformed JSON",
peer.servername)
return {'errcode': 'M_BAD_JSON', 'error': 'Malformed JSON'}
if 'sgAssocs' not in inJson:
logger.warn(
"Peer %s made push connection with no 'sgAssocs' key in JSON",
peer.servername)
return {
'errcode': 'M_BAD_JSON',
'error': 'No "sgAssocs" key in JSON'
}
failedIds = []
globalAssocsStore = GlobalAssociationStore(self.sydent)
for originId, sgAssoc in inJson['sgAssocs'].items():
try:
peer.verifyMessage(sgAssoc)
logger.debug(
"Signed association from %s with origin ID %s verified",
peer.servername, originId)
# Don't bother adding if one has already failed: we add all of them or none so we're only going to
# roll back the transaction anyway (but we continue to try & verify the rest so we can give a
# complete list of the ones that don't verify)
if len(failedIds) > 0:
continue
assocObj = threePidAssocFromDict(sgAssoc)
if assocObj.mxid is not None:
globalAssocsStore.addAssociation(assocObj,
json.dumps(sgAssoc),
peer.servername,
originId,
commit=False)
else:
logger.info(
"Incoming deletion: removing associations for %s / %s",
assocObj.medium, assocObj.address)
globalAssocsStore.removeAssociation(
assocObj.medium, assocObj.address)
logger.info("Stored association origin ID %s from %s",
originId, peer.servername)
except:
failedIds.append(originId)
logger.warn(
"Failed to verify signed association from %s with origin ID %s",
peer.servername, originId)
twisted.python.log.err()
if len(failedIds) > 0:
self.sydent.db.rollback()
request.setResponseCode(400)
return {
'errcode': 'M_VERIFICATION_FAILED',
'error': 'Verification failed for one or more associations',
'failed_ids': failedIds
}
else:
self.sydent.db.commit()
return {'success': True}
def render_POST(self, request):
send_cors(request)
authIfV2(self.sydent, request)
args = get_args(request, ("medium", "address", "room_id", "sender",))
medium = args["medium"]
address = args["address"]
roomId = args["room_id"]
sender = args["sender"]
globalAssocStore = GlobalAssociationStore(self.sydent)
mxid = globalAssocStore.getMxid(medium, address)
if mxid:
request.setResponseCode(400)
return {
"errcode": "M_THREEPID_IN_USE",
"error": "Binding already known",
"mxid": mxid,
}
if medium != "email":
request.setResponseCode(400)
return {
"errcode": "M_UNRECOGNIZED",
"error": "Didn't understand medium '%s'" % (medium,),
}
token = self._randomString(128)
tokenStore = JoinTokenStore(self.sydent)
ephemeralPrivateKey = nacl.signing.SigningKey.generate()
ephemeralPublicKey = ephemeralPrivateKey.verify_key
ephemeralPrivateKeyBase64 = encode_base64(ephemeralPrivateKey.encode(), True)
ephemeralPublicKeyBase64 = encode_base64(ephemeralPublicKey.encode(), True)
tokenStore.storeEphemeralPublicKey(ephemeralPublicKeyBase64)
tokenStore.storeToken(medium, address, roomId, sender, token)
# Variables to substitute in the template.
substitutions = {}
# Include all arguments sent via the request.
for k, v in args.items():
if isinstance(v, string_types):
substitutions[k] = v
substitutions["token"] = token
# Substitutions that the template requires, but are optional to provide
# to the API.
extra_substitutions = [
'sender_display_name',
'token',
'room_name',
'bracketed_room_name',
'room_avatar_url',
'sender_avatar_url',
'guest_user_id',
'guest_access_token',
]
for k in extra_substitutions:
substitutions.setdefault(k, '')
substitutions["ephemeral_private_key"] = ephemeralPrivateKeyBase64
if substitutions["room_name"] != '':
substitutions["bracketed_room_name"] = "(%s)" % substitutions["room_name"]
substitutions["web_client_location"] = self.sydent.default_web_client_location
if 'org.matrix.web_client_location' in substitutions:
substitutions["web_client_location"] = substitutions.pop("org.matrix.web_client_location")
subject_header = Header(self.sydent.cfg.get('email', 'email.invite.subject', raw=True) % substitutions, 'utf8')
substitutions["subject_header_value"] = subject_header.encode()
brand = self.sydent.brand_from_request(request)
templateFile = self.sydent.get_branded_template(
brand,
"invite_template.eml",
('email', 'email.invite_template'),
)
sendEmail(self.sydent, templateFile, address, substitutions)
pubKey = self.sydent.keyring.ed25519.verify_key
pubKeyBase64 = encode_base64(pubKey.encode())
baseUrl = "%s/_matrix/identity/api/v1" % (self.sydent.cfg.get('http', 'client_http_base'),)
keysToReturn = []
keysToReturn.append({
"public_key": pubKeyBase64,
"key_validity_url": baseUrl + "/pubkey/isvalid",
})
keysToReturn.append({
"public_key": ephemeralPublicKeyBase64,
"key_validity_url": baseUrl + "/pubkey/ephemeral/isvalid",
})
resp = {
"token": token,
"public_key": pubKeyBase64,
"public_keys": keysToReturn,
"display_name": self.redact_email_address(address),
}
return resp
def render_POST(self, request):
peerCert = request.transport.getPeerCertificate()
peerCertCn = peerCert.get_subject().commonName
peerStore = PeerStore(self.sydent)
peer = peerStore.getPeerByName(peerCertCn)
if not peer:
logger.warn(
"Got connection from %s but no peer found by that name",
peerCertCn)
raise MatrixRestError(403, 'M_UNKNOWN_PEER',
'This peer is not known to this server')
logger.info("Push connection made from peer %s", peer.servername)
if not request.requestHeaders.hasHeader('Content-Type') or \
request.requestHeaders.getRawHeaders('Content-Type')[0] != 'application/json':
logger.warn(
"Peer %s made push connection with non-JSON content (type: %s)",
peer.servername,
request.requestHeaders.getRawHeaders('Content-Type')[0])
raise MatrixRestError(400, 'M_NOT_JSON',
'This endpoint expects JSON')
try:
# json.loads doesn't allow bytes in Python 3.5
inJson = json.loads(request.content.read().decode("UTF-8"))
except ValueError:
logger.warn("Peer %s made push connection with malformed JSON",
peer.servername)
raise MatrixRestError(400, 'M_BAD_JSON', 'Malformed JSON')
if 'sgAssocs' not in inJson:
logger.warn(
"Peer %s made push connection with no 'sgAssocs' key in JSON",
peer.servername)
raise MatrixRestError(400, 'M_BAD_JSON',
'No "sgAssocs" key in JSON')
failedIds = []
globalAssocsStore = GlobalAssociationStore(self.sydent)
# Ensure items are pulled out of the dictionary in order of origin_id.
sg_assocs = inJson.get('sgAssocs', {})
sg_assocs = sorted(sg_assocs.items(), key=lambda k: int(k[0]))
for originId, sgAssoc in sg_assocs:
try:
peer.verifySignedAssociation(sgAssoc)
logger.debug(
"Signed association from %s with origin ID %s verified",
peer.servername, originId)
# Don't bother adding if one has already failed: we add all of them or none so
# we're only going to roll back the transaction anyway (but we continue to try
# & verify the rest so we can give a complete list of the ones that don't
# verify)
if len(failedIds) > 0:
continue
assocObj = threePidAssocFromDict(sgAssoc)
if assocObj.mxid is not None:
# Calculate the lookup hash with our own pepper for this association
str_to_hash = u' '.join([
assocObj.address, assocObj.medium,
self.hashing_store.get_lookup_pepper()
], )
assocObj.lookup_hash = sha256_and_url_safe_base64(
str_to_hash)
# Add this association
globalAssocsStore.addAssociation(assocObj,
json.dumps(sgAssoc),
peer.servername,
originId,
commit=False)
else:
logger.info(
"Incoming deletion: removing associations for %s / %s",
assocObj.medium, assocObj.address)
globalAssocsStore.removeAssociation(
assocObj.medium, assocObj.address)
logger.info("Stored association origin ID %s from %s",
originId, peer.servername)
except:
failedIds.append(originId)
logger.warn(
"Failed to verify signed association from %s with origin ID %s",
peer.servername, originId)
twisted.python.log.err()
if len(failedIds) > 0:
self.sydent.db.rollback()
request.setResponseCode(400)
return {
'errcode': 'M_VERIFICATION_FAILED',
'error': 'Verification failed for one or more associations',
'failed_ids': failedIds
}
else:
self.sydent.db.commit()
return {'success': True}
def render_POST(self, request: Request) -> JsonDict:
send_cors(request)
args = get_args(
request,
(
"medium",
"address",
"room_id",
"sender",
),
)
medium = args["medium"]
address = args["address"]
roomId = args["room_id"]
sender = args["sender"]
# ensure we are casefolding email address before storing
normalised_address = normalise_address(address, medium)
verified_sender = None
if self.require_auth:
account = authV2(self.sydent, request)
verified_sender = sender
if account.userId != sender:
raise MatrixRestError(403, "M_UNAUTHORIZED",
"'sender' doesn't match")
globalAssocStore = GlobalAssociationStore(self.sydent)
mxid = globalAssocStore.getMxid(medium, normalised_address)
if mxid:
request.setResponseCode(400)
return {
"errcode": "M_THREEPID_IN_USE",
"error": "Binding already known",
"mxid": mxid,
}
if medium != "email":
request.setResponseCode(400)
return {
"errcode": "M_UNRECOGNIZED",
"error": "Didn't understand medium '%s'" % (medium, ),
}
if not (0 < len(address) <= MAX_EMAIL_ADDRESS_LENGTH):
request.setResponseCode(400)
return {
"errcode": "M_INVALID_PARAM",
"error": "Invalid email provided"
}
token = self._randomString(128)
tokenStore = JoinTokenStore(self.sydent)
ephemeralPrivateKey = nacl.signing.SigningKey.generate()
ephemeralPublicKey = ephemeralPrivateKey.verify_key
ephemeralPrivateKeyBase64 = encode_base64(ephemeralPrivateKey.encode(),
True)
ephemeralPublicKeyBase64 = encode_base64(ephemeralPublicKey.encode(),
True)
tokenStore.storeEphemeralPublicKey(ephemeralPublicKeyBase64)
tokenStore.storeToken(medium, normalised_address, roomId, sender,
token)
# Variables to substitute in the template.
substitutions = {}
# Include all arguments sent via the request.
for k, v in args.items():
if isinstance(v, str):
substitutions[k] = v
substitutions["token"] = token
# Substitutions that the template requires, but are optional to provide
# to the API.
extra_substitutions = [
"sender_display_name",
"token",
"room_name",
"bracketed_room_name",
"room_avatar_url",
"sender_avatar_url",
"guest_user_id",
"guest_access_token",
]
for k in extra_substitutions:
substitutions.setdefault(k, "")
# For MSC3288 room type, prefer the stable field, but fallback to the
# unstable field.
if "room_type" not in substitutions:
substitutions["room_type"] = substitutions.get(
"org.matrix.msc3288.room_type", "")
substitutions["bracketed_verified_sender"] = ""
if verified_sender:
substitutions["bracketed_verified_sender"] = "(%s) " % (
verified_sender, )
substitutions["ephemeral_private_key"] = ephemeralPrivateKeyBase64
if substitutions["room_name"] != "":
substitutions[
"bracketed_room_name"] = "(%s) " % substitutions["room_name"]
substitutions[
"web_client_location"] = self.sydent.config.email.default_web_client_location
if "org.matrix.web_client_location" in substitutions:
substitutions["web_client_location"] = substitutions[
"org.matrix.web_client_location"]
if substitutions["room_type"] == "m.space":
subject = self.sydent.config.email.invite_subject_space % substitutions
else:
subject = self.sydent.config.email.invite_subject % substitutions
substitutions["subject_header_value"] = Header(subject,
"utf8").encode()
brand = self.sydent.brand_from_request(request)
# self.sydent.config.email.invite_template is deprecated
if self.sydent.config.email.invite_template is None:
templateFile = self.sydent.get_branded_template(
brand,
"invite_template.eml",
)
else:
templateFile = self.sydent.config.email.invite_template
try:
sendEmail(self.sydent, templateFile, normalised_address,
substitutions)
except EmailAddressException:
request.setResponseCode(HTTPStatus.BAD_REQUEST)
return {
"errcode": "M_INVALID_EMAIL",
"error": "Invalid email address"
}
pubKey = self.sydent.keyring.ed25519.verify_key
pubKeyBase64 = encode_base64(pubKey.encode())
baseUrl = "%s/_matrix/identity/api/v1" % (
self.sydent.config.http.server_http_url_base, )
keysToReturn = []
keysToReturn.append({
"public_key": pubKeyBase64,
"key_validity_url": baseUrl + "/pubkey/isvalid",
})
keysToReturn.append({
"public_key":
ephemeralPublicKeyBase64,
"key_validity_url":
baseUrl + "/pubkey/ephemeral/isvalid",
})
resp = {
"token": token,
"public_key": pubKeyBase64,
"public_keys": keysToReturn,
"display_name": self.redact_email_address(address),
}
return resp
def __init__(self, syd, lookup_pepper):
self.sydent = syd
self.globalAssociationStore = GlobalAssociationStore(self.sydent)
self.lookup_pepper = lookup_pepper
def render_POST(self, request):
send_cors(request)
err, args = get_args(request, ("medium", "address", "room_id", "sender",))
if err:
return json.dumps(err)
medium = args["medium"]
address = args["address"]
roomId = args["room_id"]
sender = args["sender"]
globalAssocStore = GlobalAssociationStore(self.sydent)
mxid = globalAssocStore.getMxid(medium, address)
if mxid:
request.setResponseCode(400)
return json.dumps({
"errcode": "THREEPID_IN_USE",
"error": "Binding already known",
"mxid": mxid,
})
if medium != "email":
request.setResponseCode(400)
return json.dumps({
"errcode": "M_UNRECOGNIZED",
"error": "Didn't understand medium '%s'" % (medium,),
})
token = self._randomString(128)
tokenStore = JoinTokenStore(self.sydent)
ephemeralPrivateKey = nacl.signing.SigningKey.generate()
ephemeralPublicKey = ephemeralPrivateKey.verify_key
ephemeralPrivateKeyBase64 = encode_base64(ephemeralPrivateKey.encode(), True)
ephemeralPublicKeyBase64 = encode_base64(ephemeralPublicKey.encode(), True)
tokenStore.storeEphemeralPublicKey(ephemeralPublicKeyBase64)
tokenStore.storeToken(medium, address, roomId, sender, token)
substitutions = {}
for key, values in request.args.items():
if len(values) == 1 and type(values[0]) == str:
substitutions[key] = values[0]
substitutions["token"] = token
required = [
'sender_display_name',
'token',
'room_name',
'bracketed_room_name',
'room_avatar_url',
'sender_display_name',
'guest_user_id',
'guest_access_token',
]
for k in required:
substitutions.setdefault(k, '')
substitutions["ephemeral_private_key"] = ephemeralPrivateKeyBase64
if substitutions["room_name"] != '':
substitutions["bracketed_room_name"] = "(%s)" % substitutions["room_name"]
subject_header = Header(self.sydent.cfg.get('email', 'email.invite.subject', raw=True) % substitutions, 'utf8')
substitutions["subject_header_value"] = subject_header.encode()
sendEmail(self.sydent, "email.invite_template", address, substitutions)
pubKey = self.sydent.keyring.ed25519.verify_key
pubKeyBase64 = encode_base64(pubKey.encode())
baseUrl = "%s/_matrix/identity/api/v1" % (self.sydent.cfg.get('http', 'client_http_base'),)
keysToReturn = []
keysToReturn.append({
"public_key": pubKeyBase64,
"key_validity_url": baseUrl + "/pubkey/isvalid",
})
keysToReturn.append({
"public_key": ephemeralPublicKeyBase64,
"key_validity_url": baseUrl + "/pubkey/ephemeral/isvalid",
})
resp = {
"token": token,
"public_key": pubKeyBase64,
"public_keys": keysToReturn,
"display_name": self.redact(address),
}
return json.dumps(resp)
class LookupV2Servlet(Resource):
isLeaf = True
def __init__(self, syd, lookup_pepper):
self.sydent = syd
self.globalAssociationStore = GlobalAssociationStore(self.sydent)
self.lookup_pepper = lookup_pepper
@jsonwrap
def render_POST(self, request):
"""
Perform lookups with potentially hashed 3PID details.
Depending on our response to /hash_details, the client will choose a
hash algorithm and pepper, hash the 3PIDs it wants to lookup, and
send them to us, along with the algorithm and pepper it used.
We first check this algorithm/pepper combo matches what we expect,
then compare the 3PID details to what we have in the database.
Params: A JSON object containing the following keys:
* 'addresses': List of hashed/plaintext (depending on the
algorithm) 3PID addresses and mediums.
* 'algorithm': The algorithm the client has used to process
the 3PIDs.
* 'pepper': The pepper the client has attached to the 3PIDs.
Returns: Object with key 'mappings', which is a dictionary of results
where each result is a key/value pair of what the client sent, and
the matching Matrix User ID that claims to own that 3PID.
User IDs for which no mapping is found are omitted.
"""
send_cors(request)
authIfV2(self.sydent, request)
args = get_args(request, ('addresses', 'algorithm', 'pepper'))
addresses = args['addresses']
if not isinstance(addresses, list):
request.setResponseCode(400)
return {'errcode': 'M_INVALID_PARAM', 'error': 'addresses must be a list'}
algorithm = str(args['algorithm'])
if algorithm not in HashDetailsServlet.known_algorithms:
request.setResponseCode(400)
return {'errcode': 'M_INVALID_PARAM', 'error': 'algorithm is not supported'}
# Ensure address count is under the configured limit
limit = int(self.sydent.cfg.get("general", "address_lookup_limit"))
if len(addresses) > limit:
request.setResponseCode(400)
return {'errcode': 'M_TOO_LARGE', 'error': 'More than the maximum amount of '
'addresses provided'}
pepper = str(args['pepper'])
if pepper != self.lookup_pepper:
request.setResponseCode(400)
return {
'errcode': 'M_INVALID_PEPPER',
'error': "pepper does not match '%s'" % (self.lookup_pepper,),
'algorithm': algorithm,
'lookup_pepper': self.lookup_pepper,
}
logger.info("Lookup of %d threepid(s) with algorithm %s", len(addresses), algorithm)
if algorithm == "none":
# Lookup without hashing
medium_address_tuples = []
for address_and_medium in addresses:
# Parse medium, address components
address_medium_split = address_and_medium.split()
# Forbid addresses that contain a space
if len(address_medium_split) != 2:
request.setResponseCode(400)
return {
'errcode': 'M_UNKNOWN',
'error': 'Invalid "address medium" pair: "%s"' % address_and_medium
}
# Get the mxid for the address/medium combo if known
address, medium = address_medium_split
medium_address_tuples.append((medium, address))
# Lookup the mxids
medium_address_mxid_tuples = self.globalAssociationStore.getMxids(medium_address_tuples)
# Return a dictionary of lookup_string: mxid values
return {'mappings': {"%s %s" % (x[1], x[0]): x[2]
for x in medium_address_mxid_tuples}}
elif algorithm == "sha256":
# Lookup using SHA256 with URL-safe base64 encoding
mappings = self.globalAssociationStore.retrieveMxidsForHashes(addresses)
return {'mappings': mappings}
request.setResponseCode(400)
return {'errcode': 'M_INVALID_PARAM', 'error': 'algorithm is not supported'}
def render_OPTIONS(self, request):
send_cors(request)
return b''
