Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Keep Space links consistent during key rotation

Neeraj Gupta98d768feb253
diff --git a/rust/space/src/client/keys.rs b/rust/space/src/client/keys.rs
index c30cb932f5..353a9a6ea7 100644
--- a/rust/space/src/client/keys.rs
+++ b/rust/space/src/client/keys.rs
@@ -105,7 +105,7 @@ impl AccountSpaceCtx {
};
let next_space_key = generate_key();
let space_root_key = self.get_or_create_space_root_key().await?;
- let link_encrypted_space_key = self.active_link_wrapper(space_id, &next_space_key).await?;
+ let link_rotation = self.active_link_wrapper(space_id, &next_space_key).await?;
let request = RotateSpaceKeyRequest {
key_version: current.key_version,
root_wrapped_space_key: b64::encode(&encrypt_secretbox_payload(
@@ -120,7 +120,8 @@ impl AccountSpaceCtx {
&next_space_key,
&next_profile,
)?),
- link_encrypted_space_key,
+ expected_link_id: Some(link_rotation.expected_link_id),
+ link_encrypted_space_key: link_rotation.encrypted_space_key,
};
let path = format!("/spaces/{space_id}/rotate");
let response = self
diff --git a/rust/space/src/client/links.rs b/rust/space/src/client/links.rs
index 8bf15d89c7..48085e76ea 100644
--- a/rust/space/src/client/links.rs
+++ b/rust/space/src/client/links.rs
@@ -1,4 +1,4 @@
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, sync::Mutex};
use ente_core::{
b64,
@@ -6,7 +6,9 @@ use ente_core::{
http::Api,
};
-use super::{AccountSpaceCtx, build_api, build_space_key_history_map, decrypt_space_profile};
+use super::{
+ AccountSpaceCtx, build_api, build_space_key_history_map, cache_lock, decrypt_space_profile,
+};
use crate::{
crypto::{decrypt_asset_payload, decrypt_secretbox_payload, encrypt_secretbox_payload},
error::{Result, SpaceError},
@@ -30,13 +32,25 @@ struct DerivedLinkKeys {
wrap: Vec<u8>,
}
+struct SpaceLinkSnapshot {
+ profile: DecryptedSpaceProfile,
+ posts: i64,
+ key_history: BTreeMap<i32, Vec<u8>>,
+}
+
+pub(crate) struct SpaceLinkKeyRotation {
+ pub(crate) expected_link_id: i64,
+ pub(crate) encrypted_space_key: Option<String>,
+}
+
pub struct SpaceLinkCtx {
api: Api,
space_slug: String,
auth_key: String,
+ wrap_key: Vec<u8>,
profile: DecryptedSpaceProfile,
posts: i64,
- key_history: BTreeMap<i32, Vec<u8>>,
+ key_history: Mutex<BTreeMap<i32, Vec<u8>>>,
}
impl AccountSpaceCtx {
@@ -56,10 +70,18 @@ impl AccountSpaceCtx {
&self,
space_id: &str,
next_space_key: &[u8],
- ) -> Result<Option<String>> {
+ ) -> Result<SpaceLinkKeyRotation> {
let status = self.get_space_link_status(space_id).await?;
if !status.active {
- return Ok(None);
+ return Ok(SpaceLinkKeyRotation {
+ expected_link_id: 0,
+ encrypted_space_key: None,
+ });
+ }
+ if status.link_id <= 0 {
+ return Err(SpaceError::InvalidInput(
+ "active space link is missing its ID".into(),
+ ));
}
let access_key = self.decrypt_link_access_key(&status)?;
let keys = derive_link_keys(
@@ -68,10 +90,13 @@ impl AccountSpaceCtx {
status.kdf_mem_limit,
status.kdf_ops_limit,
)?;
- Ok(Some(b64::encode(&encrypt_secretbox_payload(
- &keys.wrap,
- next_space_key,
- )?)))
+ Ok(SpaceLinkKeyRotation {
+ expected_link_id: status.link_id,
+ encrypted_space_key: Some(b64::encode(&encrypt_secretbox_payload(
+ &keys.wrap,
+ next_space_key,
+ )?)),
+ })
}
async fn get_space_link_status(&self, space_id: &str) -> Result<SpaceLinkStatusResponse> {
@@ -190,42 +215,15 @@ impl SpaceLinkCtx {
bootstrap.kdf_ops_limit,
)?;
let auth_key = b64::encode(&keys.auth);
- let fetch_profile = async {
- Ok::<SpaceLinkProfileResponse, SpaceError>(
- api.get(&format!("{prefix}/profile"))
- .header(AUTH_HEADER, &auth_key)
- .send()
- .await?
- .error_for_status()?
- .json()
- .await?,
- )
- };
- let fetch_versions = async {
- Ok::<Vec<SpaceKeyVersionResponse>, SpaceError>(
- api.get(&format!("{prefix}/versions"))
- .header(AUTH_HEADER, &auth_key)
- .send()
- .await?
- .error_for_status()?
- .json()
- .await?,
- )
- };
- let (profile_response, versions): (SpaceLinkProfileResponse, Vec<SpaceKeyVersionResponse>) =
- futures_util::try_join!(fetch_profile, fetch_versions)?;
- let encrypted_space_key = b64::decode(&profile_response.encrypted_space_key)?;
- let space_key = decrypt_secretbox_payload(&keys.wrap, &encrypted_space_key)?;
- let profile = decrypt_space_profile(&profile_response.profile, &space_key)?;
- let key_history =
- build_space_key_history_map(profile_response.key_version, &space_key, &versions)?;
+ let snapshot = fetch_link_snapshot(&api, &prefix, &auth_key, &keys.wrap).await?;
Ok(Self {
api,
space_slug,
auth_key,
- profile,
- posts: profile_response.posts,
- key_history,
+ wrap_key: keys.wrap,
+ profile: snapshot.profile,
+ posts: snapshot.posts,
+ key_history: Mutex::new(snapshot.key_history),
})
}
@@ -238,7 +236,7 @@ impl SpaceLinkCtx {
}
pub async fn list_posts(&self) -> Result<PostPage> {
- Ok(self
+ let page: PostPage = self
.api
.get(&format!("{}/posts", self.prefix()))
.header(AUTH_HEADER, &self.auth_key)
@@ -246,16 +244,25 @@ impl SpaceLinkCtx {
.await?
.error_for_status()?
.json()
- .await?)
+ .await?;
+ if !self.has_keys_for_posts(&page)? {
+ let snapshot =
+ fetch_link_snapshot(&self.api, &self.prefix(), &self.auth_key, &self.wrap_key)
+ .await?;
+ *cache_lock(&self.key_history, "space link key history")? = snapshot.key_history;
+ }
+ if !self.has_keys_for_posts(&page)? {
+ return Err(SpaceError::InvalidInput(
+ "space link changed while posts were being loaded".into(),
+ ));
+ }
+ Ok(page)
}
pub fn decrypt_post(&self, post: &PostResponse) -> Result<DecryptedPost> {
- let space_key = self
- .key_history
- .get(&post.key_version)
- .ok_or_else(|| SpaceError::InvalidInput("missing space key for post".into()))?;
+ let space_key = self.space_key(post.key_version, "post")?;
let post_key =
- decrypt_secretbox_payload(space_key, &b64::decode(&post.encrypted_post_key)?)?;
+ decrypt_secretbox_payload(&space_key, &b64::decode(&post.encrypted_post_key)?)?;
let caption_plaintext = if post.caption_cipher.is_empty() {
None
} else {
@@ -276,11 +283,8 @@ impl SpaceLinkCtx {
key_version: i32,
object_key: &str,
) -> Result<Vec<u8>> {
- let space_key = self
- .key_history
- .get(&key_version)
- .ok_or_else(|| SpaceError::InvalidInput("missing space key for post".into()))?;
- let post_key = decrypt_secretbox_payload(space_key, &b64::decode(encrypted_post_key)?)?;
+ let space_key = self.space_key(key_version, "post")?;
+ let post_key = decrypt_secretbox_payload(&space_key, &b64::decode(encrypted_post_key)?)?;
self.download_asset(vec![("objectKey", object_key.to_owned())], &post_key)
.await
}
@@ -291,16 +295,13 @@ impl SpaceLinkCtx {
object_id: &str,
key_version: i32,
) -> Result<Vec<u8>> {
- let space_key = self
- .key_history
- .get(&key_version)
- .ok_or_else(|| SpaceError::InvalidInput("missing space key for profile".into()))?;
+ let space_key = self.space_key(key_version, "profile")?;
self.download_asset(
vec![
("assetType", asset_type.to_owned()),
("objectID", object_id.to_owned()),
],
- space_key,
+ &space_key,
)
.await
}
@@ -331,6 +332,72 @@ impl SpaceLinkCtx {
fn prefix(&self) -> String {
format!("/space/public/by-slug/{}/link", self.space_slug)
}
+
+ fn has_keys_for_posts(&self, page: &PostPage) -> Result<bool> {
+ let key_history = cache_lock(&self.key_history, "space link key history")?;
+ Ok(page
+ .items
+ .iter()
+ .all(|post| key_history.contains_key(&post.key_version)))
+ }
+
+ fn space_key(&self, key_version: i32, subject: &str) -> Result<Vec<u8>> {
+ cache_lock(&self.key_history, "space link key history")?
+ .get(&key_version)
+ .cloned()
+ .ok_or_else(|| SpaceError::InvalidInput(format!("missing space key for {subject}")))
+ }
+}
+
+async fn fetch_link_snapshot(
+ api: &Api,
+ prefix: &str,
+ auth_key: &str,
+ wrap_key: &[u8],
+) -> Result<SpaceLinkSnapshot> {
+ for _ in 0..2 {
+ let fetch_profile = async {
+ Ok::<SpaceLinkProfileResponse, SpaceError>(
+ api.get(&format!("{prefix}/profile"))
+ .header(AUTH_HEADER, auth_key)
+ .send()
+ .await?
+ .error_for_status()?
+ .json()
+ .await?,
+ )
+ };
+ let fetch_versions = async {
+ Ok::<Vec<SpaceKeyVersionResponse>, SpaceError>(
+ api.get(&format!("{prefix}/versions"))
+ .header(AUTH_HEADER, auth_key)
+ .send()
+ .await?
+ .error_for_status()?
+ .json()
+ .await?,
+ )
+ };
+ let (profile_response, versions) = futures_util::try_join!(fetch_profile, fetch_versions)?;
+ let current_version = profile_response.key_version;
+ let versions_current =
+ versions.iter().map(|version| version.version).max() == Some(current_version);
+ if profile_response.profile.version != current_version || !versions_current {
+ continue;
+ }
+ let encrypted_space_key = b64::decode(&profile_response.encrypted_space_key)?;
+ let space_key = decrypt_secretbox_payload(wrap_key, &encrypted_space_key)?;
+ let profile = decrypt_space_profile(&profile_response.profile, &space_key)?;
+ let key_history = build_space_key_history_map(current_version, &space_key, &versions)?;
+ return Ok(SpaceLinkSnapshot {
+ profile,
+ posts: profile_response.posts,
+ key_history,
+ });
+ }
+ Err(SpaceError::InvalidInput(
+ "space link changed while it was being opened".into(),
+ ))
}
fn validate_access_key(access_key: &str) -> Result<()> {
diff --git a/rust/space/src/transport.rs b/rust/space/src/transport.rs
index 739be5ddd2..a85fb54fc6 100644
--- a/rust/space/src/transport.rs
+++ b/rust/space/src/transport.rs
@@ -343,6 +343,8 @@ pub struct RotateSpaceKeyRequest {
pub wrapped_prev_key: String,
pub encrypted_profile: String,
#[serde(skip_serializing_if = "Option::is_none")]
+ pub expected_link_id: Option<i64>,
+ #[serde(skip_serializing_if = "Option::is_none")]
pub link_encrypted_space_key: Option<String>,
}
@@ -370,6 +372,8 @@ pub struct SpaceLinkWriteRequest {
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SpaceLinkStatusResponse {
+ #[serde(default)]
+ pub link_id: i64,
pub space_id: String,
pub space_slug: String,
pub active: bool,
diff --git a/server/space/controller/links.go b/server/space/controller/links.go
index d74c32dc90..481adb02f3 100644
--- a/server/space/controller/links.go
+++ b/server/space/controller/links.go
@@ -33,6 +33,7 @@ type LinksController struct {
func spaceLinkStatus(link *repo.SpaceLinkRecord) *models.SpaceLinkStatusResponse {
return &models.SpaceLinkStatusResponse{
+ LinkID: link.LinkID,
SpaceID: link.SpaceID,
SpaceSlug: link.SpaceSlug,
Active: link.Active,
@@ -176,17 +177,13 @@ func (c *LinksController) authorize(ctx *gin.Context, slug string) (*repo.SpaceL
return nil, nil, ente.ErrNotFound
}
sum := sha256.Sum256(authKey)
- link, err := c.LinksRepo.GetActiveBySlugAndAuthHash(ctx, strings.TrimSpace(slug), sum[:])
+ link, space, err := c.LinksRepo.GetActiveSpaceBySlugAndAuthHash(ctx, strings.TrimSpace(slug), sum[:])
if err != nil {
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
return nil, nil, ente.ErrNotFound
}
return nil, nil, err
}
- space, err := c.SpacesRepo.GetSpaceByID(ctx, link.SpaceID)
- if err != nil {
- return nil, nil, err
- }
return link, space, nil
}
diff --git a/server/space/controller/spaces.go b/server/space/controller/spaces.go
index df4f52a6b0..ea78063960 100644
--- a/server/space/controller/spaces.go
+++ b/server/space/controller/spaces.go
@@ -271,14 +271,25 @@ func (c *SpacesController) RotateKey(ctx context.Context, current *repo.SpaceRec
if err != nil {
return nil, err
}
+ if req.ExpectedLinkID != nil {
+ hasExpectedLink := *req.ExpectedLinkID > 0
+ if *req.ExpectedLinkID < 0 || hasExpectedLink != (len(linkEncryptedSpaceKey) > 0) {
+ return nil, ente.NewBadRequestWithMessage("expectedLinkId does not match linkEncryptedSpaceKey")
+ }
+ } else if len(linkEncryptedSpaceKey) > 0 {
+ return nil, ente.NewBadRequestWithMessage("expectedLinkId is required with linkEncryptedSpaceKey")
+ }
if req.KeyVersion != current.CurrentVersion {
return nil, ente.NewBadRequestWithMessage("keyVersion does not match current space version")
}
- space, err := c.SpacesRepo.RotateKey(ctx, current.SpaceID, req.KeyVersion, rootWrappedSpaceKey, wrappedPrevKey, encryptedProfile, linkEncryptedSpaceKey)
+ space, err := c.SpacesRepo.RotateKey(ctx, current.SpaceID, req.KeyVersion, rootWrappedSpaceKey, wrappedPrevKey, encryptedProfile, req.ExpectedLinkID, linkEncryptedSpaceKey)
if err != nil {
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
return nil, ente.NewBadRequestWithMessage("keyVersion does not match current space version")
}
+ if errors.Is(err, repo.ErrSpaceLinkStateChanged) {
+ return nil, ente.NewConflictError("active space link changed; retry space key rotation")
+ }
return nil, err
}
return toSpaceKeyResponse(space), nil
diff --git a/server/space/controller/test_helpers_test.go b/server/space/controller/test_helpers_test.go
index 01a58f19db..510ff0957c 100644
--- a/server/space/controller/test_helpers_test.go
+++ b/server/space/controller/test_helpers_test.go
@@ -39,7 +39,7 @@ func testUpdateProfile(ctx context.Context, module *spacerepo.Module, _ int64, s
}
func testRotateKey(ctx context.Context, module *spacerepo.Module, _ int64, spaceID string, keyVersion int, rootWrappedSpaceKey string, wrappedPrevKey string, encryptedProfile string) (*spacerepo.SpaceRecord, error) {
- return module.Spaces.RotateKey(ctx, spaceID, keyVersion, testSpaceBytes(rootWrappedSpaceKey), testSpaceBytes(wrappedPrevKey), testSpaceBytes(encryptedProfile), nil)
+ return module.Spaces.RotateKey(ctx, spaceID, keyVersion, testSpaceBytes(rootWrappedSpaceKey), testSpaceBytes(wrappedPrevKey), testSpaceBytes(encryptedProfile), nil, nil)
}
func testAddFriend(ctx context.Context, module *spacerepo.Module, requesterID int64, requesterSpaceID string, targetSpaceID string, targetFriendSealedSpaceKey string, targetKeyVersion int, requesterFriendSealedSpaceKey string, requesterKeyVersion int) error {
diff --git a/server/space/models/models.go b/server/space/models/models.go
index 1f5e885b5c..c671ba8878 100644
--- a/server/space/models/models.go
+++ b/server/space/models/models.go
@@ -92,6 +92,7 @@ type SpaceLinkWriteRequest struct {
}
type SpaceLinkStatusResponse struct {
+ LinkID int64 `json:"linkId,omitempty"`
SpaceID string `json:"spaceId"`
SpaceSlug string `json:"spaceSlug"`
Active bool `json:"active"`
@@ -241,6 +242,7 @@ type RotateSpaceKeyRequest struct {
RootWrappedSpaceKey string `json:"rootWrappedSpaceKey" binding:"required"`
WrappedPrevKey string `json:"wrappedPrevKey" binding:"required"`
EncryptedProfile string `json:"encryptedProfile" binding:"required"`
+ ExpectedLinkID *int64 `json:"expectedLinkId,omitempty"`
LinkEncryptedSpaceKey string `json:"linkEncryptedSpaceKey,omitempty"`
}
diff --git a/server/space/repo/links.go b/server/space/repo/links.go
index 890dceda15..56c26d9d96 100644
--- a/server/space/repo/links.go
+++ b/server/space/repo/links.go
@@ -11,6 +11,7 @@ import (
var (
ErrSpaceLinkSecretReused = errors.New("space link secret reused")
+ ErrSpaceLinkStateChanged = errors.New("space link state changed")
)
func isSpaceLinkUniqueViolation(err error, constraint string) bool {
@@ -20,9 +21,8 @@ func isSpaceLinkUniqueViolation(err error, constraint string) bool {
pgErr.Constraint == constraint
}
-func scanSpaceLink(scanner interface{ Scan(dest ...any) error }) (*SpaceLinkRecord, error) {
- var rec SpaceLinkRecord
- if err := scanner.Scan(
+func spaceLinkScanDest(rec *SpaceLinkRecord) []any {
+ return []any{
&rec.LinkID,
&rec.SpaceID,
&rec.SpaceSlug,
@@ -36,17 +36,26 @@ func scanSpaceLink(scanner interface{ Scan(dest ...any) error }) (*SpaceLinkReco
&rec.Active,
&rec.CreatedAt,
&rec.UpdatedAt,
- ); err != nil {
+ }
+}
+
+func scanSpaceLink(scanner interface{ Scan(dest ...any) error }) (*SpaceLinkRecord, error) {
+ var rec SpaceLinkRecord
+ if err := scanner.Scan(spaceLinkScanDest(&rec)...); err != nil {
return nil, stacktrace.Propagate(err, "")
}
return &rec, nil
}
+const spaceLinkSelectColumns = `
+ l.link_id, l.space_id, s.space_slug, l.auth_key_hash,
+ l.kdf_salt, l.kdf_mem_limit, l.kdf_ops_limit, l.key_version,
+ l.encrypted_space_key, l.encrypted_access_key, l.active,
+ l.created_at, l.updated_at
+`
+
const spaceLinkSelect = `
- SELECT l.link_id, l.space_id, s.space_slug, l.auth_key_hash,
- l.kdf_salt, l.kdf_mem_limit, l.kdf_ops_limit, l.key_version,
- l.encrypted_space_key, l.encrypted_access_key, l.active,
- l.created_at, l.updated_at
+ SELECT ` + spaceLinkSelectColumns + `
FROM space_links l
JOIN spaces s ON s.space_id = l.space_id
`
@@ -66,6 +75,26 @@ func (r *LinksRepository) GetActiveBySlugAndAuthHash(ctx context.Context, slug s
`, slug, authKeyHash))
}
+func (r *LinksRepository) GetActiveSpaceBySlugAndAuthHash(ctx context.Context, slug string, authKeyHash []byte) (*SpaceLinkRecord, *SpaceRecord, error) {
+ row := r.DB.QueryRowContext(ctx, `
+ SELECT `+spaceLinkSelectColumns+`, `+spaceRecordSelectColumns+`
+ FROM space_links l
+ JOIN spaces s ON s.space_id = l.space_id
+ `+spaceRecordProfileAssetJoins+`
+ JOIN users u ON u.user_id = s.owner_id AND u.encrypted_email IS NOT NULL
+ WHERE s.space_slug = LOWER($1)
+ AND l.auth_key_hash = $2
+ AND l.active = TRUE
+ `, slug, authKeyHash)
+ var link SpaceLinkRecord
+ var space SpaceRecord
+ dest := append(spaceLinkScanDest(&link), spaceRecordScanDest(&space)...)
+ if err := row.Scan(dest...); err != nil {
+ return nil, nil, stacktrace.Propagate(err, "")
+ }
+ return &link, &space, nil
+}
+
func (r *LinksRepository) GetActiveBootstrap(ctx context.Context, slug string) (*SpaceLinkRecord, error) {
return scanSpaceLink(r.DB.QueryRowContext(ctx, spaceLinkSelect+`
JOIN users u ON u.user_id = s.owner_id AND u.encrypted_email IS NOT NULL
diff --git a/server/space/repo/links_test.go b/server/space/repo/links_test.go
index 2052d0cdea..386ed2d515 100644
--- a/server/space/repo/links_test.go
+++ b/server/space/repo/links_test.go
@@ -81,7 +81,7 @@ func TestSpaceKeyRotationRewrapsOrDisablesActiveLink(t *testing.T) {
require.NoError(t, err)
auth := sha256.Sum256([]byte("rotation-auth-key"))
- _, err = module.Links.Create(
+ link, err := module.Links.Create(
ctx,
space.SpaceID,
auth[:],
@@ -93,6 +93,7 @@ func TestSpaceKeyRotationRewrapsOrDisablesActiveLink(t *testing.T) {
[]byte("encrypted-access-key"),
)
require.NoError(t, err)
+ expectedLinkID := link.LinkID
rotated, err := module.Spaces.RotateKey(
ctx,
@@ -101,10 +102,11 @@ func TestSpaceKeyRotationRewrapsOrDisablesActiveLink(t *testing.T) {
[]byte("root-v2"),
[]byte("wrapped-v1"),
[]byte("profile-v2"),
+ &expectedLinkID,
[]byte("encrypted-space-key-v2"),
)
require.NoError(t, err)
- link, err := module.Links.GetActive(ctx, space.SpaceID)
+ link, err = module.Links.GetActive(ctx, space.SpaceID)
require.NoError(t, err)
require.Equal(t, rotated.CurrentVersion, link.KeyVersion)
require.Equal(t, []byte("encrypted-space-key-v2"), link.EncryptedSpaceKey)
@@ -117,6 +119,7 @@ func TestSpaceKeyRotationRewrapsOrDisablesActiveLink(t *testing.T) {
[]byte("wrapped-v2"),
[]byte("profile-v3"),
nil,
+ nil,
)
require.NoError(t, err)
_, err = module.Links.GetActive(ctx, space.SpaceID)
diff --git a/server/space/repo/module_test.go b/server/space/repo/module_test.go
index 67af56d039..3b7e7dc276 100644
--- a/server/space/repo/module_test.go
+++ b/server/space/repo/module_test.go
@@ -125,7 +125,7 @@ func testUpdateProfile(ctx context.Context, module *Module, _ int64, spaceID str
}
func testRotateKey(ctx context.Context, module *Module, _ int64, spaceID string, keyVersion int, rootWrappedSpaceKey string, wrappedPrevKey string, encryptedProfile string) (*SpaceRecord, error) {
- return module.Spaces.RotateKey(ctx, spaceID, keyVersion, testSpaceBytes(rootWrappedSpaceKey), testSpaceBytes(wrappedPrevKey), testSpaceBytes(encryptedProfile), nil)
+ return module.Spaces.RotateKey(ctx, spaceID, keyVersion, testSpaceBytes(rootWrappedSpaceKey), testSpaceBytes(wrappedPrevKey), testSpaceBytes(encryptedProfile), nil, nil)
}
func testAddFriend(ctx context.Context, module *Module, requesterID int64, requesterSpaceID string, targetSpaceID string, targetFriendSealedSpaceKey string, targetKeyVersion int, requesterFriendSealedSpaceKey string, requesterKeyVersion int) error {
diff --git a/server/space/repo/spaces.go b/server/space/repo/spaces.go
index 02a65c29ff..9b4520f291 100644
--- a/server/space/repo/spaces.go
+++ b/server/space/repo/spaces.go
@@ -227,7 +227,7 @@ func (r *SpacesRepository) UpdateSlug(ctx context.Context, spaceID, spaceSlug st
return rec, nil
}
-func (r *SpacesRepository) RotateKey(ctx context.Context, spaceID string, keyVersion int, rootWrappedSpaceKey, wrappedPrevKey, encryptedProfile, linkEncryptedSpaceKey []byte) (*SpaceRecord, error) {
+func (r *SpacesRepository) RotateKey(ctx context.Context, spaceID string, keyVersion int, rootWrappedSpaceKey, wrappedPrevKey, encryptedProfile []byte, expectedLinkID *int64, linkEncryptedSpaceKey []byte) (*SpaceRecord, error) {
tx, err := r.DB.BeginTx(ctx, nil)
if err != nil {
return nil, stacktrace.Propagate(err, "")
@@ -263,14 +263,36 @@ func (r *SpacesRepository) RotateKey(ctx context.Context, spaceID string, keyVer
`, rootWrappedSpaceKey, encryptedProfile, newVersion, spaceID); err != nil {
return nil, stacktrace.Propagate(err, "")
}
- if len(linkEncryptedSpaceKey) > 0 {
- if _, err := tx.ExecContext(ctx, `
+ if expectedLinkID != nil && *expectedLinkID > 0 {
+ result, err := tx.ExecContext(ctx, `
UPDATE space_links
SET key_version = $2, encrypted_space_key = $3
- WHERE space_id = $1 AND active = TRUE
- `, spaceID, newVersion, linkEncryptedSpaceKey); err != nil {
+ WHERE space_id = $1 AND link_id = $4 AND active = TRUE
+ `, spaceID, newVersion, linkEncryptedSpaceKey, *expectedLinkID)
+ if err != nil {
+ return nil, stacktrace.Propagate(err, "")
+ }
+ updated, err := result.RowsAffected()
+ if err != nil {
+ return nil, stacktrace.Propagate(err, "")
+ }
+ if updated != 1 {
+ return nil, ErrSpaceLinkStateChanged
+ }
+ } else if expectedLinkID != nil {
+ var active bool
+ if err := tx.QueryRowContext(ctx, `
+ SELECT EXISTS (
+ SELECT 1
+ FROM space_links
+ WHERE space_id = $1 AND active = TRUE
+ )
+ `, spaceID).Scan(&active); err != nil {
return nil, stacktrace.Propagate(err, "")
}
+ if active {
+ return nil, ErrSpaceLinkStateChanged
+ }
} else {
if _, err := tx.ExecContext(ctx, `
UPDATE space_links
@@ -330,9 +352,8 @@ func (r *SpacesRepository) GetVersion(ctx context.Context, spaceID string, versi
return &rec, nil
}
-func scanSpaceRecord(scanner interface{ Scan(dest ...any) error }) (*SpaceRecord, error) {
- var rec SpaceRecord
- if err := scanner.Scan(
+func spaceRecordScanDest(rec *SpaceRecord) []any {
+ return []any{
&rec.SpaceID,
&rec.OwnerID,
&rec.SpaceSlug,
@@ -350,7 +371,12 @@ func scanSpaceRecord(scanner interface{ Scan(dest ...any) error }) (*SpaceRecord
&rec.CoverSize,
&rec.CreatedAt,
&rec.UpdatedAt,
- ); err != nil {
+ }
+}
+
+func scanSpaceRecord(scanner interface{ Scan(dest ...any) error }) (*SpaceRecord, error) {
+ var rec SpaceRecord
+ if err := scanner.Scan(spaceRecordScanDest(&rec)...); err != nil {
return nil, stacktrace.Propagate(err, "")
}
return &rec, nil