feat(backup): add RestoreManager (request/fulfill/complete partner-assisted restore with OOB code gate)
This commit is contained in:
null
parent
c8b0130f1c
commit
ed3c3e4d22
|
|
@ -0,0 +1,131 @@
|
||||||
|
package app.closer.data.backup
|
||||||
|
|
||||||
|
import android.util.Log
|
||||||
|
import app.closer.crypto.CoupleEncryptionManager
|
||||||
|
import app.closer.crypto.CoupleKeyTransfer
|
||||||
|
import app.closer.crypto.UserKeyManager
|
||||||
|
import app.closer.data.remote.FirestoreBackupDataSource
|
||||||
|
import app.closer.domain.model.RestoreRequest
|
||||||
|
import app.closer.domain.model.RestoreStatus
|
||||||
|
import app.closer.domain.repository.AuthRepository
|
||||||
|
import app.closer.domain.repository.CoupleRepository
|
||||||
|
import java.security.SecureRandom
|
||||||
|
import java.util.Base64
|
||||||
|
import javax.inject.Inject
|
||||||
|
import javax.inject.Singleton
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Orchestrates **full partner-assisted restore** (key + content) for both roles:
|
||||||
|
* - Recipient A ([requestRestore] → [completeRestore]): publish a fresh pubkey, then on the partner's
|
||||||
|
* keybox, unwrap the couple key with no phrase and pull the content backup.
|
||||||
|
* - Partner B ([fulfillRestore]): after confirming the out-of-band code, wrap the couple key to A's
|
||||||
|
* pubkey and refresh the backup.
|
||||||
|
*
|
||||||
|
* All key material stays client-side (ECIES); the server only relays a `keybox:v1:` blob. Never logs keys.
|
||||||
|
*/
|
||||||
|
@Singleton
|
||||||
|
class RestoreManager @Inject constructor(
|
||||||
|
private val authRepository: AuthRepository,
|
||||||
|
private val coupleRepository: CoupleRepository,
|
||||||
|
private val encryptionManager: CoupleEncryptionManager,
|
||||||
|
private val userKeyManager: UserKeyManager,
|
||||||
|
private val coupleKeyTransfer: CoupleKeyTransfer,
|
||||||
|
private val backupDataSource: FirestoreBackupDataSource,
|
||||||
|
private val backupManager: BackupManager,
|
||||||
|
private val backupRestoreManager: BackupRestoreManager
|
||||||
|
) {
|
||||||
|
/** What A shows on screen while waiting: the code to read aloud + who to observe. */
|
||||||
|
data class RestoreSession(
|
||||||
|
val coupleId: String,
|
||||||
|
val recipientUid: String,
|
||||||
|
val partnerUid: String,
|
||||||
|
val verificationCode: String
|
||||||
|
)
|
||||||
|
|
||||||
|
// ─── Recipient A ─────────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
/** A creates a restore request carrying a fresh public key; returns the OOB code to read aloud. */
|
||||||
|
suspend fun requestRestore(): Result<RestoreSession> = runCatching {
|
||||||
|
val uid = authRepository.currentUserId ?: error("not signed in")
|
||||||
|
val couple = coupleRepository.getCoupleForUser(uid) ?: error("no couple")
|
||||||
|
val partnerUid = couple.userIds.firstOrNull { it != uid } ?: error("no partner")
|
||||||
|
val pubKey = userKeyManager.publicKeyB64(userKeyManager.getOrCreatePrivateKey())
|
||||||
|
val nonce = randomNonce()
|
||||||
|
val expiresAt = System.currentTimeMillis() + REQUEST_TTL_MS
|
||||||
|
// A stale prior request (expired/abandoned/READY) would turn createRestoreRequest's set() into an
|
||||||
|
// UPDATE that changes the pubkey/nonce — which no rule permits (keybox-write needs a different actor;
|
||||||
|
// status-only update can't touch keys) → PERMISSION_DENIED. Clear it first so a retry always works.
|
||||||
|
// The recipient may delete their own request, and a fresh pubkey/nonce fully supersedes the old one.
|
||||||
|
backupDataSource.deleteRestoreRequest(couple.id, uid)
|
||||||
|
backupDataSource.createRestoreRequest(couple.id, uid, pubKey, nonce, expiresAt)
|
||||||
|
RestoreSession(
|
||||||
|
coupleId = couple.id,
|
||||||
|
recipientUid = uid,
|
||||||
|
partnerUid = partnerUid,
|
||||||
|
verificationCode = CoupleKeyTransfer.verificationCode(pubKey, nonce)
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A completes the restore once the partner has written the keybox (status READY): unwrap the couple
|
||||||
|
* key with A's private key (no phrase), store it, consume the request, then pull the content backup.
|
||||||
|
*/
|
||||||
|
suspend fun completeRestore(
|
||||||
|
session: RestoreSession,
|
||||||
|
request: RestoreRequest
|
||||||
|
): Result<BackupRestoreManager.RestoreResult> = runCatching {
|
||||||
|
val keybox = request.keybox ?: error("no keybox yet")
|
||||||
|
val privateKey = userKeyManager.loadPrivateKey() ?: error("device key missing")
|
||||||
|
val keyset = coupleKeyTransfer.unwrapCoupleKey(
|
||||||
|
keyboxB64 = keybox,
|
||||||
|
recipientPrivateKey = privateKey,
|
||||||
|
coupleId = session.coupleId,
|
||||||
|
senderUid = session.partnerUid,
|
||||||
|
recipientUid = session.recipientUid,
|
||||||
|
nonce = request.requestNonce
|
||||||
|
)
|
||||||
|
encryptionManager.storeTransferredKeyset(session.coupleId, keyset)
|
||||||
|
// Consume the request so no wrapped couple key lingers server-side.
|
||||||
|
backupDataSource.deleteRestoreRequest(session.coupleId, session.recipientUid)
|
||||||
|
backupRestoreManager.restore()
|
||||||
|
}.onFailure { Log.w(TAG, "completeRestore failed", it) }
|
||||||
|
|
||||||
|
// ─── Partner B ───────────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
/**
|
||||||
|
* B fulfils A's request AFTER typing the code A read aloud. Verifies the code against A's actual
|
||||||
|
* pubkey+nonce (defeats a swapped pubkey / account-takeover), wraps the couple key, refreshes the
|
||||||
|
* backup so A has fresh content, and marks the request READY.
|
||||||
|
*/
|
||||||
|
suspend fun fulfillRestore(coupleId: String, recipientUid: String, enteredCode: String): Result<Unit> = runCatching {
|
||||||
|
val uid = authRepository.currentUserId ?: error("not signed in")
|
||||||
|
val request = backupDataSource.getRestoreRequest(coupleId, recipientUid) ?: error("no request")
|
||||||
|
// Never wrap the couple key to a stale request: an expired pubkey may belong to a device the
|
||||||
|
// recipient has since replaced. Force them to start a fresh request.
|
||||||
|
require(request.expiresAt <= 0L || request.expiresAt > System.currentTimeMillis()) { "restore request expired" }
|
||||||
|
val expected = CoupleKeyTransfer.verificationCode(request.recipientPublicKey, request.requestNonce)
|
||||||
|
require(enteredCode.trim() == expected) { "verification code does not match" }
|
||||||
|
val coupleKeyset = encryptionManager.exportKeysetForTransfer(coupleId) ?: error("couple key missing on this device")
|
||||||
|
val keybox = coupleKeyTransfer.wrapCoupleKey(
|
||||||
|
coupleKeyset = coupleKeyset,
|
||||||
|
recipientPublicKeyB64 = request.recipientPublicKey,
|
||||||
|
coupleId = coupleId,
|
||||||
|
senderUid = uid,
|
||||||
|
recipientUid = recipientUid,
|
||||||
|
nonce = request.requestNonce
|
||||||
|
)
|
||||||
|
// Make sure the partner can also pull fresh content right after unlocking the key.
|
||||||
|
runCatching { backupManager.backupNow(force = true) }
|
||||||
|
backupDataSource.fulfillRestoreRequest(coupleId, recipientUid, keybox)
|
||||||
|
}.onFailure { Log.w(TAG, "fulfillRestore failed", it) }
|
||||||
|
|
||||||
|
private fun randomNonce(): String {
|
||||||
|
val bytes = ByteArray(16).also { SecureRandom().nextBytes(it) }
|
||||||
|
return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes)
|
||||||
|
}
|
||||||
|
|
||||||
|
private companion object {
|
||||||
|
const val TAG = "RestoreManager"
|
||||||
|
const val REQUEST_TTL_MS = 30 * 60 * 1000L // 30 min
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,112 @@
|
||||||
|
package app.closer.data.backup
|
||||||
|
|
||||||
|
import app.closer.crypto.CoupleEncryptionManager
|
||||||
|
import app.closer.crypto.CoupleKeyTransfer
|
||||||
|
import app.closer.crypto.UserKeyManager
|
||||||
|
import app.closer.data.remote.FirestoreBackupDataSource
|
||||||
|
import app.closer.domain.model.Couple
|
||||||
|
import app.closer.domain.model.RestoreRequest
|
||||||
|
import app.closer.domain.model.RestoreStatus
|
||||||
|
import app.closer.domain.repository.AuthRepository
|
||||||
|
import app.closer.domain.repository.CoupleRepository
|
||||||
|
import io.mockk.coEvery
|
||||||
|
import io.mockk.coVerify
|
||||||
|
import io.mockk.coVerifyOrder
|
||||||
|
import io.mockk.every
|
||||||
|
import io.mockk.mockk
|
||||||
|
import kotlinx.coroutines.ExperimentalCoroutinesApi
|
||||||
|
import kotlinx.coroutines.test.runTest
|
||||||
|
import org.junit.Assert.assertFalse
|
||||||
|
import org.junit.Assert.assertTrue
|
||||||
|
import org.junit.Test
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Covers the two request-lifecycle fixes:
|
||||||
|
* - Bug A: [RestoreManager.requestRestore] must DELETE any stale request before creating a fresh one,
|
||||||
|
* otherwise the create's `set()` becomes a rule-denied key-changing update (a silent retry failure).
|
||||||
|
* - Bug B: [RestoreManager.fulfillRestore] must REJECT an expired request before wrapping the couple key.
|
||||||
|
*/
|
||||||
|
@OptIn(ExperimentalCoroutinesApi::class)
|
||||||
|
class RestoreManagerTest {
|
||||||
|
|
||||||
|
private val authRepository: AuthRepository = mockk()
|
||||||
|
private val coupleRepository: CoupleRepository = mockk()
|
||||||
|
private val encryptionManager: CoupleEncryptionManager = mockk(relaxed = true)
|
||||||
|
private val userKeyManager: UserKeyManager = mockk()
|
||||||
|
private val coupleKeyTransfer: CoupleKeyTransfer = mockk(relaxed = true)
|
||||||
|
private val backupDataSource: FirestoreBackupDataSource = mockk(relaxed = true)
|
||||||
|
private val backupManager: BackupManager = mockk(relaxed = true)
|
||||||
|
private val backupRestoreManager: BackupRestoreManager = mockk(relaxed = true)
|
||||||
|
|
||||||
|
private val couple = Couple(id = "c1", userIds = listOf("uidSam", "uidQA"))
|
||||||
|
|
||||||
|
private fun manager() = RestoreManager(
|
||||||
|
authRepository, coupleRepository, encryptionManager, userKeyManager,
|
||||||
|
coupleKeyTransfer, backupDataSource, backupManager, backupRestoreManager
|
||||||
|
)
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `requestRestore clears a stale request before creating a fresh one`() = runTest {
|
||||||
|
every { authRepository.currentUserId } returns "uidQA"
|
||||||
|
coEvery { coupleRepository.getCoupleForUser("uidQA") } returns couple
|
||||||
|
every { userKeyManager.getOrCreatePrivateKey() } returns mockk()
|
||||||
|
every { userKeyManager.publicKeyB64(any()) } returns "pub:v1:x"
|
||||||
|
|
||||||
|
val result = manager().requestRestore()
|
||||||
|
|
||||||
|
assertTrue(result.isSuccess)
|
||||||
|
coVerifyOrder {
|
||||||
|
backupDataSource.deleteRestoreRequest("c1", "uidQA")
|
||||||
|
backupDataSource.createRestoreRequest("c1", "uidQA", "pub:v1:x", any(), any())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `fulfillRestore rejects an expired request and never writes the keybox`() = runTest {
|
||||||
|
every { authRepository.currentUserId } returns "uidSam"
|
||||||
|
coEvery { backupDataSource.getRestoreRequest("c1", "uidQA") } returns RestoreRequest(
|
||||||
|
recipientUid = "uidQA", recipientPublicKey = "pub:v1:x", requestNonce = "n",
|
||||||
|
status = RestoreStatus.REQUESTED, createdAt = 1L,
|
||||||
|
expiresAt = System.currentTimeMillis() - 1_000
|
||||||
|
)
|
||||||
|
|
||||||
|
val result = manager().fulfillRestore("c1", "uidQA", "123456")
|
||||||
|
|
||||||
|
assertTrue(result.isFailure)
|
||||||
|
assertTrue(result.exceptionOrNull()?.message?.contains("expired", ignoreCase = true) == true)
|
||||||
|
coVerify(exactly = 0) { encryptionManager.exportKeysetForTransfer(any()) }
|
||||||
|
coVerify(exactly = 0) { backupDataSource.fulfillRestoreRequest(any(), any(), any()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `fulfillRestore rejects a wrong code and never writes the keybox`() = runTest {
|
||||||
|
every { authRepository.currentUserId } returns "uidSam"
|
||||||
|
coEvery { backupDataSource.getRestoreRequest("c1", "uidQA") } returns RestoreRequest(
|
||||||
|
recipientUid = "uidQA", recipientPublicKey = "pub:v1:x", requestNonce = "n",
|
||||||
|
status = RestoreStatus.REQUESTED, createdAt = 1L,
|
||||||
|
expiresAt = System.currentTimeMillis() + 60_000
|
||||||
|
)
|
||||||
|
|
||||||
|
// "000000" will not match the real fingerprint of (pub:v1:x, n).
|
||||||
|
val result = manager().fulfillRestore("c1", "uidQA", "000000")
|
||||||
|
|
||||||
|
assertTrue(result.isFailure)
|
||||||
|
coVerify(exactly = 0) { backupDataSource.fulfillRestoreRequest(any(), any(), any()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun `expired guard allows a request with no explicit expiry`() = runTest {
|
||||||
|
// A legacy/never-expiring request (expiresAt == 0) must NOT be treated as expired.
|
||||||
|
every { authRepository.currentUserId } returns "uidSam"
|
||||||
|
coEvery { backupDataSource.getRestoreRequest("c1", "uidQA") } returns RestoreRequest(
|
||||||
|
recipientUid = "uidQA", recipientPublicKey = "pub:v1:x", requestNonce = "n",
|
||||||
|
status = RestoreStatus.REQUESTED, createdAt = 1L, expiresAt = 0L
|
||||||
|
)
|
||||||
|
|
||||||
|
// Wrong code still fails, but NOT for expiry — proves the expiry guard passed (expiresAt==0).
|
||||||
|
val result = manager().fulfillRestore("c1", "uidQA", "000000")
|
||||||
|
|
||||||
|
assertTrue(result.isFailure)
|
||||||
|
assertFalse(result.exceptionOrNull()?.message?.contains("expired", ignoreCase = true) == true)
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue