Page MenuHomePhabricator
Differential D8976

[keyserver] Determine which ids to fetch based on specs
ClosedPublic
Actions

Authored by tomek on Aug 28 2023, 5:08 AM.
Tags
None
Referenced Files
Unknown Object (File)
Tue, Apr 8, 9:54 AM
Unknown Object (File)
Thu, Apr 3, 7:36 AM
Unknown Object (File)
Tue, Apr 1, 12:05 PM
Unknown Object (File)
Mar 23 2025, 10:21 PM
Unknown Object (File)
Mar 7 2025, 7:57 AM
Unknown Object (File)
Mar 3 2025, 4:12 PM
Unknown Object (File)
Mar 1 2025, 3:24 PM
Unknown Object (File)
Mar 1 2025, 3:24 PM
View All Files
Subscribers
ashoat

Details

Reviewers
kamil
bartek
inka
Commits
rCOMM62cd9949117a: [keyserver] Determine which ids to fetch based on specs
Summary

Specify for which entry types we would like to narrow down the data we're synchronizing and determine a set of ids to fetch based on that.

https://linear.app/comm/issue/ENG-4631/migrate-checkstate-from-session-utils-to-a-spec

Depends on D8949

Test Plan

Modify keyserver db and check if the store get fixed.

Diff Detail

Repository
rCOMM Comm
Branch
state-sync
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
keyserver/
src/
shared/
state-sync/
1 line
1 line
1 line
1 line
socket/
32 lines

Diff 30434

View Options

keyserver/src/shared/state-sync/entries-state-sync-spec.js

