mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
1267 lines
48 KiB
Go
1267 lines
48 KiB
Go
package fileserver
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"encoding/base64"
|
||
"encoding/binary"
|
||
"fmt"
|
||
"hash/crc32"
|
||
"image"
|
||
"image/color"
|
||
"image/png"
|
||
"net/http"
|
||
"net/http/httptest"
|
||
"os"
|
||
"path/filepath"
|
||
"strings"
|
||
"testing"
|
||
"time"
|
||
|
||
"github.com/stretchr/testify/require"
|
||
"google.golang.org/protobuf/types/known/fieldmaskpb"
|
||
"google.golang.org/protobuf/types/known/timestamppb"
|
||
|
||
"github.com/usememos/memos/internal/httphandler"
|
||
"github.com/usememos/memos/internal/profile"
|
||
"github.com/usememos/memos/internal/random"
|
||
"github.com/usememos/memos/internal/testutil"
|
||
"github.com/usememos/memos/internal/testutil/fakes3"
|
||
"github.com/usememos/memos/markdown"
|
||
apipb "github.com/usememos/memos/proto/gen/api"
|
||
storepb "github.com/usememos/memos/proto/gen/store"
|
||
"github.com/usememos/memos/server/api"
|
||
"github.com/usememos/memos/server/auth"
|
||
"github.com/usememos/memos/store"
|
||
"github.com/usememos/memos/store/db"
|
||
teststore "github.com/usememos/memos/store/test"
|
||
)
|
||
|
||
// configureFakeS3Storage makes the fake S3 bucket "file-server-attachments"
|
||
// the instance's default attachment storage.
|
||
func configureFakeS3Storage(ctx context.Context, t *testing.T, stores *store.Store, fake *fakes3.Server) {
|
||
t.Helper()
|
||
configuredStorage := &storepb.Storage{
|
||
Id: "s3-files",
|
||
Name: "File server S3",
|
||
Type: storepb.StorageType_STORAGE_TYPE_S3,
|
||
Config: &storepb.Storage_S3Config{S3Config: fake.Config("file-server-attachments")},
|
||
}
|
||
_, err := stores.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{
|
||
Key: storepb.InstanceSettingKey_STORAGE,
|
||
Value: &storepb.InstanceSetting_StorageSetting{StorageSetting: &storepb.InstanceStorageSetting{
|
||
FilepathTemplate: "files/{uuid}_{filename}",
|
||
Storages: []*storepb.Storage{configuredStorage},
|
||
DefaultStorageId: configuredStorage.Id,
|
||
}},
|
||
})
|
||
require.NoError(t, err)
|
||
}
|
||
|
||
// configureLocalStorage makes the data directory the instance's default
|
||
// attachment storage.
|
||
func configureLocalStorage(ctx context.Context, t *testing.T, stores *store.Store) {
|
||
t.Helper()
|
||
_, err := stores.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{
|
||
Key: storepb.InstanceSettingKey_STORAGE,
|
||
Value: &storepb.InstanceSetting_StorageSetting{StorageSetting: &storepb.InstanceStorageSetting{
|
||
Storages: []*storepb.Storage{{Id: "local", Name: "Local", Type: storepb.StorageType_STORAGE_TYPE_LOCAL}},
|
||
DefaultStorageId: "local",
|
||
}},
|
||
})
|
||
require.NoError(t, err)
|
||
}
|
||
|
||
func TestServeAttachmentFile_S3(t *testing.T) {
|
||
ctx := context.Background()
|
||
fake := fakes3.New(t, "file-server-attachments")
|
||
svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
configureFakeS3Storage(ctx, t, stores, fake)
|
||
|
||
creator, err := stores.CreateUser(ctx, &store.User{
|
||
Username: "s3-file-owner",
|
||
Role: store.RoleUser,
|
||
Email: "s3-file-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
content := []byte("content streamed from S3")
|
||
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{Attachment: &apipb.Attachment{
|
||
Filename: "document.txt",
|
||
Type: "text/plain",
|
||
Content: content,
|
||
}})
|
||
require.NoError(t, err)
|
||
_, err = svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{Memo: &apipb.Memo{
|
||
Content: "public S3 attachment",
|
||
Visibility: apipb.Visibility_PUBLIC,
|
||
Attachments: []*apipb.Attachment{{Name: attachment.Name}},
|
||
}})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
recorder := httptest.NewRecorder()
|
||
e.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename), nil))
|
||
|
||
require.Equal(t, http.StatusOK, recorder.Code)
|
||
require.Equal(t, content, recorder.Body.Bytes())
|
||
require.Equal(t, "text/plain; charset=utf-8", recorder.Header().Get("Content-Type"))
|
||
|
||
// S3 cannot produce multipart range responses. The fileserver may ignore a
|
||
// Range request and send the complete representation instead of forwarding
|
||
// a request the backend rejects.
|
||
multiRangeRequest := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename), nil)
|
||
multiRangeRequest.Header.Set("Range", "bytes=0-2,5-7")
|
||
multiRangeRecorder := httptest.NewRecorder()
|
||
e.ServeHTTP(multiRangeRecorder, multiRangeRequest)
|
||
require.Equal(t, http.StatusOK, multiRangeRecorder.Code)
|
||
require.Equal(t, content, multiRangeRecorder.Body.Bytes())
|
||
require.Empty(t, multiRangeRecorder.Header().Get("Content-Range"))
|
||
}
|
||
|
||
// A failed media fetch must answer with the JSON error it actually is, not the
|
||
// attachment's media type: browsers route a Content-Type like application/pdf
|
||
// to their document viewer, which then reports a misleading "Failed to load
|
||
// PDF document" for the JSON body (usememos/memos#6515).
|
||
func TestServeAttachmentFile_StorageFailureIsAJSONError(t *testing.T) {
|
||
ctx := context.Background()
|
||
fake := fakes3.New(t, "file-server-attachments")
|
||
svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
configureFakeS3Storage(ctx, t, stores, fake)
|
||
|
||
creator, err := stores.CreateUser(ctx, &store.User{
|
||
Username: "s3-failure-owner",
|
||
Role: store.RoleUser,
|
||
Email: "s3-failure-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
|
||
var attachments []*apipb.Attachment
|
||
for _, spec := range []struct{ filename, contentType string }{
|
||
{"document.pdf", "application/pdf"},
|
||
{"archive.zip", "application/zip"},
|
||
} {
|
||
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{Attachment: &apipb.Attachment{
|
||
Filename: spec.filename,
|
||
Type: spec.contentType,
|
||
Content: []byte("s3 bytes"),
|
||
}})
|
||
require.NoError(t, err)
|
||
attachments = append(attachments, attachment)
|
||
}
|
||
_, err = svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{Memo: &apipb.Memo{
|
||
Content: "public S3 attachments",
|
||
Visibility: apipb.Visibility_PUBLIC,
|
||
Attachments: []*apipb.Attachment{{Name: attachments[0].Name}, {Name: attachments[1].Name}},
|
||
}})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
|
||
// Healthy PDFs keep their media type and are served inline so a new tab
|
||
// renders them in the browser's document viewer.
|
||
recorder := httptest.NewRecorder()
|
||
e.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s", attachments[0].Name, attachments[0].Filename), nil))
|
||
require.Equal(t, http.StatusOK, recorder.Code)
|
||
require.Equal(t, "application/pdf", recorder.Header().Get("Content-Type"))
|
||
require.Empty(t, recorder.Header().Get("Content-Disposition"))
|
||
|
||
// Drop the backing objects so the S3 reads fail after the handler has
|
||
// already prepared the attachments' media headers.
|
||
for _, attachment := range attachments {
|
||
uid := strings.TrimPrefix(attachment.Name, "attachments/")
|
||
stored, err := svc.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid})
|
||
require.NoError(t, err)
|
||
require.NoError(t, fake.DeleteObject("file-server-attachments", stored.Payload.GetS3Object().Key))
|
||
}
|
||
|
||
for _, attachment := range attachments {
|
||
recorder := httptest.NewRecorder()
|
||
e.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename), nil))
|
||
require.Equal(t, http.StatusInternalServerError, recorder.Code)
|
||
require.Equal(t, "application/json", recorder.Header().Get("Content-Type"))
|
||
require.Empty(t, recorder.Header().Get("Content-Disposition"))
|
||
require.Contains(t, recorder.Body.String(), "failed to stream from S3")
|
||
}
|
||
}
|
||
|
||
// External attachments store no blob; the file route answers with a redirect
|
||
// to the recorded external URL, for thumbnail requests as well as full reads,
|
||
// instead of an empty 200 body (usememos/memos#6573).
|
||
func TestServeAttachmentFile_ExternalAttachmentRedirectsToReference(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
creator, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "external-owner",
|
||
Role: store.RoleUser,
|
||
Email: "external-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
|
||
memo, err := svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{Memo: &apipb.Memo{
|
||
Content: "external attachment",
|
||
Visibility: apipb.Visibility_PUBLIC,
|
||
}})
|
||
require.NoError(t, err)
|
||
memoUID := strings.TrimPrefix(memo.Name, "memos/")
|
||
storedMemo, err := stores.GetMemo(ctx, &store.FindMemo{UID: &memoUID})
|
||
require.NoError(t, err)
|
||
require.NotNil(t, storedMemo)
|
||
|
||
// Memo import is the path that records EXTERNAL rows: the reference is
|
||
// the external URL and the row carries no blob.
|
||
attachment, err := stores.CreateAttachment(ctx, &store.Attachment{
|
||
UID: random.UUID(),
|
||
CreatorID: creator.ID,
|
||
MemoID: &storedMemo.ID,
|
||
Filename: "linked.png",
|
||
Type: "image/png",
|
||
Size: 1234,
|
||
StorageType: storepb.AttachmentStorageType_EXTERNAL,
|
||
Reference: "https://cdn.example.com/linked.png",
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
|
||
url := fmt.Sprintf("/file/attachments/%s/%s", attachment.UID, attachment.Filename)
|
||
for _, suffix := range []string{"", "?thumbnail=true"} {
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url+suffix, nil))
|
||
require.Equal(t, http.StatusFound, rec.Code, "request %q", suffix)
|
||
require.Equal(t, attachment.Reference, rec.Header().Get("Location"))
|
||
}
|
||
|
||
// A stored reference that is not a servable http(s) URL cannot be
|
||
// redirected to; the request fails instead of serving another scheme,
|
||
// a hostless URL, or an empty body.
|
||
for _, reference := range []string{"javascript:alert(1)", "https://:443/file"} {
|
||
badAttachment, err := stores.CreateAttachment(ctx, &store.Attachment{
|
||
UID: random.UUID(),
|
||
CreatorID: creator.ID,
|
||
MemoID: &storedMemo.ID,
|
||
Filename: "not-a-url.png",
|
||
Type: "image/png",
|
||
StorageType: storepb.AttachmentStorageType_EXTERNAL,
|
||
Reference: reference,
|
||
})
|
||
require.NoError(t, err)
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/attachments/%s/%s", badAttachment.UID, badAttachment.Filename), nil))
|
||
require.Equal(t, http.StatusInternalServerError, rec.Code, "reference %q", reference)
|
||
require.Empty(t, rec.Header().Get("Location"), "reference %q", reference)
|
||
}
|
||
}
|
||
|
||
func TestServeAttachmentFile_ShareTokenAllowsDirectMemoAttachment(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
creator, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "share-parent-owner",
|
||
Role: store.RoleUser,
|
||
Email: "share-parent-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
|
||
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{
|
||
Attachment: &apipb.Attachment{
|
||
Filename: "memo.txt",
|
||
Type: "text/plain",
|
||
Content: []byte("memo attachment"),
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
parentMemo, err := svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{
|
||
Memo: &apipb.Memo{
|
||
Content: "shared parent",
|
||
Visibility: apipb.Visibility_PROTECTED,
|
||
Attachments: []*apipb.Attachment{
|
||
{Name: attachment.Name},
|
||
},
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
share, err := svc.CreateMemoShare(creatorCtx, &apipb.CreateMemoShareRequest{
|
||
Parent: parentMemo.Name,
|
||
MemoShare: &apipb.MemoShare{},
|
||
})
|
||
require.NoError(t, err)
|
||
shareToken := share.Name[strings.LastIndex(share.Name, "/")+1:]
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
|
||
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s?share_token=%s", attachment.Name, attachment.Filename, shareToken), nil)
|
||
req.AddCookie(newExpiredRefreshTokenCookie(ctx, t, stores, creator.ID, svc.Secret))
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, req)
|
||
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "memo attachment", rec.Body.String())
|
||
}
|
||
|
||
func TestServeAttachmentFile_CanonicalRouteAndVisibilityAwareCache(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
creator, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "canonical-route-owner",
|
||
Role: store.RoleUser,
|
||
Email: "canonical-route-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{Attachment: &apipb.Attachment{
|
||
Filename: "canonical.png",
|
||
Type: "image/png",
|
||
Content: []byte("canonical image"),
|
||
}})
|
||
require.NoError(t, err)
|
||
memo, err := svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{Memo: &apipb.Memo{
|
||
Content: "canonical route",
|
||
Visibility: apipb.Visibility_PUBLIC,
|
||
Attachments: []*apipb.Attachment{{Name: attachment.Name}},
|
||
}})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
url := "/file/" + attachment.Name
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "canonical image", rec.Body.String())
|
||
require.Equal(t, publicAttachmentCacheControl, rec.Header().Get("Cache-Control"))
|
||
|
||
_, err = svc.UpdateMemo(creatorCtx, &apipb.UpdateMemoRequest{
|
||
Memo: &apipb.Memo{Name: memo.Name, Visibility: apipb.Visibility_PROTECTED},
|
||
UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"visibility"}},
|
||
})
|
||
require.NoError(t, err)
|
||
rec = httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))
|
||
require.Equal(t, http.StatusUnauthorized, rec.Code)
|
||
require.Equal(t, privateAttachmentCacheControl, rec.Header().Get("Cache-Control"))
|
||
}
|
||
|
||
func TestServeAttachmentFileMemoCreatorLifecycle(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
creator, err := stores.CreateUser(ctx, &store.User{
|
||
Username: "file-memo-creator-lifecycle", Role: store.RoleUser, Email: "file-creator@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{Attachment: &apipb.Attachment{
|
||
Filename: "creator-lifecycle.txt", Type: "text/plain", Content: []byte("creator lifecycle"),
|
||
}})
|
||
require.NoError(t, err)
|
||
memo, err := svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{Memo: &apipb.Memo{
|
||
Content: "public file", Visibility: apipb.Visibility_PUBLIC, Attachments: []*apipb.Attachment{{Name: attachment.Name}},
|
||
}})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
url := fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename)
|
||
archived := store.Archived
|
||
_, err = stores.UpdateUser(ctx, &store.UpdateUser{ID: creator.ID, RowStatus: &archived})
|
||
require.NoError(t, err)
|
||
recorder := httptest.NewRecorder()
|
||
e.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, url, nil))
|
||
require.Equal(t, http.StatusOK, recorder.Code, "an archived creator does not invalidate the memo's PUBLIC audience")
|
||
|
||
memoUID := strings.TrimPrefix(memo.Name, "memos/")
|
||
storedMemo, err := stores.GetMemo(ctx, &store.FindMemo{UID: &memoUID})
|
||
require.NoError(t, err)
|
||
require.NotNil(t, storedMemo)
|
||
_, err = stores.GetDriver().GetDB().ExecContext(ctx,
|
||
fmt.Sprintf("UPDATE memo SET creator_id = 2147483000 WHERE id = %d", storedMemo.ID))
|
||
require.NoError(t, err)
|
||
recorder = httptest.NewRecorder()
|
||
e.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, url, nil))
|
||
require.Equal(t, http.StatusNotFound, recorder.Code, "a dangling memo creator must fail closed for files")
|
||
}
|
||
|
||
func TestServeAttachmentFile_CommentUsesOwnVisibility(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
owner, err := svc.Store.CreateUser(ctx, &store.User{Username: "comment-parent-owner", Role: store.RoleUser, Email: "parent@example.com"})
|
||
require.NoError(t, err)
|
||
commenter, err := svc.Store.CreateUser(ctx, &store.User{Username: "comment-file-owner", Role: store.RoleUser, Email: "commenter@example.com"})
|
||
require.NoError(t, err)
|
||
ownerCtx := context.WithValue(ctx, auth.UserIDContextKey, owner.ID)
|
||
commenterCtx := context.WithValue(ctx, auth.UserIDContextKey, commenter.ID)
|
||
parent, err := svc.CreateMemo(ownerCtx, &apipb.CreateMemoRequest{Memo: &apipb.Memo{Content: "parent", Visibility: apipb.Visibility_PUBLIC}})
|
||
require.NoError(t, err)
|
||
attachment, err := svc.CreateAttachment(commenterCtx, &apipb.CreateAttachmentRequest{Attachment: &apipb.Attachment{
|
||
Filename: "comment.png",
|
||
Type: "image/png",
|
||
Content: []byte("comment image"),
|
||
}})
|
||
require.NoError(t, err)
|
||
comment, err := svc.CreateMemoComment(commenterCtx, &apipb.CreateMemoCommentRequest{
|
||
Parent: parent.Name,
|
||
Comment: &apipb.Memo{
|
||
Content: "comment",
|
||
Visibility: apipb.Visibility_PUBLIC,
|
||
Attachments: []*apipb.Attachment{{Name: attachment.Name}},
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
url := "/file/" + attachment.Name
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
|
||
_, err = svc.UpdateMemo(ownerCtx, &apipb.UpdateMemoRequest{
|
||
Memo: &apipb.Memo{Name: parent.Name, Visibility: apipb.Visibility_PRIVATE},
|
||
UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"visibility"}},
|
||
})
|
||
require.NoError(t, err)
|
||
rec = httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))
|
||
require.Equal(t, http.StatusOK, rec.Code, "changing the context memo must not change attachment access")
|
||
require.Equal(t, publicAttachmentCacheControl, rec.Header().Get("Cache-Control"))
|
||
|
||
_, err = svc.UpdateMemo(commenterCtx, &apipb.UpdateMemoRequest{
|
||
Memo: &apipb.Memo{Name: comment.Name, Visibility: apipb.Visibility_PROTECTED},
|
||
UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"visibility"}},
|
||
})
|
||
require.NoError(t, err)
|
||
rec = httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))
|
||
require.Equal(t, http.StatusUnauthorized, rec.Code)
|
||
require.Equal(t, privateAttachmentCacheControl, rec.Header().Get("Cache-Control"))
|
||
}
|
||
|
||
func TestServeAttachmentFile_LocalStaticFileSupportsRangeRequests(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
creator, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "range-owner",
|
||
Role: store.RoleUser,
|
||
Email: "range-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
|
||
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{
|
||
Attachment: &apipb.Attachment{
|
||
Filename: "range.txt",
|
||
Type: "text/plain",
|
||
Content: []byte("0123456789"),
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
_, err = svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{
|
||
Memo: &apipb.Memo{
|
||
Content: "range memo",
|
||
Visibility: apipb.Visibility_PUBLIC,
|
||
Attachments: []*apipb.Attachment{
|
||
{Name: attachment.Name},
|
||
},
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
|
||
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename), nil)
|
||
req.Header.Set("Range", "bytes=2-5")
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, req)
|
||
|
||
require.Equal(t, http.StatusPartialContent, rec.Code)
|
||
require.Equal(t, "2345", rec.Body.String())
|
||
require.Equal(t, "bytes 2-5/10", rec.Header().Get("Content-Range"))
|
||
}
|
||
|
||
func TestServeAttachmentFile_ShareTokenRejectsCommentAttachment(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
creator, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "private-parent-owner",
|
||
Role: store.RoleUser,
|
||
Email: "private-parent-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
commenter, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "share-commenter",
|
||
Role: store.RoleUser,
|
||
Email: "share-commenter@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
commenterCtx := context.WithValue(ctx, auth.UserIDContextKey, commenter.ID)
|
||
|
||
parentMemo, err := svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{
|
||
Memo: &apipb.Memo{
|
||
Content: "shared parent",
|
||
Visibility: apipb.Visibility_PROTECTED,
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
commentAttachment, err := svc.CreateAttachment(commenterCtx, &apipb.CreateAttachmentRequest{
|
||
Attachment: &apipb.Attachment{
|
||
Filename: "comment.txt",
|
||
Type: "text/plain",
|
||
Content: []byte("comment attachment"),
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
_, err = svc.CreateMemoComment(commenterCtx, &apipb.CreateMemoCommentRequest{
|
||
Parent: parentMemo.Name,
|
||
Comment: &apipb.Memo{
|
||
Content: "comment with attachment",
|
||
Visibility: apipb.Visibility_PROTECTED,
|
||
Attachments: []*apipb.Attachment{
|
||
{Name: commentAttachment.Name},
|
||
},
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
share, err := svc.CreateMemoShare(creatorCtx, &apipb.CreateMemoShareRequest{
|
||
Parent: parentMemo.Name,
|
||
MemoShare: &apipb.MemoShare{},
|
||
})
|
||
require.NoError(t, err)
|
||
shareToken := share.Name[strings.LastIndex(share.Name, "/")+1:]
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
|
||
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s?share_token=%s", commentAttachment.Name, commentAttachment.Filename, shareToken), nil)
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, req)
|
||
|
||
require.Equal(t, http.StatusUnauthorized, rec.Code)
|
||
}
|
||
|
||
func TestServeAttachmentFile_MotionClip(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
creator, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "motion-owner",
|
||
Role: store.RoleUser,
|
||
Email: "motion-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
|
||
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{
|
||
Attachment: &apipb.Attachment{
|
||
Filename: "motion.jpg",
|
||
Type: "image/jpeg",
|
||
Content: testutil.BuildMotionPhotoJPEG(),
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
_, err = svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{
|
||
Memo: &apipb.Memo{
|
||
Content: "motion memo",
|
||
Visibility: apipb.Visibility_PUBLIC,
|
||
Attachments: []*apipb.Attachment{
|
||
{Name: attachment.Name},
|
||
},
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
|
||
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s?motion=true", attachment.Name, attachment.Filename), nil)
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, req)
|
||
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "video/mp4", rec.Header().Get("Content-Type"))
|
||
require.Contains(t, rec.Body.String(), "ftyp")
|
||
}
|
||
|
||
func TestServeAttachmentFile_SVGThumbnailServedAsImageWithSecurityHeaders(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
creator, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "svg-owner",
|
||
Role: store.RoleUser,
|
||
Email: "svg-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
|
||
svgContent := []byte(`<svg xmlns="http://www.w3.org/2000/svg" width="120" height="40"><text x="0" y="20">memos</text></svg>`)
|
||
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{
|
||
Attachment: &apipb.Attachment{
|
||
Filename: "preview.svg",
|
||
Type: "image/svg+xml",
|
||
Content: svgContent,
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
_, err = svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{
|
||
Memo: &apipb.Memo{
|
||
Content: "svg memo",
|
||
Visibility: apipb.Visibility_PUBLIC,
|
||
Attachments: []*apipb.Attachment{
|
||
{Name: attachment.Name},
|
||
},
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
|
||
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s?thumbnail=true", attachment.Name, attachment.Filename), nil)
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, req)
|
||
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "image/svg+xml", rec.Header().Get("Content-Type"))
|
||
require.Empty(t, rec.Header().Get("Content-Disposition"))
|
||
require.Equal(t, "nosniff", rec.Header().Get("X-Content-Type-Options"))
|
||
require.Equal(t, "default-src 'none'; style-src 'unsafe-inline';", rec.Header().Get("Content-Security-Policy"))
|
||
require.Equal(t, svgContent, rec.Body.Bytes())
|
||
}
|
||
|
||
func TestServeAttachmentFile_ThumbnailWithSensitiveMetadataServesOriginal(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
creator, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "hdr-owner",
|
||
Role: store.RoleUser,
|
||
Email: "hdr-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
|
||
imageContent := testPNGWithChunk(t, "cICP", []byte{9, 16, 9, 1})
|
||
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{
|
||
Attachment: &apipb.Attachment{
|
||
Filename: "hdr.png",
|
||
Type: "image/png",
|
||
Content: imageContent,
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
_, err = svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{
|
||
Memo: &apipb.Memo{
|
||
Content: "hdr memo",
|
||
Visibility: apipb.Visibility_PUBLIC,
|
||
Attachments: []*apipb.Attachment{
|
||
{Name: attachment.Name},
|
||
},
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
|
||
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s?thumbnail=true", attachment.Name, attachment.Filename), nil)
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, req)
|
||
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "image/png", rec.Header().Get("Content-Type"))
|
||
require.Equal(t, imageContent, rec.Body.Bytes())
|
||
}
|
||
|
||
func TestHasThumbnailSensitiveMetadata(t *testing.T) {
|
||
tests := []struct {
|
||
name string
|
||
data []byte
|
||
want bool
|
||
}{
|
||
{
|
||
name: "jpeg hdr gain map",
|
||
data: []byte("xmp hdrgm:Version=\"1.0\""),
|
||
want: true,
|
||
},
|
||
{
|
||
name: "jpeg icc profile",
|
||
data: []byte("ICC_PROFILE"),
|
||
want: true,
|
||
},
|
||
{
|
||
name: "png cicp chunk",
|
||
data: []byte("cICP"),
|
||
want: true,
|
||
},
|
||
{
|
||
name: "plain jpeg",
|
||
data: []byte("plain image data"),
|
||
want: false,
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
require.Equal(t, tt.want, hasThumbnailSensitiveMetadata(tt.data))
|
||
})
|
||
}
|
||
}
|
||
|
||
func testPNGWithChunk(t *testing.T, chunkType string, chunkData []byte) []byte {
|
||
t.Helper()
|
||
|
||
img := image.NewRGBA(image.Rect(0, 0, 1, 1))
|
||
img.Set(0, 0, color.RGBA{R: 255, A: 255})
|
||
|
||
var encoded bytes.Buffer
|
||
require.NoError(t, png.Encode(&encoded, img))
|
||
|
||
pngData := encoded.Bytes()
|
||
iendIndex := bytes.LastIndex(pngData, []byte("IEND"))
|
||
require.GreaterOrEqual(t, iendIndex, 4)
|
||
|
||
chunkStart := iendIndex - 4
|
||
var chunk bytes.Buffer
|
||
require.NoError(t, binary.Write(&chunk, binary.BigEndian, uint32(len(chunkData))))
|
||
chunk.WriteString(chunkType)
|
||
chunk.Write(chunkData)
|
||
checksum := crc32.ChecksumIEEE(append([]byte(chunkType), chunkData...))
|
||
require.NoError(t, binary.Write(&chunk, binary.BigEndian, checksum))
|
||
|
||
result := make([]byte, 0, len(pngData)+chunk.Len())
|
||
result = append(result, pngData[:chunkStart]...)
|
||
result = append(result, chunk.Bytes()...)
|
||
result = append(result, pngData[chunkStart:]...)
|
||
return result
|
||
}
|
||
|
||
func newShareAttachmentTestServices(ctx context.Context, t *testing.T) (*api.APIService, *FileServerService, *store.Store, func()) {
|
||
t.Helper()
|
||
|
||
testStore := teststore.NewTestingStore(ctx, t)
|
||
setInstanceAccessMode(ctx, t, testStore, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PUBLIC)
|
||
testProfile := &profile.Profile{
|
||
Demo: true,
|
||
Version: "test-1.0.0",
|
||
InstanceURL: "http://localhost:8080",
|
||
Driver: "sqlite",
|
||
DSN: ":memory:",
|
||
Data: t.TempDir(),
|
||
}
|
||
secret := "test-secret"
|
||
markdownService := markdown.NewService(markdown.WithTagExtension())
|
||
apiService := &api.APIService{
|
||
Secret: secret,
|
||
Profile: testProfile,
|
||
Store: testStore,
|
||
MarkdownService: markdownService,
|
||
SSEHub: api.NewSSEHub(),
|
||
}
|
||
fileService := NewFileServerService(testProfile, testStore, secret)
|
||
|
||
return apiService, fileService, testStore, func() {
|
||
testStore.Close()
|
||
}
|
||
}
|
||
|
||
func setInstanceAccessMode(ctx context.Context, t *testing.T, stores *store.Store, mode storepb.InstanceAccessMode) {
|
||
t.Helper()
|
||
_, err := stores.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{
|
||
Key: storepb.InstanceSettingKey_ACCESS,
|
||
Value: &storepb.InstanceSetting_AccessSetting{AccessSetting: &storepb.InstanceAccessSetting{
|
||
AccessMode: mode,
|
||
}},
|
||
})
|
||
require.NoError(t, err)
|
||
}
|
||
|
||
// makePNGDataURI returns a minimal valid PNG encoded as a data URI, suitable for a
|
||
// user avatar.
|
||
func makePNGDataURI(t *testing.T) string {
|
||
t.Helper()
|
||
img := image.NewRGBA(image.Rect(0, 0, 1, 1))
|
||
img.Set(0, 0, color.RGBA{R: 1, G: 2, B: 3, A: 255})
|
||
var buf bytes.Buffer
|
||
require.NoError(t, png.Encode(&buf, img))
|
||
return "data:image/png;base64," + base64.StdEncoding.EncodeToString(buf.Bytes())
|
||
}
|
||
|
||
// TestServeAttachmentFile_PrivateInstanceDeniesAnonymous verifies that a public
|
||
// memo's attachment is served to anonymous visitors on an open instance but denied
|
||
// when the instance access policy is private.
|
||
func TestServeAttachmentFile_PrivateInstanceDeniesAnonymous(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
creator, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "private-attachment-owner",
|
||
Role: store.RoleUser,
|
||
Email: "private-attachment-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
|
||
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{
|
||
Attachment: &apipb.Attachment{
|
||
Filename: "public.txt",
|
||
Type: "text/plain",
|
||
Content: []byte("public content"),
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
_, err = svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{
|
||
Memo: &apipb.Memo{
|
||
Content: "public memo",
|
||
Visibility: apipb.Visibility_PUBLIC,
|
||
Attachments: []*apipb.Attachment{{Name: attachment.Name}},
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
url := fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename)
|
||
|
||
anonymousGet := func() int {
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))
|
||
return rec.Code
|
||
}
|
||
|
||
// Open instance: anonymous access to a public memo's attachment is allowed.
|
||
setInstanceAccessMode(ctx, t, stores, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PUBLIC)
|
||
require.Equal(t, http.StatusOK, anonymousGet())
|
||
|
||
// A stale browser session must not prevent access to an otherwise public
|
||
// attachment. Public authorization is independent of invalid credentials.
|
||
req := httptest.NewRequest(http.MethodGet, url, nil)
|
||
req.AddCookie(newExpiredRefreshTokenCookie(ctx, t, stores, creator.ID, svc.Secret))
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, req)
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "public content", rec.Body.String())
|
||
|
||
// Private instance: the same anonymous request is denied.
|
||
setInstanceAccessMode(ctx, t, stores, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PRIVATE)
|
||
require.Equal(t, http.StatusUnauthorized, anonymousGet())
|
||
}
|
||
|
||
// TestServeUserAvatar_PrivateInstanceRequiresAuth verifies that avatars are exposed
|
||
// to anonymous visitors on an open instance but require authentication on a private
|
||
// instance.
|
||
func TestServeUserAvatar_PrivateInstanceRequiresAuth(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
owner, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "avatar-owner",
|
||
Role: store.RoleUser,
|
||
Email: "avatar-owner@example.com",
|
||
AvatarURL: makePNGDataURI(t),
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
|
||
anonymousGet := func() *httptest.ResponseRecorder {
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/file/users/avatar-owner/avatar", nil))
|
||
return rec
|
||
}
|
||
|
||
// Open instance: anonymous avatar access is allowed.
|
||
setInstanceAccessMode(ctx, t, stores, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PUBLIC)
|
||
publicRec := anonymousGet()
|
||
require.Equal(t, http.StatusOK, publicRec.Code)
|
||
require.Equal(t, cacheMaxAge, publicRec.Header().Get("Cache-Control"))
|
||
|
||
// A stale browser session must not turn a public avatar request into an
|
||
// authentication error.
|
||
req := httptest.NewRequest(http.MethodGet, "/file/users/avatar-owner/avatar", nil)
|
||
req.AddCookie(newExpiredRefreshTokenCookie(ctx, t, stores, owner.ID, svc.Secret))
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, req)
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "image/png", rec.Header().Get("Content-Type"))
|
||
|
||
// Private instance: anonymous avatar access is denied.
|
||
setInstanceAccessMode(ctx, t, stores, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PRIVATE)
|
||
require.Equal(t, http.StatusUnauthorized, anonymousGet().Code)
|
||
|
||
// An authenticated private-instance response must not be stored by shared
|
||
// or browser caches.
|
||
tokenID := random.UUID()
|
||
require.NoError(t, stores.AddUserRefreshToken(ctx, owner.ID, &storepb.RefreshTokensUserSetting_RefreshToken{
|
||
TokenId: tokenID,
|
||
ExpiresAt: timestamppb.New(time.Now().Add(auth.RefreshTokenDuration)),
|
||
CreatedAt: timestamppb.Now(),
|
||
}))
|
||
refreshToken, _, err := auth.GenerateRefreshToken(owner.ID, tokenID, []byte(svc.Secret))
|
||
require.NoError(t, err)
|
||
privateReq := httptest.NewRequest(http.MethodGet, "/file/users/avatar-owner/avatar", nil)
|
||
privateReq.AddCookie(&http.Cookie{Name: auth.RefreshTokenCookieName, Value: refreshToken})
|
||
privateRec := httptest.NewRecorder()
|
||
e.ServeHTTP(privateRec, privateReq)
|
||
require.Equal(t, http.StatusOK, privateRec.Code)
|
||
require.Equal(t, privateAttachmentCacheControl, privateRec.Header().Get("Cache-Control"))
|
||
}
|
||
|
||
// TestServeAttachmentFile_RefreshCookieAuthenticatesOwner verifies that the file
|
||
// server authenticates a request via the refresh-token cookie (the browser <img>
|
||
// flow) — the AuthenticateToUser cookie fallback — letting the owner fetch their own
|
||
// private memo's attachment without an Authorization header.
|
||
func TestServeAttachmentFile_RefreshCookieAuthenticatesOwner(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
owner, err := svc.Store.CreateUser(ctx, &store.User{
|
||
Username: "cookie-owner",
|
||
Role: store.RoleUser,
|
||
Email: "cookie-owner@example.com",
|
||
})
|
||
require.NoError(t, err)
|
||
ownerCtx := context.WithValue(ctx, auth.UserIDContextKey, owner.ID)
|
||
|
||
attachment, err := svc.CreateAttachment(ownerCtx, &apipb.CreateAttachmentRequest{
|
||
Attachment: &apipb.Attachment{
|
||
Filename: "secret.txt",
|
||
Type: "text/plain",
|
||
Content: []byte("secret content"),
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
_, err = svc.CreateMemo(ownerCtx, &apipb.CreateMemoRequest{
|
||
Memo: &apipb.Memo{
|
||
Content: "private memo",
|
||
Visibility: apipb.Visibility_PRIVATE,
|
||
Attachments: []*apipb.Attachment{{Name: attachment.Name}},
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
// Mint a valid refresh token for the owner and store its record.
|
||
tokenID := random.UUID()
|
||
require.NoError(t, svc.Store.AddUserRefreshToken(ctx, owner.ID, &storepb.RefreshTokensUserSetting_RefreshToken{
|
||
TokenId: tokenID,
|
||
ExpiresAt: timestamppb.New(time.Now().Add(auth.RefreshTokenDuration)),
|
||
CreatedAt: timestamppb.Now(),
|
||
}))
|
||
refreshToken, _, err := auth.GenerateRefreshToken(owner.ID, tokenID, []byte(svc.Secret))
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
url := fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename)
|
||
|
||
// Without credentials, the private attachment is denied.
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))
|
||
require.Equal(t, http.StatusUnauthorized, rec.Code)
|
||
|
||
// With the refresh-token cookie, the owner is authenticated and served.
|
||
req := httptest.NewRequest(http.MethodGet, url, nil)
|
||
req.AddCookie(&http.Cookie{Name: auth.RefreshTokenCookieName, Value: refreshToken})
|
||
rec = httptest.NewRecorder()
|
||
e.ServeHTTP(rec, req)
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "secret content", rec.Body.String())
|
||
}
|
||
|
||
// TestServeAttachmentFile_UnlinkedAttachmentOwnerOrAdmin verifies an
|
||
// attachment not linked to a memo follows the API's GetAttachment rule: its
|
||
// creator and an instance admin may read it, other users may not.
|
||
func TestServeAttachmentFile_UnlinkedAttachmentOwnerOrAdmin(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
newUser := func(username string, role store.Role) *store.User {
|
||
user, err := svc.Store.CreateUser(ctx, &store.User{Username: username, Role: role, Email: username + "@example.com"})
|
||
require.NoError(t, err)
|
||
return user
|
||
}
|
||
owner := newUser("unlinked-owner", store.RoleUser)
|
||
admin := newUser("unlinked-admin", store.RoleAdmin)
|
||
other := newUser("unlinked-other", store.RoleUser)
|
||
|
||
attachment, err := svc.CreateAttachment(context.WithValue(ctx, auth.UserIDContextKey, owner.ID), &apipb.CreateAttachmentRequest{
|
||
Attachment: &apipb.Attachment{
|
||
Filename: "draft.txt",
|
||
Type: "text/plain",
|
||
Content: []byte("draft content"),
|
||
},
|
||
})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
url := fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename)
|
||
getAs := func(user *store.User) int {
|
||
req := httptest.NewRequest(http.MethodGet, url, nil)
|
||
req.AddCookie(newRefreshTokenCookie(ctx, t, stores, user.ID, svc.Secret))
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, req)
|
||
return rec.Code
|
||
}
|
||
|
||
require.Equal(t, http.StatusOK, getAs(owner))
|
||
require.Equal(t, http.StatusOK, getAs(admin))
|
||
require.Equal(t, http.StatusForbidden, getAs(other))
|
||
}
|
||
|
||
func newRefreshTokenCookie(ctx context.Context, t *testing.T, stores *store.Store, userID int32, secret string) *http.Cookie {
|
||
t.Helper()
|
||
tokenID := random.UUID()
|
||
require.NoError(t, stores.AddUserRefreshToken(ctx, userID, &storepb.RefreshTokensUserSetting_RefreshToken{
|
||
TokenId: tokenID,
|
||
ExpiresAt: timestamppb.New(time.Now().Add(auth.RefreshTokenDuration)),
|
||
CreatedAt: timestamppb.Now(),
|
||
}))
|
||
refreshToken, _, err := auth.GenerateRefreshToken(userID, tokenID, []byte(secret))
|
||
require.NoError(t, err)
|
||
return &http.Cookie{Name: auth.RefreshTokenCookieName, Value: refreshToken}
|
||
}
|
||
|
||
func newExpiredRefreshTokenCookie(ctx context.Context, t *testing.T, stores *store.Store, userID int32, secret string) *http.Cookie {
|
||
t.Helper()
|
||
tokenID := random.UUID()
|
||
require.NoError(t, stores.AddUserRefreshToken(ctx, userID, &storepb.RefreshTokensUserSetting_RefreshToken{
|
||
TokenId: tokenID,
|
||
ExpiresAt: timestamppb.New(time.Now().Add(-time.Hour)),
|
||
CreatedAt: timestamppb.New(time.Now().Add(-2 * time.Hour)),
|
||
}))
|
||
refreshToken, _, err := auth.GenerateRefreshToken(userID, tokenID, []byte(secret))
|
||
require.NoError(t, err)
|
||
return &http.Cookie{Name: auth.RefreshTokenCookieName, Value: refreshToken}
|
||
}
|
||
|
||
// oversizedPNGHeader returns a valid PNG header that declares width×height
|
||
// pixels without carrying pixel data, the shape of a decompression bomb.
|
||
func oversizedPNGHeader(width, height uint32) []byte {
|
||
var buf bytes.Buffer
|
||
buf.Write([]byte{0x89, 'P', 'N', 'G', '\r', '\n', 0x1a, '\n'})
|
||
ihdr := make([]byte, 13)
|
||
binary.BigEndian.PutUint32(ihdr[0:4], width)
|
||
binary.BigEndian.PutUint32(ihdr[4:8], height)
|
||
ihdr[8] = 8
|
||
ihdr[9] = 2
|
||
for _, chunk := range []struct {
|
||
kind string
|
||
data []byte
|
||
}{{"IHDR", ihdr}, {"IEND", nil}} {
|
||
_ = binary.Write(&buf, binary.BigEndian, uint32(len(chunk.data)))
|
||
buf.WriteString(chunk.kind)
|
||
buf.Write(chunk.data)
|
||
_ = binary.Write(&buf, binary.BigEndian, crc32.ChecksumIEEE(append([]byte(chunk.kind), chunk.data...)))
|
||
}
|
||
return buf.Bytes()
|
||
}
|
||
|
||
func createPublicImageMemo(ctx context.Context, t *testing.T, svc *api.APIService, username, filename, mimeType string, content []byte) *apipb.Attachment {
|
||
t.Helper()
|
||
creator, err := svc.Store.CreateUser(ctx, &store.User{Username: username, Role: store.RoleUser, Email: username + "@example.com"})
|
||
require.NoError(t, err)
|
||
creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID)
|
||
attachment, err := svc.CreateAttachment(creatorCtx, &apipb.CreateAttachmentRequest{Attachment: &apipb.Attachment{
|
||
Filename: filename, Type: mimeType, Content: content,
|
||
}})
|
||
require.NoError(t, err)
|
||
_, err = svc.CreateMemo(creatorCtx, &apipb.CreateMemoRequest{Memo: &apipb.Memo{
|
||
Content: "image memo", Visibility: apipb.Visibility_PUBLIC, Attachments: []*apipb.Attachment{{Name: attachment.Name}},
|
||
}})
|
||
require.NoError(t, err)
|
||
return attachment
|
||
}
|
||
|
||
// A small PNG that declares billions of pixels must not be decoded for a
|
||
// thumbnail; the original is served and the failure is remembered so later
|
||
// requests do not retry the decode.
|
||
func TestServeAttachmentFile_ThumbnailRefusesOversizedImage(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
bomb := oversizedPNGHeader(100_000, 100_000)
|
||
attachment := createPublicImageMemo(ctx, t, svc, "bomb-owner", "bomb.png", "image/png", bomb)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
for range 2 {
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/bomb.png?thumbnail=true", attachment.Name), nil))
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "image/png", rec.Header().Get("Content-Type"))
|
||
require.Equal(t, bomb, rec.Body.Bytes(), "original is served instead of a thumbnail")
|
||
}
|
||
uid := strings.TrimPrefix(attachment.Name, "attachments/")
|
||
require.NoFileExists(t, filepath.Join(fs.Profile.Data, thumbnailCacheFolder, uid+".v2.jpeg"))
|
||
require.FileExists(t, filepath.Join(fs.Profile.Data, thumbnailCacheFolder, uid+".v2.jpeg"+thumbnailFailedMarkerSuffix))
|
||
}
|
||
|
||
// newSharedProfileTestServices builds the API service, file server, and
|
||
// store on one profile, as in production, so derived caches written by the
|
||
// file server live in the directory the store cleans up.
|
||
func newSharedProfileTestServices(ctx context.Context, t *testing.T) (*api.APIService, *FileServerService, func()) {
|
||
t.Helper()
|
||
dataDir := t.TempDir()
|
||
testProfile := &profile.Profile{
|
||
Demo: true,
|
||
Version: "test-1.0.0",
|
||
InstanceURL: "http://localhost:8080",
|
||
Driver: "sqlite",
|
||
DSN: filepath.Join(dataDir, "memos_test.db"),
|
||
Data: dataDir,
|
||
}
|
||
dbDriver, err := db.NewDBDriver(testProfile)
|
||
require.NoError(t, err)
|
||
testStore := store.New(dbDriver, testProfile)
|
||
require.NoError(t, testStore.Migrate(ctx))
|
||
setInstanceAccessMode(ctx, t, testStore, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PUBLIC)
|
||
secret := "test-secret"
|
||
apiService := &api.APIService{
|
||
Secret: secret,
|
||
Profile: testProfile,
|
||
Store: testStore,
|
||
MarkdownService: markdown.NewService(markdown.WithTagExtension()),
|
||
SSEHub: api.NewSSEHub(),
|
||
}
|
||
return apiService, NewFileServerService(testProfile, testStore, secret), func() { testStore.Close() }
|
||
}
|
||
|
||
// Deleting an attachment removes the cached thumbnail written for it.
|
||
func TestDeleteAttachmentRemovesCachedThumbnail(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, cleanup := newSharedProfileTestServices(ctx, t)
|
||
defer cleanup()
|
||
|
||
var pngBuf bytes.Buffer
|
||
require.NoError(t, png.Encode(&pngBuf, image.NewRGBA(image.Rect(0, 0, 8, 8))))
|
||
attachment := createPublicImageMemo(ctx, t, svc, "thumb-owner", "small.png", "image/png", pngBuf.Bytes())
|
||
owner, err := svc.Store.GetUser(ctx, &store.FindUser{Username: func() *string { s := "thumb-owner"; return &s }()})
|
||
require.NoError(t, err)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/small.png?thumbnail=true", attachment.Name), nil))
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "image/jpeg", rec.Header().Get("Content-Type"))
|
||
uid := strings.TrimPrefix(attachment.Name, "attachments/")
|
||
thumbnailPath := filepath.Join(fs.Profile.Data, thumbnailCacheFolder, uid+".v2.jpeg")
|
||
require.FileExists(t, thumbnailPath)
|
||
|
||
ownerCtx := context.WithValue(ctx, auth.UserIDContextKey, owner.ID)
|
||
_, err = svc.DeleteAttachment(ownerCtx, &apipb.DeleteAttachmentRequest{Name: attachment.Name})
|
||
require.NoError(t, err)
|
||
require.NoFileExists(t, thumbnailPath)
|
||
}
|
||
|
||
// A storage read failure is transient and must not be remembered as a
|
||
// thumbnail verdict; only unsupported images get the failure marker.
|
||
func TestThumbnailFailureMarkerOnlyForUnsupportedImages(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, cleanup := newSharedProfileTestServices(ctx, t)
|
||
defer cleanup()
|
||
configureLocalStorage(ctx, t, svc.Store)
|
||
|
||
var pngBuf bytes.Buffer
|
||
require.NoError(t, png.Encode(&pngBuf, image.NewRGBA(image.Rect(0, 0, 8, 8))))
|
||
attachment := createPublicImageMemo(ctx, t, svc, "transient-owner", "gone.png", "image/png", pngBuf.Bytes())
|
||
uid := strings.TrimPrefix(attachment.Name, "attachments/")
|
||
stored, err := svc.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid})
|
||
require.NoError(t, err)
|
||
require.Equal(t, storepb.AttachmentStorageType_LOCAL, stored.StorageType)
|
||
localPath := fs.resolveLocalPath(stored.Reference)
|
||
require.NoError(t, os.Rename(localPath, localPath+".away"))
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/gone.png?thumbnail=true", attachment.Name), nil))
|
||
marker := filepath.Join(fs.Profile.Data, thumbnailCacheFolder, uid+".v2.jpeg"+thumbnailFailedMarkerSuffix)
|
||
require.NoFileExists(t, marker, "a read failure is not a verdict on the image")
|
||
|
||
// Once the bytes are back, the thumbnail is generated normally.
|
||
require.NoError(t, os.Rename(localPath+".away", localPath))
|
||
rec = httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/gone.png?thumbnail=true", attachment.Name), nil))
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "image/jpeg", rec.Header().Get("Content-Type"))
|
||
}
|
||
|
||
// A local attachment whose file is gone from disk answers with the JSON error
|
||
// envelope like every other storage failure, not net/http's plain-text page.
|
||
func TestServeAttachmentFile_MissingLocalFileIsAJSONError(t *testing.T) {
|
||
ctx := context.Background()
|
||
svc, fs, cleanup := newSharedProfileTestServices(ctx, t)
|
||
defer cleanup()
|
||
configureLocalStorage(ctx, t, svc.Store)
|
||
|
||
attachment := createPublicImageMemo(ctx, t, svc, "local-owner", "report.pdf", "application/pdf", []byte("%PDF-1.4 local bytes"))
|
||
uid := strings.TrimPrefix(attachment.Name, "attachments/")
|
||
stored, err := svc.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid})
|
||
require.NoError(t, err)
|
||
require.Equal(t, storepb.AttachmentStorageType_LOCAL, stored.StorageType)
|
||
|
||
e := http.NewServeMux()
|
||
fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))
|
||
rec := httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/report.pdf", attachment.Name), nil))
|
||
require.Equal(t, http.StatusOK, rec.Code)
|
||
require.Equal(t, "application/pdf", rec.Header().Get("Content-Type"))
|
||
|
||
require.NoError(t, os.Remove(fs.resolveLocalPath(stored.Reference)))
|
||
rec = httptest.NewRecorder()
|
||
e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/report.pdf", attachment.Name), nil))
|
||
require.Equal(t, http.StatusNotFound, rec.Code)
|
||
require.Equal(t, "application/json", rec.Header().Get("Content-Type"))
|
||
require.JSONEq(t, `{"message":"attachment file not found"}`, rec.Body.String())
|
||
}
|