diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index f1e7007e3..0f13050f0 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -72,6 +72,12 @@ jobs: grep -q 'keygo-core feature "crypto"' <<<"$client" server=$(cargo tree -p keygo-server -e features) if grep -E 'keygo-client|keygo-core feature "crypto"' <<<"$server"; then exit 1; fi + - name: keygo-client cannot mint server ids or tokens + run: | + server=$(cargo tree -p keygo-server -e features) + grep -q 'keygo-api feature "server"' <<<"$server" + client=$(cargo tree -p keygo-client -e features) + if grep 'keygo-api feature "server"' <<<"$client"; then exit 1; fi # Rust-native tests (no NDK). Runs in parallel with android-test once lint passes. rust-test: diff --git a/CLAUDE.md b/CLAUDE.md index df071e2c2..b03c7f00e 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -47,6 +47,7 @@ Android password manager using Clean Architecture per module: | `:core:identity` | Key wrapping, auth data, proto schemas (`core/identity/src/main/proto/`) | | `:core:item` | Room database, login/item entities | | `:core:ui` | Shared composables and UI utilities | +| `:core:sync` | OkHttp `HttpTransport` for the Rust `SyncClient` | | `:core:util` | Shared utilities, `Result` type | | `:feature:auth` | Auth/session flow (login gate, biometric prompt routing) | | `:feature:autofill` | Android autofill service (framework + Chrome/inline datasets) | @@ -65,10 +66,12 @@ Rust workspace (`rust/`, toolchain pinned in `rust-toolchain.toml`, edition 2024 | Crate | Purpose | |-----------------|-------------------------------------------------------------------------------| | `keygo-core` | Key hierarchy, ids, `Sealed`, shared by client and server. Crypto sits behind the `crypto` feature; the server must leave it off, so it can store wrapped keys but never hold one | +| `keygo-api` | Sync API wire types (requests, responses, ids, tokens, `ErrorCode`) and the endpoint table, shared by server and client; no HTTP stack. JSON shapes are wire identity, pinned by `tests/wire.rs` | | `keygo-client` | App-only: ARK session, passkeys, TOTP, backup format, card formatting. The server must not depend on it. `keygo_client::crypto` re-exports `keygo-core` | | `keygo-uniffi` | UniFFI bindings exposing `keygo-client` to Kotlin (`libkeygo_bindings.so`) | | `keygo-opaque` | OPAQUE (opaque-ke, ristretto255 + Argon2) client/server wrapper, `forbid(unsafe_code)` | | `keygo-server` | Self-hostable sync server (axum + sqlx/Postgres + clap CLI), see Sync Server | +| `keygo-e2e` | Test-only: drives the real `SyncClient` against the real server router (in-process, real OPAQUE and DPoP) | | `tools/uniffi-bindgen` | Bindgen runner used by `make bindgen` | ## Key Patterns @@ -199,8 +202,9 @@ Caddy as TLS proxy; `.env.example` sets `DOMAIN` and signups). multiple statements. - **Trailing commas** on multi-line parameter lists and collection literals. - **Rust constructors** — ids are made with `random()`, secret material (keys, tokens, codes) with - `generate()`. Ids the client and server share live in `keygo-core`; server-only ids come from the - `random_id!`/`uuid_id!` macros in `domain/ids.rs`. + `generate()`. Ids the client and server share live in `keygo-core`; the wire handles `LoginId` + and `RegistrationId` come from `random_id!` in `keygo-api`, and their `random()` needs its + `server` feature. Server-only ids stay in `keygo-server`. ## Testing diff --git a/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt b/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt new file mode 100644 index 000000000..62dc8a99a --- /dev/null +++ b/core/rust/src/testFixtures/kotlin/de/davis/keygo/rust/FakeSyncClient.kt @@ -0,0 +1,48 @@ +package de.davis.keygo.rust + +import de.davisalessandro.keygo.rust.Account +import de.davisalessandro.keygo.rust.ArkSession +import de.davisalessandro.keygo.rust.DeviceDetails +import de.davisalessandro.keygo.rust.DeviceId +import de.davisalessandro.keygo.rust.ServerInfo +import de.davisalessandro.keygo.rust.SyncClientInterface +import de.davisalessandro.keygo.rust.SyncDevice +import de.davisalessandro.keygo.rust.UserId + +class FakeSyncClient : SyncClientInterface { + + var deleteDeviceResult: Result = Result.success(Unit) + var devicesResult: Result> = Result.success(emptyList()) + var loginResult: Result? = null + var logoutResult: Result = Result.success(Unit) + var metaResult: Result? = null + var registerResult: Result? = null + var stepUpResult: Result = Result.success(Unit) + + override suspend fun deleteDevice(id: DeviceId) = deleteDeviceResult.getOrThrow() + + override suspend fun devices(): List = devicesResult.getOrThrow() + + override suspend fun login( + arkSession: ArkSession, + username: String, + password: String, + device: DeviceDetails, + ): Account = checkNotNull(loginResult) { "loginResult not set" }.getOrThrow() + + override suspend fun logout() = logoutResult.getOrThrow() + + override suspend fun meta(): ServerInfo = + checkNotNull(metaResult) { "metaResult not set" }.getOrThrow() + + override suspend fun register( + arkSession: ArkSession, + userId: UserId, + username: String, + password: String, + invite: String?, + device: DeviceDetails, + ): Account = checkNotNull(registerResult) { "registerResult not set" }.getOrThrow() + + override suspend fun stepUp(password: String) = stepUpResult.getOrThrow() +} diff --git a/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/AccountRecordSealerImpl.kt b/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/AccountRecordSealerImpl.kt index 02676976f..25b388083 100644 --- a/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/AccountRecordSealerImpl.kt +++ b/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/AccountRecordSealerImpl.kt @@ -46,7 +46,11 @@ internal class AccountRecordSealerImpl( private fun SessionError.toAccountRecordError(): AccountRecordError = when (this) { SessionError.Locked -> AccountRecordError.NoActiveSession SessionError.DecryptionFailed -> AccountRecordError.Corrupted - SessionError.WrongPassword, is SessionError.Derivation, is SessionError.KeyWrap -> + SessionError.AccountMismatch, + SessionError.WrongPassword, + is SessionError.Derivation, + is SessionError.KeyWrap, + -> AccountRecordError.KeyUnwrapFailed } diff --git a/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/CryptographicScopeProviderImpl.kt b/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/CryptographicScopeProviderImpl.kt index b194c61e8..747d75017 100644 --- a/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/CryptographicScopeProviderImpl.kt +++ b/core/security/src/main/kotlin/de/davis/keygo/core/security/data/crypto/CryptographicScopeProviderImpl.kt @@ -122,7 +122,11 @@ internal class CryptographicScopeProviderImpl( private fun SessionError.toCryptoScopeError(): CryptoScopeError = when (this) { SessionError.Locked -> CryptoScopeError.NoActiveSession is SessionError.KeyWrap -> CryptoScopeError.KeyWrapError(cause) - SessionError.WrongPassword, is SessionError.Derivation, SessionError.DecryptionFailed -> + SessionError.AccountMismatch, + SessionError.WrongPassword, + is SessionError.Derivation, + SessionError.DecryptionFailed, + -> CryptoScopeError.KeyWrapError(KeyWrapException.UnwrapFailed()) } diff --git a/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/Session.kt b/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/Session.kt index 19278db5a..30a1385e8 100644 --- a/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/Session.kt +++ b/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/Session.kt @@ -103,6 +103,7 @@ inline fun Session.useArk(block: (ByteArray) -> T): Result @PublishedApi internal fun ArkSessionException.toSessionError(): SessionError = when (this) { is ArkSessionException.Locked -> SessionError.Locked + is ArkSessionException.AccountMismatch -> SessionError.AccountMismatch is ArkSessionException.WrongPassword -> SessionError.WrongPassword is ArkSessionException.Derivation -> SessionError.Derivation(v1) is ArkSessionException.DecryptionFailed -> SessionError.DecryptionFailed diff --git a/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/SessionError.kt b/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/SessionError.kt index 067c80d27..20a3764bf 100644 --- a/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/SessionError.kt +++ b/core/security/src/main/kotlin/de/davis/keygo/core/security/domain/SessionError.kt @@ -5,6 +5,7 @@ import de.davisalessandro.keygo.rust.KeyWrapException sealed interface SessionError { data object Locked : SessionError + data object AccountMismatch : SessionError data object WrongPassword : SessionError data class Derivation(val message: String) : SessionError data object DecryptionFailed : SessionError diff --git a/core/sync/build.gradle.kts b/core/sync/build.gradle.kts new file mode 100644 index 000000000..033447896 --- /dev/null +++ b/core/sync/build.gradle.kts @@ -0,0 +1,18 @@ +plugins { + alias(libs.plugins.keygo.android.library) +} + +android { + namespace = "de.davis.keygo.core.sync" +} + +dependencies { + api(projects.core.rust) + + implementation(libs.okhttp) + implementation(libs.kotlinx.coroutines.core) + + testImplementation(libs.okhttp.jvm) + testImplementation(libs.okhttp.mockwebserver) + testImplementation(testFixtures(projects.core.rust)) +} diff --git a/core/sync/consumer-rules.pro b/core/sync/consumer-rules.pro new file mode 100644 index 000000000..e69de29bb diff --git a/core/sync/src/main/kotlin/de/davis/keygo/core/sync/data/OkHttpTransport.kt b/core/sync/src/main/kotlin/de/davis/keygo/core/sync/data/OkHttpTransport.kt new file mode 100644 index 000000000..a3d046cdc --- /dev/null +++ b/core/sync/src/main/kotlin/de/davis/keygo/core/sync/data/OkHttpTransport.kt @@ -0,0 +1,81 @@ +package de.davis.keygo.core.sync.data + +import de.davisalessandro.keygo.rust.Header +import de.davisalessandro.keygo.rust.HttpRequest +import de.davisalessandro.keygo.rust.HttpResponse +import de.davisalessandro.keygo.rust.HttpTransport +import de.davisalessandro.keygo.rust.TransportException +import kotlinx.coroutines.suspendCancellableCoroutine +import okhttp3.Call +import okhttp3.Callback +import okhttp3.OkHttpClient +import okhttp3.Request +import okhttp3.RequestBody.Companion.toRequestBody +import okhttp3.Response +import java.io.IOException +import java.util.concurrent.TimeUnit +import kotlin.coroutines.resume +import kotlin.coroutines.resumeWithException + +/** Never log [HttpRequest] or [HttpResponse]: their `toString()` prints tokens. */ +class OkHttpTransport(client: OkHttpClient) : HttpTransport { + + // No redirects: a DPoP proof is bound to one URL. + private val client = client.newBuilder() + .retryOnConnectionFailure(false) + .followRedirects(false) + .followSslRedirects(false) + .callTimeout(CALL_TIMEOUT_SECONDS, TimeUnit.SECONDS) + .build() + + override suspend fun send(request: HttpRequest): HttpResponse { + val okRequest = try { + request.toOkHttp() + } catch (e: IllegalArgumentException) { + throw e.toTransportException() + } + + return suspendCancellableCoroutine { continuation -> + val call = client.newCall(okRequest) + continuation.invokeOnCancellation { call.cancel() } + call.enqueue(object : Callback { + override fun onFailure(call: Call, e: IOException) { + continuation.resumeWithException(e.toTransportException()) + } + + override fun onResponse(call: Call, response: Response) { + try { + continuation.resume(response.use { it.toRust() }) + } catch (e: IOException) { + continuation.resumeWithException(e.toTransportException()) + } + } + }) + } + } + + private fun HttpRequest.toOkHttp(): Request { + val requestBody = + if (body.isEmpty() && method != "POST") null + else body.toRequestBody(null) + + return Request.Builder() + .url(url) + .apply { headers.forEach { addHeader(it.name, it.value) } } + .method(method, requestBody) + .build() + } + + private fun Response.toRust() = HttpResponse( + status = code.toUShort(), + headers = headers.map { (name, value) -> Header(name = name, value = value) }, + body = body.bytes(), + ) + + private fun Exception.toTransportException() = + TransportException.Failed(reason = message ?: this::class.java.simpleName) + + private companion object { + const val CALL_TIMEOUT_SECONDS = 30L + } +} diff --git a/core/sync/src/main/kotlin/de/davis/keygo/core/sync/di/CoreSyncModule.kt b/core/sync/src/main/kotlin/de/davis/keygo/core/sync/di/CoreSyncModule.kt new file mode 100644 index 000000000..ff450012b --- /dev/null +++ b/core/sync/src/main/kotlin/de/davis/keygo/core/sync/di/CoreSyncModule.kt @@ -0,0 +1,18 @@ +package de.davis.keygo.core.sync.di + +import de.davis.keygo.core.sync.data.OkHttpTransport +import de.davisalessandro.keygo.rust.HttpTransport +import okhttp3.OkHttpClient +import org.koin.core.annotation.ComponentScan +import org.koin.core.annotation.Configuration +import org.koin.core.annotation.Module +import org.koin.core.annotation.Single + +@Module +@Configuration +@ComponentScan("de.davis.keygo.core.sync") +object CoreSyncModule { + + @Single + internal fun provideHttpTransport(): HttpTransport = OkHttpTransport(OkHttpClient()) +} diff --git a/core/sync/src/test/kotlin/de/davis/keygo/core/sync/data/OkHttpTransportTest.kt b/core/sync/src/test/kotlin/de/davis/keygo/core/sync/data/OkHttpTransportTest.kt new file mode 100644 index 000000000..f41c4d023 --- /dev/null +++ b/core/sync/src/test/kotlin/de/davis/keygo/core/sync/data/OkHttpTransportTest.kt @@ -0,0 +1,120 @@ +package de.davis.keygo.core.sync.data + +import de.davisalessandro.keygo.rust.Header +import de.davisalessandro.keygo.rust.HttpRequest +import de.davisalessandro.keygo.rust.TransportException +import kotlinx.coroutines.test.runTest +import mockwebserver3.MockResponse +import mockwebserver3.MockWebServer +import mockwebserver3.SocketEffect +import okhttp3.OkHttpClient +import kotlin.test.AfterTest +import kotlin.test.BeforeTest +import kotlin.test.Test +import kotlin.test.assertContentEquals +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith + +class OkHttpTransportTest { + + private val server = MockWebServer() + private val transport = OkHttpTransport(OkHttpClient()) + + @BeforeTest + fun setUp() = server.start() + + @AfterTest + fun tearDown() = server.close() + + private fun request( + method: String, + body: ByteArray = byteArrayOf(), + headers: List
= emptyList(), + ) = HttpRequest( + method = method, + url = server.url("/api").toString(), + headers = headers, + body = body, + ) + + @Test + fun round_trips_method_headers_and_body_bytes() = runTest { + val payload = byteArrayOf(0, 1, 2, -1, -128, 127) + server.enqueue( + MockResponse.Builder() + .code(201) + .addHeader("x-reply", "yes") + .body(okio.Buffer().write(payload)) + .build(), + ) + + val response = transport.send( + request("POST", payload, listOf(Header(name = "dpop", value = "proof"))), + ) + + val recorded = server.takeRequest() + assertEquals("POST", recorded.method) + assertEquals("proof", recorded.headers["dpop"]) + assertContentEquals(payload, recorded.body!!.toByteArray()) + assertEquals(201.toUShort(), response.status) + assertEquals("yes", response.headers.first { it.name.equals("x-reply", true) }.value) + assertContentEquals(payload, response.body) + } + + @Test + fun post_with_empty_body_is_sent() = runTest { + server.enqueue(MockResponse.Builder().build()) + + transport.send(request("POST")) + + val recorded = server.takeRequest() + assertEquals("POST", recorded.method) + assertEquals(0, recorded.bodySize) + } + + @Test + fun get_sends_no_body() = runTest { + server.enqueue(MockResponse.Builder().build()) + + transport.send(request("GET")) + + val recorded = server.takeRequest() + assertEquals("GET", recorded.method) + assertEquals(0, recorded.bodySize) + } + + @Test + fun does_not_retry_after_a_connection_failure() = runTest { + server.enqueue( + MockResponse.Builder() + .onResponseStart(SocketEffect.CloseSocket()) + .build(), + ) + + assertFailsWith { transport.send(request("GET")) } + assertEquals(1, server.requestCount) + } + + @Test + fun does_not_follow_redirects() = runTest { + server.enqueue( + MockResponse.Builder() + .code(302) + .addHeader("Location", server.url("/elsewhere").toString()) + .build(), + ) + + val response = transport.send(request("GET")) + + assertEquals(302.toUShort(), response.status) + assertEquals(1, server.requestCount) + } + + @Test + fun io_failure_throws_transport_exception() = runTest { + val unreachable = request("GET") + server.close() + + assertFailsWith { transport.send(unreachable) } + } +} diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 78d29ed35..d2b50af69 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -115,6 +115,7 @@ squareup-kotlinpoet = { group = "com.squareup", name = "kotlinpoet-ksp", version okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" } okhttp-jvm = { group = "com.squareup.okhttp3", name = "okhttp-jvm", version.ref = "okhttp" } +okhttp-mockwebserver = { group = "com.squareup.okhttp3", name = "mockwebserver3", version.ref = "okhttp" } gosimple-nbvcxz = { group = "me.gosimple", name = "nbvcxz", version.ref = "nbvcxz" } diff --git a/rust/Cargo.lock b/rust/Cargo.lock index b3709f88e..3265e9bbd 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -1593,6 +1593,25 @@ dependencies = [ "cpufeatures 0.3.1", ] +[[package]] +name = "keygo-api" +version = "0.1.0" +dependencies = [ + "base64 0.23.1", + "getrandom 0.4.3", + "hex", + "keygo-core", + "keygo-opaque", + "serde", + "serde_json", + "sha2 0.11.1", + "thiserror", + "unicode-normalization", + "unicode-properties", + "uuid", + "zeroize", +] + [[package]] name = "keygo-client" version = "0.1.0" @@ -1603,7 +1622,10 @@ dependencies = [ "coset", "csv", "email_address", + "keygo-api", "keygo-core", + "keygo-dpop", + "keygo-opaque", "passkey", "passkey-authenticator", "passkey-types", @@ -1652,6 +1674,26 @@ dependencies = [ "zeroize", ] +[[package]] +name = "keygo-e2e" +version = "0.1.0" +dependencies = [ + "async-trait", + "axum", + "http-body-util", + "keygo-api", + "keygo-client", + "keygo-core", + "keygo-dpop", + "keygo-opaque", + "keygo-server", + "serde_json", + "sqlx", + "tokio", + "tower", + "url", +] + [[package]] name = "keygo-opaque" version = "0.1.0" @@ -1684,6 +1726,7 @@ dependencies = [ "hmac 0.13.0", "http-body-util", "humantime", + "keygo-api", "keygo-core", "keygo-dpop", "keygo-opaque", @@ -1701,8 +1744,6 @@ dependencies = [ "tower-http", "tracing", "tracing-subscriber", - "unicode-normalization", - "unicode-properties", "url", "uuid", "zeroize", @@ -1712,11 +1753,17 @@ dependencies = [ name = "keygo-uniffi" version = "0.1.0" dependencies = [ + "async-compat", + "async-trait", + "keygo-api", "keygo-client", + "keygo-dpop", "thiserror", "tokio", "uniffi", + "url", "uuid", + "zeroize", ] [[package]] diff --git a/rust/crates/keygo-api/Cargo.toml b/rust/crates/keygo-api/Cargo.toml new file mode 100644 index 000000000..5549f424b --- /dev/null +++ b/rust/crates/keygo-api/Cargo.toml @@ -0,0 +1,28 @@ +[package] +name = "keygo-api" +description = "KeyGo sync API wire types, shared by the server and the client." +version.workspace = true +edition.workspace = true + +[features] +server = ["dep:getrandom", "dep:sha2"] + +[dependencies] +keygo-core = { path = "../keygo-core" } +keygo-opaque = { path = "../keygo-opaque" } + +serde = { workspace = true, features = ["derive"] } +thiserror.workspace = true +uuid.workspace = true +base64.workspace = true +getrandom = { workspace = true, optional = true } +sha2 = { workspace = true, optional = true, features = ["zeroize"] } +zeroize = { workspace = true, features = ["derive"] } +unicode-normalization = "0.1.25" +unicode-properties = { version = "0.1.4", default-features = false, features = ["general-category"] } + +[dev-dependencies] +getrandom.workspace = true +serde_json.workspace = true +sha2.workspace = true +hex = "0.4.3" diff --git a/rust/crates/keygo-api/src/auth/handshake.rs b/rust/crates/keygo-api/src/auth/handshake.rs new file mode 100644 index 000000000..42238fad0 --- /dev/null +++ b/rust/crates/keygo-api/src/auth/handshake.rs @@ -0,0 +1,11 @@ +use crate::domain::LoginId; +use keygo_opaque::CredentialResponse; +use serde::{Deserialize, Serialize}; + +/// Shared by sign-in and step-up. +#[derive(Serialize, Deserialize)] +pub struct StartResponse { + pub login_id: LoginId, + pub credential_response: CredentialResponse, + pub expires_in: u64, +} diff --git a/rust/crates/keygo-api/src/auth/login.rs b/rust/crates/keygo-api/src/auth/login.rs new file mode 100644 index 000000000..b591c61d0 --- /dev/null +++ b/rust/crates/keygo-api/src/auth/login.rs @@ -0,0 +1,28 @@ +use super::Session; +use crate::domain::{DeviceClaim, KeyBundle, LoginId, Username}; +use keygo_core::UserId; +use keygo_opaque::{CredentialFinalization, CredentialRequest, DpopBinding}; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize)] +pub struct StartRequest { + /// Parsed in the handler so a bad name answers `invalid_username`, not `invalid_request`. + pub username: String, + pub credential_request: CredentialRequest, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishRequest { + pub login_id: LoginId, + pub credential_finalization: CredentialFinalization, + pub device: DeviceClaim, + pub dpop_binding: DpopBinding, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishResponse { + pub user_id: UserId, + pub username: Username, + pub key_bundle: KeyBundle, + pub session: Session, +} diff --git a/rust/crates/keygo-api/src/auth/mod.rs b/rust/crates/keygo-api/src/auth/mod.rs new file mode 100644 index 000000000..27a5a616f --- /dev/null +++ b/rust/crates/keygo-api/src/auth/mod.rs @@ -0,0 +1,24 @@ +use crate::domain::{AccessToken, RefreshToken}; +use keygo_core::DeviceId; +use serde::{Deserialize, Serialize}; + +pub mod handshake; +pub mod login; +pub mod register; +pub mod step_up; +pub mod token; + +#[derive(Serialize, Deserialize)] +pub struct Access { + pub access_token: AccessToken, + pub access_expires_in: u64, +} + +#[derive(Serialize, Deserialize)] +pub struct Session { + pub device_id: DeviceId, + #[serde(flatten)] + pub access: Access, + pub refresh_token: RefreshToken, + pub refresh_expires_in: u64, +} diff --git a/rust/crates/keygo-api/src/auth/register.rs b/rust/crates/keygo-api/src/auth/register.rs new file mode 100644 index 000000000..68843d67b --- /dev/null +++ b/rust/crates/keygo-api/src/auth/register.rs @@ -0,0 +1,35 @@ +use super::Session; +use crate::domain::{DeviceInfo, KeyBundle, RegistrationId, Username}; +use keygo_core::UserId; +use keygo_opaque::{RegistrationRequest, RegistrationResponse, RegistrationUpload}; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize)] +pub struct StartRequest { + /// Parsed in the handler so a bad name answers `invalid_username`, not `invalid_request`. + pub username: String, + pub user_id: UserId, + pub invite: Option, + pub registration_request: RegistrationRequest, +} + +#[derive(Serialize, Deserialize)] +pub struct StartResponse { + pub registration_id: RegistrationId, + pub registration_response: RegistrationResponse, + pub expires_in: u64, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishRequest { + pub registration_id: RegistrationId, + pub registration_upload: RegistrationUpload, + pub key_bundle: KeyBundle, + pub device: DeviceInfo, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishResponse { + pub username: Username, + pub session: Session, +} diff --git a/rust/crates/keygo-api/src/auth/step_up.rs b/rust/crates/keygo-api/src/auth/step_up.rs new file mode 100644 index 000000000..afc9980a1 --- /dev/null +++ b/rust/crates/keygo-api/src/auth/step_up.rs @@ -0,0 +1,23 @@ +use super::Access; +use crate::domain::LoginId; +use keygo_opaque::{CredentialFinalization, CredentialRequest, DpopBinding}; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize)] +pub struct StartRequest { + pub credential_request: CredentialRequest, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishRequest { + pub login_id: LoginId, + pub credential_finalization: CredentialFinalization, + pub dpop_binding: DpopBinding, +} + +#[derive(Serialize, Deserialize)] +pub struct FinishResponse { + #[serde(flatten)] + pub access: Access, + pub auth_time: u64, +} diff --git a/rust/crates/keygo-api/src/auth/token.rs b/rust/crates/keygo-api/src/auth/token.rs new file mode 100644 index 000000000..2e1550996 --- /dev/null +++ b/rust/crates/keygo-api/src/auth/token.rs @@ -0,0 +1,7 @@ +use crate::domain::RefreshToken; +use serde::{Deserialize, Serialize}; + +#[derive(Serialize, Deserialize)] +pub struct TokenRequest { + pub refresh_token: T, +} diff --git a/rust/crates/keygo-api/src/devices.rs b/rust/crates/keygo-api/src/devices.rs new file mode 100644 index 000000000..29edbb76a --- /dev/null +++ b/rust/crates/keygo-api/src/devices.rs @@ -0,0 +1,7 @@ +use crate::domain::Device; +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Serialize, Deserialize)] +pub struct Devices { + pub devices: Vec, +} diff --git a/rust/crates/keygo-api/src/domain/access_token.rs b/rust/crates/keygo-api/src/domain/access_token.rs new file mode 100644 index 000000000..fca25aa76 --- /dev/null +++ b/rust/crates/keygo-api/src/domain/access_token.rs @@ -0,0 +1,29 @@ +use serde::{Deserialize, Serialize}; +use zeroize::{Zeroize, ZeroizeOnDrop}; + +#[derive(Serialize, Deserialize, Zeroize, ZeroizeOnDrop)] +pub struct AccessToken(String); + +impl AccessToken { + pub fn expose(&self) -> &str { + &self.0 + } + + #[cfg(any(test, feature = "server"))] + pub fn from_signed(token: String) -> Self { + Self(token) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + #[test] + fn round_trips_as_a_plain_string() { + let token: AccessToken = serde_json::from_value(json!("a.b.c")).unwrap(); + assert_eq!(token.expose(), "a.b.c"); + assert_eq!(serde_json::to_value(&token).unwrap(), "a.b.c"); + } +} diff --git a/rust/crates/keygo-server/src/domain/device.rs b/rust/crates/keygo-api/src/domain/device.rs similarity index 98% rename from rust/crates/keygo-server/src/domain/device.rs rename to rust/crates/keygo-api/src/domain/device.rs index 1bff999e5..c83a195c5 100644 --- a/rust/crates/keygo-server/src/domain/device.rs +++ b/rust/crates/keygo-api/src/domain/device.rs @@ -1,5 +1,5 @@ -use super::DeviceId; use super::string_enum::string_enum; +use keygo_core::DeviceId; use serde::{Deserialize, Serialize}; use thiserror::Error; use unicode_properties::{GeneralCategory, UnicodeGeneralCategory}; @@ -113,7 +113,7 @@ pub struct DeviceInfo { pub app_version: AppVersion, } -#[derive(Debug, Deserialize)] +#[derive(Debug, Serialize, Deserialize)] pub struct DeviceClaim { #[serde(rename = "device_id")] pub id: Option, @@ -121,7 +121,7 @@ pub struct DeviceClaim { pub info: DeviceInfo, } -#[derive(Debug, Serialize)] +#[derive(Debug, Serialize, Deserialize)] pub struct Device { pub id: DeviceId, #[serde(flatten)] diff --git a/rust/crates/keygo-api/src/domain/ids.rs b/rust/crates/keygo-api/src/domain/ids.rs new file mode 100644 index 000000000..3ea2c5ad1 --- /dev/null +++ b/rust/crates/keygo-api/src/domain/ids.rs @@ -0,0 +1,107 @@ +use base64::Engine; +use base64::engine::general_purpose::URL_SAFE_NO_PAD; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use thiserror::Error; + +const LEN: usize = 16; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)] +#[error("{field} must be {LEN} bytes of base64url without padding")] +pub struct InvalidId { + field: &'static str, +} + +/// Declares an opaque handle of 16 random bytes that travels as base64url without padding. +macro_rules! random_id { + ($($(#[$attr:meta])* $name:ident as $field:literal;)+) => {$( + $(#[$attr])* + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] + pub struct $name([u8; LEN]); + + impl $name { + #[cfg(any(test, feature = "server"))] + pub fn random() -> Self { + let mut bytes = [0u8; LEN]; + getrandom::fill(&mut bytes).expect("OS random number generator unavailable"); + Self(bytes) + } + + pub fn to_base64(self) -> String { + URL_SAFE_NO_PAD.encode(self.0) + } + + pub fn from_base64(text: &str) -> Result { + const INVALID: InvalidId = InvalidId { field: $field }; + let bytes = URL_SAFE_NO_PAD.decode(text).map_err(|_| INVALID)?; + bytes.try_into().map(Self).map_err(|_| INVALID) + } + } + + impl Serialize for $name { + fn serialize(&self, serializer: S) -> Result { + serializer.serialize_str(&self.to_base64()) + } + } + + impl<'de> Deserialize<'de> for $name { + fn deserialize>(deserializer: D) -> Result { + let text = String::deserialize(deserializer)?; + Self::from_base64(&text).map_err(serde::de::Error::custom) + } + } + )+}; +} + +random_id! { + /// Handle for one pending registration, from start to finish. + RegistrationId as "registration_id"; + + /// Handle for one OPAQUE login or step-up, from start to finish. + LoginId as "login_id"; +} + +impl RegistrationId { + #[cfg(any(test, feature = "server"))] + pub const fn as_bytes(&self) -> &[u8; LEN] { + &self.0 + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn random_ids_differ() { + assert_ne!(RegistrationId::random(), RegistrationId::random()); + } + + #[test] + fn base64_round_trips() { + let id = RegistrationId::random(); + + assert_eq!(RegistrationId::from_base64(&id.to_base64()), Ok(id)); + } + + #[test] + fn serializes_as_unpadded_base64url() { + let id = RegistrationId([0xff; LEN]); + + assert_eq!(serde_json::to_value(id).unwrap(), "_____________________w"); + } + + #[test] + fn rejects_wrong_length_and_alphabet() { + assert!(RegistrationId::from_base64(&URL_SAFE_NO_PAD.encode([0; 15])).is_err()); + assert!(RegistrationId::from_base64(&URL_SAFE_NO_PAD.encode([0; 17])).is_err()); + assert!(RegistrationId::from_base64("+++++++++++++++++++++w").is_err()); + assert!(RegistrationId::from_base64("_____________________w==").is_err()); + } + + #[test] + fn error_names_the_field() { + let err = LoginId::from_base64("").unwrap_err(); + + assert!(err.to_string().starts_with("login_id ")); + } +} diff --git a/rust/crates/keygo-server/src/domain/key_bundle.rs b/rust/crates/keygo-api/src/domain/key_bundle.rs similarity index 52% rename from rust/crates/keygo-server/src/domain/key_bundle.rs rename to rust/crates/keygo-api/src/domain/key_bundle.rs index a248d05c0..d7c8c0d9d 100644 --- a/rust/crates/keygo-server/src/domain/key_bundle.rs +++ b/rust/crates/keygo-api/src/domain/key_bundle.rs @@ -1,7 +1,7 @@ -use crate::domain::SealedBlob; +use keygo_core::{AccountRootKey, Sealed}; use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize)] pub struct KeyBundle { - pub wrapped_ark: SealedBlob, + pub wrapped_ark: Sealed, } diff --git a/rust/crates/keygo-api/src/domain/mod.rs b/rust/crates/keygo-api/src/domain/mod.rs new file mode 100644 index 000000000..65cb28d17 --- /dev/null +++ b/rust/crates/keygo-api/src/domain/mod.rs @@ -0,0 +1,20 @@ +mod access_token; +mod device; +mod ids; +mod key_bundle; +mod sealed_blob; +mod session; +mod string_enum; +mod username; + +pub use access_token::AccessToken; +pub use device::{ + AppVersion, AppVersionError, Device, DeviceClaim, DeviceInfo, DeviceName, DeviceNameError, + Platform, +}; +pub use ids::{InvalidId, LoginId, RegistrationId}; +pub use key_bundle::KeyBundle; +pub use sealed_blob::{InvalidBlob, check_wrapped_ark}; +pub use session::{ParseRefreshTokenError, RefreshToken, RevokeReason}; +pub use string_enum::UnknownVariant; +pub use username::{Username, UsernameError}; diff --git a/rust/crates/keygo-server/src/domain/sealed_blob.rs b/rust/crates/keygo-api/src/domain/sealed_blob.rs similarity index 78% rename from rust/crates/keygo-server/src/domain/sealed_blob.rs rename to rust/crates/keygo-api/src/domain/sealed_blob.rs index 36050a8d0..2657f10e3 100644 --- a/rust/crates/keygo-server/src/domain/sealed_blob.rs +++ b/rust/crates/keygo-api/src/domain/sealed_blob.rs @@ -1,19 +1,17 @@ -use keygo_core::{KEY_LEN, NONCE_LEN, Sealed, TAG_LEN}; +use keygo_core::{AccountRootKey, KEY_LEN, NONCE_LEN, Sealed, TAG_LEN}; use thiserror::Error; -pub type SealedBlob = Sealed<[u8]>; - const WRAPPED_ARK_LEN: usize = NONCE_LEN + KEY_LEN + TAG_LEN; #[derive(Debug, Clone, Copy, PartialEq, Eq, Error)] #[error("wrapped key has the wrong length")] pub struct InvalidBlob; -fn len(blob: &SealedBlob) -> usize { +fn len(blob: &Sealed) -> usize { NONCE_LEN + blob.ciphertext().len() } -pub fn check_wrapped_ark(blob: &SealedBlob) -> Result<(), InvalidBlob> { +pub fn check_wrapped_ark(blob: &Sealed) -> Result<(), InvalidBlob> { if len(blob) == WRAPPED_ARK_LEN { Ok(()) } else { @@ -25,8 +23,8 @@ pub fn check_wrapped_ark(blob: &SealedBlob) -> Result<(), InvalidBlob> { mod tests { use super::*; - fn blob(len: usize) -> SealedBlob { - SealedBlob::from_bytes(&vec![7; len]).unwrap() + fn blob(len: usize) -> Sealed { + Sealed::::from_bytes(&vec![7; len]).unwrap() } /// Clients and stored rows depend on these sizes, so a change to the constants must fail here. diff --git a/rust/crates/keygo-api/src/domain/session.rs b/rust/crates/keygo-api/src/domain/session.rs new file mode 100644 index 000000000..e9ea367b1 --- /dev/null +++ b/rust/crates/keygo-api/src/domain/session.rs @@ -0,0 +1,232 @@ +use super::string_enum::string_enum; +use base64::Engine; +use base64::engine::general_purpose::URL_SAFE_NO_PAD; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +#[cfg(any(test, feature = "server"))] +use sha2::{Digest, Sha256}; +use std::str::FromStr; +use thiserror::Error; +use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing}; + +string_enum! { + pub enum RevokeReason { + Replaced => "replaced", + ReuseDetected => "reuse_detected", + Logout => "logout", + } +} + +const PREFIX: &str = "kgr_"; +const TOKEN_BYTES: usize = 32; +const ENCODED_LEN: usize = PREFIX.len() + + base64::encoded_len(TOKEN_BYTES, false).expect("encoded length can be represented by usize"); + +#[derive(Zeroize, ZeroizeOnDrop)] +pub struct RefreshToken([u8; TOKEN_BYTES]); + +impl RefreshToken { + #[cfg(any(test, feature = "server"))] + pub fn generate() -> Self { + let mut token = [0u8; TOKEN_BYTES]; + getrandom::fill(token.as_mut_slice()).expect("OS random number generator unavailable"); + Self(token) + } + + pub fn expose_encoded(&self) -> Zeroizing { + let mut out = Zeroizing::new(String::with_capacity(ENCODED_LEN)); + out.push_str(PREFIX); + URL_SAFE_NO_PAD.encode_string(self.0, &mut out); + out + } + + #[cfg(any(test, feature = "server"))] + pub fn digest(&self) -> [u8; TOKEN_BYTES] { + Sha256::digest(self.0).into() + } +} + +impl Serialize for RefreshToken { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_str(&self.expose_encoded()) + } +} + +#[derive(Debug, Error)] +pub enum ParseRefreshTokenError { + #[error("invalid prefix")] + InvalidPrefix, + #[error("invalid token")] + InvalidToken, +} + +impl FromStr for RefreshToken { + type Err = ParseRefreshTokenError; + + fn from_str(s: &str) -> Result { + let Some(token) = s.strip_prefix(PREFIX) else { + return Err(ParseRefreshTokenError::InvalidPrefix); + }; + + if token.len() != ENCODED_LEN - PREFIX.len() { + return Err(ParseRefreshTokenError::InvalidToken); + } + + let mut out = RefreshToken([0; TOKEN_BYTES]); + URL_SAFE_NO_PAD + .decode_slice(token, &mut out.0) + .map_err(|_| ParseRefreshTokenError::InvalidToken)?; + + Ok(out) + } +} + +impl<'de> Deserialize<'de> for RefreshToken { + fn deserialize>(deserializer: D) -> Result { + let text = Zeroizing::new(String::deserialize(deserializer)?); + text.parse().map_err(serde::de::Error::custom) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn revoke_reason_round_trips_its_stored_name() { + for &reason in RevokeReason::ALL { + assert_eq!(reason.as_str().parse::().unwrap(), reason); + } + assert!("logout_typo".parse::().is_err()); + } + + #[test] + fn generated_tokens_differ() { + assert_ne!( + RefreshToken::generate().digest(), + RefreshToken::generate().digest(), + ); + } + + #[test] + fn encodes_as_prefixed_unpadded_base64url() { + let encoded = RefreshToken([0xff; TOKEN_BYTES]).expose_encoded(); + + assert_eq!( + encoded.as_str(), + "kgr___________________________________________8" + ); + assert_eq!(encoded.len(), ENCODED_LEN); + } + + #[test] + fn encoding_round_trips_the_secret() { + let token = RefreshToken::generate(); + let encoded = token.expose_encoded(); + + let raw = URL_SAFE_NO_PAD + .decode(encoded.strip_prefix(PREFIX).unwrap()) + .unwrap(); + + assert_eq!(raw, token.0); + } + + #[test] + fn serializes_as_the_encoded_token() { + let token = RefreshToken::generate(); + + assert_eq!( + serde_json::to_value(&token).unwrap(), + token.expose_encoded().as_str(), + ); + } + + #[test] + fn parse_round_trips_the_encoding() { + let token = RefreshToken::generate(); + + let parsed: RefreshToken = token.expose_encoded().parse().unwrap(); + + assert_eq!(parsed.0, token.0); + } + + #[test] + fn parse_rejects_a_missing_prefix() { + let encoded = RefreshToken::generate().expose_encoded(); + let unprefixed = encoded.strip_prefix(PREFIX).unwrap(); + + assert!(matches!( + unprefixed.parse::(), + Err(ParseRefreshTokenError::InvalidPrefix), + )); + assert!(matches!( + format!("kga_{unprefixed}").parse::(), + Err(ParseRefreshTokenError::InvalidPrefix), + )); + } + + #[test] + fn parse_rejects_the_wrong_length() { + let encoded = RefreshToken::generate().expose_encoded(); + + for text in [ + &encoded[..ENCODED_LEN - 1], + &format!("{}A", encoded.as_str()), + ] { + assert!(matches!( + text.parse::(), + Err(ParseRefreshTokenError::InvalidToken), + )); + } + } + + #[test] + fn parse_rejects_non_base64url() { + let text = format!("{PREFIX}{}", "+".repeat(ENCODED_LEN - PREFIX.len())); + + assert!(matches!( + text.parse::(), + Err(ParseRefreshTokenError::InvalidToken), + )); + } + + #[test] + fn parse_rejects_non_canonical_trailing_bits() { + // Same bytes as the canonical "…8", but the unused low bits of the last char are set. + let text = "kgr___________________________________________9"; + + assert!(matches!( + text.parse::(), + Err(ParseRefreshTokenError::InvalidToken), + )); + } + + #[test] + fn deserializes_from_the_encoded_token() { + let token = RefreshToken::generate(); + let json = serde_json::to_value(&token).unwrap(); + + let parsed: RefreshToken = serde_json::from_value(json).unwrap(); + + assert_eq!(parsed.0, token.0); + } + + #[test] + fn deserialize_rejects_a_malformed_token() { + assert!(serde_json::from_str::(r#""kgr_short""#).is_err()); + assert!( + serde_json::from_value::(serde_json::json!(vec![0u8; TOKEN_BYTES])) + .is_err() + ); + } + + #[test] + fn digest_is_sha256_of_the_raw_secret() { + assert_eq!( + hex::encode(RefreshToken([0; TOKEN_BYTES]).digest()), + "66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925", + ); + } +} diff --git a/rust/crates/keygo-server/src/domain/string_enum.rs b/rust/crates/keygo-api/src/domain/string_enum.rs similarity index 100% rename from rust/crates/keygo-server/src/domain/string_enum.rs rename to rust/crates/keygo-api/src/domain/string_enum.rs diff --git a/rust/crates/keygo-server/src/domain/username.rs b/rust/crates/keygo-api/src/domain/username.rs similarity index 100% rename from rust/crates/keygo-server/src/domain/username.rs rename to rust/crates/keygo-api/src/domain/username.rs diff --git a/rust/crates/keygo-api/src/endpoint.rs b/rust/crates/keygo-api/src/endpoint.rs new file mode 100644 index 000000000..fdc674807 --- /dev/null +++ b/rust/crates/keygo-api/src/endpoint.rs @@ -0,0 +1,41 @@ +use serde::Serialize; +use serde::de::DeserializeOwned; +use std::borrow::Cow; + +/// What a request must carry for the server to accept it. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Auth { + None, + /// A DPoP proof, but no access token. + Proof, + /// An access token and the DPoP proof it is bound to. + AccessToken, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Method { + Get, + Post, + Delete, +} + +impl Method { + pub const fn as_str(self) -> &'static str { + match self { + Self::Get => "GET", + Self::Post => "POST", + Self::Delete => "DELETE", + } + } +} + +pub trait Endpoint { + /// `()` when the route takes no body. + type Request: Serialize + DeserializeOwned; + /// `()` when the route answers 204. + type Response: Serialize + DeserializeOwned; + const METHOD: Method; + const AUTH: Auth; + + fn path(&self) -> Cow<'static, str>; +} diff --git a/rust/crates/keygo-api/src/endpoints.rs b/rust/crates/keygo-api/src/endpoints.rs new file mode 100644 index 000000000..f6d4d1a5f --- /dev/null +++ b/rust/crates/keygo-api/src/endpoints.rs @@ -0,0 +1,85 @@ +use crate::endpoint::{Auth, Endpoint, Method}; +use crate::{auth, devices, meta}; +use keygo_core::DeviceId; +use std::borrow::Cow; +use uuid::Uuid; + +macro_rules! endpoints { + ($($name:ident: $method:ident $path:literal, $auth:ident, $request:ty => $response:ty;)+) => { + $( + pub struct $name; + + impl Endpoint for $name { + type Request = $request; + type Response = $response; + const METHOD: Method = Method::$method; + const AUTH: Auth = Auth::$auth; + + fn path(&self) -> Cow<'static, str> { + Cow::Borrowed($path) + } + } + )+ + + fn fixed_routes() -> Vec { + vec![$(route($name)),+] + } + }; +} + +endpoints! { + Meta: Get "/api/v1/meta", None, () => meta::ServerInfo; + RegisterStart: Post "/api/v1/auth/register/start", None, + auth::register::StartRequest => auth::register::StartResponse; + RegisterFinish: Post "/api/v1/auth/register/finish", Proof, + auth::register::FinishRequest => auth::register::FinishResponse; + LoginStart: Post "/api/v1/auth/login/start", None, + auth::login::StartRequest => auth::handshake::StartResponse; + LoginFinish: Post "/api/v1/auth/login/finish", Proof, + auth::login::FinishRequest => auth::login::FinishResponse; + StepUpStart: Post "/api/v1/auth/step-up/start", AccessToken, + auth::step_up::StartRequest => auth::handshake::StartResponse; + StepUpFinish: Post "/api/v1/auth/step-up/finish", AccessToken, + auth::step_up::FinishRequest => auth::step_up::FinishResponse; + Token: Post "/api/v1/auth/token", Proof, auth::token::TokenRequest => auth::Session; + Logout: Post "/api/v1/auth/logout", AccessToken, () => (); + ListDevices: Get "/api/v1/devices", AccessToken, () => devices::Devices; +} + +pub struct DeleteDevice { + pub id: DeviceId, +} + +impl Endpoint for DeleteDevice { + type Request = (); + type Response = (); + const METHOD: Method = Method::Delete; + const AUTH: Auth = Auth::AccessToken; + + fn path(&self) -> Cow<'static, str> { + Cow::Owned(format!("/api/v1/devices/{}", self.id.as_uuid())) + } +} + +#[derive(Debug)] +pub struct Route { + pub method: Method, + pub path: String, + pub auth: Auth, +} + +fn route(endpoint: E) -> Route { + Route { + method: E::METHOD, + path: endpoint.path().into_owned(), + auth: E::AUTH, + } +} + +pub fn all_routes() -> Vec { + let mut routes = fixed_routes(); + routes.push(route(DeleteDevice { + id: Uuid::nil().into(), + })); + routes +} diff --git a/rust/crates/keygo-api/src/error.rs b/rust/crates/keygo-api/src/error.rs new file mode 100644 index 000000000..0f5391a76 --- /dev/null +++ b/rust/crates/keygo-api/src/error.rs @@ -0,0 +1,110 @@ +use serde::{Deserialize, Serialize}; + +/// Clients match on the serialized name. A code this build does not know becomes +/// `Unknown`, so a newer server cannot break an older client. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum ErrorCode { + // general + Internal, + InvalidRequest, + NotFound, + RateLimited, + // auth + InvalidUsername, + InvalidCredentials, + UsernameTaken, + UserIdTaken, + InviteRequired, + InviteInvalid, + RegistrationExpired, + LoginExpired, + // session + FreshAuthRequired, + InvalidToken, + RefreshExpired, + SessionRevoked, + // dpop + InvalidDpopProof, + UseDpopNonce, + #[serde(other)] + Unknown, +} + +#[derive(Debug, Serialize, Deserialize)] +pub struct ApiError { + pub code: ErrorCode, + pub message: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub reason: Option, +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + #[test] + fn every_code_keeps_its_wire_name() { + for (code, name) in [ + (ErrorCode::Internal, "internal"), + (ErrorCode::InvalidRequest, "invalid_request"), + (ErrorCode::NotFound, "not_found"), + (ErrorCode::RateLimited, "rate_limited"), + (ErrorCode::InvalidUsername, "invalid_username"), + (ErrorCode::InvalidCredentials, "invalid_credentials"), + (ErrorCode::UsernameTaken, "username_taken"), + (ErrorCode::UserIdTaken, "user_id_taken"), + (ErrorCode::InviteRequired, "invite_required"), + (ErrorCode::InviteInvalid, "invite_invalid"), + (ErrorCode::RegistrationExpired, "registration_expired"), + (ErrorCode::LoginExpired, "login_expired"), + (ErrorCode::FreshAuthRequired, "fresh_auth_required"), + (ErrorCode::InvalidToken, "invalid_token"), + (ErrorCode::RefreshExpired, "refresh_expired"), + (ErrorCode::SessionRevoked, "session_revoked"), + (ErrorCode::InvalidDpopProof, "invalid_dpop_proof"), + (ErrorCode::UseDpopNonce, "use_dpop_nonce"), + ] { + assert_eq!(serde_json::to_value(code).unwrap(), name); + assert_eq!( + serde_json::from_value::(name.into()).unwrap(), + code + ); + } + } + + #[test] + fn unknown_code_decodes_as_unknown() { + assert_eq!( + serde_json::from_value::("brand_new".into()).unwrap(), + ErrorCode::Unknown, + ); + } + + #[test] + fn absent_reason_is_omitted() { + let error = ApiError { + code: ErrorCode::NotFound, + message: "m".into(), + reason: None, + }; + assert_eq!( + serde_json::to_value(&error).unwrap(), + json!({"code": "not_found", "message": "m"}) + ); + } + + #[test] + fn present_reason_is_written() { + let error = ApiError { + code: ErrorCode::SessionRevoked, + message: "m".into(), + reason: Some("logout".into()), + }; + assert_eq!( + serde_json::to_value(&error).unwrap(), + json!({"code": "session_revoked", "message": "m", "reason": "logout"}), + ); + } +} diff --git a/rust/crates/keygo-api/src/lib.rs b/rust/crates/keygo-api/src/lib.rs new file mode 100644 index 000000000..624a372f3 --- /dev/null +++ b/rust/crates/keygo-api/src/lib.rs @@ -0,0 +1,12 @@ +#![forbid(unsafe_code)] + +pub mod auth; +pub mod devices; +pub mod domain; +mod endpoint; +pub mod endpoints; +mod error; +pub mod meta; + +pub use endpoint::{Auth, Endpoint, Method}; +pub use error::{ApiError, ErrorCode}; diff --git a/rust/crates/keygo-api/src/meta.rs b/rust/crates/keygo-api/src/meta.rs new file mode 100644 index 000000000..08aea5f70 --- /dev/null +++ b/rust/crates/keygo-api/src/meta.rs @@ -0,0 +1,8 @@ +use serde::{Deserialize, Serialize}; + +#[derive(Debug, Serialize, Deserialize)] +pub struct ServerInfo { + pub version: String, + pub public_url: String, + pub allow_signups: bool, +} diff --git a/rust/crates/keygo-api/tests/wire.rs b/rust/crates/keygo-api/tests/wire.rs new file mode 100644 index 000000000..f11372a99 --- /dev/null +++ b/rust/crates/keygo-api/tests/wire.rs @@ -0,0 +1,369 @@ +//! Wire identity: every JSON shape the API exchanges, written out by hand. +//! A failure here means a field name or shape changed, which breaks deployed clients. + +use keygo_api::auth::handshake; +use keygo_api::auth::login; +use keygo_api::auth::register; +use keygo_api::auth::step_up; +use keygo_api::auth::token::TokenRequest; +use keygo_api::auth::{Access, Session}; +use keygo_api::devices::Devices; +use keygo_api::domain::RefreshToken; +use keygo_api::meta::ServerInfo; +use keygo_opaque::client::{ClientLogin, ClientRegistration}; +use keygo_opaque::server::{self, ServerLogin, ServerSetup}; +use keygo_opaque::{ + CredentialFinalization, CredentialRequest, CredentialResponse, DpopBinding, + RegistrationRequest, RegistrationResponse, RegistrationUpload, +}; +use serde::Serialize; +use serde::de::DeserializeOwned; +use serde_json::{Value, json}; + +const NIL: &str = "00000000-0000-0000-0000-000000000000"; +const HANDSHAKE_ID: &str = "_____________________w"; +const REFRESH: &str = "kgr___________________________________________8"; + +fn pin(value: &T, expected: Value) { + assert_eq!(serde_json::to_value(value).unwrap(), expected); + let decoded: T = serde_json::from_value(expected.clone()).unwrap(); + assert_eq!(serde_json::to_value(&decoded).unwrap(), expected); +} + +fn from(value: Value) -> T { + serde_json::from_value(value).unwrap() +} + +fn wrapped_ark() -> String { + "BwcH".repeat(20) +} + +fn device() -> Value { + json!({"name": "Pixel 9", "platform": "android", "app_version": "2.3.0"}) +} + +fn key_bundle() -> Value { + json!({"wrapped_ark": wrapped_ark()}) +} + +fn session_json() -> Value { + json!({ + "device_id": NIL, + "access_token": "a.b.c", + "access_expires_in": 900, + "refresh_token": REFRESH, + "refresh_expires_in": 2592000, + }) +} + +fn sample_session() -> Session { + from(session_json()) +} + +/// One real OPAQUE registration and login, with each message kept as its base64 text. +struct Messages { + registration_request: (RegistrationRequest, String), + registration_response: (RegistrationResponse, String), + registration_upload: (RegistrationUpload, String), + credential_request: (CredentialRequest, String), + credential_response: (CredentialResponse, String), + credential_finalization: (CredentialFinalization, String), + dpop_binding: (DpopBinding, String), +} + +fn messages() -> Messages { + let password = b"correct horse battery staple"; + let setup = ServerSetup::generate(); + + let (registration, request) = ClientRegistration::start(password).unwrap(); + let registration_request = request.to_base64(); + let response = server::registration_start(&setup, request, b"account-1").unwrap(); + let registration_response = response.to_base64(); + let finish = registration.finish(password, response).unwrap(); + let registration_upload = finish.upload.to_base64(); + let file = server::registration_finish(finish.upload); + + let (client, request) = ClientLogin::start(password).unwrap(); + let credential_request = request.to_base64(); + let (server, response) = ServerLogin::start(&setup, Some(file), request, b"account-1").unwrap(); + let credential_response = response.to_base64(); + let login = client.finish(password, response).unwrap(); + let credential_finalization = login.finalization.to_base64(); + let binding = login.session_key.dpop_binding(&[0x40; 32]); + let dpop_binding = binding.to_base64(); + server.finish(login.finalization).unwrap(); + + Messages { + registration_request: ( + RegistrationRequest::from_base64(®istration_request).unwrap(), + registration_request, + ), + registration_response: ( + RegistrationResponse::from_base64(®istration_response).unwrap(), + registration_response, + ), + registration_upload: ( + RegistrationUpload::from_base64(®istration_upload).unwrap(), + registration_upload, + ), + credential_request: ( + CredentialRequest::from_base64(&credential_request).unwrap(), + credential_request, + ), + credential_response: ( + CredentialResponse::from_base64(&credential_response).unwrap(), + credential_response, + ), + credential_finalization: ( + CredentialFinalization::from_base64(&credential_finalization).unwrap(), + credential_finalization, + ), + dpop_binding: (binding, dpop_binding), + } +} + +#[test] +fn register_start_request() { + let m = messages(); + let make = |invite: Option<&str>| register::StartRequest { + username: "alice".into(), + user_id: from(json!(NIL)), + invite: invite.map(String::from), + registration_request: RegistrationRequest::from_base64(&m.registration_request.1).unwrap(), + }; + let expected = |invite: Value| { + json!({ + "username": "alice", + "user_id": NIL, + "invite": invite, + "registration_request": m.registration_request.1, + }) + }; + pin(&make(Some("code")), expected(json!("code"))); + pin(&make(None), expected(Value::Null)); +} + +#[test] +fn register_start_response() { + let m = messages(); + pin( + ®ister::StartResponse { + registration_id: from(json!(HANDSHAKE_ID)), + registration_response: m.registration_response.0, + expires_in: 300, + }, + json!({ + "registration_id": HANDSHAKE_ID, + "registration_response": m.registration_response.1, + "expires_in": 300, + }), + ); +} + +#[test] +fn register_finish_request() { + let m = messages(); + pin( + ®ister::FinishRequest { + registration_id: from(json!(HANDSHAKE_ID)), + registration_upload: m.registration_upload.0, + key_bundle: from(key_bundle()), + device: from(device()), + }, + json!({ + "registration_id": HANDSHAKE_ID, + "registration_upload": m.registration_upload.1, + "key_bundle": {"wrapped_ark": wrapped_ark()}, + "device": {"name": "Pixel 9", "platform": "android", "app_version": "2.3.0"}, + }), + ); +} + +#[test] +fn register_finish_response() { + pin( + ®ister::FinishResponse { + username: from(json!("alice")), + session: sample_session(), + }, + json!({"username": "alice", "session": session_json()}), + ); +} + +#[test] +fn login_start_request() { + let m = messages(); + pin( + &login::StartRequest { + username: "alice".into(), + credential_request: m.credential_request.0, + }, + json!({"username": "alice", "credential_request": m.credential_request.1}), + ); +} + +#[test] +fn handshake_start_response() { + let m = messages(); + pin( + &handshake::StartResponse { + login_id: from(json!(HANDSHAKE_ID)), + credential_response: m.credential_response.0, + expires_in: 60, + }, + json!({ + "login_id": HANDSHAKE_ID, + "credential_response": m.credential_response.1, + "expires_in": 60, + }), + ); +} + +fn login_finish(device_id: Option<&str>) -> (login::FinishRequest, Value) { + let m = messages(); + let mut claim = device(); + claim["device_id"] = json!(device_id); + let request = login::FinishRequest { + login_id: from(json!(HANDSHAKE_ID)), + credential_finalization: m.credential_finalization.0, + device: from(claim.clone()), + dpop_binding: m.dpop_binding.0, + }; + let expected = json!({ + "login_id": HANDSHAKE_ID, + "credential_finalization": m.credential_finalization.1, + "device": claim, + "dpop_binding": m.dpop_binding.1, + }); + (request, expected) +} + +#[test] +fn login_finish_request_with_device() { + let (request, expected) = login_finish(Some(NIL)); + assert_eq!(expected["device"]["device_id"], NIL); + pin(&request, expected); +} + +#[test] +fn login_finish_request_without_device() { + let (request, expected) = login_finish(None); + assert_eq!(expected["device"]["device_id"], Value::Null); + pin(&request, expected); +} + +#[test] +fn login_finish_response() { + pin( + &login::FinishResponse { + user_id: from(json!(NIL)), + username: from(json!("alice")), + key_bundle: from(key_bundle()), + session: sample_session(), + }, + json!({ + "user_id": NIL, + "username": "alice", + "key_bundle": {"wrapped_ark": wrapped_ark()}, + "session": session_json(), + }), + ); +} + +#[test] +fn step_up_start_request() { + let m = messages(); + pin( + &step_up::StartRequest { + credential_request: m.credential_request.0, + }, + json!({"credential_request": m.credential_request.1}), + ); +} + +#[test] +fn step_up_finish_request() { + let m = messages(); + pin( + &step_up::FinishRequest { + login_id: from(json!(HANDSHAKE_ID)), + credential_finalization: m.credential_finalization.0, + dpop_binding: m.dpop_binding.0, + }, + json!({ + "login_id": HANDSHAKE_ID, + "credential_finalization": m.credential_finalization.1, + "dpop_binding": m.dpop_binding.1, + }), + ); +} + +#[test] +fn step_up_finish_response() { + pin( + &step_up::FinishResponse { + access: Access { + access_token: from(json!("a.b.c")), + access_expires_in: 900, + }, + auth_time: 1_700_000_000, + }, + json!({"access_token": "a.b.c", "access_expires_in": 900, "auth_time": 1_700_000_000u64}), + ); +} + +#[test] +fn token_request() { + pin( + &TokenRequest { + refresh_token: from::(json!(REFRESH)), + }, + json!({"refresh_token": REFRESH}), + ); +} + +#[test] +fn session() { + pin(&sample_session(), session_json()); +} + +#[test] +fn devices() { + let listed = json!({ + "devices": [ + { + "id": NIL, + "name": "Pixel 9", + "platform": "android", + "app_version": "2.3.0", + "created_at": 1_600_000_000u64, + "last_seen_at": 1_700_000_000u64, + "auth_time": 1_700_000_100u64, + "logged_in": true, + }, + { + "id": NIL, + "name": "Pixel 9", + "platform": "android", + "app_version": "2.3.0", + "created_at": 1_600_000_000u64, + "last_seen_at": 1_700_000_000u64, + "auth_time": null, + "logged_in": false, + }, + ], + }); + pin(&from::(listed.clone()), listed); +} + +#[test] +fn server_info() { + pin( + &ServerInfo { + version: "0.1.0".into(), + public_url: "https://keygo.example".into(), + allow_signups: true, + }, + json!({"version": "0.1.0", "public_url": "https://keygo.example", "allow_signups": true}), + ); +} diff --git a/rust/crates/keygo-client/Cargo.toml b/rust/crates/keygo-client/Cargo.toml index 0e20912d1..0bcdba854 100644 --- a/rust/crates/keygo-client/Cargo.toml +++ b/rust/crates/keygo-client/Cargo.toml @@ -3,8 +3,14 @@ name = "keygo-client" version.workspace = true edition.workspace = true +[features] +test-support = ["keygo-dpop/test-support", "tokio/rt"] + [dependencies] keygo-core = { path = "../keygo-core", features = ["crypto"] } +keygo-api = { path = "../keygo-api" } +keygo-opaque = { path = "../keygo-opaque" } +keygo-dpop = { path = "../keygo-dpop" } thiserror.workspace = true uuid.workspace = true @@ -26,6 +32,8 @@ email_address = "0.2.9" subtle = "2.6" totp-rs = { version = "6.0.0", features = ["otpauth", "zeroize"] } url = "2.5.8" +tokio = { workspace = true, features = ["sync"] } [dev-dependencies] +keygo-dpop = { path = "../keygo-dpop", features = ["test-support"] } tokio = { workspace = true, features = ["rt", "macros"] } diff --git a/rust/crates/keygo-client/src/ark_session.rs b/rust/crates/keygo-client/src/ark_session.rs index 348062718..5c579baee 100644 --- a/rust/crates/keygo-client/src/ark_session.rs +++ b/rust/crates/keygo-client/src/ark_session.rs @@ -1,8 +1,10 @@ use crate::crypto::kdf::new_salt; use crate::crypto::{ AccountRootKey, CryptoError, Encrypts, KeyMaterial, NamespaceDataAad, NamespaceId, - NamespaceKey, NamespaceKeyAad, RootKek, Sealed, SecretKind, UserId, VaultId, VaultKey, Wraps, + NamespaceKey, NamespaceKeyAad, OpaqueKek, RootKek, Sealed, SecretKind, UserId, VaultId, + VaultKey, Wraps, }; +use keygo_opaque::ExportKey; use std::sync::{Mutex, MutexGuard}; use subtle::ConstantTimeEq; use zeroize::Zeroizing; @@ -11,6 +13,8 @@ use zeroize::Zeroizing; pub enum ArkSessionError { #[error("No active session")] Locked, + #[error("Session holds a different account")] + AccountMismatch, #[error("Wrong password")] WrongPassword, #[error("Key derivation failed: {0}")] @@ -92,6 +96,26 @@ impl ArkSession { }) } + pub fn unlock_with_server( + &self, + export_key: &ExportKey, + wrapped: &Sealed, + user_id: UserId, + ) -> ArkSessionResult<()> { + let ark = OpaqueKek::from_export_key(export_key.as_bytes(), user_id) + .map_err(ArkSessionError::Derivation)? + .unwrap_key(wrapped, &user_id)?; + + let mut live = self.lock(); + match live.as_ref() { + None => *live = Some(ark), + Some(current) if bool::from(current.as_bytes().ct_eq(ark.as_bytes())) => {} + Some(_) => return Err(ArkSessionError::AccountMismatch), + } + + Ok(()) + } + pub fn unlock_with_password( &self, password: &str, @@ -147,6 +171,16 @@ impl ArkSession { Ok(PasswordWrappedArk { salt, wrapped }) } + pub fn wrap_for_server( + &self, + export_key: &ExportKey, + user_id: UserId, + ) -> ArkSessionResult> { + let kek = OpaqueKek::from_export_key(export_key.as_bytes(), user_id) + .map_err(ArkSessionError::Derivation)?; + self.with_live_ark(|ark| Ok(kek.wrap_key(ark, &user_id)?)) + } + pub fn wrap_vault_key( &self, vault_key: &VaultKey, @@ -224,6 +258,75 @@ mod tests { (session, new_account) } + fn export_key() -> ExportKey { + crate::sync::testing::FakeOpaqueAccount::register(PASSWORD).1 + } + + #[test] + fn server_wrapped_ark_unlocks_a_locked_session() { + let (session, account) = unlocked(); + let key = export_key(); + let wrapped = session.wrap_for_server(&key, account.user_id).unwrap(); + let ark = session.export_ark().unwrap(); + session.end(); + + session + .unlock_with_server(&key, &wrapped, account.user_id) + .unwrap(); + + assert_eq!(session.export_ark().unwrap(), ark); + } + + #[test] + fn server_wrapped_ark_matching_the_live_one_is_accepted() { + let (session, account) = unlocked(); + let key = export_key(); + let wrapped = session.wrap_for_server(&key, account.user_id).unwrap(); + + session + .unlock_with_server(&key, &wrapped, account.user_id) + .unwrap(); + } + + #[test] + fn server_wrapped_ark_of_another_account_is_a_mismatch() { + let (session, account) = unlocked(); + let ark = session.export_ark().unwrap(); + let (other, _) = unlocked(); + let key = export_key(); + let wrapped = other.wrap_for_server(&key, account.user_id).unwrap(); + + let result = session.unlock_with_server(&key, &wrapped, account.user_id); + + assert!(matches!(result, Err(ArkSessionError::AccountMismatch))); + assert_eq!(session.export_ark().unwrap(), ark, "the live ARK stays"); + } + + #[test] + fn server_wrapped_ark_is_bound_to_its_user() { + let (session, account) = unlocked(); + let key = export_key(); + let wrapped = session.wrap_for_server(&key, account.user_id).unwrap(); + session.end(); + + let result = session.unlock_with_server(&key, &wrapped, UserId::random()); + + assert!(matches!( + result, + Err(ArkSessionError::KeyWrap(CryptoError::KeyUnwrapFailed)), + )); + assert!(!session.is_active()); + } + + #[test] + fn wrap_for_server_needs_a_live_ark() { + let session = ArkSession::new(); + + let result = session.wrap_for_server(&export_key(), UserId::random()); + + assert!(matches!(result, Err(ArkSessionError::Locked))); + } + #[test] fn create_account_leaves_session_unlocked() { let (session, _) = unlocked(); diff --git a/rust/crates/keygo-client/src/lib.rs b/rust/crates/keygo-client/src/lib.rs index a8fcb9c61..d09d77257 100644 --- a/rust/crates/keygo-client/src/lib.rs +++ b/rust/crates/keygo-client/src/lib.rs @@ -6,5 +6,6 @@ pub mod backup; pub mod card; pub use keygo_core as crypto; pub mod passkey; +pub mod sync; pub mod totp; mod url; diff --git a/rust/crates/keygo-client/src/sync/client.rs b/rust/crates/keygo-client/src/sync/client.rs new file mode 100644 index 000000000..12bb0357e --- /dev/null +++ b/rust/crates/keygo-client/src/sync/client.rs @@ -0,0 +1,1042 @@ +use super::error::{SyncError, SyncResult}; +use super::pipeline::store_failure; +use super::signer::SharedSigner; +use super::state::{AuthState, Clock, SystemClock}; +use super::tokens::TokenStore; +use super::transport::Transport; +use crate::ark_session::{ArkSession, ArkSessionError}; +use keygo_api::Endpoint; +use keygo_api::auth::{Session, login, register, step_up}; +use keygo_api::domain::{Device, DeviceClaim, DeviceInfo, KeyBundle, Username}; +use keygo_api::endpoints::{ + DeleteDevice, ListDevices, LoginFinish, LoginStart, Logout, Meta, RegisterFinish, + RegisterStart, StepUpFinish, StepUpStart, +}; +use keygo_api::meta::ServerInfo; +use keygo_core::{CryptoError, DeviceId, UserId}; +use keygo_dpop::DpopProver; +use keygo_opaque::OpaqueError; +use keygo_opaque::client::{ClientLogin, ClientRegistration}; +use std::fmt::Debug; +use std::sync::Arc; +use tokio::sync::Mutex; +use url::Url; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Account { + pub user_id: UserId, + pub username: Username, + pub device_id: DeviceId, +} + +pub struct SyncClient { + pub(super) base_url: Url, + pub(super) transport: Arc, + pub(super) prover: DpopProver, + pub(super) tokens: Arc, + pub(super) clock: Arc, + pub(super) auth: Mutex, + /// Not inside `auth`: a refresh holds that lock across the network and signs with the nonce. + pub(super) nonce: std::sync::Mutex>, +} + +fn check_base_url(url: &Url) -> SyncResult<()> { + let is_origin = matches!(url.scheme(), "http" | "https") + && url.has_host() + && url.path() == "/" + && url.query().is_none() + && url.fragment().is_none(); + if is_origin { + return Ok(()); + } + Err(SyncError::Client { + message: "the server url must be a plain http(s) origin".into(), + }) +} + +impl SyncClient { + pub fn new( + base_url: Url, + transport: Arc, + signer: SharedSigner, + tokens: Arc, + ) -> SyncResult { + check_base_url(&base_url)?; + Ok(Self { + base_url, + transport, + prover: DpopProver::new(signer), + tokens, + clock: Arc::new(SystemClock), + auth: Mutex::new(AuthState::default()), + nonce: std::sync::Mutex::default(), + }) + } + + #[cfg(any(test, feature = "test-support"))] + pub fn with_clock(mut self, clock: Arc) -> Self { + self.clock = clock; + self + } + + pub async fn meta(&self) -> SyncResult { + self.call(&Meta, &()).await + } + + pub async fn devices(&self) -> SyncResult> { + Ok(self.call(&ListDevices, &()).await?.devices) + } + + pub async fn delete_device(&self, id: DeviceId) -> SyncResult<()> { + self.call(&DeleteDevice { id }, &()).await + } + + /// Proves the password again for a fresh access token. The refresh token is kept. + pub async fn step_up(&self, password: &str) -> SyncResult<()> { + let (login, credential_request) = + ClientLogin::start(password.as_bytes()).map_err(opaque_failure)?; + let started = self + .call(&StepUpStart, &step_up::StartRequest { credential_request }) + .await?; + let finish = login + .finish(password.as_bytes(), started.credential_response) + .map_err(opaque_failure)?; + let dpop_binding = finish.session_key.dpop_binding(self.prover.jkt()); + + let sent_at = self.clock.now_secs(); + let response = self + .call( + &StepUpFinish, + &step_up::FinishRequest { + login_id: started.login_id, + credential_finalization: finish.finalization, + dpop_binding, + }, + ) + .await?; + + self.auth + .lock() + .await + .replace_access(response.access, sent_at); + Ok(()) + } + + /// Creates an account holding a server-wrapped copy of `ark_session`'s ARK, and signs in. + /// + /// `user_id` must be the local account's id: the wrapped ARK is bound to it, and `ark_session` + /// holds no id to check it against. The previous session is logged out only once the new one + /// exists. + pub async fn register( + &self, + ark_session: &ArkSession, + user_id: UserId, + username: String, + password: &str, + invite: Option, + device: DeviceInfo, + ) -> SyncResult { + if !ark_session.is_active() { + return Err(SyncError::VaultLocked); + } + let (client, registration_request) = + ClientRegistration::start(password.as_bytes()).map_err(opaque_failure)?; + + let started = self + .call( + &RegisterStart, + ®ister::StartRequest { + username, + user_id, + invite, + registration_request, + }, + ) + .await?; + let finish = client + .finish(password.as_bytes(), started.registration_response) + .map_err(|error| SyncError::invalid_response(error.to_string()))?; + + let wrapped_ark = ark_session + .wrap_for_server(&finish.export_key, user_id) + .map_err(|error| match error { + ArkSessionError::Locked => SyncError::VaultLocked, + other => client_failure(other), + })?; + let key_bundle = KeyBundle { wrapped_ark }; + + let sent_at = self.clock.now_secs(); + let response = self + .call( + &RegisterFinish, + ®ister::FinishRequest { + registration_id: started.registration_id, + registration_upload: finish.upload, + key_bundle, + device, + }, + ) + .await?; + + let account = Account { + user_id, + username: response.username, + device_id: response.session.device_id, + }; + self.replace_session(response.session, sent_at, None).await; + Ok(account) + } + + /// Signs in and unlocks `ark_session` with the server's copy of the ARK. An `ark_session` that + /// is already unlocked must hold that same ARK, or the login fails with + /// [`SyncError::AccountMismatch`]. + /// + /// Claims the device this client last signed in as, so a re-login replaces its session instead + /// of adding a device. + pub async fn login( + &self, + ark_session: &ArkSession, + username: String, + password: &str, + device: DeviceInfo, + ) -> SyncResult { + let (client, credential_request) = + ClientLogin::start(password.as_bytes()).map_err(opaque_failure)?; + let claimed = self.current_device().await; + let started = self + .call( + &LoginStart, + &login::StartRequest { + username, + credential_request, + }, + ) + .await?; + let finish = client + .finish(password.as_bytes(), started.credential_response) + .map_err(opaque_failure)?; + let dpop_binding = finish.session_key.dpop_binding(self.prover.jkt()); + + let sent_at = self.clock.now_secs(); + let response = self + .call( + &LoginFinish, + &login::FinishRequest { + login_id: started.login_id, + credential_finalization: finish.finalization, + device: DeviceClaim { + id: claimed, + info: device, + }, + dpop_binding, + }, + ) + .await?; + + let unlocked = ark_session.unlock_with_server( + &finish.export_key, + &response.key_bundle.wrapped_ark, + response.user_id, + ); + if let Err(error) = unlocked { + self.discard(&response.session, claimed).await; + return Err(unlock_failure(error)); + } + + let account = Account { + user_id: response.user_id, + username: response.username, + device_id: response.session.device_id, + }; + self.replace_session(response.session, sent_at, claimed) + .await; + Ok(account) + } + + async fn current_device(&self) -> Option { + let state = self.auth.lock().await; + if let Some(unsaved) = &state.unsaved { + return Some(unsaved.device_id); + } + // An unreadable store only costs the reattach: the server makes a new device instead. + self.tokens.load().await.ok().flatten().map(|s| s.device_id) + } + + async fn replace_session(&self, session: Session, sent_at: u64, claimed: Option) { + // The server already revoked a reattached device's old session. The logout is best effort: + // the new session is live on the server either way. + if !is_reattached(&session, claimed) { + let _ = self.logout().await; + } + self.adopt_session(session, sent_at).await; + } + + /// Ends a session this client will not keep, signing with that session's own token. Best + /// effort: one left behind expires unused. + async fn discard(&self, session: &Session, claimed: Option) { + let token = Some(session.access.access_token.expose()); + let _ = if is_reattached(session, claimed) { + // The device was this client's before the login, so it stays. + self.send_signed(Logout::METHOD, &Logout.path(), token, None) + .await + } else { + // The device exists only for this login. Deleting it ends its session too. + let endpoint = DeleteDevice { + id: session.device_id, + }; + self.send_signed(DeleteDevice::METHOD, &endpoint.path(), token, None) + .await + }; + } + + /// Always ends the session locally and returns the server's result. If the server was not told + /// and the token is still on disk, the store error is returned instead. + pub async fn logout(&self) -> SyncResult<()> { + let sent = self.call(&Logout, &()).await; + let mut state = self.auth.lock().await; + let cleared = self.end_session(&mut state).await; + match (sent, cleared) { + (Err(_), Err(error)) => Err(store_failure(error)), + (sent, _) => sent, + } + } +} + +fn is_reattached(session: &Session, claimed: Option) -> bool { + claimed == Some(session.device_id) +} + +fn client_failure(error: impl std::fmt::Display) -> SyncError { + SyncError::Client { + message: error.to_string(), + } +} + +/// OPAQUE already proved the password, so a key bundle that does not open is the server's fault. +fn unlock_failure(error: ArkSessionError) -> SyncError { + match error { + ArkSessionError::AccountMismatch => SyncError::AccountMismatch, + ArkSessionError::KeyWrap( + error @ (CryptoError::KeyUnwrapFailed | CryptoError::DecryptionFailed), + ) => SyncError::invalid_response(format!("the server's key bundle: {error}")), + other => client_failure(other), + } +} + +fn opaque_failure(error: OpaqueError) -> SyncError { + match error { + OpaqueError::InvalidLogin | OpaqueError::EmptyPassword => SyncError::InvalidCredentials, + other => client_failure(other), + } +} + +#[cfg(test)] +mod tests { + use super::super::error::SyncError; + use super::super::testing::{error_body, fake_client, header}; + use super::super::tokens::StoredSession; + use super::super::transport::HttpRequest; + use serde_json::json; + + const INFO: &str = r#"{"version":"1","public_url":"https://kg.example","allow_signups":true}"#; + + #[tokio::test] + async fn none_auth_sends_no_proof_or_token() { + let (client, transport) = fake_client(); + transport.push(200, &[], INFO.as_bytes()); + + client.meta().await.unwrap(); + + let requests = transport.requests(); + assert_eq!(requests.len(), 1); + assert_eq!(header(&requests[0], "dpop"), None); + assert_eq!(header(&requests[0], "authorization"), None); + assert_eq!(requests[0].method, keygo_api::Method::Get); + assert_eq!(requests[0].url, "https://kg.example/api/v1/meta"); + } + + #[tokio::test] + async fn unit_request_has_no_body_or_content_type() { + let (client, transport) = fake_client(); + transport.push(200, &[], INFO.as_bytes()); + + client.meta().await.unwrap(); + + let request = &transport.requests()[0]; + assert!(request.body.is_empty()); + assert_eq!(header(request, "content-type"), None); + } + + #[tokio::test] + async fn error_codes_map_to_sync_errors() { + for (code, expected) in [ + ("invalid_credentials", SyncError::InvalidCredentials), + ("invalid_username", SyncError::InvalidUsername), + ("username_taken", SyncError::UsernameTaken), + ("invite_required", SyncError::InviteRequired), + ("invite_invalid", SyncError::InviteInvalid), + ("fresh_auth_required", SyncError::FreshAuthRequired), + ("rate_limited", SyncError::RateLimited), + ] { + let (client, transport) = fake_client(); + transport.push(400, &[], &error_body(code)); + + assert_eq!(client.meta().await.unwrap_err(), expected, "{code}"); + } + } + + #[tokio::test] + async fn rate_limited_is_not_retried() { + let (client, transport) = fake_client(); + transport.push( + 429, + &[], + br#"{"code":"rate_limited","message":"slow down"}"#, + ); + + assert_eq!(client.meta().await.unwrap_err(), SyncError::RateLimited); + assert_eq!(transport.requests().len(), 1); + } + + #[tokio::test] + async fn unknown_code_is_a_server_error() { + let (client, transport) = fake_client(); + transport.push(400, &[], br#"{"code":"brand_new","message":"m"}"#); + + assert_eq!( + client.meta().await.unwrap_err(), + SyncError::Server { + code: "unknown".into(), + message: "m".into(), + }, + ); + } + + #[tokio::test] + async fn html_200_is_an_invalid_response() { + let (client, transport) = fake_client(); + transport.push(200, &[], b""); + + assert!(matches!( + client.meta().await.unwrap_err(), + SyncError::Server { code, .. } if code == "invalid_response", + )); + } + + #[tokio::test] + async fn html_502_is_a_server_error() { + let (client, transport) = fake_client(); + transport.push(502, &[], b""); + + assert!(matches!( + client.meta().await.unwrap_err(), + SyncError::Server { code, .. } if code == "http_502", + )); + } + + mod register { + use super::super::super::testing::{FakeSigner, client_with_store, error_body, header}; + use super::super::super::transport::HttpRequest; + use super::super::SyncError; + use super::{OLD_REFRESH, old_session_reply, paths, previous_session}; + use crate::ark_session::ArkSession; + use base64::Engine; + use base64::engine::general_purpose::URL_SAFE_NO_PAD; + use keygo_api::domain::DeviceInfo; + use keygo_core::UserId; + use keygo_opaque::server::{self, ServerSetup}; + use keygo_opaque::{OpaqueError, RegistrationRequest}; + use serde_json::{Value, json}; + use std::sync::Arc; + + const REGISTRATION_ID: &str = "BwcHBwcHBwcHBwcHBwcHBw"; + const REFRESH: &str = "kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; + + fn unlocked() -> (ArkSession, UserId) { + let ark_session = ArkSession::new(); + let user_id = ark_session + .create_account("local password") + .unwrap() + .user_id; + (ark_session, user_id) + } + + fn device() -> DeviceInfo { + serde_json::from_value(json!({ + "name": "Pixel 9", + "platform": "android", + "app_version": "2.3.0", + })) + .unwrap() + } + + fn body(request: &HttpRequest) -> Value { + serde_json::from_slice(&request.body).unwrap() + } + + /// What a real server answers to `register/start`. + fn start_reply(request: &HttpRequest) -> Vec { + let registration_request: RegistrationRequest = + serde_json::from_value(body(request)["registration_request"].clone()).unwrap(); + let response = + server::registration_start(&ServerSetup::generate(), registration_request, b"u") + .unwrap(); + serde_json::to_vec(&json!({ + "registration_id": REGISTRATION_ID, + "registration_response": response, + "expires_in": 300, + })) + .unwrap() + } + + fn finish_reply() -> Vec { + serde_json::to_vec(&json!({ + "username": "ada", + "session": { + "device_id": "00000000-0000-0000-0000-000000000001", + "access_token": "a.b.c", + "access_expires_in": 600, + "refresh_token": REFRESH, + "refresh_expires_in": 86400, + }, + })) + .unwrap() + } + + #[tokio::test] + async fn registers_and_keeps_the_session() { + let (client, transport, store) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + transport.push_with(200, start_reply); + transport.push(200, &[], &finish_reply()); + let (ark_session, user_id) = unlocked(); + + let account = client + .register(&ark_session, user_id, "Ada".into(), "pw", None, device()) + .await + .unwrap(); + + assert_eq!(account.user_id, user_id); + assert_eq!(account.username.as_str(), "ada"); + assert_eq!(store.current_refresh_token().as_deref(), Some(REFRESH)); + + let requests = transport.requests(); + assert_eq!(requests.len(), 2, "a signed-out client sends no logout"); + assert_eq!(header(&requests[0], "dpop"), None); + assert!(header(&requests[1], "dpop").is_some()); + + let finish = body(&requests[1]); + assert_eq!(finish["registration_id"], REGISTRATION_ID); + let wrapped_ark = URL_SAFE_NO_PAD + .decode(finish["key_bundle"]["wrapped_ark"].as_str().unwrap()) + .unwrap(); + assert_eq!(wrapped_ark.len(), 60); + } + + #[tokio::test] + async fn locked_vault_sends_nothing() { + let (client, transport, _) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + + let error = client + .register( + &ArkSession::new(), + UserId::random(), + "ada".into(), + "pw", + None, + device(), + ) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::VaultLocked); + assert!(transport.requests().is_empty()); + } + + #[tokio::test] + async fn empty_password_sends_nothing() { + let (client, transport, _) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + let (ark_session, user_id) = unlocked(); + + let error = client + .register(&ark_session, user_id, "ada".into(), "", None, device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::InvalidCredentials); + assert!(transport.requests().is_empty()); + } + + /// A server that echoes the blinded element would learn the OPRF output; the client + /// refuses, and that is the server's fault, not a wrong password. + #[tokio::test] + async fn reflected_response_is_an_invalid_response() { + let (client, transport, _) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + transport.push_with(200, |request| { + let blinded = URL_SAFE_NO_PAD + .decode(body(request)["registration_request"].as_str().unwrap()) + .unwrap(); + let reflected = [blinded, ServerSetup::generate().public_key()].concat(); + serde_json::to_vec(&json!({ + "registration_id": REGISTRATION_ID, + "registration_response": URL_SAFE_NO_PAD.encode(reflected), + "expires_in": 300, + })) + .unwrap() + }); + let (ark_session, user_id) = unlocked(); + + let error = client + .register(&ark_session, user_id, "ada".into(), "pw", None, device()) + .await + .unwrap_err(); + + assert_eq!( + error, + SyncError::invalid_response(OpaqueError::ReflectedValue.to_string()), + ); + assert_eq!(transport.requests().len(), 1, "finish is never sent"); + } + + #[tokio::test] + async fn failed_register_keeps_the_previous_session() { + let (client, transport, store) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + store.seed(previous_session()); + transport.push(409, &[], &error_body("username_taken")); + let (ark_session, user_id) = unlocked(); + + let error = client + .register(&ark_session, user_id, "ada".into(), "pw", None, device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::UsernameTaken); + assert_eq!(store.current_refresh_token().as_deref(), Some(OLD_REFRESH)); + assert_eq!(transport.requests().len(), 1, "no logout"); + } + + #[tokio::test] + async fn previous_session_is_logged_out_once_registered() { + let (client, transport, store) = + client_with_store("https://kg.example", Arc::new(FakeSigner::new())); + store.seed(previous_session()); + transport.push_with(200, start_reply); + transport.push(200, &[], &finish_reply()); + transport.push(200, &[], &old_session_reply()); + transport.push(204, &[], b""); + let (ark_session, user_id) = unlocked(); + + client + .register(&ark_session, user_id, "ada".into(), "pw", None, device()) + .await + .unwrap(); + + let paths = paths(&transport.requests()); + assert_eq!( + paths, + [ + "/api/v1/auth/register/start", + "/api/v1/auth/register/finish", + "/api/v1/auth/token", + "/api/v1/auth/logout", + ], + ); + assert_eq!(store.current_refresh_token().as_deref(), Some(REFRESH)); + } + } + + pub(super) const OLD_REFRESH: &str = "kgr___________________________________________8"; + const OLD_DEVICE: &str = "00000000-0000-0000-0000-00000000000d"; + + /// A session of whatever account this client was signed in to before. + pub(super) fn previous_session() -> StoredSession { + StoredSession { + device_id: serde_json::from_value(json!(OLD_DEVICE)).unwrap(), + refresh_token: OLD_REFRESH.parse().unwrap(), + refresh_expires_at: u64::MAX / 2, + } + } + + /// What the token endpoint answers when the previous session refreshes to log out. + pub(super) fn old_session_reply() -> Vec { + serde_json::to_vec(&json!({ + "device_id": OLD_DEVICE, + "access_token": "old.access.token", + "access_expires_in": 600, + "refresh_token": "kgr_AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE", + "refresh_expires_in": 86400, + })) + .unwrap() + } + + pub(super) fn paths(requests: &[HttpRequest]) -> Vec { + requests + .iter() + .map(|r| r.url.trim_start_matches("https://kg.example").to_owned()) + .collect() + } + + mod login { + use super::super::super::testing::{ + FakeOpaqueAccount, FakeSigner, FakeTokenStore, FakeTransport, client_with_store, header, + }; + use super::super::super::transport::HttpRequest; + use super::super::{SyncClient, SyncError}; + use super::{OLD_DEVICE, OLD_REFRESH, old_session_reply, paths, previous_session}; + use crate::ark_session::ArkSession; + use keygo_api::Method; + use keygo_api::domain::DeviceInfo; + use keygo_core::UserId; + use keygo_opaque::{CredentialRequest, ExportKey}; + use serde_json::{Value, json}; + use std::sync::Arc; + + const PASSWORD: &str = "pw"; + const LOGIN_ID: &str = "CQkJCQkJCQkJCQkJCQkJCQ"; + const REFRESH: &str = "kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; + const ACCESS: &str = "new.access.token"; + const NEW_DEVICE: &str = "00000000-0000-0000-0000-00000000000e"; + + /// A server account whose key bundle wraps the ARK `ark_session` holds. + struct Server { + opaque: FakeOpaqueAccount, + user_id: UserId, + wrapped_ark: Value, + } + + impl Server { + fn holding(ark_session: &ArkSession) -> Self { + let (opaque, export_key) = FakeOpaqueAccount::register(PASSWORD); + Self::with_key(opaque, &export_key, ark_session) + } + + fn with_key( + opaque: FakeOpaqueAccount, + export_key: &ExportKey, + ark_session: &ArkSession, + ) -> Self { + let user_id = UserId::random(); + let wrapped = ark_session.wrap_for_server(export_key, user_id).unwrap(); + Self { + opaque, + user_id, + wrapped_ark: serde_json::to_value(wrapped).unwrap(), + } + } + + fn answer_start(&self, transport: &FakeTransport) { + let opaque = self.opaque.clone(); + transport.push_with(200, move |request| { + start_body(opaque.credential_response(credential_request(request))) + }); + } + + fn answer_finish(&self, transport: &FakeTransport, device_id: &str) { + let body = json!({ + "user_id": self.user_id, + "username": "ada", + "key_bundle": { "wrapped_ark": self.wrapped_ark }, + "session": { + "device_id": device_id, + "access_token": ACCESS, + "access_expires_in": 600, + "refresh_token": REFRESH, + "refresh_expires_in": 86400, + }, + }); + transport.push(200, &[], &serde_json::to_vec(&body).unwrap()); + } + } + + fn credential_request(request: &HttpRequest) -> CredentialRequest { + let body: Value = serde_json::from_slice(&request.body).unwrap(); + serde_json::from_value(body["credential_request"].clone()).unwrap() + } + + fn start_body(response: keygo_opaque::CredentialResponse) -> Vec { + serde_json::to_vec(&json!({ + "login_id": LOGIN_ID, + "credential_response": response, + "expires_in": 60, + })) + .unwrap() + } + + fn unlocked() -> ArkSession { + let ark_session = ArkSession::new(); + ark_session.create_account("local password").unwrap(); + ark_session + } + + fn device() -> DeviceInfo { + serde_json::from_value(json!({ + "name": "Pixel 9", + "platform": "android", + "app_version": "2.3.0", + })) + .unwrap() + } + + fn client() -> (SyncClient, Arc, Arc) { + client_with_store("https://kg.example", Arc::new(FakeSigner::new())) + } + + fn claimed_device(request: &HttpRequest) -> Value { + let body: Value = serde_json::from_slice(&request.body).unwrap(); + body["device"]["device_id"].clone() + } + + #[tokio::test] + async fn signs_in_and_keeps_the_session() { + let (client, transport, store) = client(); + let ark_session = unlocked(); + let server = Server::holding(&ark_session); + server.answer_start(&transport); + server.answer_finish(&transport, NEW_DEVICE); + + let account = client + .login(&ark_session, "Ada".into(), PASSWORD, device()) + .await + .unwrap(); + + assert_eq!(account.user_id, server.user_id); + assert_eq!(account.device_id.as_uuid().to_string(), NEW_DEVICE); + assert_eq!(store.current_refresh_token().as_deref(), Some(REFRESH)); + + let requests = transport.requests(); + assert_eq!(requests.len(), 2, "a signed-out client sends no logout"); + assert_eq!(header(&requests[0], "dpop"), None); + assert!(header(&requests[1], "dpop").is_some()); + assert_eq!(claimed_device(&requests[1]), Value::Null); + } + + #[tokio::test] + async fn unlocks_a_locked_session_with_the_server_copy() { + let (client, transport, _) = client(); + let ark_session = unlocked(); + let server = Server::holding(&ark_session); + let local = ark_session.export_ark().unwrap(); + ark_session.end(); + server.answer_start(&transport); + server.answer_finish(&transport, NEW_DEVICE); + + client + .login(&ark_session, "ada".into(), PASSWORD, device()) + .await + .unwrap(); + + assert_eq!(ark_session.export_ark().unwrap(), local); + } + + #[tokio::test] + async fn wrong_password_sends_no_finish() { + let (client, transport, store) = client(); + store.seed(previous_session()); + let ark_session = unlocked(); + Server::holding(&ark_session).answer_start(&transport); + + let error = client + .login(&ark_session, "ada".into(), "wrong", device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::InvalidCredentials); + assert_eq!(transport.requests().len(), 1); + assert_eq!(store.current_refresh_token().as_deref(), Some(OLD_REFRESH)); + } + + #[tokio::test] + async fn unknown_username_fails_like_a_wrong_password() { + let (client, transport, _) = client(); + transport.push_with(200, |request| { + start_body(FakeOpaqueAccount::unknown_user_response( + credential_request(request), + )) + }); + + let error = client + .login(&unlocked(), "nobody".into(), PASSWORD, device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::InvalidCredentials); + assert_eq!(transport.requests().len(), 1); + } + + #[tokio::test] + async fn empty_password_sends_nothing() { + let (client, transport, _) = client(); + + let error = client + .login(&unlocked(), "ada".into(), "", device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::InvalidCredentials); + assert!(transport.requests().is_empty()); + } + + /// The server reattached the device and ended its old session, so there is nothing to + /// log out. + #[tokio::test] + async fn reclaims_the_device_it_was_signed_in_as() { + let (client, transport, store) = client(); + store.seed(previous_session()); + let ark_session = unlocked(); + let server = Server::holding(&ark_session); + server.answer_start(&transport); + server.answer_finish(&transport, OLD_DEVICE); + + client + .login(&ark_session, "ada".into(), PASSWORD, device()) + .await + .unwrap(); + + let requests = transport.requests(); + assert_eq!(requests.len(), 2); + assert_eq!(claimed_device(&requests[1]), OLD_DEVICE); + assert_eq!(store.current_refresh_token().as_deref(), Some(REFRESH)); + } + + /// The claim went to another account's device, so the server made a new one and the old + /// session would otherwise stay valid. + #[tokio::test] + async fn logs_the_previous_session_out_on_a_new_device() { + let (client, transport, store) = client(); + store.seed(previous_session()); + let ark_session = unlocked(); + let server = Server::holding(&ark_session); + server.answer_start(&transport); + server.answer_finish(&transport, NEW_DEVICE); + transport.push(200, &[], &old_session_reply()); + transport.push(204, &[], b""); + + client + .login(&ark_session, "ada".into(), PASSWORD, device()) + .await + .unwrap(); + + let requests = transport.requests(); + assert_eq!( + paths(&requests), + [ + "/api/v1/auth/login/start", + "/api/v1/auth/login/finish", + "/api/v1/auth/token", + "/api/v1/auth/logout", + ], + ); + assert_eq!( + header(&requests[3], "authorization"), + Some("DPoP old.access.token"), + ); + assert_eq!(store.current_refresh_token().as_deref(), Some(REFRESH)); + } + + #[tokio::test] + async fn mismatch_keeps_the_previous_session_and_deletes_the_new_device() { + let (client, transport, store) = client(); + store.seed(previous_session()); + let ark_session = unlocked(); + let local = ark_session.export_ark().unwrap(); + let server = Server::holding(&unlocked()); + server.answer_start(&transport); + server.answer_finish(&transport, NEW_DEVICE); + transport.push(204, &[], b""); + + let error = client + .login(&ark_session, "ada".into(), PASSWORD, device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::AccountMismatch); + assert_eq!(store.current_refresh_token().as_deref(), Some(OLD_REFRESH)); + assert_eq!(ark_session.export_ark().unwrap(), local); + + let requests = transport.requests(); + assert_eq!(requests.len(), 3); + assert_eq!(requests[2].method, Method::Delete); + assert_eq!( + requests[2].url, + format!("https://kg.example/api/v1/devices/{NEW_DEVICE}"), + ); + assert_eq!( + header(&requests[2], "authorization"), + Some(format!("DPoP {ACCESS}").as_str()), + ); + } + + /// A reattached device was this client's before the login, so it stays; only the session + /// the login made is ended. + #[tokio::test] + async fn mismatch_on_a_reattached_device_only_logs_out() { + let (client, transport, _) = client(); + client_seed(&client).await; + let server = Server::holding(&unlocked()); + server.answer_start(&transport); + server.answer_finish(&transport, OLD_DEVICE); + transport.push(204, &[], b""); + + let error = client + .login(&unlocked(), "ada".into(), PASSWORD, device()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::AccountMismatch); + let requests = transport.requests(); + assert_eq!(requests.len(), 3); + assert_eq!(requests[2].url, "https://kg.example/api/v1/auth/logout",); + assert_eq!( + header(&requests[2], "authorization"), + Some(format!("DPoP {ACCESS}").as_str()), + ); + } + + /// OPAQUE proved the password, so a bundle that does not open is the server's fault. + #[tokio::test] + async fn bundle_that_does_not_open_is_an_invalid_response() { + let (client, transport, _) = client(); + let ark_session = unlocked(); + let (opaque, _) = FakeOpaqueAccount::register(PASSWORD); + let (_, other_key) = FakeOpaqueAccount::register(PASSWORD); + let server = Server::with_key(opaque, &other_key, &ark_session); + ark_session.end(); + server.answer_start(&transport); + server.answer_finish(&transport, NEW_DEVICE); + transport.push(204, &[], b""); + + let error = client + .login(&ark_session, "ada".into(), PASSWORD, device()) + .await + .unwrap_err(); + + assert!( + matches!(&error, SyncError::Server { code, .. } if code == "invalid_response"), + "{error:?}", + ); + assert!(!ark_session.is_active()); + assert_eq!(transport.requests().len(), 3, "the new device is deleted"); + } + + async fn client_seed(client: &SyncClient) { + client.tokens.save(&previous_session()).await.unwrap(); + } + } + + #[tokio::test] + async fn transport_failure_is_network() { + let (client, transport) = fake_client(); + transport.push_network_error("offline"); + + assert_eq!( + client.meta().await.unwrap_err(), + SyncError::Network { + message: "offline".into(), + }, + ); + } +} diff --git a/rust/crates/keygo-client/src/sync/error.rs b/rust/crates/keygo-client/src/sync/error.rs new file mode 100644 index 000000000..ddc1fcdac --- /dev/null +++ b/rust/crates/keygo-client/src/sync/error.rs @@ -0,0 +1,77 @@ +use keygo_api::domain::RevokeReason; +use keygo_api::{ApiError, ErrorCode}; + +pub type SyncResult = Result; + +#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)] +pub enum SyncError { + #[error("invalid credentials")] + InvalidCredentials, + #[error("invalid username")] + InvalidUsername, + #[error("username taken")] + UsernameTaken, + #[error("invite required")] + InviteRequired, + #[error("invite invalid")] + InviteInvalid, + #[error("fresh authentication required")] + FreshAuthRequired, + #[error("signed out")] + SignedOut { reason: Option }, + #[error("rate limited")] + RateLimited, + #[error("vault locked")] + VaultLocked, + /// The account signed in to holds a different ARK than the unlocked local vault. + #[error("account mismatch")] + AccountMismatch, + #[error("network error: {message}")] + Network { message: String }, + #[error("server error {code}: {message}")] + Server { code: String, message: String }, + #[error("client error: {message}")] + Client { message: String }, + #[error(transparent)] + InvalidUrl(#[from] url::ParseError), +} + +impl SyncError { + pub(super) fn invalid_response(message: impl Into) -> Self { + Self::Server { + code: "invalid_response".into(), + message: message.into(), + } + } +} + +/// `session_revoked` and `refresh_expired` never reach this: they end the session first. +pub(super) fn from_response(status: u16, body: &[u8]) -> SyncError { + let Ok(error) = serde_json::from_slice::(body) else { + return SyncError::Server { + code: format!("http_{status}"), + message: String::from_utf8_lossy(body).chars().take(200).collect(), + }; + }; + + match error.code { + ErrorCode::InvalidCredentials => SyncError::InvalidCredentials, + ErrorCode::InvalidUsername => SyncError::InvalidUsername, + ErrorCode::UsernameTaken => SyncError::UsernameTaken, + ErrorCode::InviteRequired => SyncError::InviteRequired, + ErrorCode::InviteInvalid => SyncError::InviteInvalid, + ErrorCode::FreshAuthRequired => SyncError::FreshAuthRequired, + ErrorCode::RateLimited => SyncError::RateLimited, + code => SyncError::Server { + code: wire_name(code), + message: error.message, + }, + } +} + +fn wire_name(code: ErrorCode) -> String { + serde_json::to_value(code) + .ok() + .and_then(|v| v.as_str().map(str::to_owned)) + .unwrap_or_else(|| "unknown".into()) +} diff --git a/rust/crates/keygo-client/src/sync/mod.rs b/rust/crates/keygo-client/src/sync/mod.rs new file mode 100644 index 000000000..a67a4b69f --- /dev/null +++ b/rust/crates/keygo-client/src/sync/mod.rs @@ -0,0 +1,19 @@ +//! The sync client: the auth protocol over three host-supplied dependencies +//! ([`Transport`], [`SharedSigner`], [`TokenStore`]). No HTTP stack lives here. + +mod client; +mod error; +mod pipeline; +mod signer; +mod state; +#[cfg(any(test, feature = "test-support"))] +pub mod testing; +mod tokens; +mod transport; + +pub use client::{Account, SyncClient}; +pub use error::{SyncError, SyncResult}; +pub use signer::{SharedSigner, SignError}; +pub use state::{Clock, SystemClock}; +pub use tokens::{StoredSession, TokenStore, TokenStoreError}; +pub use transport::{Header, HttpRequest, HttpResponse, Transport, TransportError}; diff --git a/rust/crates/keygo-client/src/sync/pipeline.rs b/rust/crates/keygo-client/src/sync/pipeline.rs new file mode 100644 index 000000000..a1cfb3d4b --- /dev/null +++ b/rust/crates/keygo-client/src/sync/pipeline.rs @@ -0,0 +1,1300 @@ +use super::client::SyncClient; +use super::error::{SyncError, SyncResult, from_response}; +use super::state::AuthState; +use super::tokens::{StoredSession, TokenStoreError}; +use super::transport::{Header, HttpRequest, HttpResponse}; +use keygo_api::auth::Session; +use keygo_api::auth::token::TokenRequest; +use keygo_api::endpoints::Token; +use keygo_api::{ApiError, Auth, Endpoint, ErrorCode, Method}; +use keygo_dpop::{Htm, ProofRequest}; +use serde::Serialize; +use serde::de::DeserializeOwned; +use std::ops::DerefMut; +use std::sync::{MutexGuard, PoisonError}; +use zeroize::Zeroizing; + +fn to_json(value: &T) -> SyncResult> { + serde_json::to_vec(value).map_err(|e| SyncError::Client { + message: format!("request does not serialize: {e}"), + }) +} + +/// A serialized `null` (the `()` body) is sent as no body at all. +fn encode_body(value: &T) -> SyncResult>> { + let json = to_json(value)?; + Ok((json != b"null").then_some(json)) +} + +fn json_content_type() -> Header { + Header { + name: "content-type".into(), + value: "application/json".into(), + } +} + +/// An empty body decodes as `null`, so `()` accepts a 204. +fn decode_body(body: &[u8]) -> SyncResult { + let body = if body.is_empty() { + b"null".as_slice() + } else { + body + }; + serde_json::from_slice(body).map_err(|e| SyncError::invalid_response(e.to_string())) +} + +fn proof_method(method: Method) -> Htm { + match method { + Method::Get => Htm::Get, + Method::Post => Htm::Post, + Method::Delete => Htm::Delete, + } +} + +impl HttpResponse { + fn header_value(&self, name: &str) -> Option<&str> { + self.headers + .iter() + .find(|h| h.name.eq_ignore_ascii_case(name)) + .map(|h| h.value.as_str()) + } + + fn is_success(&self) -> bool { + (200..300).contains(&self.status) + } + + /// A 2xx is never an error, whatever its body says. + fn api_error(&self) -> Option { + if self.is_success() { + return None; + } + serde_json::from_slice(&self.body).ok() + } + + fn is_invalid_token(&self) -> bool { + self.api_error() + .is_some_and(|error| error.code == ErrorCode::InvalidToken) + } + + /// An unknown revoke reason becomes `None`, so a newer server can still sign an older app out. + fn sign_out_error(&self) -> Option { + let error = self.api_error()?; + matches!( + error.code, + ErrorCode::SessionRevoked | ErrorCode::RefreshExpired + ) + .then(|| SyncError::SignedOut { + reason: error.reason.and_then(|reason| reason.parse().ok()), + }) + } +} + +pub(super) fn store_failure(error: TokenStoreError) -> SyncError { + SyncError::Client { + message: format!("token store failed: {error}"), + } +} + +impl SyncClient { + fn url(&self, path: &str) -> SyncResult { + Ok(self.base_url.join(path)?.to_string()) + } + + fn nonce_slot(&self) -> MutexGuard<'_, Option> { + self.nonce.lock().unwrap_or_else(PoisonError::into_inner) + } + + fn remember_nonce_and_check_challenge(&self, response: &HttpResponse) -> bool { + let Some(fresh) = response.header_value("dpop-nonce") else { + return false; + }; + *self.nonce_slot() = Some(fresh.to_owned()); + response + .api_error() + .is_some_and(|error| error.code == ErrorCode::UseDpopNonce) + } + + async fn send(&self, request: HttpRequest) -> SyncResult { + self.transport + .send(request) + .await + .map_err(|e| SyncError::Network { message: e.message }) + } + + async fn send_signed_once( + &self, + method: Method, + url: &str, + access_token: Option<&str>, + body: Option<&[u8]>, + ) -> SyncResult { + let nonce = self.nonce_slot().clone(); + let proof = self + .prover + .proof(&ProofRequest { + htm: proof_method(method), + htu: url, + access_token, + nonce: nonce.as_deref(), + }) + .map_err(|e| SyncError::Client { + message: format!("could not sign the DPoP proof: {e}"), + })?; + + let mut headers = vec![Header { + name: "dpop".into(), + value: proof, + }]; + if let Some(token) = access_token { + headers.push(Header { + name: "authorization".into(), + value: format!("DPoP {token}"), + }); + } + if body.is_some() { + headers.push(json_content_type()); + } + + self.send(HttpRequest { + method, + url: url.to_owned(), + headers, + body: body.map(<[u8]>::to_vec).unwrap_or_default(), + }) + .await + } + + /// Signs and sends one request, and re-signs once if the server answers with a nonce challenge + /// that carries a nonce. + /// Every `DPoP-Nonce` header the server sends replaces the stored nonce. + pub(super) async fn send_signed( + &self, + method: Method, + path: &str, + access_token: Option<&str>, + body: Option<&[u8]>, + ) -> SyncResult { + let url = self.url(path)?; + + let response = self + .send_signed_once(method, &url, access_token, body) + .await?; + if self.remember_nonce_and_check_challenge(&response) { + let retried = self + .send_signed_once(method, &url, access_token, body) + .await?; + self.remember_nonce_and_check_challenge(&retried); + return Ok(retried); + } + Ok(response) + } + + pub(super) async fn end_session(&self, state: &mut AuthState) -> Result<(), TokenStoreError> { + state.reset(); + *self.nonce_slot() = None; + self.tokens.clear().await + } + + /// If the store refuses, `state` keeps the live copy and the next call tries again. + async fn flush_unsaved(&self, state: &mut AuthState) { + let Some(unsaved) = &state.unsaved else { + return; + }; + if self.tokens.save(unsaved).await.is_ok() { + state.unsaved = None; + } + } + + async fn refresh(&self, state: &mut AuthState) -> SyncResult> { + // If the previous refresh could not successfully store the refresh token, it is + // kept in-memory, so we will use that one instead. + let refresh_token = match &state.unsaved { + Some(unsaved) => &unsaved.refresh_token, + None => { + &self + .tokens + .load() + .await + .map_err(store_failure)? + .ok_or(SyncError::SignedOut { reason: None })? + .refresh_token + } + }; + + let body = Zeroizing::new(to_json(&TokenRequest { refresh_token })?); + + let sent_at = self.clock.now_secs(); + let response = self + .send_signed(Token::METHOD, &Token.path(), None, Some(body.as_slice())) + .await?; + + if !response.is_success() { + return Err(self.failure(state, &response).await); + } + + let body = Zeroizing::new(response.body); + let session: Session = decode_body(&body)?; + + let token = Zeroizing::new(session.access.access_token.expose().to_owned()); + self.adopt_session_with_state(state, session, sent_at).await; + Ok(token) + } + + pub(super) async fn adopt_session(&self, session: Session, sent_at: u64) { + let mut state = self.auth.lock().await; + self.adopt_session_with_state(&mut state, session, sent_at) + .await; + } + + async fn adopt_session_with_state( + &self, + state: &mut AuthState, + session: Session, + sent_at: u64, + ) { + state.unsaved = Some(StoredSession { + device_id: session.device_id, + refresh_token: session.refresh_token, + refresh_expires_at: sent_at.saturating_add(session.refresh_expires_in), + }); + self.flush_unsaved(state).await; + state.replace_access(session.access, sent_at); + } + + /// Only a refresh holds the lock across the network. It is released before the request itself. + async fn access_token(&self, rejected: Option) -> SyncResult<(Zeroizing, u64)> { + let mut state = self.auth.lock().await; + self.flush_unsaved(&mut state).await; + + let now = self.clock.now_secs(); + let usable = Some(state.generation) != rejected; + let live = state + .access() + .filter(|access| usable && now < access.expires_at); + let token = match live { + Some(access) => Zeroizing::new(access.token.expose().to_owned()), + None => self.refresh(&mut state).await?, + }; + Ok((token, state.generation)) + } + + /// An `invalid_token` earns one retry. The refresh before it is skipped if another caller has + /// already replaced the token. + async fn authenticated( + &self, + method: Method, + path: &str, + body: Option<&[u8]>, + ) -> SyncResult { + let mut rejected = None; + loop { + let (token, generation) = self.access_token(rejected).await?; + + let response = self + .send_signed(method, path, Some(token.as_str()), body) + .await?; + + if rejected.is_some() || !response.is_invalid_token() { + return Ok(response); + } + rejected = Some(generation); + } + } + + pub(super) async fn call( + &self, + endpoint: &E, + body: &E::Request, + ) -> SyncResult { + let body = encode_body(body)?; + let path = endpoint.path(); + + let response = match E::AUTH { + Auth::None => { + self.send(HttpRequest { + method: E::METHOD, + url: self.url(&path)?, + headers: body.is_some().then(json_content_type).into_iter().collect(), + body: body.unwrap_or_default(), + }) + .await? + } + Auth::Proof => { + self.send_signed(E::METHOD, &path, None, body.as_deref()) + .await? + } + Auth::AccessToken => { + self.authenticated(E::METHOD, &path, body.as_deref()) + .await? + } + }; + + if response.is_success() { + // Sign-in responses carry tokens. + let body = Zeroizing::new(response.body); + return decode_body(&body); + } + Err(self + .failure(self.auth.lock().await.deref_mut(), &response) + .await) + } + + async fn failure(&self, state: &mut AuthState, response: &HttpResponse) -> SyncError { + let Some(signed_out) = response.sign_out_error() else { + return from_response(response.status, &response.body); + }; + // The server has killed this token, so a failed clear is harmless. + let _ = self.end_session(state).await; + signed_out + } +} + +#[cfg(test)] +mod tests { + use super::super::signer::SignError; + use super::super::testing::{ + FakeSigner, FakeTokenStore, FakeTransport, FixedClock, client_for, error_body, fake_client, + header, + }; + use super::super::tokens::TokenStore; + use super::*; + use base64::Engine; + use base64::engine::general_purpose::URL_SAFE_NO_PAD; + use keygo_api::domain::RevokeReason; + use keygo_api::meta::ServerInfo; + use keygo_core::DeviceId; + use keygo_dpop::{DpopSigner, Signature, VerifyingKey}; + use serde_json::{Value, json}; + use std::sync::Arc; + use std::sync::atomic::{AtomicBool, Ordering}; + use url::Url; + + #[test] + fn empty_body_decodes_as_unit() { + assert_eq!(decode_body::<()>(b""), Ok(())); + } + + #[test] + fn empty_body_is_not_a_struct() { + assert!(matches!( + decode_body::(b""), + Err(SyncError::Server { code, .. }) if code == "invalid_response", + )); + } + + const SESSION: &str = r#"{"device_id":"00000000-0000-0000-0000-000000000001","access_token":"a.b.c","access_expires_in":300,"refresh_token":"kgr___________________________________________8","refresh_expires_in":86400}"#; + const CHALLENGE: &[u8] = br#"{"code":"use_dpop_nonce","message":"m"}"#; + + fn token_request() -> TokenRequest { + serde_json::from_value(json!({"refresh_token": OLD_REFRESH})).unwrap() + } + + fn proof_claims(request: &HttpRequest) -> Value { + let proof = header(request, "dpop").expect("request carries a dpop header"); + let claims = proof.split('.').nth(1).unwrap(); + serde_json::from_slice(&URL_SAFE_NO_PAD.decode(claims).unwrap()).unwrap() + } + + #[tokio::test] + async fn proof_endpoint_signs_without_ath() { + let (client, transport) = fake_client(); + transport.push(200, &[], SESSION.as_bytes()); + + client.call(&Token, &token_request()).await.ok().unwrap(); + + let request = &transport.requests()[0]; + let claims = proof_claims(request); + assert_eq!(claims["htm"], "POST"); + assert_eq!(claims["htu"], "https://kg.example/api/v1/auth/token"); + assert!(claims.get("ath").is_none()); + assert_eq!(header(request, "authorization"), None); + } + + #[tokio::test] + async fn nonce_challenge_retries_with_the_new_nonce() { + let (client, transport) = fake_client(); + transport.push(400, &[("DPoP-Nonce", "n1")], CHALLENGE); + transport.push(200, &[], SESSION.as_bytes()); + + client.call(&Token, &token_request()).await.ok().unwrap(); + + let requests = transport.requests(); + assert_eq!(requests.len(), 2); + let (first, second) = (proof_claims(&requests[0]), proof_claims(&requests[1])); + assert!(first.get("nonce").is_none()); + assert_eq!(second["nonce"], "n1"); + assert_ne!(first["jti"], second["jti"]); + } + + #[tokio::test] + async fn second_nonce_challenge_is_returned() { + let (client, transport) = fake_client(); + transport.push(400, &[("DPoP-Nonce", "n1")], CHALLENGE); + transport.push(400, &[("DPoP-Nonce", "n2")], CHALLENGE); + + let error = client.call(&Token, &token_request()).await.err().unwrap(); + + assert_eq!(transport.requests().len(), 2); + assert!(matches!(error, SyncError::Server { code, .. } if code == "use_dpop_nonce")); + } + + #[tokio::test] + async fn challenge_without_header_is_returned() { + let (client, transport) = fake_client(); + transport.push(400, &[], CHALLENGE); + + let error = client.call(&Token, &token_request()).await.err().unwrap(); + + assert_eq!(transport.requests().len(), 1); + assert!(matches!(error, SyncError::Server { code, .. } if code == "use_dpop_nonce")); + } + + #[tokio::test] + async fn last_nonce_is_reused() { + let (client, transport) = fake_client(); + transport.push(400, &[("DPoP-Nonce", "n1")], CHALLENGE); + transport.push(200, &[], SESSION.as_bytes()); + transport.push(200, &[], SESSION.as_bytes()); + + client.call(&Token, &token_request()).await.ok().unwrap(); + client.call(&Token, &token_request()).await.ok().unwrap(); + + let requests = transport.requests(); + assert_eq!(requests.len(), 3); + assert_eq!(proof_claims(&requests[2])["nonce"], "n1"); + } + + #[tokio::test] + async fn nonce_on_a_success_is_kept() { + let (client, transport) = fake_client(); + transport.push(200, &[("DPoP-Nonce", "n1")], SESSION.as_bytes()); + transport.push(200, &[], SESSION.as_bytes()); + + client.call(&Token, &token_request()).await.ok().unwrap(); + client.call(&Token, &token_request()).await.ok().unwrap(); + + let requests = transport.requests(); + assert_eq!(requests.len(), 2); + assert_eq!(proof_claims(&requests[1])["nonce"], "n1"); + } + + #[tokio::test] + async fn a_response_without_a_nonce_keeps_a_newer_one() { + let (client, transport) = fake_client(); + transport.push(200, &[("DPoP-Nonce", "n1")], SESSION.as_bytes()); + transport.push(200, &[], SESSION.as_bytes()); + transport.push(200, &[], SESSION.as_bytes()); + + let request = token_request(); + let (first, second) = + tokio::join!(client.call(&Token, &request), client.call(&Token, &request),); + first.ok().unwrap(); + second.ok().unwrap(); + client.call(&Token, &request).await.ok().unwrap(); + + assert_eq!(proof_claims(&transport.requests()[2])["nonce"], "n1"); + } + + #[tokio::test] + async fn ending_the_session_forgets_the_nonce() { + let h = fresh().await; + h.transport.push(204, &[("DPoP-Nonce", "n1")], b""); + h.client.logout().await.unwrap(); + + h.transport.push(200, &[], SESSION.as_bytes()); + h.client.call(&Token, &token_request()).await.ok().unwrap(); + + let requests = h.transport.requests(); + assert!( + proof_claims(requests.last().unwrap()) + .get("nonce") + .is_none() + ); + } + + #[tokio::test] + async fn trailing_slash_in_base_url_is_harmless() { + let (plain, plain_transport) = fake_client(); + let (slashed, slashed_transport) = + client_for("https://kg.example/", Arc::new(FakeSigner::new())); + plain_transport.push(200, &[], SESSION.as_bytes()); + slashed_transport.push(200, &[], SESSION.as_bytes()); + + plain.call(&Token, &token_request()).await.ok().unwrap(); + slashed.call(&Token, &token_request()).await.ok().unwrap(); + + let (a, b) = ( + &plain_transport.requests()[0], + &slashed_transport.requests()[0], + ); + assert_eq!(a.url, b.url); + assert_eq!(proof_claims(a)["htu"], proof_claims(b)["htu"]); + } + + struct FailingSigner(FakeSigner); + + impl DpopSigner for FailingSigner { + type Error = SignError; + + fn verifying_key(&self) -> &VerifyingKey { + self.0.verifying_key() + } + + fn sign(&self, _: &[u8]) -> Result { + Err(SignError { + message: "keystore locked".into(), + }) + } + } + + #[tokio::test] + async fn keystore_failure_is_a_client_error() { + let (client, transport) = client_for( + "https://kg.example", + Arc::new(FailingSigner(FakeSigner::new())), + ); + + let error = client.call(&Token, &token_request()).await.err().unwrap(); + + assert!(matches!( + error, + SyncError::Client { message } if message.contains("keystore locked"), + )); + assert!(transport.requests().is_empty()); + } + + const OLD_REFRESH: &str = "kgr___________________________________________8"; + const ROTATED_REFRESH: &str = "kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; + const NEXT_REFRESH: &str = "kgr_AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE"; + const DEVICES: &[u8] = br#"{"devices":[]}"#; + /// Requests `fresh` has already spent. + const FRESH: usize = 2; + + fn session(access_token: &str) -> Vec { + session_with(access_token, ROTATED_REFRESH) + } + + fn session_with(access_token: &str, refresh_token: &str) -> Vec { + serde_json::to_vec(&json!({ + "device_id": "00000000-0000-0000-0000-000000000001", + "access_token": access_token, + "access_expires_in": 600, + "refresh_token": refresh_token, + "refresh_expires_in": 86400, + })) + .unwrap() + } + + fn revoked_body(reason: &str) -> Vec { + serde_json::to_vec(&json!({ + "code": "session_revoked", + "message": "m", + "reason": reason, + })) + .unwrap() + } + + struct Harness { + client: SyncClient, + transport: Arc, + store: Arc, + clock: Arc, + } + + impl Harness { + fn token_requests(&self) -> usize { + self.spent_tokens().len() + } + + fn spent_tokens(&self) -> Vec { + self.transport + .requests() + .iter() + .filter(|r| r.url.ends_with("/api/v1/auth/token")) + .map(|r| { + let body: Value = serde_json::from_slice(&r.body).unwrap(); + body["refresh_token"].as_str().unwrap().to_owned() + }) + .collect() + } + + async fn assert_signed_out_locally(&self) { + let sent = self.transport.requests().len(); + + assert_eq!( + self.client.devices().await.unwrap_err(), + SyncError::SignedOut { reason: None }, + ); + assert_eq!(self.transport.requests().len(), sent); + assert_eq!(self.store.current_refresh_token(), None); + } + } + + fn unseeded() -> Harness { + let transport = FakeTransport::new(); + let store = Arc::new(FakeTokenStore::new()); + let clock = FixedClock::new(1_000); + let client = SyncClient::new( + Url::parse("https://kg.example").unwrap(), + transport.clone(), + Arc::new(FakeSigner::new()), + store.clone(), + ) + .unwrap() + .with_clock(clock.clone()); + Harness { + client, + transport, + store, + clock, + } + } + + fn seeded() -> Harness { + let harness = unseeded(); + harness.store.seed(StoredSession { + device_id: DeviceId::random(), + refresh_token: OLD_REFRESH.parse().unwrap(), + refresh_expires_at: 1_000_000, + }); + harness + } + + async fn after_first_call(harness: Harness) -> Harness { + harness.transport.push(200, &[], &session("a.b.c")); + harness.transport.push(200, &[], DEVICES); + harness.client.devices().await.unwrap(); + harness + } + + /// Holds a live access token: one refresh and one `devices()` have run. + async fn fresh() -> Harness { + after_first_call(seeded()).await + } + + /// Holds a rotated token the store refused, with saves still failing. + async fn refused() -> Harness { + let harness = seeded(); + harness.store.fail_saves(); + after_first_call(harness).await + } + + struct HangingStore { + inner: FakeTokenStore, + hang: AtomicBool, + } + + #[async_trait::async_trait] + impl TokenStore for HangingStore { + async fn load(&self) -> Result, TokenStoreError> { + self.inner.load().await + } + + async fn save(&self, session: &StoredSession) -> Result<(), TokenStoreError> { + if self.hang.load(Ordering::SeqCst) { + std::future::pending::<()>().await; + } + self.inner.save(session).await + } + + async fn clear(&self) -> Result<(), TokenStoreError> { + self.inner.clear().await + } + } + + #[tokio::test] + async fn no_stored_session_signs_out_without_sending() { + let h = unseeded(); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { reason: None }, + ); + assert!(h.transport.requests().is_empty()); + } + + #[tokio::test] + async fn access_token_sends_token_and_bound_proof() { + let h = seeded(); + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + + h.client.devices().await.unwrap(); + + let request = &h.transport.requests()[1]; + assert_eq!(header(request, "authorization"), Some("DPoP a.b.c")); + let claims = proof_claims(request); + assert_eq!(claims["htm"], "GET"); + assert_eq!(claims["htu"], "https://kg.example/api/v1/devices"); + assert!(claims["ath"].is_string()); + } + + #[tokio::test] + async fn refresh_carries_its_token_in_the_body_only() { + let h = fresh().await; + + let request = &h.transport.requests()[0]; + assert_eq!(request.url, "https://kg.example/api/v1/auth/token"); + assert_eq!(header(request, "authorization"), None); + assert!(proof_claims(request).get("ath").is_none()); + let body: Value = serde_json::from_slice(&request.body).unwrap(); + assert_eq!(body, json!({"refresh_token": OLD_REFRESH})); + } + + #[tokio::test] + async fn rotated_refresh_token_is_saved_and_spent_next() { + let h = fresh().await; + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(ROTATED_REFRESH) + ); + + h.clock.advance(601); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + let requests = h.transport.requests(); + let body: Value = serde_json::from_slice(&requests[FRESH].body).unwrap(); + assert_eq!(body, json!({"refresh_token": ROTATED_REFRESH})); + assert_eq!( + header(&requests[FRESH + 1], "authorization"), + Some("DPoP d.e.f"), + ); + } + + #[tokio::test] + async fn fresh_token_is_reused() { + let h = seeded(); + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + h.transport.push(200, &[], DEVICES); + + h.client.devices().await.unwrap(); + h.clock.advance(599); + h.client.devices().await.unwrap(); + + assert_eq!(h.transport.requests().len(), 3); + assert_eq!(h.token_requests(), 1); + } + + #[tokio::test] + async fn expired_token_refreshes_before_sending() { + let h = seeded(); + for _ in 0..2 { + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + } + + h.client.devices().await.unwrap(); + h.clock.advance(601); + h.client.devices().await.unwrap(); + + let urls: Vec<_> = h.transport.requests().into_iter().map(|r| r.url).collect(); + assert_eq!( + urls, + [ + "https://kg.example/api/v1/auth/token", + "https://kg.example/api/v1/devices", + "https://kg.example/api/v1/auth/token", + "https://kg.example/api/v1/devices", + ], + ); + } + + #[tokio::test] + async fn token_is_expired_at_its_expiry_second() { + let h = fresh().await; + h.clock.advance(600); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + + h.client.devices().await.unwrap(); + + assert_eq!(h.token_requests(), 2); + } + + #[tokio::test] + async fn concurrent_callers_refresh_once() { + let h = seeded(); + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + h.transport.push(200, &[], DEVICES); + + let (first, second) = tokio::join!(h.client.devices(), h.client.devices()); + + first.unwrap(); + second.unwrap(); + assert_eq!(h.token_requests(), 1); + } + + #[tokio::test] + async fn concurrent_rejected_callers_refresh_once() { + let h = fresh().await; + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + h.transport.push(200, &[], DEVICES); + + let (first, second) = tokio::join!(h.client.devices(), h.client.devices()); + + first.unwrap(); + second.unwrap(); + // One from `fresh`, one here. + assert_eq!(h.token_requests(), 2); + } + + #[tokio::test] + async fn failed_save_still_uses_the_rotated_token() { + let h = seeded(); + h.store.fail_saves(); + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + + h.client.devices().await.unwrap(); + + let requests = h.transport.requests(); + assert_eq!(requests.len(), 2); + assert_eq!(header(&requests[1], "authorization"), Some("DPoP a.b.c")); + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(OLD_REFRESH) + ); + } + + #[tokio::test] + async fn failed_save_is_retried_on_the_next_call() { + let h = refused().await; + + h.store.allow_saves(); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!(h.token_requests(), 1); + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(ROTATED_REFRESH) + ); + } + + #[tokio::test] + async fn the_store_is_trusted_again_after_a_retry_succeeds() { + let h = refused().await; + h.store.allow_saves(); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + // Only a client that went back to the store can see this entry. + h.store.seed(StoredSession { + device_id: DeviceId::random(), + refresh_token: NEXT_REFRESH.parse().unwrap(), + refresh_expires_at: 1_000_000, + }); + h.clock.advance(601); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!(h.spent_tokens(), [OLD_REFRESH, NEXT_REFRESH]); + } + + #[tokio::test] + async fn refresh_after_a_failed_save_spends_the_rotated_token() { + let h = refused().await; + + h.clock.advance(601); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!(h.spent_tokens(), [OLD_REFRESH, ROTATED_REFRESH]); + let requests = h.transport.requests(); + assert_eq!(header(&requests[3], "authorization"), Some("DPoP d.e.f")); + } + + #[tokio::test] + async fn a_failed_refresh_keeps_a_token_the_store_refused() { + let h = refused().await; + + h.clock.advance(601); + h.transport.push_network_error("offline"); + h.client.devices().await.unwrap_err(); + h.transport.push(500, &[], &error_body("internal")); + h.client.devices().await.unwrap_err(); + h.transport + .push(200, &[], &session_with("d.e.f", NEXT_REFRESH)); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!( + h.spent_tokens(), + [ + OLD_REFRESH, + ROTATED_REFRESH, + ROTATED_REFRESH, + ROTATED_REFRESH, + ], + ); + } + + #[tokio::test] + async fn a_second_rotation_replaces_a_token_the_store_refused() { + let h = refused().await; + + h.clock.advance(601); + h.transport + .push(200, &[], &session_with("d.e.f", NEXT_REFRESH)); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + h.clock.advance(601); + h.transport.push(200, &[], &session("g.h.i")); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!( + h.spent_tokens(), + [OLD_REFRESH, ROTATED_REFRESH, NEXT_REFRESH], + ); + } + + #[tokio::test] + async fn invalid_token_after_a_failed_save_spends_the_rotated_token() { + let h = refused().await; + + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport + .push(200, &[], &session_with("d.e.f", NEXT_REFRESH)); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!(h.spent_tokens(), [OLD_REFRESH, ROTATED_REFRESH]); + } + + #[tokio::test] + async fn a_caller_dropped_during_the_write_keeps_the_rotated_token() { + let store = Arc::new(HangingStore { + inner: FakeTokenStore::new(), + hang: AtomicBool::new(true), + }); + store.inner.seed(StoredSession { + device_id: DeviceId::random(), + refresh_token: OLD_REFRESH.parse().unwrap(), + refresh_expires_at: 1_000_000, + }); + let transport = FakeTransport::new(); + let client = SyncClient::new( + Url::parse("https://kg.example").unwrap(), + transport.clone(), + Arc::new(FakeSigner::new()), + store.clone(), + ) + .unwrap() + .with_clock(FixedClock::new(1_000)); + + transport.push(200, &[], &session("a.b.c")); + tokio::select! { + biased; + _ = client.devices() => panic!("the save should still be hanging"), + () = async { + for _ in 0..16 { + tokio::task::yield_now().await; + } + } => {} + } + assert_eq!(transport.requests().len(), 1); + + store.hang.store(false, Ordering::SeqCst); + transport.push(200, &[], &session_with("d.e.f", NEXT_REFRESH)); + transport.push(200, &[], DEVICES); + client.devices().await.unwrap(); + + let body: Value = serde_json::from_slice(&transport.requests()[1].body).unwrap(); + assert_eq!(body, json!({"refresh_token": ROTATED_REFRESH})); + assert_eq!( + store.inner.current_refresh_token().as_deref(), + Some(NEXT_REFRESH), + ); + } + + #[tokio::test] + async fn concurrent_callers_share_a_token_the_store_refused() { + let h = seeded(); + h.store.fail_saves(); + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + h.transport.push(200, &[], DEVICES); + + let (first, second) = tokio::join!(h.client.devices(), h.client.devices()); + + first.unwrap(); + second.unwrap(); + assert_eq!(h.token_requests(), 1); + } + + #[tokio::test] + async fn an_ordinary_call_signing_out_forgets_a_token_the_store_refused() { + let h = refused().await; + + h.transport.push(401, &[], &revoked_body("reuse_detected")); + h.client.devices().await.unwrap_err(); + + h.store.allow_saves(); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn a_revoked_refresh_forgets_a_token_the_store_refused() { + let h = refused().await; + + h.clock.advance(601); + h.transport.push(401, &[], &revoked_body("reuse_detected")); + h.client.devices().await.unwrap_err(); + + h.store.allow_saves(); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn an_expired_refresh_forgets_a_token_the_store_refused() { + let h = refused().await; + + h.clock.advance(601); + h.transport.push(401, &[], &error_body("refresh_expired")); + h.client.devices().await.unwrap_err(); + + h.store.allow_saves(); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn logout_forgets_a_token_the_store_refused() { + let h = refused().await; + + h.transport.push(204, &[], b""); + h.client.logout().await.unwrap(); + + h.store.allow_saves(); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn invalid_token_refreshes_and_retries_once() { + let h = fresh().await; + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + + h.client.devices().await.unwrap(); + + let requests = h.transport.requests(); + assert_eq!(requests.len() - FRESH, 3); + assert_eq!( + header(&requests[FRESH + 2], "authorization"), + Some("DPoP d.e.f"), + ); + } + + #[tokio::test] + async fn second_invalid_token_is_returned() { + let h = fresh().await; + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(401, &[], &error_body("invalid_token")); + + let error = h.client.devices().await.unwrap_err(); + + assert!(matches!(error, SyncError::Server { code, .. } if code == "invalid_token")); + assert_eq!(h.transport.requests().len() - FRESH, 3); + } + + #[tokio::test] + async fn nonce_and_invalid_token_each_retry_once() { + let h = fresh().await; + h.transport.push(400, &[("DPoP-Nonce", "n1")], CHALLENGE); + h.transport.push(401, &[], &error_body("invalid_token")); + h.transport.push(200, &[], &session("d.e.f")); + h.transport.push(200, &[], DEVICES); + + h.client.devices().await.unwrap(); + + assert_eq!(h.transport.requests().len() - FRESH, 4); + } + + #[tokio::test] + async fn session_revoked_clears_store_and_keeps_reason() { + let h = seeded(); + h.transport.push(401, &[], &revoked_body("reuse_detected")); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { + reason: Some(RevokeReason::ReuseDetected), + }, + ); + assert_eq!(h.store.current_refresh_token(), None); + } + + #[tokio::test] + async fn session_revoked_on_an_ordinary_call_ends_the_session() { + let h = fresh().await; + h.transport.push(401, &[], &revoked_body("logout")); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { + reason: Some(RevokeReason::Logout), + }, + ); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn refresh_expired_clears_store() { + let h = seeded(); + h.transport.push(401, &[], &error_body("refresh_expired")); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { reason: None }, + ); + assert_eq!(h.store.current_refresh_token(), None); + } + + #[tokio::test] + async fn unknown_revoke_reason_still_signs_out() { + let h = seeded(); + h.transport.push(401, &[], &revoked_body("brand_new")); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { reason: None }, + ); + assert_eq!(h.store.current_refresh_token(), None); + } + + #[tokio::test] + async fn a_success_status_never_signs_out() { + let h = fresh().await; + h.transport.push(200, &[], &error_body("session_revoked")); + + let error = h.client.devices().await.unwrap_err(); + + assert!(matches!(error, SyncError::Server { code, .. } if code == "invalid_response")); + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(ROTATED_REFRESH) + ); + } + + #[tokio::test] + async fn network_failure_during_refresh_keeps_store() { + let h = seeded(); + h.transport.push_network_error("offline"); + + let error = h.client.devices().await.unwrap_err(); + + assert!(matches!(error, SyncError::Network { .. })); + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(OLD_REFRESH) + ); + } + + #[tokio::test] + async fn logout_ends_the_session() { + let h = fresh().await; + h.transport.push(204, &[], b""); + + h.client.logout().await.unwrap(); + + let request = &h.transport.requests()[FRESH]; + assert_eq!(request.url, "https://kg.example/api/v1/auth/logout"); + assert_eq!(header(request, "authorization"), Some("DPoP a.b.c")); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn logout_clears_local_state_when_offline() { + let h = fresh().await; + h.transport.push_network_error("offline"); + + let error = h.client.logout().await.unwrap_err(); + + assert!(matches!(error, SyncError::Network { .. })); + h.assert_signed_out_locally().await; + } + + #[tokio::test] + async fn offline_logout_reports_a_failed_clear() { + let h = fresh().await; + h.store.fail_clears(); + h.transport.push_network_error("offline"); + + let error = h.client.logout().await.unwrap_err(); + + assert!(matches!(error, SyncError::Client { .. })); + assert!(h.client.auth.lock().await.access().is_none()); + // The server still accepts this token, so this cannot pass as an offline logout. + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(ROTATED_REFRESH) + ); + } + + #[tokio::test] + async fn sent_logout_ignores_a_failed_clear() { + let h = fresh().await; + h.store.fail_clears(); + h.transport.push(204, &[], b""); + + h.client.logout().await.unwrap(); + + assert!(h.client.auth.lock().await.access().is_none()); + } + + #[tokio::test] + async fn fresh_auth_required_is_not_retried() { + let h = fresh().await; + let id = DeviceId::random(); + h.transport + .push(403, &[], &error_body("fresh_auth_required")); + + assert_eq!( + h.client.delete_device(id).await.unwrap_err(), + SyncError::FreshAuthRequired, + ); + + let requests = h.transport.requests(); + assert_eq!(requests.len() - FRESH, 1); + assert_eq!(requests[FRESH].method, Method::Delete); + assert_eq!( + requests[FRESH].url, + format!("https://kg.example/api/v1/devices/{}", id.as_uuid()), + ); + } + + #[tokio::test] + async fn a_refresh_dropped_midway_leaves_nothing_behind() { + let h = seeded(); + + // The fake transport yields once before it answers, so this drops the call while it holds + // the lock and is waiting on `/auth/token`. + tokio::select! { + biased; + _ = h.client.devices() => panic!("the call should still be waiting"), + () = std::future::ready(()) => {} + } + assert!(h.transport.requests().is_empty()); + assert_eq!( + h.store.current_refresh_token().as_deref(), + Some(OLD_REFRESH) + ); + + h.transport.push(200, &[], &session("a.b.c")); + h.transport.push(200, &[], DEVICES); + h.client.devices().await.unwrap(); + + assert_eq!(h.transport.requests().len(), 2); + } +} diff --git a/rust/crates/keygo-client/src/sync/signer.rs b/rust/crates/keygo-client/src/sync/signer.rs new file mode 100644 index 000000000..12a35bff8 --- /dev/null +++ b/rust/crates/keygo-client/src/sync/signer.rs @@ -0,0 +1,11 @@ +use keygo_dpop::DpopSigner; +use std::sync::Arc; + +#[derive(Debug, thiserror::Error)] +#[error("{message}")] +pub struct SignError { + pub message: String, +} + +/// The key that binds this device's tokens, held by the host +pub type SharedSigner = Arc + Send + Sync>; diff --git a/rust/crates/keygo-client/src/sync/state.rs b/rust/crates/keygo-client/src/sync/state.rs new file mode 100644 index 000000000..82a5099c0 --- /dev/null +++ b/rust/crates/keygo-client/src/sync/state.rs @@ -0,0 +1,77 @@ +use super::tokens::StoredSession; +use keygo_api::auth::Access; +use keygo_api::domain::AccessToken; +use std::time::{SystemTime, UNIX_EPOCH}; + +pub(super) struct AccessState { + pub(super) token: AccessToken, + pub(super) expires_at: u64, +} + +#[derive(Default)] +pub(super) struct AuthState { + access: Option, + /// Moves whenever `access` changes. A call whose token was rejected uses it to tell whether + /// someone has already replaced that token. + pub(super) generation: u64, + /// A rotated session the store has not accepted yet. Until it does, the store may still hold + /// the spent token, which the server would treat as reuse, so this copy wins over the store. + pub(super) unsaved: Option, +} + +impl AuthState { + pub(super) fn access(&self) -> Option<&AccessState> { + self.access.as_ref() + } + + pub(super) fn replace_access(&mut self, access: Access, sent_at: u64) { + self.access = Some(AccessState { + token: access.access_token, + expires_at: sent_at.saturating_add(access.access_expires_in), + }); + self.generation += 1; + } + + pub(super) fn reset(&mut self) { + self.access = None; + self.unsaved = None; + + // Keep counting up, so a request started before the reset can tell its token is stale + self.generation += 1; + } +} + +pub trait Clock: Send + Sync { + fn now_secs(&self) -> u64; +} + +pub struct SystemClock; + +impl Clock for SystemClock { + fn now_secs(&self) -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|d| d.as_secs()) + .unwrap_or(0) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn replacing_access_moves_the_generation() { + let mut state = AuthState::default(); + let before = state.generation; + state.replace_access( + Access { + access_token: serde_json::from_value(serde_json::json!("a.b.c")).unwrap(), + access_expires_in: 1, + }, + 0, + ); + assert_eq!(state.generation, before + 1); + assert!(state.access().is_some()); + } +} diff --git a/rust/crates/keygo-client/src/sync/testing.rs b/rust/crates/keygo-client/src/sync/testing.rs new file mode 100644 index 000000000..afbfaa588 --- /dev/null +++ b/rust/crates/keygo-client/src/sync/testing.rs @@ -0,0 +1,300 @@ +use super::client::SyncClient; +use super::signer::{SharedSigner, SignError}; +use super::state::Clock; +use super::tokens::{StoredSession, TokenStore, TokenStoreError}; +use super::transport::{Header, HttpRequest, HttpResponse, Transport, TransportError}; +use async_trait::async_trait; +use keygo_dpop::testing::TestSigner; +use keygo_dpop::{DpopSigner, Signature, VerifyingKey}; +use keygo_opaque::client::ClientRegistration; +use keygo_opaque::server::{self, ServerLogin, ServerSetup}; +use keygo_opaque::{CredentialRequest, CredentialResponse, ExportKey, PasswordFile}; +use std::collections::VecDeque; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; +use std::sync::{Arc, Mutex}; +use url::Url; + +pub fn client_for(base: &str, signer: SharedSigner) -> (SyncClient, Arc) { + let (client, transport, _) = client_with_store(base, signer); + (client, transport) +} + +pub fn client_with_store( + base: &str, + signer: SharedSigner, +) -> (SyncClient, Arc, Arc) { + let transport = FakeTransport::new(); + let store = Arc::new(FakeTokenStore::new()); + let client = SyncClient::new( + Url::parse(base).unwrap(), + transport.clone(), + signer, + store.clone(), + ) + .unwrap(); + (client, transport, store) +} + +pub fn fake_client() -> (SyncClient, Arc) { + client_for("https://kg.example", Arc::new(FakeSigner::new())) +} + +pub fn header<'a>(request: &'a HttpRequest, name: &str) -> Option<&'a str> { + request + .headers + .iter() + .find(|h| h.name == name) + .map(|h| h.value.as_str()) +} + +pub fn error_body(code: &str) -> Vec { + serde_json::to_vec(&serde_json::json!({"code": code, "message": "m"})).unwrap() +} + +type Reply = Box Result + Send>; + +pub struct FakeTransport { + script: Mutex>, + requests: Mutex>, +} + +impl FakeTransport { + pub fn new() -> Arc { + Arc::new(Self { + script: Mutex::default(), + requests: Mutex::default(), + }) + } + + pub fn push(&self, status: u16, headers: &[(&str, &str)], body: &[u8]) { + let response = HttpResponse { + status, + headers: headers + .iter() + .map(|(name, value)| Header { + name: (*name).into(), + value: (*value).into(), + }) + .collect(), + body: body.to_vec(), + }; + self.reply(move |_| Ok(response)); + } + + /// Answers with a body built from the request, for replies that depend on what the client + /// generated, such as an OPAQUE response. + pub fn push_with( + &self, + status: u16, + body: impl FnOnce(&HttpRequest) -> Vec + Send + 'static, + ) { + self.reply(move |request| { + Ok(HttpResponse { + status, + headers: Vec::new(), + body: body(request), + }) + }); + } + + pub fn push_network_error(&self, message: &str) { + let message = message.to_owned(); + self.reply(move |_| Err(TransportError { message })); + } + + fn reply( + &self, + reply: impl FnOnce(&HttpRequest) -> Result + Send + 'static, + ) { + self.script.lock().unwrap().push_back(Box::new(reply)); + } + + pub fn requests(&self) -> Vec { + self.requests.lock().unwrap().clone() + } +} + +#[async_trait] +impl Transport for FakeTransport { + async fn send(&self, request: HttpRequest) -> Result { + // Lets concurrent tests really interleave. + tokio::task::yield_now().await; + let reply = self + .script + .lock() + .unwrap() + .pop_front() + .expect("FakeTransport script is empty"); + let response = reply(&request); + self.requests.lock().unwrap().push(request); + response + } +} + +#[derive(Default)] +pub struct FakeTokenStore { + stored: Mutex>, + fail_saves: AtomicBool, + fail_clears: AtomicBool, +} + +impl FakeTokenStore { + pub fn new() -> Self { + Self::default() + } + + pub fn seed(&self, session: StoredSession) { + *self.stored.lock().unwrap() = Some(session); + } + + pub fn current_refresh_token(&self) -> Option { + self.stored + .lock() + .unwrap() + .as_ref() + .map(|s| s.refresh_token.expose_encoded().to_string()) + } + + pub fn fail_saves(&self) { + self.fail_saves.store(true, Ordering::SeqCst); + } + + pub fn allow_saves(&self) { + self.fail_saves.store(false, Ordering::SeqCst); + } + + pub fn fail_clears(&self) { + self.fail_clears.store(true, Ordering::SeqCst); + } +} + +impl StoredSession { + pub(super) fn duplicate(&self) -> Self { + Self { + device_id: self.device_id, + refresh_token: self + .refresh_token + .expose_encoded() + .parse() + .expect("a refresh token parses its own encoding"), + refresh_expires_at: self.refresh_expires_at, + } + } +} + +#[async_trait] +impl TokenStore for FakeTokenStore { + async fn load(&self) -> Result, TokenStoreError> { + Ok(self + .stored + .lock() + .unwrap() + .as_ref() + .map(StoredSession::duplicate)) + } + + async fn save(&self, session: &StoredSession) -> Result<(), TokenStoreError> { + if self.fail_saves.load(Ordering::SeqCst) { + return Err(TokenStoreError { + message: "save failed".into(), + }); + } + *self.stored.lock().unwrap() = Some(session.duplicate()); + Ok(()) + } + + async fn clear(&self) -> Result<(), TokenStoreError> { + if self.fail_clears.load(Ordering::SeqCst) { + return Err(TokenStoreError { + message: "clear failed".into(), + }); + } + *self.stored.lock().unwrap() = None; + Ok(()) + } +} + +/// The same key as [`TestSigner::new`]. +pub struct FakeSigner(TestSigner); + +impl FakeSigner { + pub fn new() -> Self { + Self(TestSigner::new()) + } +} + +impl Default for FakeSigner { + fn default() -> Self { + Self::new() + } +} + +impl DpopSigner for FakeSigner { + type Error = SignError; + + fn verifying_key(&self) -> &VerifyingKey { + self.0.verifying_key() + } + + fn sign(&self, msg: &[u8]) -> Result { + self.0.sign(msg).map_err(|never| match never {}) + } +} + +pub struct FixedClock(AtomicU64); + +impl FixedClock { + pub fn new(now_secs: u64) -> Arc { + Arc::new(Self(AtomicU64::new(now_secs))) + } + + pub fn advance(&self, secs: u64) { + self.0.fetch_add(secs, Ordering::SeqCst); + } +} + +impl Clock for FixedClock { + fn now_secs(&self) -> u64 { + self.0.load(Ordering::SeqCst) + } +} + +/// One account on a real OPAQUE server, so a test can answer `login/start` with a response the +/// client really finishes. +#[derive(Clone)] +pub struct FakeOpaqueAccount { + setup: ServerSetup, + password_file: Arc>>, +} + +impl FakeOpaqueAccount { + /// Registers `password` and returns the export key the client derives from it. + pub fn register(password: &str) -> (Self, ExportKey) { + let setup = ServerSetup::generate(); + let (client, request) = ClientRegistration::start(password.as_bytes()).unwrap(); + let response = server::registration_start(&setup, request, CREDENTIAL_ID).unwrap(); + let finish = client.finish(password.as_bytes(), response).unwrap(); + let password_file = server::registration_finish(finish.upload).to_bytes(); + let account = Self { + setup, + password_file: Arc::new(password_file), + }; + (account, finish.export_key) + } + + pub fn credential_response(&self, request: CredentialRequest) -> CredentialResponse { + let file = PasswordFile::from_bytes(&self.password_file).unwrap(); + ServerLogin::start(&self.setup, Some(file), request, CREDENTIAL_ID) + .unwrap() + .1 + } + + /// What the server answers for a username it does not know. + pub fn unknown_user_response(request: CredentialRequest) -> CredentialResponse { + ServerLogin::start(&ServerSetup::generate(), None, request, CREDENTIAL_ID) + .unwrap() + .1 + } +} + +const CREDENTIAL_ID: &[u8] = b"u"; diff --git a/rust/crates/keygo-client/src/sync/tokens.rs b/rust/crates/keygo-client/src/sync/tokens.rs new file mode 100644 index 000000000..2e2d12ccf --- /dev/null +++ b/rust/crates/keygo-client/src/sync/tokens.rs @@ -0,0 +1,22 @@ +use async_trait::async_trait; +use keygo_api::domain::RefreshToken; +use keygo_core::DeviceId; + +pub struct StoredSession { + pub device_id: DeviceId, + pub refresh_token: RefreshToken, + pub refresh_expires_at: u64, +} + +#[derive(Debug, thiserror::Error)] +#[error("{message}")] +pub struct TokenStoreError { + pub message: String, +} + +#[async_trait] +pub trait TokenStore: Send + Sync { + async fn load(&self) -> Result, TokenStoreError>; + async fn save(&self, session: &StoredSession) -> Result<(), TokenStoreError>; + async fn clear(&self) -> Result<(), TokenStoreError>; +} diff --git a/rust/crates/keygo-client/src/sync/transport.rs b/rust/crates/keygo-client/src/sync/transport.rs new file mode 100644 index 000000000..2eae668ed --- /dev/null +++ b/rust/crates/keygo-client/src/sync/transport.rs @@ -0,0 +1,107 @@ +use async_trait::async_trait; +use keygo_api::Method; +use std::fmt; + +#[derive(Clone, PartialEq, Eq)] +pub struct Header { + pub name: String, + pub value: String, +} + +#[derive(Clone, PartialEq, Eq)] +pub struct HttpRequest { + pub method: Method, + pub url: String, + pub headers: Vec
, + pub body: Vec, +} + +#[derive(Clone, PartialEq, Eq)] +pub struct HttpResponse { + pub status: u16, + pub headers: Vec
, + pub body: Vec, +} + +// Header values hold proofs and access tokens, and bodies hold refresh tokens, so none of these +// print them. +impl fmt::Debug for Header { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("Header") + .field("name", &self.name) + .field("value", &format_args!("")) + .finish() + } +} + +impl fmt::Debug for HttpRequest { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("HttpRequest") + .field("method", &self.method) + .field("url", &self.url) + .field("headers", &header_names(&self.headers)) + .field("body_len", &self.body.len()) + .finish() + } +} + +impl fmt::Debug for HttpResponse { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("HttpResponse") + .field("status", &self.status) + .field("headers", &header_names(&self.headers)) + .field("body_len", &self.body.len()) + .finish() + } +} + +fn header_names(headers: &[Header]) -> Vec<&str> { + headers.iter().map(|h| h.name.as_str()).collect() +} + +#[derive(Debug, thiserror::Error)] +#[error("{message}")] +pub struct TransportError { + pub message: String, +} + +#[async_trait] +pub trait Transport: Send + Sync { + async fn send(&self, request: HttpRequest) -> Result; +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn debug_output_hides_tokens_and_bodies() { + let request = HttpRequest { + method: Method::Post, + url: "https://kg.example/api/v1/auth/token".into(), + headers: vec![Header { + name: "authorization".into(), + value: "DPoP secret-access-token".into(), + }], + body: br#"{"refresh_token":"secret-refresh-token"}"#.to_vec(), + }; + let response = HttpResponse { + status: 200, + headers: request.headers.clone(), + body: request.body.clone(), + }; + + for output in [format!("{request:?}"), format!("{response:?}")] { + assert!(!output.contains("secret-access-token"), "{output}"); + assert!(!output.contains("secret-refresh-token"), "{output}"); + assert!(output.contains("authorization"), "{output}"); + assert!( + output.contains(&format!("body_len: {}", request.body.len())), + "{output}", + ); + } + let header = format!("{:?}", request.headers[0]); + assert!(!header.contains("secret-access-token"), "{header}"); + assert!(header.contains(""), "{header}"); + } +} diff --git a/rust/crates/keygo-core/src/crypto/hierarchy.rs b/rust/crates/keygo-core/src/crypto/hierarchy.rs index 21a49a136..696f9c9dd 100644 --- a/rust/crates/keygo-core/src/crypto/hierarchy.rs +++ b/rust/crates/keygo-core/src/crypto/hierarchy.rs @@ -10,15 +10,21 @@ use crate::crypto::aad::{Aad, aad}; use crate::crypto::kdf::argon2::{Argon2Params, derive_argon2id}; use crate::crypto::{CipherKey, Encrypts, KeyMaterial, Wraps}; use crate::{ - AccountRootKey, CryptoResult, ItemId, ItemKey, NamespaceId, NamespaceKey, RootKek, UserId, - VaultId, VaultKey, + AccountRootKey, CryptoResult, ItemId, ItemKey, NamespaceId, NamespaceKey, OpaqueKek, RootKek, + UserId, VaultId, VaultKey, }; use aead::Generate; +use hkdf::Hkdf; use serde::{Serialize, Serializer}; +use sha2::Sha256; +use zeroize::Zeroizing; /// Part of every password KEK's salt; must never change. const PASSWORD_DOMAIN: &[u8] = b"v1:kek/pwd"; +/// The HKDF info of every OPAQUE KEK; must never change. +const OPAQUE_KEK_DOMAIN: &[u8] = b"v1:kek/opaque"; + /// Part of every namespace-key wrap AAD; must never change. const NAMESPACE_KEY_DOMAIN: &str = "v1:ns/key"; @@ -110,6 +116,7 @@ macro_rules! wraps { } wraps! { + OpaqueKek -> AccountRootKey with UserId, RootKek -> AccountRootKey with UserId, // TODO: bind the credential epoch AccountRootKey -> VaultKey with VaultId, // TODO: bind vault_key_epoch AccountRootKey -> NamespaceKey with NamespaceKeyAad, @@ -131,6 +138,16 @@ impl RootKek { } } +impl OpaqueKek { + pub fn from_export_key(key: &[u8], user_id: UserId) -> CryptoResult { + let mut derived = Zeroizing::new([0u8; 32]); + Hkdf::::new(Some(user_id.as_uuid().as_bytes()), key) + .expand(OPAQUE_KEK_DOMAIN, derived.as_mut()) + .expect("32 bytes is a valid HKDF-SHA256 output length"); + Self::from_bytes(derived.as_slice()) + } +} + macro_rules! impl_generate { ($($key:ident),+) => { $(impl $key { @@ -180,6 +197,34 @@ mod tests { ); } + fn user(byte: u8) -> UserId { + UserId::from(uuid::Uuid::from_bytes([byte; 16])) + } + + /// Pins `OPAQUE_KEK_DOMAIN` and the salt; drift makes every server-held ARK unopenable. + #[test] + fn opaque_kek_domain_is_pinned() { + assert_eq!(OPAQUE_KEK_DOMAIN, b"v1:kek/opaque"); + + let kek = OpaqueKek::from_export_key(&[9; 64], user(3)).unwrap(); + + // Cross-checked against RFC 5869 HKDF-SHA256 outside Rust. + assert_eq!( + kek.as_bytes(), + &[ + 27, 101, 7, 214, 170, 93, 0, 161, 91, 141, 171, 209, 225, 137, 214, 134, 221, 88, + 108, 144, 212, 175, 208, 136, 181, 194, 182, 0, 55, 168, 52, 233, + ][..] + ); + } + + #[test] + fn server_kek_depends_on_the_user() { + let a = OpaqueKek::from_export_key(&[9; 64], user(3)).unwrap(); + let b = OpaqueKek::from_export_key(&[9; 64], user(4)).unwrap(); + assert_ne!(a.as_bytes(), b.as_bytes()); + } + /// Pins every label; drift makes that field undecryptable everywhere. #[test] fn secret_kind_labels_are_pinned() { diff --git a/rust/crates/keygo-core/src/ids.rs b/rust/crates/keygo-core/src/ids.rs index 8552710c9..9e4d9df8b 100644 --- a/rust/crates/keygo-core/src/ids.rs +++ b/rust/crates/keygo-core/src/ids.rs @@ -25,4 +25,19 @@ macro_rules! id { }; } -id!(UserId, VaultId, ItemId, NamespaceId); +id!(UserId, VaultId, ItemId, NamespaceId, DeviceId, SessionId); + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn device_id_travels_as_the_uuids_string_form() { + let id = DeviceId::from(Uuid::nil()); + + assert_eq!( + serde_json::to_value(id).unwrap(), + "00000000-0000-0000-0000-000000000000" + ); + } +} diff --git a/rust/crates/keygo-core/src/keys.rs b/rust/crates/keygo-core/src/keys.rs index 348f2a750..96a596dd1 100644 --- a/rust/crates/keygo-core/src/keys.rs +++ b/rust/crates/keygo-core/src/keys.rs @@ -42,6 +42,7 @@ macro_rules! symmetric_key { pub(crate) use symmetric_key; symmetric_key! { + pub struct OpaqueKek, pub struct RootKek, pub struct AccountRootKey, diff --git a/rust/crates/keygo-core/src/lib.rs b/rust/crates/keygo-core/src/lib.rs index 0e95c46e0..bbcbfd012 100644 --- a/rust/crates/keygo-core/src/lib.rs +++ b/rust/crates/keygo-core/src/lib.rs @@ -15,6 +15,6 @@ mod sealed; #[cfg(feature = "crypto")] pub use crypto::*; pub use error::{CryptoError, CryptoResult}; -pub use ids::{ItemId, NamespaceId, UserId, VaultId}; -pub use keys::{AccountRootKey, BackupKey, ItemKey, NamespaceKey, RootKek, VaultKey}; +pub use ids::{DeviceId, ItemId, NamespaceId, SessionId, UserId, VaultId}; +pub use keys::*; pub use sealed::{KEY_LEN, NONCE_LEN, Sealed, TAG_LEN}; diff --git a/rust/crates/keygo-dpop/src/lib.rs b/rust/crates/keygo-dpop/src/lib.rs index 4d05bb6ce..483eef9f3 100644 --- a/rust/crates/keygo-dpop/src/lib.rs +++ b/rust/crates/keygo-dpop/src/lib.rs @@ -12,6 +12,7 @@ use std::time::{SystemTime, UNIX_EPOCH}; pub use jwk::JwkError; pub use nonce::Nonce; +pub use p256::ecdsa::{Signature, VerifyingKey}; pub use proof::{DpopError, DpopProver, DpopSigner, ProofRequest}; pub use verify::{Bound, Checked, DpopVerifier, Expected, InvalidProof, VerifyError}; pub use wire::{DecodeError, Htm}; diff --git a/rust/crates/keygo-dpop/src/proof.rs b/rust/crates/keygo-dpop/src/proof.rs index 00140f286..21ebc3f8b 100644 --- a/rust/crates/keygo-dpop/src/proof.rs +++ b/rust/crates/keygo-dpop/src/proof.rs @@ -4,6 +4,7 @@ use crate::{Htm, htu, unix_now}; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; use p256::ecdsa::{Signature, VerifyingKey}; +use std::sync::Arc; pub trait DpopSigner { type Error: std::error::Error; @@ -14,6 +15,18 @@ pub trait DpopSigner { fn sign(&self, msg: &[u8]) -> Result; } +impl DpopSigner for Arc { + type Error = S::Error; + + fn verifying_key(&self) -> &VerifyingKey { + S::verifying_key(self) + } + + fn sign(&self, msg: &[u8]) -> Result { + S::sign(self, msg) + } +} + pub struct ProofRequest<'a> { pub htm: Htm, /// The request URL. Query and fragment are dropped before it goes into the proof. @@ -84,8 +97,8 @@ impl DpopProver { #[derive(Debug, thiserror::Error)] pub enum DpopError { - #[error("signer failed")] - Signer(#[source] E), + #[error("signer failed: {0}")] + Signer(E), #[error("random number generator failed")] Rng(#[from] getrandom::Error), #[error("htu is not an absolute URI")] diff --git a/rust/crates/keygo-dpop/src/testing.rs b/rust/crates/keygo-dpop/src/testing.rs index 543e11f05..d4ae21957 100644 --- a/rust/crates/keygo-dpop/src/testing.rs +++ b/rust/crates/keygo-dpop/src/testing.rs @@ -13,6 +13,21 @@ impl TestSigner { pub fn from_seed(seed: u8) -> Self { Self(SigningKey::from_slice(&[seed; 32]).unwrap()) } + + /// Matches what a platform keystore exports. + pub fn public_key_sec1(&self) -> Vec { + self.0 + .verifying_key() + .to_sec1_point(false) + .as_bytes() + .to_vec() + } + + /// Matches what a platform keystore produces. + pub fn sign_der(&self, msg: &[u8]) -> Vec { + let sig: Signature = self.0.sign(msg); + sig.to_der().as_bytes().to_vec() + } } impl Default for TestSigner { diff --git a/rust/crates/keygo-e2e/Cargo.toml b/rust/crates/keygo-e2e/Cargo.toml new file mode 100644 index 000000000..255799693 --- /dev/null +++ b/rust/crates/keygo-e2e/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "keygo-e2e" +description = "Drives the real sync client against the real server router." +version.workspace = true +edition.workspace = true +publish = false + +[dev-dependencies] +keygo-api = { path = "../keygo-api" } +keygo-core = { path = "../keygo-core" } +keygo-client = { path = "../keygo-client", features = ["test-support"] } +keygo-dpop = { path = "../keygo-dpop", features = ["test-support"] } +keygo-opaque = { path = "../keygo-opaque" } +keygo-server = { path = "../keygo-server", features = ["test-support"] } + +async-trait = "0.1.89" +axum = "0.8.9" +http-body-util = "0.1.5" +tower = { version = "0.5.3", features = ["util"] } +sqlx = { version = "0.9.0", default-features = false, features = ["runtime-tokio", "postgres", "migrate", "macros", "uuid", "time"] } +tokio = { workspace = true, features = ["macros", "rt-multi-thread"] } +serde_json.workspace = true +url = "2.5.8" diff --git a/rust/crates/keygo-e2e/src/lib.rs b/rust/crates/keygo-e2e/src/lib.rs new file mode 100644 index 000000000..664a2a768 --- /dev/null +++ b/rust/crates/keygo-e2e/src/lib.rs @@ -0,0 +1,2 @@ +//! The real `SyncClient` against the real `keygo-server` router, with real OPAQUE and DPoP. +//! Only this crate builds both sides, so the client's features never reach the shipped server. diff --git a/rust/crates/keygo-e2e/tests/sync.rs b/rust/crates/keygo-e2e/tests/sync.rs new file mode 100644 index 000000000..514761609 --- /dev/null +++ b/rust/crates/keygo-e2e/tests/sync.rs @@ -0,0 +1,489 @@ +use async_trait::async_trait; +use axum::body::Body; +use axum::http::{HeaderName, HeaderValue, Request}; +use http_body_util::BodyExt; +use keygo_api::domain::{Device, RevokeReason}; +use keygo_client::ark_session::ArkSession; +use keygo_client::sync::testing::{FakeSigner, FakeTokenStore, FixedClock}; +use keygo_client::sync::{ + Clock, Header, HttpRequest, HttpResponse, StoredSession, SyncClient, SyncError, SystemClock, + Transport, TransportError, +}; +use keygo_core::{AccountRootKey, KeyMaterial, OpaqueKek, Sealed, UserId, Wraps}; +use keygo_dpop::testing::TestSigner; +use keygo_opaque::server::ServerSetup; +use keygo_server::api::{AppState, router}; +use keygo_server::testing; +use sqlx::PgPool; +use std::sync::Arc; +use tower::ServiceExt; +use url::Url; + +struct TowerTransport(AppState); + +#[async_trait] +impl Transport for TowerTransport { + async fn send(&self, request: HttpRequest) -> Result { + let fail = |e: &dyn std::fmt::Display| TransportError { + message: e.to_string(), + }; + let mut built = Request::builder() + .method(request.method.as_str()) + .uri(&request.url); + for header in &request.headers { + built = built.header( + HeaderName::try_from(header.name.as_str()).map_err(|e| fail(&e))?, + HeaderValue::try_from(header.value.as_str()).map_err(|e| fail(&e))?, + ); + } + let built = built.body(Body::from(request.body)).map_err(|e| fail(&e))?; + + let response = router(self.0.clone()) + .oneshot(built) + .await + .map_err(|e| fail(&e))?; + let status = response.status().as_u16(); + let headers = response + .headers() + .iter() + .map(|(name, value)| Header { + name: name.as_str().to_owned(), + value: value.to_str().unwrap_or_default().to_owned(), + }) + .collect(); + let body = response + .into_body() + .collect() + .await + .map_err(|e| fail(&e))? + .to_bytes() + .to_vec(); + Ok(HttpResponse { + status, + headers, + body, + }) + } +} + +struct Harness { + client: SyncClient, + store: Arc, + clock: Arc, + state: AppState, + prover: keygo_dpop::DpopProver, + device_id: keygo_core::DeviceId, + access_token: String, + seed_token: String, +} + +async fn harness(db: &PgPool) -> Harness { + let prover = testing::prover(); + let (state, issued) = testing::signed_in(db, &prover).await; + let seed_token = issued.refresh_token.expose_encoded().to_string(); + let access_token = issued.access_token.expose().to_owned(); + let device_id = issued.device_id; + + let store = Arc::new(FakeTokenStore::new()); + store.seed(StoredSession { + device_id, + refresh_token: issued.refresh_token, + refresh_expires_at: SystemClock.now_secs() + issued.refresh_expires_in.as_secs(), + }); + let clock = FixedClock::new(SystemClock.now_secs()); + let client = SyncClient::new( + Url::parse(testing::ISS).unwrap(), + Arc::new(TowerTransport(state.clone())), + Arc::new(FakeSigner::new()), + store.clone(), + ) + .unwrap() + .with_clock(clock.clone()); + + Harness { + client, + store, + clock, + state, + prover, + device_id, + access_token, + seed_token, + } +} + +/// A client with nothing stored, against a server with no session for it. +fn signed_out(db: &PgPool) -> (SyncClient, Arc, AppState) { + let state = testing::app_state(db, &ServerSetup::generate()); + let (client, store) = client_of(&state); + (client, store, state) +} + +/// Another install with nothing stored, against the same server. +fn client_of(state: &AppState) -> (SyncClient, Arc) { + let store = Arc::new(FakeTokenStore::new()); + let client = SyncClient::new( + Url::parse(testing::ISS).unwrap(), + Arc::new(TowerTransport(state.clone())), + Arc::new(FakeSigner::new()), + store.clone(), + ) + .unwrap(); + (client, store) +} + +async fn device_count(db: &PgPool, user_id: UserId) -> i64 { + sqlx::query_scalar("select count(*) from devices where user_id = $1") + .bind(user_id.as_uuid()) + .fetch_one(db) + .await + .unwrap() +} + +fn local_account() -> (ArkSession, UserId) { + let ark_session = ArkSession::new(); + let user_id = ark_session.create_account(password()).unwrap().user_id; + (ark_session, user_id) +} + +async fn register(client: &SyncClient, ark_session: &ArkSession, user_id: UserId, name: &str) { + client + .register( + ark_session, + user_id, + name.into(), + password(), + None, + testing::device_info(), + ) + .await + .unwrap(); +} + +fn password() -> &'static str { + std::str::from_utf8(testing::PASSWORD).unwrap() +} + +fn other(devices: &[Device], mine: keygo_core::DeviceId) -> keygo_core::DeviceId { + devices.iter().find(|d| d.id != mine).unwrap().id +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn meta_reports_the_server(db: PgPool) { + let h = harness(&db).await; + + let info = h.client.meta().await.unwrap(); + + assert!(info.allow_signups); + assert_eq!(info.public_url, "http://localhost/"); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn first_call_refreshes_and_rotates(db: PgPool) { + let h = harness(&db).await; + + assert_eq!(h.client.devices().await.unwrap().len(), 2); + + assert_ne!(h.store.current_refresh_token().unwrap(), h.seed_token); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn expired_access_token_refreshes_again(db: PgPool) { + let h = harness(&db).await; + h.client.devices().await.unwrap(); + let first = h.store.current_refresh_token().unwrap(); + + h.clock.advance(601); + h.client.devices().await.unwrap(); + + assert_ne!(h.store.current_refresh_token().unwrap(), first); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn revoked_session_signs_out(db: PgPool) { + let h = harness(&db).await; + let (status, _) = testing::post_with_token( + &h.state, + &h.prover, + "/api/v1/auth/logout", + &h.access_token, + serde_json::Value::Null, + ) + .await; + assert!(status.is_success(), "{status}"); + + assert_eq!( + h.client.devices().await.unwrap_err(), + SyncError::SignedOut { + reason: Some(RevokeReason::Logout), + }, + ); + assert_eq!(h.store.current_refresh_token(), None); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn fresh_auth_required_then_step_up_then_retry(db: PgPool) { + let h = harness(&db).await; + sqlx::query("update sessions set auth_time = to_timestamp($1) where device_id = $2") + .bind((SystemClock.now_secs() - 301) as f64) + .bind(h.device_id.as_uuid()) + .execute(&db) + .await + .unwrap(); + + let devices = h.client.devices().await.unwrap(); + let other = other(&devices, h.device_id); + assert_eq!( + h.client.delete_device(other).await.unwrap_err(), + SyncError::FreshAuthRequired, + ); + + h.client.step_up(password()).await.unwrap(); + h.client.delete_device(other).await.unwrap(); + + assert_eq!(h.client.devices().await.unwrap().len(), 1); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn step_up_replaces_the_access_token_without_rotating(db: PgPool) { + let h = harness(&db).await; + h.client.devices().await.unwrap(); + let stored = h.store.current_refresh_token().unwrap(); + + h.client.step_up(password()).await.unwrap(); + h.client.devices().await.unwrap(); + + assert_eq!(h.store.current_refresh_token().unwrap(), stored); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn wrong_step_up_password_is_invalid_credentials(db: PgPool) { + let h = harness(&db).await; + + assert_eq!( + h.client.step_up("wrong").await.unwrap_err(), + SyncError::InvalidCredentials, + ); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn empty_step_up_password_is_invalid_credentials(db: PgPool) { + let h = harness(&db).await; + + assert_eq!( + h.client.step_up("").await.unwrap_err(), + SyncError::InvalidCredentials, + ); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn client_logout_ends_the_session_on_the_server(db: PgPool) { + let h = harness(&db).await; + + h.client.logout().await.unwrap(); + assert_eq!(h.store.current_refresh_token(), None); + + let (status, _) = testing::post_with_token( + &h.state, + &h.prover, + "/api/v1/auth/logout", + &h.access_token, + serde_json::Value::Null, + ) + .await; + assert!(!status.is_success(), "{status}"); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn register_signs_the_device_in(db: PgPool) { + let (client, store, _) = signed_out(&db); + let (ark_session, user_id) = local_account(); + + let account = client + .register( + &ark_session, + user_id, + "Ada".into(), + password(), + None, + testing::device_info(), + ) + .await + .unwrap(); + + assert_eq!(account.user_id, user_id); + assert_eq!(account.username.as_str(), "ada"); + assert!(store.current_refresh_token().is_some()); + let devices = client.devices().await.unwrap(); + assert_eq!(devices.len(), 1); + assert_eq!(devices[0].id, account.device_id); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn server_wrapped_ark_opens_after_sign_in(db: PgPool) { + let (client, _, state) = signed_out(&db); + let (ark_session, user_id) = local_account(); + register(&client, &ark_session, user_id, "ada").await; + + let (login, started) = + testing::start_login(&db, &state.login_states, &state.opaque_state, "ada").await; + let export_key = login + .finish(testing::PASSWORD, started.credential_response) + .unwrap() + .export_key; + let stored: Vec = + sqlx::query_scalar("select wrapped_ark from key_bundles where user_id = $1") + .bind(user_id.as_uuid()) + .fetch_one(&db) + .await + .unwrap(); + + let opened = OpaqueKek::from_export_key(export_key.as_bytes(), user_id) + .unwrap() + .unwrap_key( + &Sealed::::from_bytes(&stored).unwrap(), + &user_id, + ) + .unwrap(); + + assert_eq!( + opened.as_bytes(), + ark_session.export_ark().unwrap().as_slice() + ); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn registering_while_signed_in_ends_the_old_session(db: PgPool) { + let h = harness(&db).await; + let (ark_session, user_id) = local_account(); + + register(&h.client, &ark_session, user_id, "bob").await; + + let (status, _) = testing::post_with_token( + &h.state, + &h.prover, + "/api/v1/auth/logout", + &h.access_token, + serde_json::Value::Null, + ) + .await; + assert!(!status.is_success(), "{status}"); + assert_ne!(h.store.current_refresh_token().unwrap(), h.seed_token); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn refused_save_does_not_trip_reuse_detection(db: PgPool) { + let h = harness(&db).await; + h.store.fail_saves(); + + h.client.devices().await.unwrap(); + h.clock.advance(601); + h.client.devices().await.unwrap(); + + assert_eq!(h.store.current_refresh_token().unwrap(), h.seed_token); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn login_on_a_fresh_install_unlocks_the_vault(db: PgPool) { + let (client, _, state) = signed_out(&db); + let (ark_session, user_id) = local_account(); + register(&client, &ark_session, user_id, "ada").await; + + let (fresh, store) = client_of(&state); + let locked = ArkSession::new(); + let account = fresh + .login(&locked, "ada".into(), password(), testing::device_info()) + .await + .unwrap(); + + assert_eq!(account.user_id, user_id); + assert_eq!( + locked.export_ark().unwrap(), + ark_session.export_ark().unwrap() + ); + assert!(store.current_refresh_token().is_some()); + assert_eq!(fresh.devices().await.unwrap().len(), 2); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn logging_in_again_reuses_the_device(db: PgPool) { + let (client, _, _) = signed_out(&db); + let (ark_session, user_id) = local_account(); + register(&client, &ark_session, user_id, "ada").await; + let registered = client.devices().await.unwrap()[0].id; + + let account = client + .login( + &ark_session, + "ada".into(), + password(), + testing::device_info(), + ) + .await + .unwrap(); + + assert_eq!(account.device_id, registered); + assert_eq!(device_count(&db, user_id).await, 1); + client.devices().await.unwrap(); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn login_into_another_vault_leaves_nothing_behind(db: PgPool) { + let (client, _, state) = signed_out(&db); + let (ark_session, user_id) = local_account(); + register(&client, &ark_session, user_id, "ada").await; + + let (other, store) = client_of(&state); + let (other_ark, _) = local_account(); + let error = other + .login(&other_ark, "ada".into(), password(), testing::device_info()) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::AccountMismatch); + assert_eq!(store.current_refresh_token(), None); + assert_eq!( + device_count(&db, user_id).await, + 1, + "the new device is deleted" + ); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn failed_login_keeps_the_previous_session(db: PgPool) { + let h = harness(&db).await; + h.client.devices().await.unwrap(); + let before = h.store.current_refresh_token().unwrap(); + + let error = h + .client + .login( + &ArkSession::new(), + "ada".into(), + "wrong", + testing::device_info(), + ) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::InvalidCredentials); + assert_eq!(h.store.current_refresh_token().unwrap(), before); + h.client.devices().await.unwrap(); +} + +#[sqlx::test(migrations = "../keygo-server/migrations")] +async fn unknown_username_is_invalid_credentials(db: PgPool) { + let (client, _, _) = signed_out(&db); + + let error = client + .login( + &ArkSession::new(), + "nobody".into(), + password(), + testing::device_info(), + ) + .await + .unwrap_err(); + + assert_eq!(error, SyncError::InvalidCredentials); +} diff --git a/rust/crates/keygo-server/Cargo.toml b/rust/crates/keygo-server/Cargo.toml index 60fe71ef1..8cd3a07b1 100644 --- a/rust/crates/keygo-server/Cargo.toml +++ b/rust/crates/keygo-server/Cargo.toml @@ -4,7 +4,11 @@ description = "KeyGo self-hostable sync server." version.workspace = true edition.workspace = true +[features] +test-support = ["dep:http-body-util", "dep:tower", "keygo-dpop/test-support"] + [dependencies] +keygo-api = { path = "../keygo-api", features = ["server"] } keygo-core = { path = "../keygo-core" } keygo-opaque = { path = "../keygo-opaque" } keygo-dpop = { path = "../keygo-dpop" } @@ -17,6 +21,8 @@ serde = { workspace = true, features = ["derive"] } serde_json.workspace = true hmac.workspace = true sha2 = { workspace = true, features = ["zeroize"] } +http-body-util = { version = "0.1.5", optional = true } +tower = { version = "0.5.3", features = ["util"], optional = true } anstream = "1.0.0" anstyle = "1.0.14" @@ -33,8 +39,6 @@ tracing-subscriber = { version = "0.3.23", features = ["env-filter"] } tower-http = { version = "0.7.1", features = ["set-header", "trace"] } uuid = { workspace = true, features = ["v4"] } sqlx = { version = "0.9.0", default-features = false, features = ["runtime-tokio", "postgres", "migrate", "macros", "uuid", "time"] } -unicode-normalization = "0.1.25" -unicode-properties = { version = "0.1.4", default-features = false, features = ["general-category"] } humantime = "2.4.0" time = { version = "0.3.55", features = ["formatting", "macros"] } moka = { version = "0.12.16", features = ["sync"] } diff --git a/rust/crates/keygo-server/src/api/error.rs b/rust/crates/keygo-server/src/api/error.rs index 06f6b3aaa..1ee4f7eb2 100644 --- a/rust/crates/keygo-server/src/api/error.rs +++ b/rust/crates/keygo-server/src/api/error.rs @@ -2,60 +2,31 @@ use crate::domain::{InvalidBlob, UsernameError}; use axum::extract::rejection::JsonRejection; use axum::http::{HeaderMap, StatusCode}; use axum::response::{IntoResponse, Response}; +use keygo_api::ApiError; use keygo_opaque::OpaqueError; -use serde::Serialize; -use serde_json::json; use thiserror::Error; -/// Every `code` the API answers with; clients match on the serialized name. -#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)] -#[serde(rename_all = "snake_case")] -pub enum ErrorCode { - // general - Internal, - InvalidRequest, - NotFound, - RateLimited, - // auth - InvalidUsername, - InvalidCredentials, - UsernameTaken, - UserIdTaken, - InviteRequired, - InviteInvalid, - RegistrationExpired, - LoginExpired, - // session - FreshAuthRequired, - InvalidToken, - RefreshExpired, - SessionRevoked, - // dpop - InvalidDpopProof, - UseDpopNonce, -} +pub use keygo_api::ErrorCode; -impl ErrorCode { - pub fn status(self) -> StatusCode { - match self { - Self::Internal => StatusCode::INTERNAL_SERVER_ERROR, - Self::InvalidRequest - | Self::InvalidUsername - | Self::RegistrationExpired - | Self::LoginExpired - | Self::InvalidDpopProof - | Self::UseDpopNonce => StatusCode::BAD_REQUEST, - Self::InvalidCredentials - | Self::InvalidToken - | Self::RefreshExpired - | Self::SessionRevoked => StatusCode::UNAUTHORIZED, - Self::InviteRequired | Self::InviteInvalid | Self::FreshAuthRequired => { - StatusCode::FORBIDDEN - } - Self::NotFound => StatusCode::NOT_FOUND, - Self::UsernameTaken | Self::UserIdTaken => StatusCode::CONFLICT, - Self::RateLimited => StatusCode::TOO_MANY_REQUESTS, +fn status_of(code: ErrorCode) -> StatusCode { + match code { + ErrorCode::Internal | ErrorCode::Unknown => StatusCode::INTERNAL_SERVER_ERROR, + ErrorCode::InvalidRequest + | ErrorCode::InvalidUsername + | ErrorCode::RegistrationExpired + | ErrorCode::LoginExpired + | ErrorCode::InvalidDpopProof + | ErrorCode::UseDpopNonce => StatusCode::BAD_REQUEST, + ErrorCode::InvalidCredentials + | ErrorCode::InvalidToken + | ErrorCode::RefreshExpired + | ErrorCode::SessionRevoked => StatusCode::UNAUTHORIZED, + ErrorCode::InviteRequired | ErrorCode::InviteInvalid | ErrorCode::FreshAuthRequired => { + StatusCode::FORBIDDEN } + ErrorCode::NotFound => StatusCode::NOT_FOUND, + ErrorCode::UsernameTaken | ErrorCode::UserIdTaken => StatusCode::CONFLICT, + ErrorCode::RateLimited => StatusCode::TOO_MANY_REQUESTS, } } @@ -63,7 +34,7 @@ pub trait HttpError: std::error::Error + Send + Sync + 'static { fn code(&self) -> ErrorCode; fn status(&self) -> StatusCode { - self.code().status() + status_of(self.code()) } fn headers(&self) -> HeaderMap { @@ -97,10 +68,11 @@ impl IntoResponse for ServerError { self.0.to_string() }; - let mut body = json!({"code": code, "message": message}); - if let Some(reason) = reason { - body["reason"] = reason.into(); - } + let body = ApiError { + code, + message, + reason: reason.map(str::to_owned), + }; (status, headers, axum::Json(body)).into_response() } diff --git a/rust/crates/keygo-server/src/api/mod.rs b/rust/crates/keygo-server/src/api/mod.rs index 136421785..0a7b7d695 100644 --- a/rust/crates/keygo-server/src/api/mod.rs +++ b/rust/crates/keygo-server/src/api/mod.rs @@ -57,29 +57,40 @@ mod tests { use axum::body::Body; use axum::http::{Request, StatusCode}; use http_body_util::BodyExt; + use keygo_api::Auth; + use keygo_api::endpoints::Route; use keygo_dpop::DpopVerifier; use routes::auth::MAX_BODY_BYTES; use serde_json::{Value, json}; use std::sync::Arc; use tower::ServiceExt; - async fn get(state: AppState, uri: &str) -> (StatusCode, Vec) { - let request = Request::get(uri).body(Body::empty()).unwrap(); + async fn send(state: AppState, request: Request) -> (StatusCode, Vec) { let response = router(state).oneshot(request).await.unwrap(); let status = response.status(); let body = response.into_body().collect().await.unwrap().to_bytes(); (status, body.to_vec()) } + async fn get(state: AppState, uri: &str) -> (StatusCode, Vec) { + send(state, Request::get(uri).body(Body::empty()).unwrap()).await + } + async fn post_json(state: AppState, uri: &str, body: Value) -> (StatusCode, Vec) { let request = Request::post(uri) .header("content-type", "application/json") .body(Body::from(body.to_string())) .unwrap(); - let response = router(state).oneshot(request).await.unwrap(); - let status = response.status(); - let body = response.into_body().collect().await.unwrap().to_bytes(); - (status, body.to_vec()) + send(state, request).await + } + + async fn send_empty(route: &Route) -> (StatusCode, Vec) { + let request = Request::builder() + .method(route.method.as_str()) + .uri(&route.path) + .body(Body::empty()) + .unwrap(); + send(state(), request).await } pub(super) fn state() -> AppState { @@ -125,6 +136,24 @@ mod tests { ); } + #[tokio::test] + async fn every_endpoint_demands_its_declared_auth() { + for route in keygo_api::endpoints::all_routes() { + let (status, body) = send_empty(&route).await; + let code = serde_json::from_slice::(&body) + .ok() + .map(|body| body["code"].clone()); + match route.auth { + Auth::AccessToken => assert_eq!(code, Some(json!("invalid_token")), "{route:?}"), + Auth::Proof => assert_eq!(code, Some(json!("invalid_dpop_proof")), "{route:?}"), + Auth::None => assert!( + status == StatusCode::OK || status == StatusCode::UNSUPPORTED_MEDIA_TYPE, + "{route:?}", + ), + } + } + } + #[tokio::test] async fn unknown_route_is_not_found() { let (status, body) = get(state(), "/api/v1/nope").await; diff --git a/rust/crates/keygo-server/src/api/routes/auth/handshake.rs b/rust/crates/keygo-server/src/api/routes/auth/handshake.rs index fa3110201..44beb7900 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/handshake.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/handshake.rs @@ -1,8 +1,6 @@ use crate::api::{ErrorCode, HttpError}; -use crate::domain::LoginId; use crate::service::handshake; -use keygo_opaque::CredentialResponse; -use serde::Serialize; +use keygo_api::auth::handshake::StartResponse; // Sign-in and step-up run the same OPAQUE login, so they share its error codes and bodies. impl HttpError for handshake::Error { @@ -15,13 +13,6 @@ impl HttpError for handshake::Error { } } -#[derive(Serialize)] -pub struct StartResponse { - login_id: LoginId, - credential_response: CredentialResponse, - expires_in: u64, -} - impl From for StartResponse { fn from(started: handshake::Started) -> Self { Self { diff --git a/rust/crates/keygo-server/src/api/routes/auth/login.rs b/rust/crates/keygo-server/src/api/routes/auth/login.rs index 5e82007d3..2c69b82f9 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/login.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/login.rs @@ -1,14 +1,12 @@ use crate::api::dpop::SingleUseDpopProof; -use crate::api::routes::auth::handshake::StartResponse; -use crate::api::routes::auth::session::Session; use crate::api::{AppState, Json, ServerResult}; -use crate::domain::{DeviceClaim, KeyBundle, LoginId, UserId, Username}; +use crate::domain::Username; use crate::service::login::{self, FinishLogin, StartLogin}; use axum::Router; use axum::extract::State; use axum::routing::post; -use keygo_opaque::{CredentialFinalization, CredentialRequest, DpopBinding}; -use serde::{Deserialize, Serialize}; +use keygo_api::auth::handshake::StartResponse; +use keygo_api::auth::login::{FinishRequest, FinishResponse, StartRequest}; pub fn router() -> Router { Router::new() @@ -16,13 +14,6 @@ pub fn router() -> Router { .route("/finish", post(finish)) } -#[derive(Deserialize)] -struct StartRequest { - /// Parsed in the handler so a bad name answers `invalid_username`, not `invalid_request`. - username: String, - credential_request: CredentialRequest, -} - async fn start( State(state): State, Json(request): Json, @@ -37,22 +28,6 @@ async fn start( Ok(Json(started.into())) } -#[derive(Deserialize)] -struct FinishRequest { - login_id: LoginId, - credential_finalization: CredentialFinalization, - device: DeviceClaim, - dpop_binding: DpopBinding, -} - -#[derive(Serialize)] -struct FinishResponse { - user_id: UserId, - username: Username, - key_bundle: KeyBundle, - session: Session, -} - async fn finish( State(state): State, proof: SingleUseDpopProof, @@ -80,6 +55,7 @@ async fn finish( #[cfg(test)] mod tests { use super::*; + use crate::domain::LoginId; use crate::testing::{ PASSWORD, app_state, count, device_json, key_bundle_json, post_to, post_with_proof, proof_post, prover, register, replayable_post, send, diff --git a/rust/crates/keygo-server/src/api/routes/auth/register.rs b/rust/crates/keygo-server/src/api/routes/auth/register.rs index f604a36de..8b1f69d1b 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/register.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/register.rs @@ -1,14 +1,12 @@ use crate::api::dpop::SingleUseDpopProof; -use crate::api::routes::auth::session::Session; use crate::api::{AppState, ErrorCode, HttpError, Json, ServerResult}; -use crate::domain::{DeviceInfo, KeyBundle, RegistrationId, UserId, Username}; +use crate::domain::Username; use crate::service::registration::{self, FinishRegistration, StartRegistration}; use axum::Router; use axum::extract::State; use axum::http::StatusCode; use axum::routing::post; -use keygo_opaque::{RegistrationRequest, RegistrationResponse, RegistrationUpload}; -use serde::{Deserialize, Serialize}; +use keygo_api::auth::register::{FinishRequest, FinishResponse, StartRequest, StartResponse}; pub fn router() -> Router { Router::new() @@ -16,22 +14,6 @@ pub fn router() -> Router { .route("/finish", post(finish)) } -#[derive(Deserialize)] -struct StartRequest { - /// Parsed in the handler so a bad name answers `invalid_username`, not `invalid_request`. - username: String, - user_id: UserId, - invite: Option, - registration_request: RegistrationRequest, -} - -#[derive(Serialize)] -struct StartResponse { - registration_id: RegistrationId, - registration_response: RegistrationResponse, - expires_in: u64, -} - impl HttpError for registration::StartError { fn code(&self) -> ErrorCode { match self { @@ -67,20 +49,6 @@ async fn start( })) } -#[derive(Deserialize)] -struct FinishRequest { - registration_id: RegistrationId, - registration_upload: RegistrationUpload, - key_bundle: KeyBundle, - device: DeviceInfo, -} - -#[derive(Serialize)] -struct FinishResponse { - username: Username, - session: Session, -} - impl HttpError for registration::FinishError { fn code(&self) -> ErrorCode { match self { @@ -120,12 +88,14 @@ async fn finish( mod tests { use super::*; use crate::api::error::render; + use crate::domain::{RegistrationId, UserId}; use crate::testing::{ WRAPPED_ARK, app_state, count, create_invite, device_json, invite_only, key_bundle_json, post, post_to, post_with_proof, proof_post, prover, register, replayable_post, send, }; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; + use keygo_opaque::RegistrationResponse; use keygo_opaque::client::ClientRegistration; use keygo_opaque::server::ServerSetup; use serde_json::{Value, json}; diff --git a/rust/crates/keygo-server/src/api/routes/auth/session.rs b/rust/crates/keygo-server/src/api/routes/auth/session.rs index abe60d5c6..849153d48 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/session.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/session.rs @@ -1,36 +1,19 @@ -use crate::domain::{ACCESS_TOKEN_LIFETIME, AccessToken, DeviceId, RefreshToken}; +use crate::domain::{ACCESS_TOKEN_LIFETIME, AccessToken}; use crate::service::session::Issued; -use serde::Serialize; +use keygo_api::auth::{Access, Session}; -#[derive(Serialize)] -pub struct Access { - access_token: AccessToken, - access_expires_in: u64, -} - -impl From for Access { - fn from(access_token: AccessToken) -> Self { - Self { - access_token, - access_expires_in: ACCESS_TOKEN_LIFETIME.as_secs(), - } +pub fn access(access_token: AccessToken) -> Access { + Access { + access_token, + access_expires_in: ACCESS_TOKEN_LIFETIME.as_secs(), } } -#[derive(Serialize)] -pub struct Session { - device_id: DeviceId, - #[serde(flatten)] - access: Access, - refresh_token: RefreshToken, - refresh_expires_in: u64, -} - impl From for Session { fn from(value: Issued) -> Self { Self { device_id: value.device_id, - access: value.access_token.into(), + access: access(value.access_token), refresh_token: value.refresh_token, refresh_expires_in: value.refresh_expires_in.as_secs(), } diff --git a/rust/crates/keygo-server/src/api/routes/auth/step_up.rs b/rust/crates/keygo-server/src/api/routes/auth/step_up.rs index 27dabe28a..a5438caec 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/step_up.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/step_up.rs @@ -1,15 +1,13 @@ use crate::api::authenticated::{AuthError, Authenticated}; -use crate::api::routes::auth::handshake::StartResponse; -use crate::api::routes::auth::session::Access; +use crate::api::routes::auth::session::access; use crate::api::{AppState, ErrorCode, HttpError, Json, ServerResult}; -use crate::domain::LoginId; use crate::service::step_up::{self, FinishError, FinishStepUp, StartStepUp}; use axum::Router; use axum::extract::State; use axum::http::HeaderMap; use axum::routing::post; -use keygo_opaque::{CredentialFinalization, CredentialRequest, DpopBinding}; -use serde::{Deserialize, Serialize}; +use keygo_api::auth::handshake::StartResponse; +use keygo_api::auth::step_up::{FinishRequest, FinishResponse, StartRequest}; impl HttpError for FinishError { fn code(&self) -> ErrorCode { @@ -33,25 +31,6 @@ pub fn router() -> Router { .route("/finish", post(finish)) } -#[derive(Deserialize)] -struct StartRequest { - credential_request: CredentialRequest, -} - -#[derive(Deserialize)] -struct FinishRequest { - login_id: LoginId, - credential_finalization: CredentialFinalization, - dpop_binding: DpopBinding, -} - -#[derive(Serialize)] -struct FinishResponse { - #[serde(flatten)] - access: Access, - auth_time: u64, -} - async fn start( State(state): State, authenticated: Authenticated, @@ -86,7 +65,7 @@ async fn finish( step_up::finish(&state.db, &state.step_up_states, &state.token_issuer, input).await?; Ok(Json(FinishResponse { - access: finished.access_token.into(), + access: access(finished.access_token), auth_time: finished.auth_time, })) } diff --git a/rust/crates/keygo-server/src/api/routes/auth/token.rs b/rust/crates/keygo-server/src/api/routes/auth/token.rs index 0dc798253..235baec32 100644 --- a/rust/crates/keygo-server/src/api/routes/auth/token.rs +++ b/rust/crates/keygo-server/src/api/routes/auth/token.rs @@ -1,18 +1,13 @@ use crate::api::dpop::SingleUseDpopProof; -use crate::api::routes::auth::session::Session; use crate::api::{AppState, ErrorCode, HttpError, Json, ServerResult}; -use crate::domain::{RefreshToken, RevokeReason}; +use crate::domain::RevokeReason; use crate::service::session; use crate::service::session::RefreshError; use axum::Router; use axum::extract::State; use axum::routing::post; -use serde::Deserialize; - -#[derive(Deserialize)] -pub struct TokenRequest { - refresh_token: RefreshToken, -} +use keygo_api::auth::Session; +use keygo_api::auth::token::TokenRequest; impl HttpError for RefreshError { fn code(&self) -> ErrorCode { diff --git a/rust/crates/keygo-server/src/api/routes/devices.rs b/rust/crates/keygo-server/src/api/routes/devices.rs index e29733805..ebfee9f41 100644 --- a/rust/crates/keygo-server/src/api/routes/devices.rs +++ b/rust/crates/keygo-server/src/api/routes/devices.rs @@ -1,13 +1,13 @@ use crate::api::authenticated::Authenticated; use crate::api::{AppState, ErrorCode, HttpError, Json, ServerResult}; -use crate::domain::{Device, DeviceId}; +use crate::domain::DeviceId; use crate::service::device; use crate::service::device::DeleteDeviceError; use axum::Router; use axum::extract::{Path, State}; use axum::http::StatusCode; use axum::routing::{delete, get}; -use serde::Serialize; +use keygo_api::devices::Devices; pub fn router() -> Router { Router::new() @@ -24,11 +24,6 @@ impl HttpError for DeleteDeviceError { } } -#[derive(Serialize)] -struct Devices { - devices: Vec, -} - async fn devices( State(state): State, authenticated: Authenticated, diff --git a/rust/crates/keygo-server/src/api/routes/meta.rs b/rust/crates/keygo-server/src/api/routes/meta.rs index 5b0502e33..cc35569f4 100644 --- a/rust/crates/keygo-server/src/api/routes/meta.rs +++ b/rust/crates/keygo-server/src/api/routes/meta.rs @@ -3,23 +3,16 @@ use crate::service::registration::Signup; use axum::extract::State; use axum::routing::get; use axum::{Json, Router}; -use serde::Serialize; +use keygo_api::meta::ServerInfo; pub fn router() -> Router { Router::new().route("/", get(info)) } -#[derive(Serialize)] -struct ServerInfo { - version: &'static str, - public_url: String, - allow_signups: bool, -} - /// What a client needs to know before talking to this server. async fn info(State(state): State) -> Json { Json(ServerInfo { - version: env!("CARGO_PKG_VERSION"), + version: env!("CARGO_PKG_VERSION").to_owned(), public_url: state.public_url.to_string(), allow_signups: matches!(state.signup, Signup::Open), }) diff --git a/rust/crates/keygo-server/src/db/key_bundles.rs b/rust/crates/keygo-server/src/db/key_bundles.rs index 6319d77d0..f55e1adf2 100644 --- a/rust/crates/keygo-server/src/db/key_bundles.rs +++ b/rust/crates/keygo-server/src/db/key_bundles.rs @@ -1,5 +1,6 @@ use super::corrupt; -use crate::domain::{KeyBundle, SealedBlob, UserId, check_wrapped_ark}; +use crate::domain::{KeyBundle, UserId, check_wrapped_ark}; +use keygo_core::Sealed; use sqlx::PgConnection; pub async fn insert( @@ -29,7 +30,7 @@ pub async fn find(conn: &mut PgConnection, user_id: UserId) -> sqlx::Result UserId { @@ -77,7 +79,7 @@ mod tests { .await .unwrap(); - let blob = SealedBlob::from_bytes(&stored).unwrap(); + let blob = Sealed::::from_bytes(&stored).unwrap(); assert_eq!(blob.nonce(), &WRAPPED_ARK[..12]); assert_eq!(blob.ciphertext(), &WRAPPED_ARK[12..]); } diff --git a/rust/crates/keygo-server/src/domain/access_token.rs b/rust/crates/keygo-server/src/domain/access_token.rs index a27517f5c..72765f6b2 100644 --- a/rust/crates/keygo-server/src/domain/access_token.rs +++ b/rust/crates/keygo-server/src/domain/access_token.rs @@ -1,4 +1,4 @@ -use crate::domain::{SessionId, UserId, unix_now}; +use crate::domain::{AccessToken, SessionId, UserId, unix_now}; use base64::Engine; use base64::engine::general_purpose::URL_SAFE_NO_PAD; use ed25519_dalek::{Signature, Signer, SigningKey}; @@ -7,7 +7,6 @@ use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; use std::time::Duration; use thiserror::Error; -use zeroize::{Zeroize, ZeroizeOnDrop}; pub const ACCESS_TOKEN_LIFETIME: Duration = Duration::from_mins(10); pub const FRESH_AUTH_WINDOW: Duration = Duration::from_mins(5); @@ -101,9 +100,6 @@ struct Header { kid: String, } -#[derive(Serialize, Zeroize, ZeroizeOnDrop)] -pub struct AccessToken(String); - #[derive(Debug, Clone, Copy, PartialEq, Eq, Error)] pub enum TokenError { #[error("token is not a well-formed access token")] @@ -151,10 +147,6 @@ impl Claims { self.session_id } - #[cfg_attr( - not(test), - expect(dead_code, reason = "no route requires a fresh sign-in yet") - )] pub fn auth_time(&self) -> u64 { self.auth_time } @@ -172,13 +164,6 @@ impl Claims { } } -impl AccessToken { - #[cfg(test)] - pub(crate) fn expose(&self) -> &str { - &self.0 - } -} - impl AccessTokenKey { pub fn new(seed: &[u8; 32]) -> Self { let signing = SigningKey::from_bytes(seed); @@ -198,7 +183,7 @@ impl AccessTokenKey { let input = format!("{}.{}", encode(&header), encode(claims)); let signature = self.signing.sign(input.as_bytes()); - AccessToken(format!( + AccessToken::from_signed(format!( "{input}.{}", URL_SAFE_NO_PAD.encode(signature.to_bytes()) )) @@ -374,7 +359,7 @@ mod tests { let claims = Claims::new_at( String::new(), UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), 0, &JKT, 1_000, @@ -390,7 +375,7 @@ mod tests { Claims::new_at( String::new(), UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), 0, &JKT, 0, @@ -554,7 +539,7 @@ mod tests { let claims = Claims::new_at( String::new(), UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), 1_000, &JKT, 1_000, @@ -571,7 +556,7 @@ mod tests { let token = key.sign(&Claims::new_at( ISS.into(), UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), unix_now(), &JKT, unix_now(), @@ -602,7 +587,7 @@ mod tests { let key = || AccessTokenKey::new(&SEED); let token = TokenIssuer::new(key(), "https://other.example").issue( UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), unix_now(), &JKT, ); @@ -620,7 +605,7 @@ mod tests { let token = issuer.issue( UserId::from(uuid::Uuid::nil()), - SessionId::nil(), + SessionId::from(uuid::Uuid::nil()), auth_time, &JKT, ); diff --git a/rust/crates/keygo-server/src/domain/ids.rs b/rust/crates/keygo-server/src/domain/ids.rs index ec739172e..d3276901e 100644 --- a/rust/crates/keygo-server/src/domain/ids.rs +++ b/rust/crates/keygo-server/src/domain/ids.rs @@ -1,113 +1,4 @@ -use base64::Engine; -use base64::engine::general_purpose::URL_SAFE_NO_PAD; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use thiserror::Error; -use uuid::Uuid; - -/// An account. Client-generated at registration and equal to the app's local user id. -pub use keygo_core::UserId; - -const LEN: usize = 16; - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)] -#[error("{field} must be {LEN} bytes of base64url without padding")] -pub struct InvalidId { - field: &'static str, -} - -/// Declares an opaque handle of 16 random bytes that travels as base64url without padding. -macro_rules! random_id { - ($($(#[$attr:meta])* $name:ident as $field:literal;)+) => {$( - $(#[$attr])* - #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] - pub struct $name([u8; LEN]); - - impl $name { - pub fn random() -> Self { - let mut bytes = [0u8; LEN]; - getrandom::fill(&mut bytes).expect("OS random number generator unavailable"); - Self(bytes) - } - - pub fn to_base64(self) -> String { - URL_SAFE_NO_PAD.encode(self.0) - } - - pub fn from_base64(text: &str) -> Result { - const INVALID: InvalidId = InvalidId { field: $field }; - let bytes = URL_SAFE_NO_PAD.decode(text).map_err(|_| INVALID)?; - bytes.try_into().map(Self).map_err(|_| INVALID) - } - } - - impl Serialize for $name { - fn serialize(&self, serializer: S) -> Result { - serializer.serialize_str(&self.to_base64()) - } - } - - impl<'de> Deserialize<'de> for $name { - fn deserialize>(deserializer: D) -> Result { - let text = String::deserialize(deserializer)?; - Self::from_base64(&text).map_err(serde::de::Error::custom) - } - } - )+}; -} - -/// Declares a UUID-backed id that travels as the UUID's string form. -macro_rules! uuid_id { - ($($(#[$attr:meta])* $name:ident;)+) => {$( - $(#[$attr])* - #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] - pub struct $name(Uuid); - - impl $name { - #[allow(dead_code, reason = "user ids are client-generated, so only tests mint one")] - pub fn random() -> Self { - Self(Uuid::new_v4()) - } - - #[cfg(test)] - #[allow(dead_code, reason = "not every id needs a fixed value in tests")] - pub const fn nil() -> Self { - Self(Uuid::nil()) - } - - pub const fn as_uuid(self) -> Uuid { - self.0 - } - } - - impl From for $name { - fn from(value: Uuid) -> Self { - Self(value) - } - } - )+}; -} - -random_id! { - /// Handle for a pending registration, between `register/start` and `register/finish`. - RegistrationId as "registration_id"; - - /// Handle for a login handshake, between `login/start` and `login/finish`. - LoginId as "login_id"; -} - -uuid_id! { - /// A login session; the refresh-token family hangs off it. - SessionId; - - /// A device registered to an account. - DeviceId; -} - -impl RegistrationId { - pub const fn as_bytes(&self) -> &[u8; LEN] { - &self.0 - } -} +use keygo_core::UserId; /// What OPAQUE binds the password file to: registration, login and step-up must all agree on it. pub const fn opaque_identifier(user_id: &UserId) -> &[u8] { @@ -117,33 +8,7 @@ pub const fn opaque_identifier(user_id: &UserId) -> &[u8] { #[cfg(test)] mod tests { use super::*; - - #[test] - fn random_ids_differ() { - assert_ne!(RegistrationId::random(), RegistrationId::random()); - } - - #[test] - fn base64_round_trips() { - let id = RegistrationId::random(); - - assert_eq!(RegistrationId::from_base64(&id.to_base64()), Ok(id)); - } - - #[test] - fn serializes_as_unpadded_base64url() { - let id = RegistrationId([0xff; LEN]); - - assert_eq!(serde_json::to_value(id).unwrap(), "_____________________w"); - } - - #[test] - fn rejects_wrong_length_and_alphabet() { - assert!(RegistrationId::from_base64(&URL_SAFE_NO_PAD.encode([0; 15])).is_err()); - assert!(RegistrationId::from_base64(&URL_SAFE_NO_PAD.encode([0; 17])).is_err()); - assert!(RegistrationId::from_base64("+++++++++++++++++++++w").is_err()); - assert!(RegistrationId::from_base64("_____________________w==").is_err()); - } + use uuid::Uuid; #[test] fn opaque_identifier_is_pinned() { @@ -166,11 +31,4 @@ mod tests { user_id ); } - - #[test] - fn error_names_the_field() { - let err = LoginId::from_base64("").unwrap_err(); - - assert!(err.to_string().starts_with("login_id ")); - } } diff --git a/rust/crates/keygo-server/src/domain/mod.rs b/rust/crates/keygo-server/src/domain/mod.rs index 1d77121e3..702585eef 100644 --- a/rust/crates/keygo-server/src/domain/mod.rs +++ b/rust/crates/keygo-server/src/domain/mod.rs @@ -1,27 +1,22 @@ mod access_token; -mod device; mod ids; mod invite_code; mod invite_hash; mod invite_id; -mod key_bundle; -mod sealed_blob; mod session; -mod string_enum; mod time; -mod username; #[cfg(test)] pub use access_token::FRESH_AUTH_WINDOW; -pub use access_token::{ACCESS_TOKEN_LIFETIME, AccessToken, AccessTokenKey, Claims, TokenIssuer}; -pub use device::{Device, DeviceClaim, DeviceInfo}; -pub use ids::{DeviceId, LoginId, RegistrationId, SessionId, UserId, opaque_identifier}; +pub use access_token::{ACCESS_TOKEN_LIFETIME, AccessTokenKey, Claims, TokenIssuer}; +pub use ids::opaque_identifier; pub use invite_code::{InviteCode, InvitePepper}; pub use invite_hash::InviteHash; pub use invite_id::InviteId; -pub use key_bundle::KeyBundle; -pub use sealed_blob::InvalidBlob; -pub use sealed_blob::{SealedBlob, check_wrapped_ark}; -pub use session::{REFRESH_TTL, RefreshToken, RevokeReason, SESSION_LIFETIME, SESSION_RETENTION}; +pub use keygo_api::domain::{ + AccessToken, Device, DeviceClaim, DeviceInfo, InvalidBlob, KeyBundle, LoginId, RefreshToken, + RegistrationId, RevokeReason, Username, UsernameError, check_wrapped_ark, +}; +pub use keygo_core::{DeviceId, SessionId, UserId}; +pub use session::{REFRESH_TTL, SESSION_LIFETIME, SESSION_RETENTION}; pub use time::unix_now; -pub use username::{Username, UsernameError}; diff --git a/rust/crates/keygo-server/src/domain/session.rs b/rust/crates/keygo-server/src/domain/session.rs index 1c79ccca3..adb631ac5 100644 --- a/rust/crates/keygo-server/src/domain/session.rs +++ b/rust/crates/keygo-server/src/domain/session.rs @@ -1,234 +1,5 @@ -use super::string_enum::string_enum; -use base64::Engine; -use base64::engine::general_purpose::URL_SAFE_NO_PAD; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use sha2::{Digest, Sha256}; -use std::str::FromStr; use std::time::Duration; -use thiserror::Error; -use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing}; pub const SESSION_LIFETIME: Duration = Duration::from_hours(180 * 24); pub const REFRESH_TTL: Duration = Duration::from_hours(30 * 24); pub const SESSION_RETENTION: Duration = Duration::from_hours(30 * 24); - -const PREFIX: &str = "kgr_"; -const TOKEN_BYTES: usize = 32; -const ENCODED_LEN: usize = PREFIX.len() - + base64::encoded_len(TOKEN_BYTES, false).expect("encoded length can be represented by usize"); - -string_enum! { - pub enum RevokeReason { - Replaced => "replaced", - ReuseDetected => "reuse_detected", - Logout => "logout", - } -} - -#[derive(Zeroize, ZeroizeOnDrop)] -pub struct RefreshToken([u8; TOKEN_BYTES]); - -impl RefreshToken { - pub fn generate() -> Self { - let mut token = [0u8; TOKEN_BYTES]; - getrandom::fill(token.as_mut_slice()).expect("OS random number generator unavailable"); - Self(token) - } - - pub fn expose_encoded(&self) -> Zeroizing { - let mut out = Zeroizing::new(String::with_capacity(ENCODED_LEN)); - out.push_str(PREFIX); - URL_SAFE_NO_PAD.encode_string(self.0, &mut out); - out - } - - pub fn digest(&self) -> [u8; TOKEN_BYTES] { - Sha256::digest(self.0).into() - } -} - -impl Serialize for RefreshToken { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - serializer.serialize_str(&self.expose_encoded()) - } -} - -#[derive(Debug, Error)] -pub enum ParseRefreshTokenError { - #[error("invalid prefix")] - InvalidPrefix, - #[error("invalid token")] - InvalidToken, -} - -impl FromStr for RefreshToken { - type Err = ParseRefreshTokenError; - - fn from_str(s: &str) -> Result { - let Some(token) = s.strip_prefix(PREFIX) else { - return Err(ParseRefreshTokenError::InvalidPrefix); - }; - - if token.len() != ENCODED_LEN - PREFIX.len() { - return Err(ParseRefreshTokenError::InvalidToken); - } - - let mut out = RefreshToken([0; TOKEN_BYTES]); - URL_SAFE_NO_PAD - .decode_slice(token, &mut out.0) - .map_err(|_| ParseRefreshTokenError::InvalidToken)?; - - Ok(out) - } -} - -impl<'de> Deserialize<'de> for RefreshToken { - fn deserialize>(deserializer: D) -> Result { - let text = Zeroizing::new(String::deserialize(deserializer)?); - text.parse().map_err(serde::de::Error::custom) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn generated_tokens_differ() { - assert_ne!( - RefreshToken::generate().digest(), - RefreshToken::generate().digest(), - ); - } - - #[test] - fn encodes_as_prefixed_unpadded_base64url() { - let encoded = RefreshToken([0xff; TOKEN_BYTES]).expose_encoded(); - - assert_eq!( - encoded.as_str(), - "kgr___________________________________________8" - ); - assert_eq!(encoded.len(), ENCODED_LEN); - } - - #[test] - fn encoding_round_trips_the_secret() { - let token = RefreshToken::generate(); - let encoded = token.expose_encoded(); - - let raw = URL_SAFE_NO_PAD - .decode(encoded.strip_prefix(PREFIX).unwrap()) - .unwrap(); - - assert_eq!(raw, token.0); - } - - #[test] - fn serializes_as_the_encoded_token() { - let token = RefreshToken::generate(); - - assert_eq!( - serde_json::to_value(&token).unwrap(), - token.expose_encoded().as_str(), - ); - } - - #[test] - fn revoke_reason_round_trips_its_stored_name() { - for &reason in RevokeReason::ALL { - assert_eq!(reason.as_str().parse::().unwrap(), reason); - } - assert!("logout_typo".parse::().is_err()); - } - - #[test] - fn parse_round_trips_the_encoding() { - let token = RefreshToken::generate(); - - let parsed: RefreshToken = token.expose_encoded().parse().unwrap(); - - assert_eq!(parsed.0, token.0); - } - - #[test] - fn parse_rejects_a_missing_prefix() { - let encoded = RefreshToken::generate().expose_encoded(); - let unprefixed = encoded.strip_prefix(PREFIX).unwrap(); - - assert!(matches!( - unprefixed.parse::(), - Err(ParseRefreshTokenError::InvalidPrefix), - )); - assert!(matches!( - format!("kga_{unprefixed}").parse::(), - Err(ParseRefreshTokenError::InvalidPrefix), - )); - } - - #[test] - fn parse_rejects_the_wrong_length() { - let encoded = RefreshToken::generate().expose_encoded(); - - for text in [ - &encoded[..ENCODED_LEN - 1], - &format!("{}A", encoded.as_str()), - ] { - assert!(matches!( - text.parse::(), - Err(ParseRefreshTokenError::InvalidToken), - )); - } - } - - #[test] - fn parse_rejects_non_base64url() { - let text = format!("{PREFIX}{}", "+".repeat(ENCODED_LEN - PREFIX.len())); - - assert!(matches!( - text.parse::(), - Err(ParseRefreshTokenError::InvalidToken), - )); - } - - #[test] - fn parse_rejects_non_canonical_trailing_bits() { - // Same bytes as the canonical "…8", but the unused low bits of the last char are set. - let text = "kgr___________________________________________9"; - - assert!(matches!( - text.parse::(), - Err(ParseRefreshTokenError::InvalidToken), - )); - } - - #[test] - fn deserializes_from_the_encoded_token() { - let token = RefreshToken::generate(); - let json = serde_json::to_value(&token).unwrap(); - - let parsed: RefreshToken = serde_json::from_value(json).unwrap(); - - assert_eq!(parsed.0, token.0); - } - - #[test] - fn deserialize_rejects_a_malformed_token() { - assert!(serde_json::from_str::(r#""kgr_short""#).is_err()); - assert!( - serde_json::from_value::(serde_json::json!(vec![0u8; TOKEN_BYTES])) - .is_err() - ); - } - - #[test] - fn digest_is_sha256_of_the_raw_secret() { - assert_eq!( - hex::encode(RefreshToken([0; TOKEN_BYTES]).digest()), - "66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925", - ); - } -} diff --git a/rust/crates/keygo-server/src/lib.rs b/rust/crates/keygo-server/src/lib.rs new file mode 100644 index 000000000..650046ebf --- /dev/null +++ b/rust/crates/keygo-server/src/lib.rs @@ -0,0 +1,11 @@ +pub mod api; +mod cache; +pub mod cli; +mod config; +mod db; +mod domain; +mod secrets; +mod server; +mod service; +#[cfg(any(test, feature = "test-support"))] +pub mod testing; diff --git a/rust/crates/keygo-server/src/main.rs b/rust/crates/keygo-server/src/main.rs index fc5831e21..097e7cd88 100644 --- a/rust/crates/keygo-server/src/main.rs +++ b/rust/crates/keygo-server/src/main.rs @@ -1,18 +1,6 @@ -use crate::cli::Cli; +use keygo_server::cli::Cli; use std::process::ExitCode; -mod api; -mod cache; -mod cli; -mod config; -mod db; -mod domain; -mod secrets; -mod server; -mod service; -#[cfg(test)] -mod testing; - fn main() -> ExitCode { match Cli::start() { Ok(()) => ExitCode::SUCCESS, diff --git a/rust/crates/keygo-server/src/service/registration/finish.rs b/rust/crates/keygo-server/src/service/registration/finish.rs index 8b4ab13c8..5f0f9d2b7 100644 --- a/rust/crates/keygo-server/src/service/registration/finish.rs +++ b/rust/crates/keygo-server/src/service/registration/finish.rs @@ -80,12 +80,13 @@ pub async fn finish( #[cfg(test)] mod tests { use super::*; - use crate::domain::{SealedBlob, UserId}; + use crate::domain::UserId; use crate::service::registration::{self, Signup, StartRegistration, Started}; use crate::testing::{ JKT, PASSWORD, WRAPPED_ARK, count, create_invite, device_info, expire, invite_only, key_bundle, token_issuer, username, }; + use keygo_core::Sealed; use keygo_opaque::client::ClientRegistration; use keygo_opaque::server::ServerSetup; use uuid::Uuid; @@ -190,7 +191,7 @@ mod tests { let input = started_with(&db, &invite_only(), Some(&code), UserId::random(), "ada").await; let input = FinishRegistration { key_bundle: KeyBundle { - wrapped_ark: SealedBlob::from_bytes(&[7; 59]).unwrap(), + wrapped_ark: Sealed::from_bytes(&[7; 59]).unwrap(), }, ..input }; diff --git a/rust/crates/keygo-server/src/testing.rs b/rust/crates/keygo-server/src/testing.rs index 95f10ed6f..86dd242b8 100644 --- a/rust/crates/keygo-server/src/testing.rs +++ b/rust/crates/keygo-server/src/testing.rs @@ -3,7 +3,7 @@ use crate::cache::{LoginStates, StepUpStates}; use crate::db::{devices, invites, sessions, users}; use crate::domain::{ AccessTokenKey, DeviceClaim, DeviceId, DeviceInfo, InviteHash, InvitePepper, KeyBundle, - SealedBlob, SessionId, TokenIssuer, UserId, Username, + SessionId, TokenIssuer, UserId, Username, }; use crate::service::login::{self, FinishLogin, StartLogin}; use crate::service::registration::{self, FinishRegistration, Signup, StartRegistration}; @@ -13,6 +13,7 @@ use axum::body::Body; use axum::http::header::AUTHORIZATION; use axum::http::{HeaderMap, Request, StatusCode}; use http_body_util::BodyExt; +use keygo_core::{AccountRootKey, Sealed}; use keygo_dpop::DpopVerifier; use keygo_dpop::testing::TestSigner; use keygo_dpop::{DpopProver, Htm, ProofRequest}; @@ -51,7 +52,7 @@ pub fn device_claim(id: Option) -> DeviceClaim { } pub fn key_bundle_json() -> Value { - json!({ "wrapped_ark": SealedBlob::from_bytes(&WRAPPED_ARK).unwrap() }) + json!({ "wrapped_ark": Sealed::::from_bytes(&WRAPPED_ARK).unwrap() }) } pub fn key_bundle() -> KeyBundle { serde_json::from_value(key_bundle_json()).unwrap() diff --git a/rust/crates/keygo-uniffi/Cargo.toml b/rust/crates/keygo-uniffi/Cargo.toml index 3c385a069..b1758bb1d 100644 --- a/rust/crates/keygo-uniffi/Cargo.toml +++ b/rust/crates/keygo-uniffi/Cargo.toml @@ -8,9 +8,21 @@ name = "keygo_bindings" crate-type = ["cdylib"] [dependencies] +keygo-api = { path = "../keygo-api" } keygo-client = { path = "../keygo-client" } +keygo-dpop = { path = "../keygo-dpop" } thiserror.workspace = true uuid.workspace = true +zeroize.workspace = true +# Not used directly: gives uniffi's tokio runtime a worker pool, so a slow call cannot block the rest. +async-compat = { version = "0.2.6", features = ["multi-thread"] } +async-trait = "0.1.89" tokio = { workspace = true, features = ["rt", "rt-multi-thread"] } uniffi = { workspace = true, features = ["tokio"] } +url = "2.5.8" + +[dev-dependencies] +keygo-client = { path = "../keygo-client", features = ["test-support"] } +keygo-dpop = { path = "../keygo-dpop", features = ["test-support"] } +tokio = { workspace = true, features = ["macros", "sync", "time"] } diff --git a/rust/crates/keygo-uniffi/src/ark_session.rs b/rust/crates/keygo-uniffi/src/ark_session.rs index 4a18d2aa7..00b44fb76 100644 --- a/rust/crates/keygo-uniffi/src/ark_session.rs +++ b/rust/crates/keygo-uniffi/src/ark_session.rs @@ -11,6 +11,8 @@ use std::sync::Arc; pub enum ArkSessionError { #[error("No active session")] Locked, + #[error("Session holds a different account")] + AccountMismatch, #[error("Wrong password")] WrongPassword, #[error("Key derivation failed: {0}")] @@ -25,6 +27,7 @@ impl From for ArkSessionError { fn from(value: CoreArkSessionError) -> Self { match value { CoreArkSessionError::Locked => Self::Locked, + CoreArkSessionError::AccountMismatch => Self::AccountMismatch, CoreArkSessionError::WrongPassword => Self::WrongPassword, CoreArkSessionError::Derivation(e) => Self::Derivation(e.to_string()), CoreArkSessionError::KeyWrap(CryptoError::DecryptionFailed) => Self::DecryptionFailed, diff --git a/rust/crates/keygo-uniffi/src/lib.rs b/rust/crates/keygo-uniffi/src/lib.rs index f82cb37a7..dcb181d56 100644 --- a/rust/crates/keygo-uniffi/src/lib.rs +++ b/rust/crates/keygo-uniffi/src/lib.rs @@ -4,6 +4,7 @@ mod card; mod item; mod key_wrap; mod passkey; +mod sync; mod totp; mod types; mod vault; diff --git a/rust/crates/keygo-uniffi/src/sync.rs b/rust/crates/keygo-uniffi/src/sync.rs new file mode 100644 index 000000000..1c9984a92 --- /dev/null +++ b/rust/crates/keygo-uniffi/src/sync.rs @@ -0,0 +1,739 @@ +use crate::ark_session::ArkSession; +use async_trait::async_trait; +use keygo_api::domain::{AppVersion, Device, DeviceInfo, DeviceName, Platform}; +use keygo_api::meta::ServerInfo; +use keygo_client::crypto::{DeviceId, UserId}; +use keygo_client::sync::{ + Account as CoreAccount, Header, HttpRequest as CoreHttpRequest, HttpResponse, + SignError as CoreSignError, StoredSession as CoreStoredSession, SyncClient as CoreSyncClient, + SyncError as CoreSyncError, SyncResult, TokenStore as CoreTokenStore, + TokenStoreError as CoreTokenStoreError, Transport as CoreTransport, + TransportError as CoreTransportError, +}; +use keygo_dpop::{DpopSigner, Signature, VerifyingKey}; +use std::fmt::Display; +use std::sync::Arc; +use url::Url; +use zeroize::Zeroizing; + +#[derive(Debug, thiserror::Error, uniffi::Error)] +pub enum SyncError { + #[error("invalid credentials")] + InvalidCredentials, + #[error("invalid username")] + InvalidUsername, + #[error("username taken")] + UsernameTaken, + #[error("invite required")] + InviteRequired, + #[error("invite invalid")] + InviteInvalid, + #[error("fresh authentication required")] + FreshAuthRequired, + /// `reason` is the wire value: `replaced`, `reuse_detected` or `logout`. + #[error("signed out")] + SignedOut { reason: Option }, + #[error("rate limited")] + RateLimited, + #[error("vault locked")] + VaultLocked, + /// The account signed in to holds a different ARK than the unlocked local vault. + #[error("account mismatch")] + AccountMismatch, + #[error("network error: {reason}")] + Network { reason: String }, + #[error("server error {code}: {reason}")] + Server { code: String, reason: String }, + #[error("client error: {reason}")] + Client { reason: String }, + #[error("{reason}")] + InvalidUrl { reason: String }, +} + +impl From for SyncError { + fn from(value: CoreSyncError) -> Self { + match value { + CoreSyncError::InvalidCredentials => Self::InvalidCredentials, + CoreSyncError::InvalidUsername => Self::InvalidUsername, + CoreSyncError::UsernameTaken => Self::UsernameTaken, + CoreSyncError::InviteRequired => Self::InviteRequired, + CoreSyncError::InviteInvalid => Self::InviteInvalid, + CoreSyncError::FreshAuthRequired => Self::FreshAuthRequired, + CoreSyncError::SignedOut { reason } => Self::SignedOut { + reason: reason.map(|r| r.as_str().to_owned()), + }, + CoreSyncError::RateLimited => Self::RateLimited, + CoreSyncError::VaultLocked => Self::VaultLocked, + CoreSyncError::AccountMismatch => Self::AccountMismatch, + CoreSyncError::Network { message } => Self::Network { reason: message }, + CoreSyncError::Server { code, message } => Self::Server { + code, + reason: message, + }, + CoreSyncError::Client { message } => Self::Client { reason: message }, + CoreSyncError::InvalidUrl(e) => Self::InvalidUrl { + reason: e.to_string(), + }, + } + } +} + +macro_rules! callback_error { + ($($name:ident => $core:ident),+ $(,)?) => {$( + #[derive(Debug, thiserror::Error, uniffi::Error)] + pub enum $name { + #[error("{reason}")] + Failed { reason: String }, + } + + impl From for $name { + fn from(error: uniffi::UnexpectedUniFFICallbackError) -> Self { + Self::Failed { + reason: error.reason, + } + } + } + + impl From<$name> for $core { + fn from(error: $name) -> Self { + let $name::Failed { reason } = error; + Self { message: reason } + } + } + )+}; +} + +callback_error!( + TransportError => CoreTransportError, + SignError => CoreSignError, + TokenStoreError => CoreTokenStoreError, +); + +#[uniffi::remote(Record)] +pub struct Header { + pub name: String, + pub value: String, +} + +#[derive(uniffi::Record)] +pub struct HttpRequest { + pub method: String, + pub url: String, + pub headers: Vec
, + pub body: Vec, +} + +impl From for HttpRequest { + fn from(request: CoreHttpRequest) -> Self { + Self { + method: request.method.as_str().to_owned(), + url: request.url, + headers: request.headers, + body: request.body, + } + } +} + +#[uniffi::remote(Record)] +pub struct HttpResponse { + pub status: u16, + pub headers: Vec
, + pub body: Vec, +} + +#[derive(uniffi::Record)] +pub struct StoredSession { + pub device_id: DeviceId, + pub refresh_token: String, + pub refresh_expires_at: u64, +} + +impl From<&CoreStoredSession> for StoredSession { + fn from(session: &CoreStoredSession) -> Self { + Self { + device_id: session.device_id, + refresh_token: session.refresh_token.expose_encoded().to_string(), + refresh_expires_at: session.refresh_expires_at, + } + } +} + +#[derive(uniffi::Record)] +pub struct DeviceDetails { + pub name: String, + pub app_version: String, +} + +impl DeviceDetails { + fn into_core(self) -> Result { + Ok(DeviceInfo { + name: DeviceName::parse(&self.name).map_err(invalid_device)?, + platform: Platform::Android, + app_version: AppVersion::parse(&self.app_version).map_err(invalid_device)?, + }) + } +} + +fn invalid_device(error: impl Display) -> SyncError { + SyncError::Client { + reason: format!("invalid device details: {error}"), + } +} + +#[derive(uniffi::Record)] +pub struct SyncDevice { + pub id: DeviceId, + pub name: String, + pub platform: String, + pub app_version: String, + pub created_at: u64, + pub last_seen_at: u64, + pub auth_time: Option, + pub logged_in: bool, +} + +impl From for SyncDevice { + fn from(device: Device) -> Self { + Self { + id: device.id, + name: device.info.name.as_str().to_owned(), + platform: device.info.platform.as_str().to_owned(), + app_version: device.info.app_version.as_str().to_owned(), + created_at: device.created_at, + last_seen_at: device.last_seen_at, + auth_time: device.auth_time, + logged_in: device.logged_in, + } + } +} + +#[uniffi::remote(Record)] +pub struct ServerInfo { + pub version: String, + pub public_url: String, + pub allow_signups: bool, +} + +#[derive(uniffi::Record)] +pub struct Account { + pub user_id: UserId, + pub username: String, + pub device_id: DeviceId, +} + +impl From for Account { + fn from(account: CoreAccount) -> Self { + Self { + user_id: account.user_id, + username: account.username.as_str().to_owned(), + device_id: account.device_id, + } + } +} + +/// The host owns TLS, timeouts and pooling. It must not retry, follow auth challenges or log bodies. +#[uniffi::export(with_foreign)] +#[async_trait] +pub trait HttpTransport: Send + Sync { + async fn send(&self, request: HttpRequest) -> Result; +} + +/// A hardware-backed P-256 key held by the host. +#[uniffi::export(with_foreign)] +pub trait DpopKey: Send + Sync { + /// The 65-byte uncompressed P-256 point. + fn public_key(&self) -> Result, SignError>; + + /// SHA256withECDSA over `message`, DER encoded. Can be called from several threads at once. + fn sign(&self, message: Vec) -> Result, SignError>; +} + +#[uniffi::export(with_foreign)] +#[async_trait] +pub trait TokenStore: Send + Sync { + async fn load(&self) -> Result, TokenStoreError>; + async fn save(&self, session: StoredSession) -> Result<(), TokenStoreError>; + async fn clear(&self) -> Result<(), TokenStoreError>; +} + +struct TransportAdapter(Arc); + +#[async_trait] +impl CoreTransport for TransportAdapter { + async fn send(&self, request: CoreHttpRequest) -> Result { + Ok(self.0.send(request.into()).await?) + } +} + +struct ForeignSigner { + key: Arc, + verifying: VerifyingKey, +} + +impl ForeignSigner { + fn new(key: Arc) -> Result { + let public_key = key.public_key().map_err(|e| SyncError::Client { + reason: format!("could not read the DPoP public key: {e}"), + })?; + let verifying = + VerifyingKey::from_sec1_bytes(&public_key).map_err(|_| SyncError::Client { + reason: "the DPoP public key is not a P-256 point".into(), + })?; + Ok(Self { key, verifying }) + } +} + +impl DpopSigner for ForeignSigner { + type Error = CoreSignError; + + fn verifying_key(&self) -> &VerifyingKey { + &self.verifying + } + + fn sign(&self, msg: &[u8]) -> Result { + let der = self.key.sign(msg.to_vec())?; + Signature::from_der(&der).map_err(|_| CoreSignError { + message: "the DPoP signature is not DER".into(), + }) + } +} + +struct StoreAdapter(Arc); + +#[async_trait] +impl CoreTokenStore for StoreAdapter { + /// A token that no longer parses counts as no session, so the user just signs in again. + async fn load(&self) -> Result, CoreTokenStoreError> { + let Some(stored) = self.0.load().await? else { + return Ok(None); + }; + let refresh_token = Zeroizing::new(stored.refresh_token); + Ok(refresh_token + .parse() + .ok() + .map(|refresh_token| CoreStoredSession { + device_id: stored.device_id, + refresh_token, + refresh_expires_at: stored.refresh_expires_at, + })) + } + + async fn save(&self, session: &CoreStoredSession) -> Result<(), CoreTokenStoreError> { + Ok(self.0.save(session.into()).await?) + } + + async fn clear(&self) -> Result<(), CoreTokenStoreError> { + Ok(self.0.clear().await?) + } +} + +#[derive(uniffi::Object)] +pub struct SyncClient { + inner: Arc, +} + +async fn detached( + call: impl Future> + Send + 'static, +) -> Result { + tokio::spawn(call) + .await + .map_err(|_| SyncError::Client { + reason: "the sync task did not finish".into(), + })? + .map_err(Into::into) +} + +#[uniffi::export(async_runtime = "tokio")] +impl SyncClient { + #[uniffi::constructor] + pub fn new( + base_url: String, + transport: Arc, + dpop_key: Arc, + tokens: Arc, + ) -> Result, SyncError> { + let base_url = Url::parse(&base_url).map_err(|e| SyncError::Client { + reason: format!("invalid server url: {e}"), + })?; + let inner = CoreSyncClient::new( + base_url, + Arc::new(TransportAdapter(transport)), + Arc::new(ForeignSigner::new(dpop_key)?), + Arc::new(StoreAdapter(tokens)), + )?; + Ok(Arc::new(Self { + inner: Arc::new(inner), + })) + } + + pub async fn meta(self: Arc) -> Result { + detached(async move { self.inner.meta().await }).await + } + + /// `user_id` must be the local account's id; see the core `SyncClient::register`. + pub async fn register( + self: Arc, + ark_session: Arc, + user_id: UserId, + username: String, + password: String, + invite: Option, + device: DeviceDetails, + ) -> Result { + let password = Zeroizing::new(password); + let device = device.into_core()?; + let account = detached(async move { + self.inner + .register( + &ark_session.session, + user_id, + username, + &password, + invite, + device, + ) + .await + }) + .await?; + Ok(account.into()) + } + + /// Unlocks a locked `ark_session` with the server's copy of the ARK; an unlocked one must hold + /// the same ARK, or this fails with `AccountMismatch`. See the core `SyncClient::login`. + pub async fn login( + self: Arc, + ark_session: Arc, + username: String, + password: String, + device: DeviceDetails, + ) -> Result { + let password = Zeroizing::new(password); + let device = device.into_core()?; + let account = detached(async move { + self.inner + .login(&ark_session.session, username, &password, device) + .await + }) + .await?; + Ok(account.into()) + } + + pub async fn step_up(self: Arc, password: String) -> Result<(), SyncError> { + let password = Zeroizing::new(password); + detached(async move { self.inner.step_up(&password).await }).await + } + + pub async fn devices(self: Arc) -> Result, SyncError> { + let devices = detached(async move { self.inner.devices().await }).await?; + Ok(devices.into_iter().map(SyncDevice::from).collect()) + } + + pub async fn delete_device(self: Arc, id: DeviceId) -> Result<(), SyncError> { + detached(async move { self.inner.delete_device(id).await }).await + } + + pub async fn logout(self: Arc) -> Result<(), SyncError> { + detached(async move { self.inner.logout().await }).await + } +} + +#[cfg(test)] +mod tests { + use super::*; + use keygo_api::Method; + use keygo_api::domain::RevokeReason; + use keygo_dpop::testing::TestSigner; + use std::sync::Mutex; + use std::time::Duration; + use tokio::sync::Notify; + use tokio::time::timeout; + + const STORED_TOKEN: &str = "kgr___________________________________________8"; + const ROTATED_TOKEN: &str = "kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; + const ROTATED_SESSION: &str = r#"{"device_id":"00000000-0000-0000-0000-000000000001","access_token":"a.b.c","access_expires_in":300,"refresh_token":"kgr_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","refresh_expires_in":86400}"#; + + #[derive(Default)] + struct MemoryStore { + session: Mutex>, + saved: Notify, + } + + impl MemoryStore { + fn holding(refresh_token: &str) -> Arc { + Arc::new(Self { + session: Mutex::new(Some(StoredSession { + device_id: DeviceId::random(), + refresh_token: refresh_token.into(), + refresh_expires_at: u64::MAX, + })), + saved: Notify::new(), + }) + } + + fn refresh_token(&self) -> Option { + let session = self.session.lock().unwrap(); + session.as_ref().map(|s| s.refresh_token.clone()) + } + } + + #[async_trait] + impl TokenStore for MemoryStore { + async fn load(&self) -> Result, TokenStoreError> { + let session = self.session.lock().unwrap(); + Ok(session.as_ref().map(|s| StoredSession { + device_id: s.device_id, + refresh_token: s.refresh_token.clone(), + refresh_expires_at: s.refresh_expires_at, + })) + } + + async fn save(&self, session: StoredSession) -> Result<(), TokenStoreError> { + *self.session.lock().unwrap() = Some(session); + self.saved.notify_one(); + Ok(()) + } + + async fn clear(&self) -> Result<(), TokenStoreError> { + *self.session.lock().unwrap() = None; + Ok(()) + } + } + + struct PanickingStore; + + #[async_trait] + impl TokenStore for PanickingStore { + async fn load(&self) -> Result, TokenStoreError> { + panic!("the store blew up") + } + + async fn save(&self, _: StoredSession) -> Result<(), TokenStoreError> { + unreachable!() + } + + async fn clear(&self) -> Result<(), TokenStoreError> { + unreachable!() + } + } + + #[derive(Default)] + struct RecordingTransport { + methods: Mutex>, + } + + #[async_trait] + impl HttpTransport for RecordingTransport { + async fn send(&self, request: HttpRequest) -> Result { + self.methods.lock().unwrap().push(request.method); + Ok(HttpResponse { + status: 204, + headers: Vec::new(), + body: Vec::new(), + }) + } + } + + #[derive(Default)] + struct GatedTransport { + reached: Notify, + release: Notify, + } + + #[async_trait] + impl HttpTransport for GatedTransport { + async fn send(&self, _: HttpRequest) -> Result { + self.reached.notify_one(); + self.release.notified().await; + Ok(HttpResponse { + status: 200, + headers: Vec::new(), + body: ROTATED_SESSION.as_bytes().to_vec(), + }) + } + } + + struct TestKey(TestSigner); + + impl DpopKey for TestKey { + fn public_key(&self) -> Result, SignError> { + Ok(self.0.public_key_sec1()) + } + + fn sign(&self, message: Vec) -> Result, SignError> { + Ok(self.0.sign_der(&message)) + } + } + + struct ShortKey; + + impl DpopKey for ShortKey { + fn public_key(&self) -> Result, SignError> { + Ok(vec![1, 2, 3]) + } + + fn sign(&self, _: Vec) -> Result, SignError> { + unreachable!() + } + } + + struct ThrowingKey; + + impl DpopKey for ThrowingKey { + fn public_key(&self) -> Result, SignError> { + Err(SignError::Failed { + reason: "the keystore is locked".into(), + }) + } + + fn sign(&self, _: Vec) -> Result, SignError> { + unreachable!() + } + } + + fn client(transport: Arc, tokens: Arc) -> Arc { + SyncClient::new( + "https://kg.example".into(), + transport, + Arc::new(TestKey(TestSigner::new())), + tokens, + ) + .unwrap() + } + + #[tokio::test] + async fn corrupt_refresh_token_loads_as_no_session() { + let adapter = StoreAdapter(MemoryStore::holding("garbage")); + + assert!(adapter.load().await.unwrap().is_none()); + } + + #[tokio::test] + async fn stored_session_round_trips_through_the_adapter() { + let adapter = StoreAdapter(Arc::new(MemoryStore::default())); + let device_id = DeviceId::random(); + + adapter + .save(&CoreStoredSession { + device_id, + refresh_token: STORED_TOKEN.parse().unwrap(), + refresh_expires_at: 99, + }) + .await + .unwrap(); + let loaded = adapter.load().await.unwrap().unwrap(); + + assert_eq!(loaded.refresh_token.expose_encoded().as_str(), STORED_TOKEN); + assert_eq!(loaded.device_id, device_id); + assert_eq!(loaded.refresh_expires_at, 99); + } + + #[test] + fn signed_out_carries_the_wire_reason() { + let error = SyncError::from(CoreSyncError::SignedOut { + reason: Some(RevokeReason::ReuseDetected), + }); + + assert!(matches!( + error, + SyncError::SignedOut { reason } if reason.as_deref() == Some("reuse_detected"), + )); + } + + #[test] + fn device_details_reject_control_characters() { + let device = DeviceDetails { + name: "a\u{202e}b".into(), + app_version: "2.3.0".into(), + }; + + assert!(matches!(device.into_core(), Err(SyncError::Client { .. }),)); + } + + #[tokio::test] + async fn transport_adapter_passes_method_as_text() { + let transport = Arc::new(RecordingTransport::default()); + let adapter = TransportAdapter(transport.clone()); + + adapter + .send(CoreHttpRequest { + method: Method::Delete, + url: "https://kg.example/api/v1/devices/1".into(), + headers: Vec::new(), + body: Vec::new(), + }) + .await + .unwrap(); + + assert_eq!(*transport.methods.lock().unwrap(), ["DELETE"]); + } + + /// A cancelled Kotlin coroutine drops the future, but the rotated token must still reach the store. + #[tokio::test] + async fn a_dropped_call_still_finishes() { + let transport = Arc::new(GatedTransport::default()); + let store = MemoryStore::holding(STORED_TOKEN); + let client = client(transport.clone(), store.clone()); + + let mut call = Box::pin(client.devices()); + tokio::select! { + _ = &mut call => panic!("the call finished before the transport answered"), + () = transport.reached.notified() => {}, + } + drop(call); + transport.release.notify_one(); + + timeout(Duration::from_secs(5), store.saved.notified()) + .await + .expect("the dropped call never saved the rotated token"); + assert_eq!(store.refresh_token().as_deref(), Some(ROTATED_TOKEN)); + } + + #[tokio::test] + async fn a_panicking_call_is_a_client_error() { + let client = client( + Arc::new(RecordingTransport::default()), + Arc::new(PanickingStore), + ); + + assert!(matches!( + client.devices().await, + Err(SyncError::Client { .. }), + )); + } + + #[test] + fn a_throwing_public_key_is_a_client_error() { + let result = SyncClient::new( + "https://kg.example".into(), + Arc::new(RecordingTransport::default()), + Arc::new(ThrowingKey), + Arc::new(MemoryStore::default()), + ); + + assert!(matches!(result, Err(SyncError::Client { .. }))); + } + + #[test] + fn bad_public_key_is_rejected_at_construction() { + let result = SyncClient::new( + "https://kg.example".into(), + Arc::new(RecordingTransport::default()), + Arc::new(ShortKey), + Arc::new(MemoryStore::default()), + ); + + assert!(matches!(result, Err(SyncError::Client { .. }))); + } + + #[test] + fn foreign_signer_decodes_what_a_keystore_produces() { + let expected = TestSigner::new(); + let signer = ForeignSigner::new(Arc::new(TestKey(TestSigner::new()))).unwrap(); + + assert_eq!(signer.verifying_key(), expected.verifying_key()); + assert_eq!( + signer.sign(b"message").unwrap(), + expected.sign(b"message").unwrap(), + ); + } +} diff --git a/rust/crates/keygo-uniffi/src/types.rs b/rust/crates/keygo-uniffi/src/types.rs index 295acb49f..fac485ebc 100644 --- a/rust/crates/keygo-uniffi/src/types.rs +++ b/rust/crates/keygo-uniffi/src/types.rs @@ -1,4 +1,6 @@ -use keygo_client::crypto::{ItemId, ItemKey, KeyMaterial, NamespaceId, UserId, VaultId, VaultKey}; +use keygo_client::crypto::{ + DeviceId, ItemId, ItemKey, KeyMaterial, NamespaceId, UserId, VaultId, VaultKey, +}; use uuid::Uuid; uniffi::custom_type!(Uuid, String, { @@ -31,6 +33,12 @@ uniffi::custom_type!(NamespaceId, Uuid, { lower: |id| id.0, }); +uniffi::custom_type!(DeviceId, Uuid, { + remote, + try_lift: |u| Ok(DeviceId(u)), + lower: |id| id.0, +}); + uniffi::custom_type!(VaultKey, Vec, { remote, try_lift: |bytes| VaultKey::from_bytes(&bytes).map_err(|e| uniffi::deps::anyhow::anyhow!("{e}")), diff --git a/settings.gradle.kts b/settings.gradle.kts index 82d2505ab..a713d6c9e 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -37,6 +37,7 @@ include(":core:security") include(":core:biometrics") include(":core:ui") include(":core:rust") +include(":core:sync") include(":feature:credentials") include(":feature:list_screen") include(":feature:item:core")