char
/
conduit
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat: end to end encryption

next
timokoesters 2020-05-17 19:56:40 +02:00
parent 4fb79ebb4c
commit 7fc71b3968
No known key found for this signature in database
GPG Key ID: 24DA7517711A2BA4
7 changed files with 461 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

236
src/client_server.rs
View File

@ -4,7 +4,7 @@ use std::{
time::{Duration, SystemTime}, time::{Duration, SystemTime},
}; };
use log::debug; use log::{debug, warn};
use rocket::{get, options, post, put, State}; use rocket::{get, options, post, put, State};
use ruma_client_api::{ use ruma_client_api::{
error::{Error, ErrorKind}, error::{Error, ErrorKind},
@ -15,7 +15,7 @@ use ruma_client_api::{
config::{get_global_account_data, set_global_account_data}, config::{get_global_account_data, set_global_account_data},
directory::{self, get_public_rooms_filtered}, directory::{self, get_public_rooms_filtered},
filter::{self, create_filter, get_filter}, filter::{self, create_filter, get_filter},
keys::{get_keys, upload_keys}, keys::{claim_keys, get_keys, upload_keys},
media::get_media_config, media::get_media_config,
membership::{ membership::{
forget_room, get_member_events, invite_user, join_room_by_id, join_room_by_id_or_alias, forget_room, get_member_events, invite_user, join_room_by_id, join_room_by_id_or_alias,
@ -33,7 +33,7 @@ use ruma_client_api::{
state::{create_state_event_for_empty_key, create_state_event_for_key}, state::{create_state_event_for_empty_key, create_state_event_for_key},
sync::sync_events, sync::sync_events,
thirdparty::get_protocols, thirdparty::get_protocols,
to_device::send_event_to_device, to_device::{self, send_event_to_device},
typing::create_typing_event, typing::create_typing_event,
uiaa::{AuthFlow, UiaaInfo, UiaaResponse}, uiaa::{AuthFlow, UiaaInfo, UiaaResponse},
user_directory::search_users, user_directory::search_users,
@ -176,7 +176,8 @@ pub fn register_route(
.update( .update(
None, None,
&user_id, &user_id,
EduEvent::PushRules(ruma_events::push_rules::PushRulesEvent { &EventType::PushRules,
serde_json::to_value(ruma_events::push_rules::PushRulesEvent {
content: ruma_events::push_rules::PushRulesEventContent { content: ruma_events::push_rules::PushRulesEventContent {
global: ruma_events::push_rules::Ruleset { global: ruma_events::push_rules::Ruleset {
content: vec![], content: vec![],
@ -202,7 +203,8 @@ pub fn register_route(
}], }],
}, },
}, },
}), })
.unwrap(),
&db.globals, &db.globals,
) )
.unwrap(); .unwrap();
@ -353,7 +355,8 @@ pub fn set_pushrule_route(
.update( .update(
None, None,
&user_id, &user_id,
EduEvent::PushRules(ruma_events::push_rules::PushRulesEvent { &EventType::PushRules,
serde_json::to_value(ruma_events::push_rules::PushRulesEvent {
content: ruma_events::push_rules::PushRulesEventContent { content: ruma_events::push_rules::PushRulesEventContent {
global: ruma_events::push_rules::Ruleset { global: ruma_events::push_rules::Ruleset {
content: vec![], content: vec![],
@ -379,7 +382,8 @@ pub fn set_pushrule_route(
}], }],
}, },
}, },
}), })
.unwrap(),
&db.globals, &db.globals,
) )
.unwrap(); .unwrap();
@ -422,26 +426,57 @@ pub fn create_filter_route(_user_id: String) -> MatrixResult<create_filter::Resp
})) }))
} }
#[put("/_matrix/client/r0/user/<_user_id>/account_data/<_type>")] #[put(
"/_matrix/client/r0/user/<_user_id>/account_data/<_type>",
data = "<body>"
)]
pub fn set_global_account_data_route( pub fn set_global_account_data_route(
db: State<'_, Database>,
body: Ruma<set_global_account_data::Request>,
_user_id: String, _user_id: String,
_type: String, _type: String,
) -> MatrixResult<set_global_account_data::Response> { ) -> MatrixResult<set_global_account_data::Response> {
let user_id = body.user_id.as_ref().expect("user is authenticated");
db.account_data
.update(
None,
user_id,
&EventType::try_from(&body.event_type).unwrap(),
serde_json::from_str(body.data.get()).unwrap(),
&db.globals,
)
.unwrap();
MatrixResult(Ok(set_global_account_data::Response)) MatrixResult(Ok(set_global_account_data::Response))
} }
#[get("/_matrix/client/r0/user/<_user_id>/account_data/<_type>")] #[get(
"/_matrix/client/r0/user/<_user_id>/account_data/<_type>",
data = "<body>"
)]
pub fn get_global_account_data_route( pub fn get_global_account_data_route(
db: State<'_, Database>,
body: Ruma<get_global_account_data::Request>,
_user_id: String, _user_id: String,
_type: String, _type: String,
) -> MatrixResult<get_global_account_data::Response> { ) -> MatrixResult<get_global_account_data::Response> {
// TODO let user_id = body.user_id.as_ref().expect("user is authenticated");
if let Some(data) = db
.account_data
.get(None, user_id, &EventType::try_from(&body.event_type).unwrap())
.unwrap()
{
MatrixResult(Ok(get_global_account_data::Response { account_data: data }))
} else {
MatrixResult(Err(Error { MatrixResult(Err(Error {
kind: ErrorKind::NotFound, kind: ErrorKind::NotFound,
message: "Data not found.".to_owned(), message: "Data not found.".to_owned(),
status_code: http::StatusCode::NOT_FOUND, status_code: http::StatusCode::NOT_FOUND,
})) }))
} }
}
#[put("/_matrix/client/r0/profile/<_user_id>/displayname", data = "<body>")] #[put("/_matrix/client/r0/profile/<_user_id>/displayname", data = "<body>")]
pub fn set_displayname_route( pub fn set_displayname_route(
@ -648,20 +683,93 @@ pub fn set_presence_route(
MatrixResult(Ok(set_presence::Response)) MatrixResult(Ok(set_presence::Response))
} }
#[post("/_matrix/client/r0/keys/query")] #[post("/_matrix/client/r0/keys/upload", data = "<body>")]
pub fn get_keys_route() -> MatrixResult<get_keys::Response> { pub fn upload_keys_route(
// TODO db: State<'_, Database>,
MatrixResult(Ok(get_keys::Response { body: Ruma<upload_keys::Request>,
failures: BTreeMap::new(), ) -> MatrixResult<upload_keys::Response> {
device_keys: BTreeMap::new(), let user_id = body.user_id.as_ref().expect("user is authenticated");
let device_id = body.device_id.as_ref().expect("user is authenticated");
if let Some(one_time_keys) = &body.one_time_keys {
for (key_key, key_value) in one_time_keys {
db.users
.add_one_time_key(user_id, device_id, key_key, key_value)
.unwrap();
}
}
if let Some(device_keys) = &body.device_keys {
db.users
.add_device_keys(user_id, device_id, device_keys)
.unwrap();
}
MatrixResult(Ok(upload_keys::Response {
one_time_key_counts: db.users.count_one_time_keys(user_id, device_id).unwrap(),
})) }))
} }
#[post("/_matrix/client/r0/keys/upload")] #[post("/_matrix/client/r0/keys/query", data = "<body>")]
pub fn upload_keys_route() -> MatrixResult<upload_keys::Response> { pub fn get_keys_route(
// TODO db: State<'_, Database>,
MatrixResult(Ok(upload_keys::Response { body: Ruma<get_keys::Request>,
one_time_key_counts: BTreeMap::new(), ) -> MatrixResult<get_keys::Response> {
let mut device_keys = BTreeMap::new();
for (user_id, device_ids) in &body.device_keys {
if device_ids.is_empty() {
let mut container = BTreeMap::new();
for (device_id, keys) in db
.users
.all_device_keys(&user_id.clone())
.map(|r| r.unwrap())
{
container.insert(device_id, keys);
}
device_keys.insert(user_id.clone(), container);
} else {
for device_id in device_ids {
let mut container = BTreeMap::new();
for keys in db.users.get_device_keys(&user_id.clone(), &device_id) {
container.insert(device_id.clone(), keys.unwrap());
}
device_keys.insert(user_id.clone(), container);
}
}
}
MatrixResult(Ok(get_keys::Response {
failures: BTreeMap::new(),
device_keys,
}))
}
#[post("/_matrix/client/r0/keys/claim", data = "<body>")]
pub fn claim_keys_route(
db: State<'_, Database>,
body: Ruma<claim_keys::Request>,
) -> MatrixResult<claim_keys::Response> {
let mut one_time_keys = BTreeMap::new();
for (user_id, map) in &body.one_time_keys {
let mut container = BTreeMap::new();
for (device_id, key_algorithm) in map {
if let Some(one_time_keys) = db
.users
.take_one_time_key(user_id, device_id, key_algorithm)
.unwrap()
{
let mut c = BTreeMap::new();
c.insert(one_time_keys.0, one_time_keys.1);
container.insert(device_id.clone(), c);
}
}
one_time_keys.insert(user_id.clone(), container);
}
MatrixResult(Ok(claim_keys::Response {
failures: BTreeMap::new(),
one_time_keys,
})) }))
} }
@ -672,16 +780,19 @@ pub fn set_read_marker_route(
_room_id: String, _room_id: String,
) -> MatrixResult<set_read_marker::Response> { ) -> MatrixResult<set_read_marker::Response> {
let user_id = body.user_id.as_ref().expect("user is authenticated"); let user_id = body.user_id.as_ref().expect("user is authenticated");
db.account_data db.account_data
.update( .update(
Some(&body.room_id), Some(&body.room_id),
&user_id, &user_id,
EduEvent::FullyRead(ruma_events::fully_read::FullyReadEvent { &EventType::FullyRead,
serde_json::to_value(ruma_events::fully_read::FullyReadEvent {
content: ruma_events::fully_read::FullyReadEventContent { content: ruma_events::fully_read::FullyReadEventContent {
event_id: body.fully_read.clone(), event_id: body.fully_read.clone(),
}, },
room_id: Some(body.room_id.clone()), room_id: Some(body.room_id.clone()),
}), })
.unwrap(),
&db.globals, &db.globals,
) )
.unwrap(); .unwrap();
@ -745,7 +856,7 @@ pub fn create_typing_event_route(
content: ruma_events::typing::TypingEventContent { content: ruma_events::typing::TypingEventContent {
user_ids: vec![user_id.clone()], user_ids: vec![user_id.clone()],
}, },
room_id: None, // None because it can be inferred room_id: Some(body.room_id.clone()), // TODO: Can be None because it can be inferred
}); });
if body.typing { if body.typing {
@ -860,7 +971,7 @@ pub fn get_alias_route(
body: Ruma<get_alias::Request>, body: Ruma<get_alias::Request>,
_room_alias: String, _room_alias: String,
) -> MatrixResult<get_alias::Response> { ) -> MatrixResult<get_alias::Response> {
// TODO warn!("TODO: get_alias_route");
let room_id = if body.room_alias.server_name() == db.globals.server_name() { let room_id = if body.room_alias.server_name() == db.globals.server_name() {
match body.room_alias.alias() { match body.room_alias.alias() {
"conduit" => "!lgOCCXQKtXOAPlAlG5:conduit.rs", "conduit" => "!lgOCCXQKtXOAPlAlG5:conduit.rs",
@ -1092,13 +1203,13 @@ pub fn search_users_route(
#[get("/_matrix/client/r0/rooms/<_room_id>/members")] #[get("/_matrix/client/r0/rooms/<_room_id>/members")]
pub fn get_member_events_route(_room_id: String) -> MatrixResult<get_member_events::Response> { pub fn get_member_events_route(_room_id: String) -> MatrixResult<get_member_events::Response> {
// TODO warn!("TODO: get_member_events_route");
MatrixResult(Ok(get_member_events::Response { chunk: Vec::new() })) MatrixResult(Ok(get_member_events::Response { chunk: Vec::new() }))
} }
#[get("/_matrix/client/r0/thirdparty/protocols")] #[get("/_matrix/client/r0/thirdparty/protocols")]
pub fn get_protocols_route() -> MatrixResult<get_protocols::Response> { pub fn get_protocols_route() -> MatrixResult<get_protocols::Response> {
// TODO warn!("TODO: get_protocols_route");
MatrixResult(Ok(get_protocols::Response { MatrixResult(Ok(get_protocols::Response {
protocols: BTreeMap::new(), protocols: BTreeMap::new(),
})) }))
@ -1208,6 +1319,8 @@ pub fn sync_route(
) -> MatrixResult<sync_events::Response> { ) -> MatrixResult<sync_events::Response> {
std::thread::sleep(Duration::from_millis(1500)); std::thread::sleep(Duration::from_millis(1500));
let user_id = body.user_id.as_ref().expect("user is authenticated"); let user_id = body.user_id.as_ref().expect("user is authenticated");
let device_id = body.device_id.as_ref().expect("user is authenticated");
let next_batch = db.globals.current_count().unwrap().to_string(); let next_batch = db.globals.current_count().unwrap().to_string();
let mut joined_rooms = BTreeMap::new(); let mut joined_rooms = BTreeMap::new();
@ -1277,7 +1390,7 @@ pub fn sync_route(
content: ruma_events::typing::TypingEventContent { content: ruma_events::typing::TypingEventContent {
user_ids: Vec::new(), user_ids: Vec::new(),
}, },
room_id: None, // None because it can be inferred room_id: Some(room_id.clone()), // None because it can be inferred
}) })
.into(), .into(),
); );
@ -1403,10 +1516,22 @@ pub fn sync_route(
.global_edus .global_edus
.globallatests_since(since) .globallatests_since(since)
.unwrap() .unwrap()
.map(|edu| { .filter_map(|edu| {
EventJson::<ruma_events::presence::PresenceEvent>::from( // Only look for presence events
edu.unwrap().json().to_owned(), if let Ok(mut edu) = EventJson::<ruma_events::presence::PresenceEvent>::from(
edu.unwrap().into_json(),
) )
.deserialize()
{
let timestamp = edu.content.last_active_ago.unwrap();
edu.content.last_active_ago = Some(
js_int::UInt::try_from(utils::millis_since_unix_epoch()).unwrap()
- timestamp
);
Some(edu.into())
} else {
None
}
}) })
.collect(), .collect(),
}, },
@ -1421,7 +1546,12 @@ pub fn sync_route(
}, },
device_lists: Default::default(), device_lists: Default::default(),
device_one_time_keys_count: Default::default(), device_one_time_keys_count: Default::default(),
to_device: sync_events::ToDevice { events: Vec::new() }, to_device: sync_events::ToDevice {
events: db
.users
.take_to_device_events(user_id, device_id, 100)
.unwrap(),
},
})) }))
} }
@ -1468,7 +1598,7 @@ pub fn get_message_events_route(
#[get("/_matrix/client/r0/voip/turnServer")] #[get("/_matrix/client/r0/voip/turnServer")]
pub fn turn_server_route() -> MatrixResult<create_message_event::Response> { pub fn turn_server_route() -> MatrixResult<create_message_event::Response> {
// TODO warn!("TODO: turn_server_route");
MatrixResult(Err(Error { MatrixResult(Err(Error {
kind: ErrorKind::NotFound, kind: ErrorKind::NotFound,
message: "There is no turn server yet.".to_owned(), message: "There is no turn server yet.".to_owned(),
@ -1478,7 +1608,7 @@ pub fn turn_server_route() -> MatrixResult<create_message_event::Response> {
#[post("/_matrix/client/r0/publicised_groups")] #[post("/_matrix/client/r0/publicised_groups")]
pub fn publicised_groups_route() -> MatrixResult<create_message_event::Response> { pub fn publicised_groups_route() -> MatrixResult<create_message_event::Response> {
// TODO warn!("TODO: publicised_groups_route");
MatrixResult(Err(Error { MatrixResult(Err(Error {
kind: ErrorKind::NotFound, kind: ErrorKind::NotFound,
message: "There are no publicised groups yet.".to_owned(), message: "There are no publicised groups yet.".to_owned(),
@ -1486,18 +1616,48 @@ pub fn publicised_groups_route() -> MatrixResult<create_message_event::Response>
})) }))
} }
#[put("/_matrix/client/r0/sendToDevice/<_event_type>/<_txn_id>")] #[put(
"/_matrix/client/r0/sendToDevice/<_event_type>/<_txn_id>",
data = "<body>"
)]
pub fn send_event_to_device_route( pub fn send_event_to_device_route(
db: State<'_, Database>,
body: Ruma<send_event_to_device::Request>,
_event_type: String, _event_type: String,
_txn_id: String, _txn_id: String,
) -> MatrixResult<send_event_to_device::Response> { ) -> MatrixResult<send_event_to_device::Response> {
// TODO let user_id = body.user_id.as_ref().expect("user is authenticated");
for (target_user_id, map) in &body.messages {
for (target_device_id_maybe, event) in map {
match target_device_id_maybe {
to_device::DeviceIdOrAllDevices::DeviceId(target_device_id) => db
.users
.add_to_device_event(
user_id,
&target_user_id,
&target_device_id,
&body.event_type,
serde_json::from_str(event.get()).unwrap(),
&db.globals,
)
.unwrap(),
to_device::DeviceIdOrAllDevices::AllDevices => {
for target_device_id in db.users.all_device_ids(&target_user_id) {
target_device_id.unwrap();
}
}
}
}
}
MatrixResult(Ok(send_event_to_device::Response)) MatrixResult(Ok(send_event_to_device::Response))
} }
#[get("/_matrix/media/r0/config")] #[get("/_matrix/media/r0/config")]
pub fn get_media_config_route() -> MatrixResult<get_media_config::Response> { pub fn get_media_config_route() -> MatrixResult<get_media_config::Response> {
// TODO warn!("TODO: get_media_config_route");
MatrixResult(Ok(get_media_config::Response { MatrixResult(Ok(get_media_config::Response {
upload_size: 0_u32.into(), upload_size: 0_u32.into(),
})) }))
@ -1509,7 +1669,7 @@ pub fn options_route(
) -> MatrixResult<create_message_event::Response> { ) -> MatrixResult<create_message_event::Response> {
MatrixResult(Err(Error { MatrixResult(Err(Error {
kind: ErrorKind::NotFound, kind: ErrorKind::NotFound,
message: "This is the options route.".to_owned(), message: "".to_owned(),
status_code: http::StatusCode::OK, status_code: http::StatusCode::OK,
})) }))
} }

3
src/database.rs
View File

@ -59,6 +59,9 @@ impl Database {
userid_avatarurl: db.open_tree("userid_avatarurl").unwrap(), userid_avatarurl: db.open_tree("userid_avatarurl").unwrap(),
userdeviceid_token: db.open_tree("userdeviceid_token").unwrap(), userdeviceid_token: db.open_tree("userdeviceid_token").unwrap(),
token_userdeviceid: db.open_tree("token_userdeviceid").unwrap(), token_userdeviceid: db.open_tree("token_userdeviceid").unwrap(),
onetimekeyid_onetimekeys: db.open_tree("onetimekeyid_onetimekeys").unwrap(),
userdeviceid_devicekeys: db.open_tree("userdeviceid_devicekeys").unwrap(),
todeviceid_events: db.open_tree("todeviceid_events").unwrap(),
}, },
rooms: rooms::Rooms { rooms: rooms::Rooms {
edus: rooms::RoomEdus { edus: rooms::RoomEdus {

43
src/database/account_data.rs
View File

@ -1,7 +1,7 @@
use crate::Result; use crate::{utils, Error, Result};
use ruma_events::{collections::only::Event as EduEvent, EventJson}; use ruma_events::{collections::only::Event as EduEvent, EventJson, EventType};
use ruma_identifiers::{RoomId, UserId}; use ruma_identifiers::{RoomId, UserId};
use std::collections::HashMap; use std::{collections::HashMap, convert::TryFrom};
pub struct AccountData { pub struct AccountData {
pub(super) roomuserdataid_accountdata: sled::Tree, // RoomUserDataId = Room + User + Count + Type pub(super) roomuserdataid_accountdata: sled::Tree, // RoomUserDataId = Room + User + Count + Type
@ -13,7 +13,8 @@ impl AccountData {
&self, &self,
room_id: Option<&RoomId>, room_id: Option<&RoomId>,
user_id: &UserId, user_id: &UserId,
event: EduEvent, kind: &EventType,
data: serde_json::Value,
globals: &super::globals::Globals, globals: &super::globals::Globals,
) -> Result<()> { ) -> Result<()> {
let mut prefix = room_id let mut prefix = room_id
@ -48,11 +49,10 @@ impl AccountData {
let mut key = prefix; let mut key = prefix;
key.extend_from_slice(&globals.next_count()?.to_be_bytes()); key.extend_from_slice(&globals.next_count()?.to_be_bytes());
key.push(0xff); key.push(0xff);
let json = serde_json::to_value(&event)?; key.extend_from_slice(kind.to_string().as_bytes());
key.extend_from_slice(json["type"].as_str().unwrap().as_bytes());
self.roomuserdataid_accountdata self.roomuserdataid_accountdata
.insert(key, &*json.to_string()) .insert(key, &*data.to_string())
.unwrap(); .unwrap();
Ok(()) Ok(())
@ -64,7 +64,7 @@ impl AccountData {
&self, &self,
room_id: Option<&RoomId>, room_id: Option<&RoomId>,
user_id: &UserId, user_id: &UserId,
kind: &str, kind: &EventType,
) -> Result<Option<EventJson<EduEvent>>> { ) -> Result<Option<EventJson<EduEvent>>> {
Ok(self.all(room_id, user_id)?.remove(kind)) Ok(self.all(room_id, user_id)?.remove(kind))
} }
@ -75,7 +75,7 @@ impl AccountData {
room_id: Option<&RoomId>, room_id: Option<&RoomId>,
user_id: &UserId, user_id: &UserId,
since: u64, since: u64,
) -> Result<HashMap<String, EventJson<EduEvent>>> { ) -> Result<HashMap<EventType, EventJson<EduEvent>>> {
let mut userdata = HashMap::new(); let mut userdata = HashMap::new();
let mut prefix = room_id let mut prefix = room_id
@ -91,17 +91,30 @@ impl AccountData {
let mut first_possible = prefix.clone(); let mut first_possible = prefix.clone();
first_possible.extend_from_slice(&(since + 1).to_be_bytes()); first_possible.extend_from_slice(&(since + 1).to_be_bytes());
for json in self for r in self
.roomuserdataid_accountdata .roomuserdataid_accountdata
.range(&*first_possible..) .range(&*first_possible..)
.filter_map(|r| r.ok()) .filter_map(|r| r.ok())
.take_while(move |(k, _)| k.starts_with(&prefix)) .take_while(move |(k, _)| k.starts_with(&prefix))
.map(|(_, v)| serde_json::from_slice::<serde_json::Value>(&v).unwrap()) .map(|(k, v)| {
Ok::<_, Error>((
EventType::try_from(utils::string_from_bytes(
k.rsplit(|&b| b == 0xff)
.next()
.ok_or(Error::BadDatabase("roomuserdataid is invalid"))?,
)?)
.map_err(|_| Error::BadDatabase("roomuserdataid is invalid"))?,
serde_json::from_slice::<serde_json::Value>(&v).unwrap(),
))
})
{ {
let (kind, content) = r.unwrap();
let mut json = serde_json::Map::new();
json.insert("content".to_owned(), content);
json.insert("type".to_owned(), kind.to_string().into());
userdata.insert( userdata.insert(
json["type"].as_str().unwrap().to_owned(), kind,
serde_json::from_value::<EventJson<EduEvent>>(json) serde_json::from_value::<EventJson<EduEvent>>(json.into())?,
.expect("userdata in db is valid"),
); );
} }
@ -113,7 +126,7 @@ impl AccountData {
&self, &self,
room_id: Option<&RoomId>, room_id: Option<&RoomId>,
user_id: &UserId, user_id: &UserId,
) -> Result<HashMap<String, EventJson<EduEvent>>> { ) -> Result<HashMap<EventType, EventJson<EduEvent>>> {
self.changes_since(room_id, user_id, 0) self.changes_since(room_id, user_id, 0)
} }
} }

2
src/database/global_edus.rs
View File

@ -3,8 +3,8 @@ use ruma_events::{collections::only::Event as EduEvent, EventJson};
use ruma_identifiers::UserId; use ruma_identifiers::UserId;
pub struct GlobalEdus { pub struct GlobalEdus {
pub(super) globallatestid_globallatest: sled::Tree, // Presence, GlobalLatestId = Count + UserId
//pub globalallid_globalall: sled::Tree, // ToDevice, GlobalAllId = UserId + Count //pub globalallid_globalall: sled::Tree, // ToDevice, GlobalAllId = UserId + Count
pub(super) globallatestid_globallatest: sled::Tree, // Presence, GlobalLatestId = Count + UserId
} }
impl GlobalEdus { impl GlobalEdus {

222
src/database/users.rs
View File

@ -1,6 +1,9 @@
use crate::{utils, Error, Result}; use crate::{utils, Error, Result};
use ruma_identifiers::UserId; use js_int::UInt;
use std::convert::TryFrom; use ruma_client_api::r0::keys::{AlgorithmAndDeviceId, DeviceKeys, KeyAlgorithm, OneTimeKey};
use ruma_events::{to_device::AnyToDeviceEvent, EventJson, EventType};
use ruma_identifiers::{DeviceId, UserId};
use std::{collections::BTreeMap, convert::TryFrom};
pub struct Users { pub struct Users {
pub(super) userid_password: sled::Tree, pub(super) userid_password: sled::Tree,
@ -9,6 +12,11 @@ pub struct Users {
pub(super) userdeviceids: sled::Tree, pub(super) userdeviceids: sled::Tree,
pub(super) userdeviceid_token: sled::Tree, pub(super) userdeviceid_token: sled::Tree,
pub(super) token_userdeviceid: sled::Tree, pub(super) token_userdeviceid: sled::Tree,
pub(super) onetimekeyid_onetimekeys: sled::Tree, // OneTimeKeyId = UserId + AlgorithmAndDeviceId
pub(super) userdeviceid_devicekeys: sled::Tree,
pub(super) todeviceid_events: sled::Tree, // ToDeviceId = UserId + DeviceId + Count
} }
impl Users { impl Users {
@ -96,7 +104,7 @@ impl Users {
} }
/// Adds a new device to a user. /// Adds a new device to a user.
pub fn create_device(&self, user_id: &UserId, device_id: &str, token: &str) -> Result<()> { pub fn create_device(&self, user_id: &UserId, device_id: &DeviceId, token: &str) -> Result<()> {
if !self.exists(user_id)? { if !self.exists(user_id)? {
return Err(Error::BadRequest( return Err(Error::BadRequest(
"tried to create device for nonexistent user", "tried to create device for nonexistent user",
@ -114,8 +122,22 @@ impl Users {
Ok(()) Ok(())
} }
/// Returns an iterator over all device ids of this user.
pub fn all_device_ids(&self, user_id: &UserId) -> impl Iterator<Item = Result<DeviceId>> {
let mut prefix = user_id.to_string().as_bytes().to_vec();
prefix.push(0xff);
self.userdeviceids.scan_prefix(prefix).keys().map(|bytes| {
Ok(utils::string_from_bytes(
&*bytes?
.rsplit(|&b| b == 0xff)
.next()
.ok_or(Error::BadDatabase("userdeviceid is invalid"))?,
)?)
})
}
/// Replaces the access token of one device. /// Replaces the access token of one device.
pub fn set_token(&self, user_id: &UserId, device_id: &str, token: &str) -> Result<()> { pub fn set_token(&self, user_id: &UserId, device_id: &DeviceId, token: &str) -> Result<()> {
let mut userdeviceid = user_id.to_string().as_bytes().to_vec(); let mut userdeviceid = user_id.to_string().as_bytes().to_vec();
userdeviceid.push(0xff); userdeviceid.push(0xff);
userdeviceid.extend_from_slice(device_id.as_bytes()); userdeviceid.extend_from_slice(device_id.as_bytes());
@ -138,4 +160,196 @@ impl Users {
Ok(()) Ok(())
} }
pub fn add_one_time_key(
&self,
user_id: &UserId,
device_id: &DeviceId,
one_time_key_key: &AlgorithmAndDeviceId,
one_time_key_value: &OneTimeKey,
) -> Result<()> {
let mut key = user_id.to_string().as_bytes().to_vec();
key.push(0xff);
key.extend_from_slice(device_id.as_bytes());
if self.userdeviceids.get(&key)?.is_none() {
return Err(Error::BadRequest(
"Tried to set token for nonexistent device",
));
}
key.push(0xff);
// TODO: Use AlgorithmAndDeviceId::to_string when it's available (and update everything,
// because there are no wrapping quotation marks anymore)
key.extend_from_slice(&serde_json::to_string(one_time_key_key)?.as_bytes());
self.onetimekeyid_onetimekeys
.insert(&key, &*serde_json::to_string(&one_time_key_value)?)?;
Ok(())
}
pub fn take_one_time_key(
&self,
user_id: &UserId,
device_id: &DeviceId,
key_algorithm: &KeyAlgorithm,
) -> Result<Option<(AlgorithmAndDeviceId, OneTimeKey)>> {
let mut prefix = user_id.to_string().as_bytes().to_vec();
prefix.push(0xff);
prefix.extend_from_slice(device_id.as_bytes());
prefix.push(0xff);
prefix.push(b'"'); // Annoying quotation mark
prefix.extend_from_slice(key_algorithm.to_string().as_bytes());
prefix.push(b':');
self.onetimekeyid_onetimekeys
.scan_prefix(&prefix)
.next()
.map(|r| {
let (key, value) = r?;
Ok((
serde_json::from_slice(
&*key
.rsplit(|&b| b == 0xff)
.next()
.ok_or(Error::BadDatabase("onetimekeyid is invalid"))?,
)?,
serde_json::from_slice(&*value)?,
))
})
.transpose()
}
pub fn count_one_time_keys(
&self,
user_id: &UserId,
device_id: &DeviceId,
) -> Result<BTreeMap<KeyAlgorithm, UInt>> {
let mut userdeviceid = user_id.to_string().as_bytes().to_vec();
userdeviceid.push(0xff);
userdeviceid.extend_from_slice(device_id.as_bytes());
let mut counts = BTreeMap::new();
for algorithm in self
.onetimekeyid_onetimekeys
.scan_prefix(&userdeviceid)
.keys()
.map(|bytes| {
Ok::<_, Error>(
serde_json::from_slice::<AlgorithmAndDeviceId>(
&*bytes?
.rsplit(|&b| b == 0xff)
.next()
.ok_or(Error::BadDatabase("onetimekeyid is invalid"))?,
)?
.0,
)
})
{
*counts.entry(algorithm?).or_default() += UInt::from(1_u32);
}
Ok(counts)
}
pub fn add_device_keys(
&self,
user_id: &UserId,
device_id: &DeviceId,
device_keys: &DeviceKeys,
) -> Result<()> {
let mut userdeviceid = user_id.to_string().as_bytes().to_vec();
userdeviceid.push(0xff);
userdeviceid.extend_from_slice(device_id.as_bytes());
self.userdeviceid_devicekeys
.insert(&userdeviceid, &*serde_json::to_string(&device_keys)?)?;
Ok(())
}
pub fn get_device_keys(
&self,
user_id: &UserId,
device_id: &DeviceId,
) -> impl Iterator<Item = Result<DeviceKeys>> {
let mut key = user_id.to_string().as_bytes().to_vec();
key.push(0xff);
key.extend_from_slice(device_id.as_bytes());
self.userdeviceid_devicekeys
.scan_prefix(key)
.values()
.map(|bytes| Ok(serde_json::from_slice(&bytes?)?))
}
pub fn all_device_keys(
&self,
user_id: &UserId,
) -> impl Iterator<Item = Result<(String, DeviceKeys)>> {
let mut key = user_id.to_string().as_bytes().to_vec();
key.push(0xff);
self.userdeviceid_devicekeys.scan_prefix(key).map(|r| {
let (key, value) = r?;
Ok((
utils::string_from_bytes(
key.rsplit(|&b| b == 0xff)
.next()
.ok_or(Error::BadDatabase("userdeviceid is invalid"))?,
)?,
serde_json::from_slice(&*value)?,
))
})
}
pub fn add_to_device_event(
&self,
sender: &UserId,
target_user_id: &UserId,
target_device_id: &DeviceId,
event_type: &EventType,
content: serde_json::Value,
globals: &super::globals::Globals,
) -> Result<()> {
let mut key = target_user_id.to_string().as_bytes().to_vec();
key.push(0xff);
key.extend_from_slice(target_device_id.as_bytes());
key.push(0xff);
key.extend_from_slice(&globals.next_count()?.to_be_bytes());
let mut json = serde_json::Map::new();
json.insert("type".to_owned(), event_type.to_string().into());
json.insert("sender".to_owned(), sender.to_string().into());
json.insert("content".to_owned(), content);
self.todeviceid_events
.insert(&key, &*serde_json::to_string(&json)?)?;
Ok(())
}
pub fn take_to_device_events(
&self,
user_id: &UserId,
device_id: &DeviceId,
max: usize,
) -> Result<Vec<EventJson<AnyToDeviceEvent>>> {
let mut events = Vec::new();
let mut prefix = user_id.to_string().as_bytes().to_vec();
prefix.push(0xff);
prefix.extend_from_slice(device_id.as_bytes());
prefix.push(0xff);
for result in self.todeviceid_events.scan_prefix(&prefix).take(max) {
let (key, value) = result?;
events.push(serde_json::from_slice(&*value)?);
self.todeviceid_events.remove(key)?;
}
Ok(events)
}
} }

3
src/main.rs
View File

@ -43,8 +43,9 @@ fn setup_rocket() -> rocket::Rocket {
client_server::get_avatar_url_route, client_server::get_avatar_url_route,
client_server::get_profile_route, client_server::get_profile_route,
client_server::set_presence_route, client_server::set_presence_route,
client_server::get_keys_route,
client_server::upload_keys_route, client_server::upload_keys_route,
client_server::get_keys_route,
client_server::claim_keys_route,
client_server::set_read_marker_route, client_server::set_read_marker_route,
client_server::create_typing_event_route, client_server::create_typing_event_route,
client_server::create_room_route, client_server::create_room_route,

7
src/server_server.rs
View File

@ -166,7 +166,12 @@ pub fn get_server_keys(db: State<'_, Database>) -> Json<String> {
.body(), .body(),
) )
.unwrap(); .unwrap();
ruma_signatures::sign_json(db.globals.server_name(), db.globals.keypair(), &mut response).unwrap(); ruma_signatures::sign_json(
db.globals.server_name(),
db.globals.keypair(),
&mut response,
)
.unwrap();
Json(response.to_string()) Json(response.to_string())
} }