memos/store/test/attachment_access_test.go

317 lines
14 KiB
Go

package test
import (
"context"
"fmt"
"testing"
"time"
"github.com/stretchr/testify/require"
"github.com/usememos/memos/store"
)
func TestAttachmentAccessScopeFiltersBeforePagination(t *testing.T) {
ctx := context.Background()
ts := NewTestingStore(ctx, t)
defer ts.Close()
owner, err := ts.CreateUser(ctx, &store.User{Username: "attachment-space-owner", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
member, err := ts.CreateUser(ctx, &store.User{Username: "attachment-space-member", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
space, err := ts.CreateSpace(ctx, &store.Space{UID: "attachment-space", Title: "Attachments"}, owner.ID)
require.NoError(t, err)
_, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID)
require.NoError(t, err)
root, err := ts.CreateMemo(ctx, &store.Memo{UID: "attachment-space-root", CreatorID: owner.ID, Content: "root", Visibility: store.SpaceAudience, SpaceID: &space.ID})
require.NoError(t, err)
comment, err := ts.CreateMemoComment(ctx, &store.Memo{
UID: "attachment-space-comment", CreatorID: owner.ID, Content: "comment", Visibility: store.SpaceAudience, SpaceID: &space.ID,
}, root.ID, owner.ID)
require.NoError(t, err)
unlinked, err := ts.CreateAttachment(ctx, &store.Attachment{UID: "attachment-unlinked", CreatorID: member.ID, Filename: "unlinked.txt", Type: "text/plain", Size: 1, Blob: []byte("u")})
require.NoError(t, err)
linked, err := ts.CreateAttachment(ctx, &store.Attachment{UID: "attachment-linked", CreatorID: member.ID, Filename: "linked.txt", Type: "text/plain", Size: 1, Blob: []byte("l"), MemoID: &comment.ID})
require.NoError(t, err)
older, newer := time.Now().Unix()-20, time.Now().Unix()-10
require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ID: unlinked.ID, UpdatedTs: &older}))
require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ID: linked.ID, UpdatedTs: &newer}))
require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: member.ID}, owner.ID))
limit, offset := 1, 0
attachments, err := ts.ListAttachments(ctx, &store.FindAttachment{
CreatorID: &member.ID,
Access: &store.MemoAccessScope{
UserID: &member.ID,
AllowPublic: true,
AllowProtected: true,
},
Limit: &limit,
Offset: &offset,
})
require.NoError(t, err)
require.Len(t, attachments, 1)
require.Equal(t, unlinked.ID, attachments[0].ID, "the inaccessible newer row must be removed before LIMIT is applied")
}
func TestAttachmentAccessScopeUsesDirectMemoAudience(t *testing.T) {
ctx := context.Background()
ts := NewTestingStore(ctx, t)
defer ts.Close()
owner, err := ts.CreateUser(ctx, &store.User{Username: "attachment-local-owner", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
contextMemo, err := ts.CreateMemo(ctx, &store.Memo{
UID: "attachment-local-context", CreatorID: owner.ID, Content: "private context", Visibility: store.Private,
})
require.NoError(t, err)
publicComment, err := ts.CreateMemoComment(ctx, &store.Memo{
UID: "attachment-local-public", CreatorID: owner.ID, Content: "public reply", Visibility: store.Public,
}, contextMemo.ID, owner.ID)
require.NoError(t, err)
privateComment, err := ts.CreateMemoComment(ctx, &store.Memo{
UID: "attachment-local-private", CreatorID: owner.ID, Content: "private reply", Visibility: store.Private,
}, contextMemo.ID, owner.ID)
require.NoError(t, err)
publicAttachment, err := ts.CreateAttachment(ctx, &store.Attachment{
UID: "attachment-local-public-file", CreatorID: owner.ID, Filename: "public.txt", Type: "text/plain", MemoID: &publicComment.ID,
})
require.NoError(t, err)
_, err = ts.CreateAttachment(ctx, &store.Attachment{
UID: "attachment-local-private-file", CreatorID: owner.ID, Filename: "private.txt", Type: "text/plain", MemoID: &privateComment.ID,
})
require.NoError(t, err)
attachments, err := ts.ListAttachments(ctx, &store.FindAttachment{
Access: &store.MemoAccessScope{AllowPublic: true},
SkipDefaultLimit: true,
})
require.NoError(t, err)
require.Len(t, attachments, 1)
require.Equal(t, publicAttachment.ID, attachments[0].ID, "the context memo must not grant or restrict attachment access")
}
func TestAttachmentAccessScopeSpaceAudienceHasNoMemoAuthorBypass(t *testing.T) {
ctx := context.Background()
ts := NewTestingStore(ctx, t)
defer ts.Close()
author, err := ts.CreateUser(ctx, &store.User{Username: "attachment-removed-author", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
admin, err := ts.CreateUser(ctx, &store.User{Username: "attachment-remaining-admin", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
space, err := ts.CreateSpace(ctx, &store.Space{UID: "attachment-author-space", Title: "Author attachment access"}, author.ID)
require.NoError(t, err)
_, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: admin.ID, Role: store.SpaceMemberRoleAdmin}, author.ID)
require.NoError(t, err)
memo, err := ts.CreateMemo(ctx, &store.Memo{
UID: "attachment-author-memo", CreatorID: author.ID, Content: "members", Visibility: store.SpaceAudience, SpaceID: &space.ID,
})
require.NoError(t, err)
_, err = ts.CreateAttachment(ctx, &store.Attachment{
UID: "attachment-author-file", CreatorID: author.ID, Filename: "members.txt", Type: "text/plain", MemoID: &memo.ID,
})
require.NoError(t, err)
require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: author.ID}, admin.ID))
attachments, err := ts.ListAttachments(ctx, &store.FindAttachment{
CreatorID: &author.ID,
Access: &store.MemoAccessScope{UserID: &author.ID, AllowPublic: true, AllowProtected: true},
SkipDefaultLimit: true,
})
require.NoError(t, err)
require.Empty(t, attachments)
}
func TestAttachmentAccessScopeAllowsArchivedMemoCreatorAndFiltersMissingCreator(t *testing.T) {
ctx := context.Background()
ts := NewTestingStore(ctx, t)
defer ts.Close()
creator, err := ts.CreateUser(ctx, &store.User{Username: "attachment-archived-memo-creator", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
attachmentOwner, err := ts.CreateUser(ctx, &store.User{Username: "attachment-creator-viewer", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
validMemo, err := ts.CreateMemo(ctx, &store.Memo{
UID: "attachment-archived-creator-memo", CreatorID: creator.ID, Content: "valid", Visibility: store.Public,
})
require.NoError(t, err)
validAttachment, err := ts.CreateAttachment(ctx, &store.Attachment{
UID: "attachment-archived-creator-file", CreatorID: attachmentOwner.ID, Filename: "valid.txt", Type: "text/plain", MemoID: &validMemo.ID,
})
require.NoError(t, err)
archived := store.Archived
_, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: creator.ID, RowStatus: &archived})
require.NoError(t, err)
attachments, err := ts.ListAttachments(ctx, &store.FindAttachment{
Access: &store.MemoAccessScope{AllowPublic: true},
SkipDefaultLimit: true,
})
require.NoError(t, err)
require.Equal(t, []int32{validAttachment.ID}, attachmentIDs(attachments),
"attachments keep following an active memo's audience when its creator is archived")
corruptMemo, err := ts.CreateMemo(ctx, &store.Memo{
UID: "attachment-missing-creator-memo", CreatorID: attachmentOwner.ID, Content: "corrupt", Visibility: store.Public,
})
require.NoError(t, err)
_, err = ts.CreateAttachment(ctx, &store.Attachment{
UID: "attachment-missing-creator-file", CreatorID: attachmentOwner.ID, Filename: "corrupt.txt", Type: "text/plain", MemoID: &corruptMemo.ID,
})
require.NoError(t, err)
_, err = ts.GetDriver().GetDB().ExecContext(ctx,
fmt.Sprintf("UPDATE memo SET creator_id = 2147483000 WHERE id = %d", corruptMemo.ID))
require.NoError(t, err)
attachments, err = ts.ListAttachments(ctx, &store.FindAttachment{
Access: &store.MemoAccessScope{AllowPublic: true},
SkipDefaultLimit: true,
})
require.NoError(t, err)
require.Equal(t, []int32{validAttachment.ID}, attachmentIDs(attachments),
"an attachment must not reveal a memo whose creator cannot be resolved")
}
func TestAttachmentWritePolicyRevalidatesMemoSpaceMembership(t *testing.T) {
ctx := context.Background()
ts := NewTestingStore(ctx, t)
defer ts.Close()
owner, err := ts.CreateUser(ctx, &store.User{Username: "attachment-write-owner", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
member, err := ts.CreateUser(ctx, &store.User{Username: "attachment-write-member", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
space, err := ts.CreateSpace(ctx, &store.Space{UID: "attachment-write-space", Title: "Attachment Writes"}, owner.ID)
require.NoError(t, err)
_, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID)
require.NoError(t, err)
root, err := ts.CreateMemo(ctx, &store.Memo{
UID: "attachment-write-root", CreatorID: member.ID, Content: "root", Visibility: store.SpaceAudience, SpaceID: &space.ID,
})
require.NoError(t, err)
target, err := ts.CreateMemoComment(ctx, &store.Memo{
UID: "attachment-write-comment", CreatorID: member.ID, Content: "comment", Visibility: store.SpaceAudience, SpaceID: &space.ID,
}, root.ID, member.ID)
require.NoError(t, err)
secondTarget, err := ts.CreateMemoComment(ctx, &store.Memo{
UID: "attachment-write-second-comment", CreatorID: member.ID, Content: "second", Visibility: store.SpaceAudience, SpaceID: &space.ID,
}, root.ID, member.ID)
require.NoError(t, err)
policy := memoWritePolicy(member.ID, false)
unlinked, err := ts.CreateAttachment(ctx, &store.Attachment{
UID: "attachment-policy-unlinked", CreatorID: member.ID, Filename: "unlinked.txt", Type: "text/plain",
})
require.NoError(t, err)
unlinkedRename := "unlinked-renamed.txt"
require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{
ID: unlinked.ID, Filename: &unlinkedRename, Policy: policy,
}))
attachment, err := ts.CreateAttachment(ctx, &store.Attachment{
UID: "attachment-policy-linked",
CreatorID: member.ID,
Filename: "linked.txt",
Type: "text/plain",
Size: 1,
Blob: []byte("a"),
MemoID: &target.ID,
Policy: policy,
})
require.NoError(t, err)
renamed := "renamed.txt"
require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{
ID: attachment.ID, Filename: &renamed, Policy: policy,
}))
foreignAttachment, err := ts.CreateAttachment(ctx, &store.Attachment{
UID: "attachment-policy-foreign-owner",
CreatorID: owner.ID,
Filename: "foreign.txt",
Type: "text/plain",
MemoID: &target.ID,
})
require.NoError(t, err)
foreignRename := "must-not-rename-foreign.txt"
err = ts.UpdateAttachment(ctx, &store.UpdateAttachment{
ID: foreignAttachment.ID, Filename: &foreignRename, Policy: policy,
})
require.ErrorIs(t, err, store.ErrMemoPermissionDenied)
storedForeign, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &foreignAttachment.ID})
require.NoError(t, err)
require.Equal(t, "foreign.txt", storedForeign.Filename)
// A trusted internal caller can still rebind legacy data. A later transport
// update discovers and authorizes the current binding in its transaction.
require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ID: attachment.ID, MemoID: &secondTarget.ID}))
currentBindingRename := "current-binding.txt"
err = ts.UpdateAttachment(ctx, &store.UpdateAttachment{
ID: attachment.ID, Filename: &currentBindingRename, Policy: policy,
})
require.NoError(t, err)
stored, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID})
require.NoError(t, err)
require.Equal(t, currentBindingRename, stored.Filename)
require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ID: attachment.ID, MemoID: &target.ID}))
archived := store.Archived
_, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: member.ID, RowStatus: &archived})
require.NoError(t, err)
_, err = ts.CreateAttachment(ctx, &store.Attachment{
UID: "attachment-policy-archived-actor",
CreatorID: member.ID,
Filename: "archived.txt",
Type: "text/plain",
MemoID: &target.ID,
Policy: policy,
})
require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired)
archivedRename := "archived-must-not-rename.txt"
err = ts.UpdateAttachment(ctx, &store.UpdateAttachment{
ID: unlinked.ID, Filename: &archivedRename, Policy: policy,
})
require.ErrorIs(t, err, store.ErrMemoPermissionDenied)
normal := store.Normal
_, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: member.ID, RowStatus: &normal})
require.NoError(t, err)
require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: member.ID}, owner.ID))
_, err = ts.CreateAttachment(ctx, &store.Attachment{
UID: "attachment-policy-revoked-create",
CreatorID: member.ID,
Filename: "revoked.txt",
Type: "text/plain",
MemoID: &target.ID,
Policy: policy,
})
require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired)
revokedRename := "revoked-rename.txt"
err = ts.UpdateAttachment(ctx, &store.UpdateAttachment{
ID: attachment.ID, Filename: &revokedRename, Policy: policy,
})
require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired)
stored, err = ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID})
require.NoError(t, err)
require.Equal(t, currentBindingRename, stored.Filename)
_, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID)
require.NoError(t, err)
restoredRename := "restored-membership.txt"
err = ts.UpdateAttachment(ctx, &store.UpdateAttachment{
ID: attachment.ID, Filename: &restoredRename, Policy: policy,
})
require.NoError(t, err)
stored, err = ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID})
require.NoError(t, err)
require.Equal(t, restoredRename, stored.Filename)
}
func attachmentIDs(attachments []*store.Attachment) []int32 {
ids := make([]int32, 0, len(attachments))
for _, attachment := range attachments {
ids = append(ids, attachment.ID)
}
return ids
}