forked-synapse/synapse/storage/e2e_room_keys.py

338 lines
12 KiB
Python
Raw Normal View History

2017-12-04 20:29:25 -05:00
# -*- 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-12-05 12:54:48 -05:00
2018-10-12 06:48:56 -04:00
import json
2018-09-06 11:23:16 -04:00
2017-12-04 20:29:25 -05:00
from twisted.internet import defer
2018-09-06 11:23:16 -04:00
2018-01-07 18:58:32 -05:00
from synapse.api.errors import StoreError
from synapse.logging.opentracing import log_kv, trace
2017-12-04 20:29:25 -05:00
from ._base import SQLBaseStore
class EndToEndRoomKeyStore(SQLBaseStore):
@defer.inlineCallbacks
def get_e2e_room_key(self, user_id, version, room_id, session_id):
"""Get the encrypted E2E room key for a given session from a given
backup version of room_keys. We only store the 'best' room key for a given
session at a given time, as determined by the handler.
Args:
user_id(str): the user whose backup we're querying
version(str): the version ID of the backup for the set of keys we're querying
room_id(str): the ID of the room whose keys we're querying.
This is a bit redundant as it's implied by the session_id, but
we include for consistency with the rest of the API.
session_id(str): the session whose room_key we're querying.
Returns:
A deferred dict giving the session_data and message metadata for
this room key.
"""
2017-12-04 20:29:25 -05:00
row = yield self._simple_select_one(
table="e2e_room_keys",
keyvalues={
"user_id": user_id,
"version": version,
"room_id": room_id,
"session_id": session_id,
},
retcols=(
"first_message_index",
"forwarded_count",
"is_verified",
"session_data",
),
desc="get_e2e_room_key",
)
2018-09-06 11:23:16 -04:00
row["session_data"] = json.loads(row["session_data"])
return row
2017-12-04 20:29:25 -05:00
@defer.inlineCallbacks
2017-12-04 20:29:25 -05:00
def set_e2e_room_key(self, user_id, version, room_id, session_id, room_key):
"""Replaces or inserts the encrypted E2E room key for a given session in
a given backup
Args:
user_id(str): the user whose backup we're setting
version(str): the version ID of the backup we're updating
room_id(str): the ID of the room whose keys we're setting
session_id(str): the session whose room_key we're setting
room_key(dict): the room_key being set
Raises:
2018-10-12 06:48:56 -04:00
StoreError
"""
2017-12-04 20:29:25 -05:00
yield self._simple_upsert(
table="e2e_room_keys",
keyvalues={
"user_id": user_id,
"version": version,
"room_id": room_id,
"session_id": session_id,
},
values={
2019-06-20 05:32:02 -04:00
"first_message_index": room_key["first_message_index"],
"forwarded_count": room_key["forwarded_count"],
"is_verified": room_key["is_verified"],
"session_data": json.dumps(room_key["session_data"]),
},
lock=False,
2017-12-04 20:29:25 -05:00
)
log_kv(
{
"message": "Set room key",
"room_id": room_id,
"session_id": session_id,
"room_key": room_key,
}
)
2017-12-04 20:29:25 -05:00
@trace
2017-12-04 20:29:25 -05:00
@defer.inlineCallbacks
def get_e2e_room_keys(self, user_id, version, room_id=None, session_id=None):
"""Bulk get the E2E room keys for a given backup, optionally filtered to a given
room, or a given session.
Args:
user_id(str): the user whose backup we're querying
version(str): the version ID of the backup for the set of keys we're querying
room_id(str): Optional. the ID of the room whose keys we're querying, if any.
If not specified, we return the keys for all the rooms in the backup.
session_id(str): Optional. the session whose room_key we're querying, if any.
If specified, we also require the room_id to be specified.
If not specified, we return all the keys in this version of
the backup (or for the specified room)
Returns:
A deferred list of dicts giving the session_data and message metadata for
these room keys.
"""
2017-12-04 20:29:25 -05:00
2018-10-30 07:12:23 -04:00
try:
version = int(version)
except ValueError:
return {"rooms": {}}
2018-10-30 07:12:23 -04:00
keyvalues = {"user_id": user_id, "version": version}
2017-12-05 16:44:25 -05:00
if room_id:
2019-06-20 05:32:02 -04:00
keyvalues["room_id"] = room_id
if session_id:
2019-06-20 05:32:02 -04:00
keyvalues["session_id"] = session_id
2017-12-04 20:29:25 -05:00
rows = yield self._simple_select_list(
table="e2e_room_keys",
keyvalues=keyvalues,
retcols=(
2017-12-05 16:44:25 -05:00
"user_id",
"room_id",
"session_id",
2017-12-04 20:29:25 -05:00
"first_message_index",
"forwarded_count",
"is_verified",
"session_data",
),
desc="get_e2e_room_keys",
)
2019-06-20 05:32:02 -04:00
sessions = {"rooms": {}}
2017-12-05 16:44:25 -05:00
for row in rows:
2019-06-20 05:32:02 -04:00
room_entry = sessions["rooms"].setdefault(row["room_id"], {"sessions": {}})
room_entry["sessions"][row["session_id"]] = {
2017-12-05 16:44:25 -05:00
"first_message_index": row["first_message_index"],
"forwarded_count": row["forwarded_count"],
"is_verified": row["is_verified"],
"session_data": json.loads(row["session_data"]),
2017-12-05 16:44:25 -05:00
}
return sessions
2017-12-05 12:54:48 -05:00
@trace
2017-12-05 12:54:48 -05:00
@defer.inlineCallbacks
def delete_e2e_room_keys(self, user_id, version, room_id=None, session_id=None):
"""Bulk delete the E2E room keys for a given backup, optionally filtered to a given
room or a given session.
Args:
user_id(str): the user whose backup we're deleting from
version(str): the version ID of the backup for the set of keys we're deleting
room_id(str): Optional. the ID of the room whose keys we're deleting, if any.
If not specified, we delete the keys for all the rooms in the backup.
session_id(str): Optional. the session whose room_key we're querying, if any.
If specified, we also require the room_id to be specified.
If not specified, we delete all the keys in this version of
the backup (or for the specified room)
Returns:
A deferred of the deletion transaction
"""
2017-12-05 12:54:48 -05:00
keyvalues = {"user_id": user_id, "version": int(version)}
2017-12-05 16:44:25 -05:00
if room_id:
2019-06-20 05:32:02 -04:00
keyvalues["room_id"] = room_id
if session_id:
2019-06-20 05:32:02 -04:00
keyvalues["session_id"] = session_id
2017-12-05 12:54:48 -05:00
yield self._simple_delete(
table="e2e_room_keys", keyvalues=keyvalues, desc="delete_e2e_room_keys"
2017-12-05 12:54:48 -05:00
)
@staticmethod
def _get_current_version(txn, user_id):
txn.execute(
"SELECT MAX(version) FROM e2e_room_keys_versions "
"WHERE user_id=? AND deleted=0",
(user_id,),
)
row = txn.fetchone()
if not row:
2019-06-20 05:32:02 -04:00
raise StoreError(404, "No current backup version")
return row[0]
def get_e2e_room_keys_version_info(self, user_id, version=None):
"""Get info metadata about a version of our room_keys backup.
Args:
user_id(str): the user whose backup we're querying
version(str): Optional. the version ID of the backup we're querying about
If missing, we return the information about the current version.
Raises:
StoreError: with code 404 if there are no e2e_room_keys_versions present
Returns:
2018-11-09 09:38:31 -05:00
A deferred dict giving the info metadata for this backup version, with
fields including:
2018-11-09 08:25:38 -05:00
version(str)
algorithm(str)
auth_data(object): opaque dict supplied by the client
"""
def _get_e2e_room_keys_version_info_txn(txn):
if version is None:
this_version = self._get_current_version(txn, user_id)
2017-12-27 18:58:51 -05:00
else:
try:
this_version = int(version)
except ValueError:
# Our versions are all ints so if we can't convert it to an integer,
# it isn't there.
raise StoreError(404, "No row found")
result = self._simple_select_one_txn(
2017-12-31 09:35:25 -05:00
txn,
table="e2e_room_keys_versions",
keyvalues={"user_id": user_id, "version": this_version, "deleted": 0},
retcols=("version", "algorithm", "auth_data"),
)
result["auth_data"] = json.loads(result["auth_data"])
2018-10-30 06:35:18 -04:00
result["version"] = str(result["version"])
return result
return self.runInteraction(
"get_e2e_room_keys_version_info", _get_e2e_room_keys_version_info_txn
)
@trace
def create_e2e_room_keys_version(self, user_id, info):
2017-12-06 04:02:49 -05:00
"""Atomically creates a new version of this user's e2e_room_keys store
with the given version info.
Args:
user_id(str): the user whose backup we're creating a version
info(dict): the info about the backup version to be created
Returns:
A deferred string for the newly created version ID
2017-12-06 04:02:49 -05:00
"""
def _create_e2e_room_keys_version_txn(txn):
2017-12-06 04:02:49 -05:00
txn.execute(
"SELECT MAX(version) FROM e2e_room_keys_versions WHERE user_id=?",
(user_id,),
2017-12-06 04:02:49 -05:00
)
current_version = txn.fetchone()[0]
if current_version is None:
2019-06-20 05:32:02 -04:00
current_version = "0"
2017-12-06 04:02:49 -05:00
2017-12-31 09:35:25 -05:00
new_version = str(int(current_version) + 1)
2017-12-06 04:02:49 -05:00
self._simple_insert_txn(
txn,
table="e2e_room_keys_versions",
values={
"user_id": user_id,
2017-12-06 04:02:49 -05:00
"version": new_version,
"algorithm": info["algorithm"],
"auth_data": json.dumps(info["auth_data"]),
},
)
2017-12-06 04:02:49 -05:00
return new_version
return self.runInteraction(
"create_e2e_room_keys_version_txn", _create_e2e_room_keys_version_txn
)
@trace
def update_e2e_room_keys_version(self, user_id, version, info):
"""Update a given backup version
Args:
user_id(str): the user whose backup version we're updating
version(str): the version ID of the backup version we're updating
info(dict): the new backup version info to store
"""
return self._simple_update(
table="e2e_room_keys_versions",
keyvalues={"user_id": user_id, "version": version},
updatevalues={"auth_data": json.dumps(info["auth_data"])},
desc="update_e2e_room_keys_version",
)
@trace
def delete_e2e_room_keys_version(self, user_id, version=None):
"""Delete a given backup version of the user's room keys.
Doesn't delete their actual key data.
Args:
user_id(str): the user whose backup version we're deleting
version(str): Optional. the version ID of the backup version we're deleting
If missing, we delete the current backup version info.
Raises:
StoreError: with code 404 if there are no e2e_room_keys_versions present,
or if the version requested doesn't exist.
"""
def _delete_e2e_room_keys_version_txn(txn):
if version is None:
this_version = self._get_current_version(txn, user_id)
else:
this_version = version
return self._simple_update_one_txn(
txn,
table="e2e_room_keys_versions",
keyvalues={"user_id": user_id, "version": this_version},
updatevalues={"deleted": 1},
)
return self.runInteraction(
"delete_e2e_room_keys_version", _delete_e2e_room_keys_version_txn
)