use argon2::Argon2; use argon2::Argon2;
use digest::generic_array::GenericArray; use digest::generic_array::GenericArray;
use digest::Digest; use digest::Digest;
use neon::prelude::*; use neon::prelude::*;
use neon::types::buffer::TypedArray;
use opaque_ke::ciphersuite::CipherSuite; use opaque_ke::ciphersuite::CipherSuite;
use opaque_ke::errors::InternalPakeError; use opaque_ke::errors::InternalPakeError;
use opaque_ke::hash::Hash; use opaque_ke::hash::Hash;
use opaque_ke::slow_hash::SlowHash; use opaque_ke::slow_hash::SlowHash;
use opaque_ke::{ClientRegistration, RegistrationRequest}; use opaque_ke::{
ClientRegistration, ClientRegistrationFinishParameters, RegistrationRequest,
RegistrationResponse, RegistrationUpload,
};
use rand::rngs::OsRng; use rand::rngs::OsRng;
struct Cipher; struct Cipher;
impl CipherSuite for Cipher { impl CipherSuite for Cipher {
type Group = curve25519_dalek::ristretto::RistrettoPoint; type Group = curve25519_dalek::ristretto::RistrettoPoint;
type KeyExchange = opaque_ke::key_exchange::tripledh::TripleDH; type KeyExchange = opaque_ke::key_exchange::tripledh::TripleDH;
type Hash = sha2::Sha512; type Hash = sha2::Sha512;
Show All 17 Lines
struct ClientRegistrationStartResult { struct ClientRegistrationStartResult {
message: RegistrationRequest<Cipher>, message: RegistrationRequest<Cipher>,
state: ClientRegistration<Cipher>, state: ClientRegistration<Cipher>,
} }
impl Finalize for ClientRegistrationStartResult {} impl Finalize for ClientRegistrationStartResult {}
struct ClientRegistrationFinishResult {
message: RegistrationUpload<Cipher>,
}
impl Finalize for ClientRegistrationFinishResult {}
fn client_register_start( fn client_register_start(
mut cx: FunctionContext, mut cx: FunctionContext,
) -> JsResult<JsBox<ClientRegistrationStartResult>> { ) -> JsResult<JsBox<ClientRegistrationStartResult>> {
let password = cx.argument::<JsString>(0)?; let password = cx.argument::<JsString>(0)?;
let mut client_rng = OsRng; let mut client_rng = OsRng;
let client_registration_start_result = ClientRegistration::<Cipher>::start( let client_registration_start_result = ClientRegistration::<Cipher>::start(
&mut client_rng, &mut client_rng,
password.value(&mut cx).as_bytes(), password.value(&mut cx).as_bytes(),
Show All 22 Lines) -> JsResult<JsArrayBuffer> {
let client_registration_start_result = let client_registration_start_result =
cx.argument::<JsBox<ClientRegistrationStartResult>>(0)?; cx.argument::<JsBox<ClientRegistrationStartResult>>(0)?;
Ok(JsArrayBuffer::external( Ok(JsArrayBuffer::external(
&mut cx, &mut cx,
client_registration_start_result.state.serialize(), client_registration_start_result.state.serialize(),
)) ))
} }
fn client_register_finish(
mut cx: FunctionContext,
) -> JsResult<JsBox<ClientRegistrationFinishResult>> {
let client_register_state = cx.argument::<JsTypedArray<u8>>(0)?;
let server_message = cx.argument::<JsTypedArray<u8>>(1)?;
let client_register_state = ClientRegistration::<Cipher>::deserialize(
&client_register_state.as_slice(&cx),
tomekUnsubmitted
Not Done
Inline Actions

Can we avoid shadowing? I think that it reduces maintainability significantly.

tomek: Can we avoid shadowing? I think that it reduces maintainability significantly.
varunAuthorUnsubmitted
Done
Inline Actions

sure!

varun: sure!
)
.or_else(|err| cx.throw_error(err.to_string()))?;
let server_message =
RegistrationResponse::<Cipher>::deserialize(&server_message.as_slice(&cx))
.or_else(|err| cx.throw_error(err.to_string()))?;
let mut client_rng = OsRng;
let client_registration_finish_result = ClientRegistrationFinishResult {
message: client_register_state
.finish(
&mut client_rng,
server_message,
ClientRegistrationFinishParameters::Default,
)
.or_else(|err| cx.throw_error(err.to_string()))?
.message,
};
Ok(cx.boxed(client_registration_finish_result))
}
fn get_registration_finish_message_array(
mut cx: FunctionContext,
) -> JsResult<JsArrayBuffer> {
let client_registration_finish_result =
cx.argument::<JsBox<ClientRegistrationFinishResult>>(0)?;
Ok(JsArrayBuffer::external(
&mut cx,
client_registration_finish_result.message.serialize(),
))
}
#[neon::main] #[neon::main]
fn main(mut cx: ModuleContext) -> NeonResult<()> { fn main(mut cx: ModuleContext) -> NeonResult<()> {
cx.export_function("client_register_start", client_register_start)?; cx.export_function("client_register_start", client_register_start)?;
cx.export_function( cx.export_function(
"get_registration_start_message_array", "get_registration_start_message_array",
get_registration_start_message_array, get_registration_start_message_array,
)?; )?;
cx.export_function( cx.export_function(
"get_registration_start_state_array", "get_registration_start_state_array",
get_registration_start_state_array, get_registration_start_state_array,
)?; )?;
cx.export_function("client_register_finish", client_register_finish)?;
cx.export_function(
"get_registration_finish_message_array",
get_registration_finish_message_array,
)?;
Ok(()) Ok(())
} }
View Options

keyserver/src/shared/state-sync/state-sync-spec.js

use argon2::Argon2; use argon2::Argon2;
use digest::generic_array::GenericArray; use digest::generic_array::GenericArray;
use digest::Digest; use digest::Digest;
use neon::prelude::*; use neon::prelude::*;
use neon::types::buffer::TypedArray;
use opaque_ke::ciphersuite::CipherSuite; use opaque_ke::ciphersuite::CipherSuite;
use opaque_ke::errors::InternalPakeError; use opaque_ke::errors::InternalPakeError;
use opaque_ke::hash::Hash; use opaque_ke::hash::Hash;
use opaque_ke::slow_hash::SlowHash; use opaque_ke::slow_hash::SlowHash;
use opaque_ke::{ClientRegistration, RegistrationRequest}; use opaque_ke::{
ClientRegistration, ClientRegistrationFinishParameters, RegistrationRequest,
RegistrationResponse, RegistrationUpload,
};
use rand::rngs::OsRng; use rand::rngs::OsRng;
struct Cipher; struct Cipher;
impl CipherSuite for Cipher { impl CipherSuite for Cipher {
type Group = curve25519_dalek::ristretto::RistrettoPoint; type Group = curve25519_dalek::ristretto::RistrettoPoint;
type KeyExchange = opaque_ke::key_exchange::tripledh::TripleDH; type KeyExchange = opaque_ke::key_exchange::tripledh::TripleDH;
type Hash = sha2::Sha512; type Hash = sha2::Sha512;
Show All 17 Lines
struct ClientRegistrationStartResult { struct ClientRegistrationStartResult {
message: RegistrationRequest<Cipher>, message: RegistrationRequest<Cipher>,
state: ClientRegistration<Cipher>, state: ClientRegistration<Cipher>,
} }
impl Finalize for ClientRegistrationStartResult {} impl Finalize for ClientRegistrationStartResult {}
struct ClientRegistrationFinishResult {
message: RegistrationUpload<Cipher>,
}
impl Finalize for ClientRegistrationFinishResult {}
fn client_register_start( fn client_register_start(
mut cx: FunctionContext, mut cx: FunctionContext,
) -> JsResult<JsBox<ClientRegistrationStartResult>> { ) -> JsResult<JsBox<ClientRegistrationStartResult>> {
let password = cx.argument::<JsString>(0)?; let password = cx.argument::<JsString>(0)?;
let mut client_rng = OsRng; let mut client_rng = OsRng;
let client_registration_start_result = ClientRegistration::<Cipher>::start( let client_registration_start_result = ClientRegistration::<Cipher>::start(
&mut client_rng, &mut client_rng,
password.value(&mut cx).as_bytes(), password.value(&mut cx).as_bytes(),
Show All 22 Lines) -> JsResult<JsArrayBuffer> {
let client_registration_start_result = let client_registration_start_result =
cx.argument::<JsBox<ClientRegistrationStartResult>>(0)?; cx.argument::<JsBox<ClientRegistrationStartResult>>(0)?;
Ok(JsArrayBuffer::external( Ok(JsArrayBuffer::external(
&mut cx, &mut cx,
client_registration_start_result.state.serialize(), client_registration_start_result.state.serialize(),
)) ))
} }
fn client_register_finish(
mut cx: FunctionContext,
) -> JsResult<JsBox<ClientRegistrationFinishResult>> {
let client_register_state = cx.argument::<JsTypedArray<u8>>(0)?;
let server_message = cx.argument::<JsTypedArray<u8>>(1)?;
let client_register_state = ClientRegistration::<Cipher>::deserialize(
&client_register_state.as_slice(&cx),
tomekUnsubmitted
Not Done
Inline Actions

Can we avoid shadowing? I think that it reduces maintainability significantly.

tomek: Can we avoid shadowing? I think that it reduces maintainability significantly.
varunAuthorUnsubmitted
Done
Inline Actions

sure!

varun: sure!
)
.or_else(|err| cx.throw_error(err.to_string()))?;
let server_message =
RegistrationResponse::<Cipher>::deserialize(&server_message.as_slice(&cx))
.or_else(|err| cx.throw_error(err.to_string()))?;
let mut client_rng = OsRng;
let client_registration_finish_result = ClientRegistrationFinishResult {
message: client_register_state
.finish(
&mut client_rng,
server_message,
ClientRegistrationFinishParameters::Default,
)
.or_else(|err| cx.throw_error(err.to_string()))?
.message,
};
Ok(cx.boxed(client_registration_finish_result))
}
fn get_registration_finish_message_array(
mut cx: FunctionContext,
) -> JsResult<JsArrayBuffer> {
let client_registration_finish_result =
cx.argument::<JsBox<ClientRegistrationFinishResult>>(0)?;
Ok(JsArrayBuffer::external(
&mut cx,
client_registration_finish_result.message.serialize(),
))
}
#[neon::main] #[neon::main]
fn main(mut cx: ModuleContext) -> NeonResult<()> { fn main(mut cx: ModuleContext) -> NeonResult<()> {
cx.export_function("client_register_start", client_register_start)?; cx.export_function("client_register_start", client_register_start)?;
cx.export_function( cx.export_function(
"get_registration_start_message_array", "get_registration_start_message_array",
get_registration_start_message_array, get_registration_start_message_array,
)?; )?;
cx.export_function( cx.export_function(
"get_registration_start_state_array", "get_registration_start_state_array",
get_registration_start_state_array, get_registration_start_state_array,
)?; )?;
cx.export_function("client_register_finish", client_register_finish)?;
cx.export_function(
"get_registration_finish_message_array",
get_registration_finish_message_array,
)?;
Ok(()) Ok(())
} }
View Options

keyserver/src/shared/state-sync/threads-state-sync-spec.js

use argon2::Argon2; use argon2::Argon2;
use digest::generic_array::GenericArray; use digest::generic_array::GenericArray;
use digest::Digest; use digest::Digest;
use neon::prelude::*; use neon::prelude::*;
use neon::types::buffer::TypedArray;
use opaque_ke::ciphersuite::CipherSuite; use opaque_ke::ciphersuite::CipherSuite;
use opaque_ke::errors::InternalPakeError; use opaque_ke::errors::InternalPakeError;
use opaque_ke::hash::Hash; use opaque_ke::hash::Hash;
use opaque_ke::slow_hash::SlowHash; use opaque_ke::slow_hash::SlowHash;
use opaque_ke::{ClientRegistration, RegistrationRequest}; use opaque_ke::{
ClientRegistration, ClientRegistrationFinishParameters, RegistrationRequest,
RegistrationResponse, RegistrationUpload,
};
use rand::rngs::OsRng; use rand::rngs::OsRng;
struct Cipher; struct Cipher;
impl CipherSuite for Cipher { impl CipherSuite for Cipher {
type Group = curve25519_dalek::ristretto::RistrettoPoint; type Group = curve25519_dalek::ristretto::RistrettoPoint;
type KeyExchange = opaque_ke::key_exchange::tripledh::TripleDH; type KeyExchange = opaque_ke::key_exchange::tripledh::TripleDH;
type Hash = sha2::Sha512; type Hash = sha2::Sha512;
Show All 17 Lines
struct ClientRegistrationStartResult { struct ClientRegistrationStartResult {
message: RegistrationRequest<Cipher>, message: RegistrationRequest<Cipher>,
state: ClientRegistration<Cipher>, state: ClientRegistration<Cipher>,
} }
impl Finalize for ClientRegistrationStartResult {} impl Finalize for ClientRegistrationStartResult {}
struct ClientRegistrationFinishResult {
message: RegistrationUpload<Cipher>,
}
impl Finalize for ClientRegistrationFinishResult {}
fn client_register_start( fn client_register_start(
mut cx: FunctionContext, mut cx: FunctionContext,
) -> JsResult<JsBox<ClientRegistrationStartResult>> { ) -> JsResult<JsBox<ClientRegistrationStartResult>> {
let password = cx.argument::<JsString>(0)?; let password = cx.argument::<JsString>(0)?;
let mut client_rng = OsRng; let mut client_rng = OsRng;
let client_registration_start_result = ClientRegistration::<Cipher>::start( let client_registration_start_result = ClientRegistration::<Cipher>::start(
&mut client_rng, &mut client_rng,
password.value(&mut cx).as_bytes(), password.value(&mut cx).as_bytes(),
Show All 22 Lines) -> JsResult<JsArrayBuffer> {
let client_registration_start_result = let client_registration_start_result =
cx.argument::<JsBox<ClientRegistrationStartResult>>(0)?; cx.argument::<JsBox<ClientRegistrationStartResult>>(0)?;
Ok(JsArrayBuffer::external( Ok(JsArrayBuffer::external(
&mut cx, &mut cx,
client_registration_start_result.state.serialize(), client_registration_start_result.state.serialize(),
)) ))
} }
fn client_register_finish(
mut cx: FunctionContext,
) -> JsResult<JsBox<ClientRegistrationFinishResult>> {
let client_register_state = cx.argument::<JsTypedArray<u8>>(0)?;
let server_message = cx.argument::<JsTypedArray<u8>>(1)?;
let client_register_state = ClientRegistration::<Cipher>::deserialize(
&client_register_state.as_slice(&cx),
tomekUnsubmitted
Not Done
Inline Actions

Can we avoid shadowing? I think that it reduces maintainability significantly.

tomek: Can we avoid shadowing? I think that it reduces maintainability significantly.
varunAuthorUnsubmitted
Done
Inline Actions

sure!

varun: sure!
)
.or_else(|err| cx.throw_error(err.to_string()))?;
let server_message =
RegistrationResponse::<Cipher>::deserialize(&server_message.as_slice(&cx))
.or_else(|err| cx.throw_error(err.to_string()))?;
let mut client_rng = OsRng;
let client_registration_finish_result = ClientRegistrationFinishResult {
message: client_register_state
.finish(
&mut client_rng,
server_message,
ClientRegistrationFinishParameters::Default,
)
.or_else(|err| cx.throw_error(err.to_string()))?
.message,
};
Ok(cx.boxed(client_registration_finish_result))
}
fn get_registration_finish_message_array(
mut cx: FunctionContext,
) -> JsResult<JsArrayBuffer> {
let client_registration_finish_result =
cx.argument::<JsBox<ClientRegistrationFinishResult>>(0)?;
Ok(JsArrayBuffer::external(
&mut cx,
client_registration_finish_result.message.serialize(),
))
}
#[neon::main] #[neon::main]
fn main(mut cx: ModuleContext) -> NeonResult<()> { fn main(mut cx: ModuleContext) -> NeonResult<()> {
cx.export_function("client_register_start", client_register_start)?; cx.export_function("client_register_start", client_register_start)?;
cx.export_function( cx.export_function(
"get_registration_start_message_array", "get_registration_start_message_array",
get_registration_start_message_array, get_registration_start_message_array,
)?; )?;
cx.export_function( cx.export_function(
"get_registration_start_state_array", "get_registration_start_state_array",
get_registration_start_state_array, get_registration_start_state_array,
)?; )?;
cx.export_function("client_register_finish", client_register_finish)?;
cx.export_function(
"get_registration_finish_message_array",
get_registration_finish_message_array,
)?;
Ok(()) Ok(())
} }
View Options

keyserver/src/shared/state-sync/users-state-sync-spec.js

use argon2::Argon2; use argon2::Argon2;
use digest::generic_array::GenericArray; use digest::generic_array::GenericArray;
use digest::Digest; use digest::Digest;
use neon::prelude::*; use neon::prelude::*;
use neon::types::buffer::TypedArray;
use opaque_ke::ciphersuite::CipherSuite; use opaque_ke::ciphersuite::CipherSuite;
use opaque_ke::errors::InternalPakeError; use opaque_ke::errors::InternalPakeError;
use opaque_ke::hash::Hash; use opaque_ke::hash::Hash;
use opaque_ke::slow_hash::SlowHash; use opaque_ke::slow_hash::SlowHash;
use opaque_ke::{ClientRegistration, RegistrationRequest}; use opaque_ke::{
ClientRegistration, ClientRegistrationFinishParameters, RegistrationRequest,
RegistrationResponse, RegistrationUpload,
};
use rand::rngs::OsRng; use rand::rngs::OsRng;
struct Cipher; struct Cipher;
impl CipherSuite for Cipher { impl CipherSuite for Cipher {
type Group = curve25519_dalek::ristretto::RistrettoPoint; type Group = curve25519_dalek::ristretto::RistrettoPoint;
type KeyExchange = opaque_ke::key_exchange::tripledh::TripleDH; type KeyExchange = opaque_ke::key_exchange::tripledh::TripleDH;
type Hash = sha2::Sha512; type Hash = sha2::Sha512;
Show All 17 Lines
struct ClientRegistrationStartResult { struct ClientRegistrationStartResult {
message: RegistrationRequest<Cipher>, message: RegistrationRequest<Cipher>,
state: ClientRegistration<Cipher>, state: ClientRegistration<Cipher>,
} }
impl Finalize for ClientRegistrationStartResult {} impl Finalize for ClientRegistrationStartResult {}
struct ClientRegistrationFinishResult {
message: RegistrationUpload<Cipher>,
}
impl Finalize for ClientRegistrationFinishResult {}
fn client_register_start( fn client_register_start(
mut cx: FunctionContext, mut cx: FunctionContext,
) -> JsResult<JsBox<ClientRegistrationStartResult>> { ) -> JsResult<JsBox<ClientRegistrationStartResult>> {
let password = cx.argument::<JsString>(0)?; let password = cx.argument::<JsString>(0)?;
let mut client_rng = OsRng; let mut client_rng = OsRng;
let client_registration_start_result = ClientRegistration::<Cipher>::start( let client_registration_start_result = ClientRegistration::<Cipher>::start(
&mut client_rng, &mut client_rng,
password.value(&mut cx).as_bytes(), password.value(&mut cx).as_bytes(),
Show All 22 Lines) -> JsResult<JsArrayBuffer> {
let client_registration_start_result = let client_registration_start_result =
cx.argument::<JsBox<ClientRegistrationStartResult>>(0)?; cx.argument::<JsBox<ClientRegistrationStartResult>>(0)?;
Ok(JsArrayBuffer::external( Ok(JsArrayBuffer::external(
&mut cx, &mut cx,
client_registration_start_result.state.serialize(), client_registration_start_result.state.serialize(),
)) ))
} }
fn client_register_finish(
mut cx: FunctionContext,
) -> JsResult<JsBox<ClientRegistrationFinishResult>> {
let client_register_state = cx.argument::<JsTypedArray<u8>>(0)?;
let server_message = cx.argument::<JsTypedArray<u8>>(1)?;
let client_register_state = ClientRegistration::<Cipher>::deserialize(
&client_register_state.as_slice(&cx),
tomekUnsubmitted
Not Done
Inline Actions

Can we avoid shadowing? I think that it reduces maintainability significantly.

tomek: Can we avoid shadowing? I think that it reduces maintainability significantly.
varunAuthorUnsubmitted
Done
Inline Actions

sure!

varun: sure!
)
.or_else(|err| cx.throw_error(err.to_string()))?;
let server_message =
RegistrationResponse::<Cipher>::deserialize(&server_message.as_slice(&cx))
.or_else(|err| cx.throw_error(err.to_string()))?;
let mut client_rng = OsRng;
let client_registration_finish_result = ClientRegistrationFinishResult {
message: client_register_state
.finish(
&mut client_rng,
server_message,
ClientRegistrationFinishParameters::Default,
)
.or_else(|err| cx.throw_error(err.to_string()))?
.message,
};
Ok(cx.boxed(client_registration_finish_result))
}
fn get_registration_finish_message_array(
mut cx: FunctionContext,
) -> JsResult<JsArrayBuffer> {
let client_registration_finish_result =
cx.argument::<JsBox<ClientRegistrationFinishResult>>(0)?;
Ok(JsArrayBuffer::external(
&mut cx,
client_registration_finish_result.message.serialize(),
))
}
#[neon::main] #[neon::main]
fn main(mut cx: ModuleContext) -> NeonResult<()> { fn main(mut cx: ModuleContext) -> NeonResult<()> {
cx.export_function("client_register_start", client_register_start)?; cx.export_function("client_register_start", client_register_start)?;
cx.export_function( cx.export_function(
"get_registration_start_message_array", "get_registration_start_message_array",
get_registration_start_message_array, get_registration_start_message_array,
)?; )?;
cx.export_function( cx.export_function(
"get_registration_start_state_array", "get_registration_start_state_array",
get_registration_start_state_array, get_registration_start_state_array,
)?; )?;
cx.export_function("client_register_finish", client_register_finish)?;
cx.export_function(
"get_registration_finish_message_array",
get_registration_finish_message_array,
)?;
Ok(()) Ok(())
} }
View Options

keyserver/src/socket/session-utils.js

Loading...