Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.
Go dockerfossgomarkdownmemomicroblognote-takingnotesopen-sourceown-your-datareactself-hostedsqlitetimeline
fix: harden attachment, auth, and import paths for public deployment
bluedbird471745b43148
diff --git a/core/memoarchive/expansion_test.go b/core/memoarchive/expansion_test.gonew file mode 100644index 000000000..3e745edcf--- /dev/null+++ b/core/memoarchive/expansion_test.go@@ -0,0 +1,31 @@+package memoarchive++import (+ "archive/zip"+ "bytes"+ "io"+ "testing"++ "github.com/stretchr/testify/require"+)++// A container whose entries declare far more bytes than it holds is refused+// before any entry is read.+func TestReadRejectsDecompressionBomb(t *testing.T) {+ var buf bytes.Buffer+ writer := zip.NewWriter(&buf)+ entry, err := writer.Create(AttachmentsDir + "bomb/zeros.bin")+ require.NoError(t, err)+ zeros := make([]byte, 1<<20)+ for range 80 {+ _, err = entry.Write(zeros)+ require.NoError(t, err)+ }+ require.NoError(t, writer.Close())+ require.Less(t, buf.Len(), 1<<20, "80 MiB of zeros deflates to well under a mebibyte")++ _, err = Read(bytes.NewReader(buf.Bytes()), int64(buf.Len()))+ require.Error(t, err)+ require.Contains(t, err.Error(), "uncompressed bytes")+ _ = io.EOF+}diff --git a/core/memoarchive/reader.go b/core/memoarchive/reader.goindex ae9217c71..3923efdf7 100644--- a/core/memoarchive/reader.go+++ b/core/memoarchive/reader.go@@ -26,6 +26,12 @@ const (// maxContentBytes bounds one memo content file. Instances enforce their// own, smaller content length limit on import.maxContentBytes = 64 << 20+ // maxExpansionRatio bounds the total declared uncompressed size relative+ // to the container, with maxExpansionSlack of headroom for tiny archives.+ // Memo text deflates around ten to one and media hardly at all, so a+ // container that claims to expand further is a decompression bomb.+ maxExpansionRatio = 64+ maxExpansionSlack = 64 << 20)// Archive is a validated, opened Memo Archive. Memos are ordered so that a@@ -50,11 +56,17 @@ func Read(r io.ReaderAt, size int64) (*Archive, error) {return nil, errors.Errorf("archive has more than %d entries", maxEntries)}archive := &Archive{entries: make(map[string]*zip.File, len(reader.File))}+ var totalCompressed, totalUncompressed uint64for _, file := range reader.File {if strings.HasSuffix(file.Name, "/") && file.UncompressedSize64 == 0 {// Directory entries carry no data; readers must not depend on them.continue}+ totalCompressed += file.CompressedSize64+ totalUncompressed += file.UncompressedSize64+ if totalUncompressed > maxExpansionRatio*totalCompressed+maxExpansionSlack {+ return nil, errors.Errorf("archive declares %d uncompressed bytes for %d compressed bytes", totalUncompressed, totalCompressed)+ }if err := ValidateEntryName(file.Name); err != nil {return nil, err}diff --git a/filter/engine.go b/filter/engine.goindex e477b0c79..74889b0ac 100644--- a/filter/engine.go+++ b/filter/engine.go@@ -21,8 +21,14 @@ type Engine struct {}// NewEngine builds a new Engine for the provided schema.+// maxFilterExpressionSize bounds a filter expression in code points. Every+// term compiles to its own SQL predicate, so the expression length is what+// bounds the query the database has to run.+const maxFilterExpressionSize = 8 << 10+func NewEngine(schema Schema) (*Engine, error) {- env, err := cel.NewEnv(schema.EnvOptions...)+ options := append([]cel.EnvOption{cel.ParserExpressionSizeLimit(maxFilterExpressionSize)}, schema.EnvOptions...)+ env, err := cel.NewEnv(options...)if err != nil {return nil, errors.Wrap(err, "failed to create CEL environment")}diff --git a/filter/engine_test.go b/filter/engine_test.goindex 5678de330..c4c773b7b 100644--- a/filter/engine_test.go+++ b/filter/engine_test.go@@ -4,6 +4,7 @@ import ("context""database/sql""fmt"+ "strings""testing""github.com/stretchr/testify/require"@@ -688,3 +689,20 @@ func TestRenderRegexLiteralFallbackOnD1(t *testing.T) {require.ErrorContains(t, err, "not supported on Cloudflare D1", expression)}}++func TestCompileRejectsOversizedExpression(t *testing.T) {+ t.Parallel()+ engine, err := NewEngine(NewSchema())+ require.NoError(t, err)++ var builder strings.Builder+ builder.WriteString(`content.contains("a")`)+ for builder.Len() < maxFilterExpressionSize+64 {+ builder.WriteString(` || content.contains("a")`)+ }+ _, err = engine.Compile(context.Background(), builder.String())+ require.Error(t, err)++ _, err = engine.Compile(context.Background(), `content.contains("a") || content.contains("b")`)+ require.NoError(t, err)+}diff --git a/go.mod b/go.modindex 53bdde078..6a02f71aa 100644--- a/go.mod+++ b/go.mod@@ -33,7 +33,7 @@ require (github.com/testcontainers/testcontainers-go/modules/mysql v0.44.0github.com/testcontainers/testcontainers-go/modules/postgres v0.44.0github.com/yuin/goldmark v1.8.5- golang.org/x/crypto v0.55.0+ golang.org/x/crypto v0.56.0golang.org/x/mod v0.40.0golang.org/x/net v0.58.0golang.org/x/oauth2 v0.36.0@@ -43,7 +43,7 @@ require (google.golang.org/genproto v0.0.0-20260810153831-ec0a7760b754google.golang.org/genproto/googleapis/api v0.0.0-20260810153831-ec0a7760b754google.golang.org/genproto/googleapis/rpc v0.0.0-20260810153831-ec0a7760b754- google.golang.org/grpc v1.83.0+ google.golang.org/grpc v1.83.1google.golang.org/protobuf v1.36.12gopkg.in/yaml.v3 v3.0.1modernc.org/libc v1.75.3diff --git a/go.sum b/go.sumindex f1a940e63..cd134531e 100644--- a/go.sum+++ b/go.sum@@ -295,8 +295,8 @@ go.shabbyrobe.org/gocovmerge v0.0.0-20230507111327-fa4f82cfbf4d/go.mod h1:92Uoe3go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=-golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M=-golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis=+golang.org/x/crypto v0.56.0 h1:GUh5Ii4J5jtcseSMiRqr1jXCNHoxjeV9Fmekc2oLy6Y=+golang.org/x/crypto v0.56.0/go.mod h1:OMW5y6CY9l38uPLmxU6l6pwcXp1obtLo3e6gT7gQR2I=golang.org/x/exp v0.0.0-20260813180055-c1d0aacb2297 h1:YXnL44eJ77R+ji4/ooy8UsXIhz+lbi2Qgdlc8iRN0gY=golang.org/x/exp v0.0.0-20260813180055-c1d0aacb2297/go.mod h1:Mkmymgv+uMpSQ/XxJ/7GpdrdYoqm3u72jEbpCLiJmNk=golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=@@ -337,8 +337,8 @@ google.golang.org/genproto/googleapis/api v0.0.0-20260810153831-ec0a7760b754 h1:google.golang.org/genproto/googleapis/api v0.0.0-20260810153831-ec0a7760b754/go.mod h1:q/3oV3jAi5vwelxsVAprMBC8BcM2zmNe+IjRGd+9/ks=google.golang.org/genproto/googleapis/rpc v0.0.0-20260810153831-ec0a7760b754 h1:k5CJw9e5ONCcA/u0webKt092npXuY+KeGh3Q8NAVf0g=google.golang.org/genproto/googleapis/rpc v0.0.0-20260810153831-ec0a7760b754/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=-google.golang.org/grpc v1.83.0 h1:JeNZEKJFbQxArAMl+hiytHauacDNqJUllNfmIMmpqnQ=-google.golang.org/grpc v1.83.0/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ=+google.golang.org/grpc v1.83.1 h1:HIO0+BEtBP6soyqvqC8sNUjZ7bTs+0hFQuFF+RAy++Y=+google.golang.org/grpc v1.83.1/go.mod h1:kDyl6SKsiHKt0uylY5gtn5cEjkrIOhQOGDgIc4JGwzQ=google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc=google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=diff --git a/internal/imagelimit/imagelimit.go b/internal/imagelimit/imagelimit.gonew file mode 100644index 000000000..e0e5c0cfe--- /dev/null+++ b/internal/imagelimit/imagelimit.go@@ -0,0 +1,49 @@+// Package imagelimit bounds the decoded size of untrusted images before a+// full decode allocates memory for them. A few kilobytes of compressed data+// can declare billions of pixels; reading only the header keeps the check+// cheap and lets callers refuse the image before paying for it.+package imagelimit++import (+ "image"+ "io"++ // Register the standard formats so DecodeConfig can read their headers.+ _ "image/gif"+ _ "image/jpeg"+ _ "image/png"++ "github.com/pkg/errors"+)++// MaxPixels is the largest decoded pixel count accepted for any image the+// server decodes itself: EXIF stripping on upload and thumbnail generation+// on read. 50 megapixels decodes to about 200 MiB of RGBA.+const MaxPixels = 50_000_000++// ErrTooLarge reports an image whose declared dimensions exceed MaxPixels.+var ErrTooLarge = errors.Errorf("image dimensions exceed maximum of %d pixels", MaxPixels)++// CheckReader reads the image header from r and reports whether the declared+// dimensions fit within MaxPixels. Formats that the image registry cannot+// size are allowed through so the full decoder decides; the caller must then+// be prepared for that decode to fail. The reader is consumed; rewind it+// before decoding.+func CheckReader(r io.Reader) error {+ config, _, err := image.DecodeConfig(r)+ if err != nil {+ return nil //nolint:nilerr // unknown formats defer to the full decoder+ }+ return CheckDimensions(config.Width, config.Height)+}++// CheckDimensions reports whether width×height fits within MaxPixels.+func CheckDimensions(width, height int) error {+ if width <= 0 || height <= 0 {+ return errors.New("invalid image dimensions")+ }+ if width > MaxPixels/height {+ return ErrTooLarge+ }+ return nil+}diff --git a/internal/imagelimit/imagelimit_test.go b/internal/imagelimit/imagelimit_test.gonew file mode 100644index 000000000..9f38c3433--- /dev/null+++ b/internal/imagelimit/imagelimit_test.go@@ -0,0 +1,50 @@+package imagelimit++import (+ "bytes"+ "encoding/binary"+ "hash/crc32"+ "image"+ "image/color"+ "image/png"+ "testing"++ "github.com/stretchr/testify/require"+)++// oversizedPNG returns a syntactically valid PNG header that declares+// width×height pixels without carrying the pixel data for them.+func oversizedPNG(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 // bit depth+ ihdr[9] = 6 // RGBA+ chunk := append([]byte("IHDR"), ihdr...)+ binary.Write(&buf, binary.BigEndian, uint32(len(ihdr)))+ buf.Write(chunk)+ binary.Write(&buf, binary.BigEndian, crc32.ChecksumIEEE(chunk))+ return buf.Bytes()+}++func TestCheckReader(t *testing.T) {+ var small bytes.Buffer+ require.NoError(t, png.Encode(&small, image.NewRGBA(image.Rect(0, 0, 4, 4))))+ require.NoError(t, CheckReader(bytes.NewReader(small.Bytes())))++ err := CheckReader(bytes.NewReader(oversizedPNG(30_000, 30_000)))+ require.ErrorIs(t, err, ErrTooLarge)++ // A format the registry cannot size defers to the full decoder.+ require.NoError(t, CheckReader(bytes.NewReader([]byte("not an image"))))+}++func TestCheckDimensions(t *testing.T) {+ require.NoError(t, CheckDimensions(8000, 6000))+ require.ErrorIs(t, CheckDimensions(10_000, 10_000), ErrTooLarge)+ require.Error(t, CheckDimensions(0, 10))+ require.Error(t, CheckDimensions(10, -1))+ _ = color.Black+}diff --git a/internal/linkmeta/image.go b/internal/linkmeta/image.godeleted file mode 100644index b569045e4..000000000--- a/internal/linkmeta/image.go+++ /dev/null@@ -1,45 +0,0 @@-package linkmeta--import (- "errors"- "io"- "net/http"- "net/url"- "strings"-)--type Image struct {- Blob []byte- Mediatype string-}--func GetImage(urlStr string) (*Image, error) {- if _, err := url.Parse(urlStr); err != nil {- return nil, err- }-- response, err := http.Get(urlStr)- if err != nil {- return nil, err- }- defer response.Body.Close()-- mediatype, err := getMediatype(response)- if err != nil {- return nil, err- }- if !strings.HasPrefix(mediatype, "image/") {- return nil, errors.New("wrong image mediatype")- }-- bodyBytes, err := io.ReadAll(response.Body)- if err != nil {- return nil, err- }-- image := &Image{- Blob: bodyBytes,- Mediatype: mediatype,- }- return image, nil-}diff --git a/server/api/v1/attachment_exif_sniff_test.go b/server/api/v1/attachment_exif_sniff_test.gonew file mode 100644index 000000000..4962c8ea0--- /dev/null+++ b/server/api/v1/attachment_exif_sniff_test.go@@ -0,0 +1,81 @@+package v1++import (+ "bytes"+ "context"+ "encoding/binary"+ "image"+ "image/color"+ "image/jpeg"+ "testing"++ "github.com/stretchr/testify/require"++ v1pb "github.com/usememos/memos/proto/gen/api/v1"+ "github.com/usememos/memos/store"+)++const exifTestMarker = "MEMOS-GPS-MARKER-0123456789"++// jpegWithExifMarker returns a decodable JPEG whose APP1 segment carries a+// recognizable marker, standing in for privacy-sensitive EXIF metadata.+func jpegWithExifMarker(t *testing.T) []byte {+ t.Helper()+ img := image.NewRGBA(image.Rect(0, 0, 16, 16))+ for y := range 16 {+ for x := range 16 {+ img.Set(x, y, color.RGBA{R: 200, G: 30, B: 30, A: 255})+ }+ }+ var encoded bytes.Buffer+ require.NoError(t, jpeg.Encode(&encoded, img, &jpeg.Options{Quality: 90}))+ raw := encoded.Bytes()+ require.Equal(t, []byte{0xFF, 0xD8}, raw[:2])++ payload := append([]byte("Exif\x00\x00"), []byte(exifTestMarker)...)+ var out bytes.Buffer+ out.Write(raw[:2])+ out.Write([]byte{0xFF, 0xE1})+ _ = binary.Write(&out, binary.BigEndian, uint16(len(payload)+2))+ out.Write(payload)+ out.Write(raw[2:])+ return out.Bytes()+}++func TestShouldStripExifContentSniffsMislabeledJPEG(t *testing.T) {+ t.Parallel()+ content := jpegWithExifMarker(t)++ for _, declared := range []string{"application/octet-stream", "image/png", "text/plain"} {+ strip, err := shouldStripExifContent(bytes.NewReader(content), declared)+ require.NoError(t, err)+ require.True(t, strip, "declared %s", declared)+ }+ strip, err := shouldStripExifContent(bytes.NewReader([]byte("plain text file")), "application/octet-stream")+ require.NoError(t, err)+ require.False(t, strip)+}++// A JPEG uploaded under a non-image declared type is still stripped of its+// metadata; the declared type alone must not decide the privacy policy.+func TestCreateAttachmentStripsExifFromMislabeledJPEG(t *testing.T) {+ svc := newIntegrationService(t)+ ctx := context.Background()+ user := createSpaceTestUser(ctx, t, svc, "exif-mislabel", store.RoleUser)+ content := jpegWithExifMarker(t)+ require.Contains(t, string(content), exifTestMarker)++ created, err := svc.CreateAttachment(userCtx(ctx, user.ID), &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{+ Filename: "photo.bin", Type: "application/octet-stream", Content: content,+ }})+ require.NoError(t, err)++ uid := created.Name[len(AttachmentNamePrefix):]+ stored, err := svc.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid})+ require.NoError(t, err)+ blob, err := svc.GetAttachmentBlob(ctx, stored)+ require.NoError(t, err)+ require.NotContains(t, string(blob), exifTestMarker)+ _, err = jpeg.Decode(bytes.NewReader(blob))+ require.NoError(t, err)+}diff --git a/server/api/v1/attachment_service.go b/server/api/v1/attachment_service.goindex bd247d050..a8e1850e8 100644--- a/server/api/v1/attachment_service.go+++ b/server/api/v1/attachment_service.go@@ -33,7 +33,6 @@ const (// Quality 95 maintains visual quality while ensuring metadata is removed.defaultJPEGQuality = 95maxBatchDeleteAttachments = 100- maxImagePixels = 50_000_000)// exifCapableImageTypes defines image formats that may contain EXIF metadata.@@ -228,7 +227,13 @@ func (s *APIV1Service) processAndSaveAttachment(ctx context.Context, create *stocontent := io.ReadSeeker(source)// Strip EXIF metadata from images for privacy protection. Motion photo// containers are kept intact because re-encoding would drop the video.- if shouldStripExif(create.Type) && !isAndroidMotionContainer(create.Payload.GetMotionMedia()) {+ // The decision uses the sniffed bytes as well as the declared type, so a+ // client cannot skip stripping by labeling a JPEG as something else.+ needsExifStrip, err := shouldStripExifContent(source, create.Type)+ if err != nil {+ return nil, status.Errorf(codes.Internal, "failed to inspect attachment content: %v", err)+ }+ if needsExifStrip && !isAndroidMotionContainer(create.Payload.GetMotionMedia()) {release, err := s.acquireImageProcessingSlot(ctx)if err != nil {return nil, status.Errorf(codes.ResourceExhausted, "too many image processing requests")@@ -298,7 +303,7 @@ func (s *APIV1Service) ListAttachments(ctx context.Context, request *v1pb.ListAtif request.PageToken != "" {// Simple implementation: page token is the offset as string// In production, you might want to use encrypted tokens- if parsed, err := fmt.Sscanf(request.PageToken, "%d", &offset); err != nil || parsed != 1 {+ if parsed, err := fmt.Sscanf(request.PageToken, "%d", &offset); err != nil || parsed != 1 || offset < 0 {return nil, status.Errorf(codes.InvalidArgument, "invalid page token")}}diff --git a/server/api/v1/attachment_service_image.go b/server/api/v1/attachment_service_image.goindex dc15965f0..39a3ffbb7 100644--- a/server/api/v1/attachment_service_image.go+++ b/server/api/v1/attachment_service_image.go@@ -3,14 +3,15 @@ package v1import ("bytes""context"- "image""io"+ "net/http""github.com/disintegration/imaging""github.com/pkg/errors""google.golang.org/grpc/codes""google.golang.org/grpc/status"+ "github.com/usememos/memos/internal/imagelimit"v1pb "github.com/usememos/memos/proto/gen/api/v1"storepb "github.com/usememos/memos/proto/gen/store")@@ -45,6 +46,28 @@ func shouldStripExif(mimeType string) bool {return exifCapableImageTypes[mimeType]}+// shouldStripExifContent reports whether the content must be stripped of+// EXIF metadata, judging by the declared type and by sniffing the leading+// bytes. The source is rewound afterwards.+func shouldStripExifContent(source io.ReadSeeker, declaredType string) (bool, error) {+ if shouldStripExif(declaredType) {+ return true, nil+ }+ if _, err := source.Seek(0, io.SeekStart); err != nil {+ return false, errors.Wrap(err, "failed to rewind attachment content")+ }+ header := make([]byte, 512)+ n, err := io.ReadFull(source, header)+ if err != nil && !errors.Is(err, io.ErrUnexpectedEOF) && !errors.Is(err, io.EOF) {+ return false, errors.Wrap(err, "failed to read attachment header")+ }+ if _, err := source.Seek(0, io.SeekStart); err != nil {+ return false, errors.Wrap(err, "failed to rewind attachment content")+ }+ sniffed, ok := normalizeMimeType(http.DetectContentType(header[:n]))+ return ok && shouldStripExif(sniffed), nil+}+func (s *APIV1Service) acquireImageProcessingSlot(ctx context.Context) (func(), error) {if s.imageProcessingSemaphore == nil {return func() {}, nil@@ -58,19 +81,7 @@ func (s *APIV1Service) acquireImageProcessingSlot(ctx context.Context) (func(),}func validateImageReaderPixelCount(reader io.Reader) error {- config, _, err := image.DecodeConfig(reader)- if err != nil {- // Some formats supported by imaging do not expose dimensions through- // the standard image registry. Let the full decoder handle those.- return nil //nolint:nilerr- }- if config.Width <= 0 || config.Height <= 0 {- return errors.New("invalid image dimensions")- }- if config.Width > maxImagePixels/config.Height {- return errors.Errorf("image dimensions exceed maximum of %d pixels", maxImagePixels)- }- return nil+ return imagelimit.CheckReader(reader)}// stripImageExif removes EXIF metadata from image files by decoding and re-encoding them.@@ -79,7 +90,7 @@ func validateImageReaderPixelCount(reader io.Reader) error {// The function preserves the correct image orientation by applying EXIF orientation tags// during decoding before stripping all metadata. Images are re-encoded with high quality// to minimize visual degradation. The re-encoded output is returned in memory; its size-// is bounded by maxImagePixels, which the decoder already has to hold.+// is bounded by imagelimit.MaxPixels, which the decoder already has to hold.//// Supported formats:// - JPEG/JPG: Re-encoded as JPEG with quality 95diff --git a/server/api/v1/attachment_service_storage.go b/server/api/v1/attachment_service_storage.goindex 49d446a75..06e2663a7 100644--- a/server/api/v1/attachment_service_storage.go+++ b/server/api/v1/attachment_service_storage.go@@ -139,8 +139,15 @@ func saveAttachmentContent(if !strings.Contains(filepathTemplate, "{filename}") {filepathTemplate = filepath.Join(filepathTemplate, "{filename}")}- filepathTemplate = replaceFilenameWithPathTemplate(filepathTemplate, create.Filename)- key, err := driver.UploadObject(ctx, filepathTemplate, create.Type, content)+ objectKey := replaceFilenameWithPathTemplate(filepathTemplate, create.Filename)+ if !strings.Contains(filepathTemplate, "{uuid}") {+ // PutObject overwrites silently, and two users can pick the same+ // filename in the same second, so a template without a random+ // component gets the attachment UID appended to keep keys unique.+ ext := filepath.Ext(objectKey)+ objectKey = strings.TrimSuffix(objectKey, ext) + "_" + create.UID + ext+ }+ key, err := driver.UploadObject(ctx, objectKey, create.Type, content)if err != nil {return errors.Wrap(err, "failed to upload via storage driver")}diff --git a/server/api/v1/auth_service_session.go b/server/api/v1/auth_service_session.goindex d92bb1c1e..55bb0b3df 100644--- a/server/api/v1/auth_service_session.go+++ b/server/api/v1/auth_service_session.go@@ -182,6 +182,28 @@ func (s *APIV1Service) RefreshToken(ctx context.Context, _ *v1pb.RefreshTokenReq}, nil}+// currentRefreshTokenID returns the token ID of the refresh cookie on the+// request, or "" when the request carries no valid refresh cookie.+func currentRefreshTokenID(ctx context.Context, secret string) string {+ md, ok := metadata.FromIncomingContext(ctx)+ if !ok {+ return ""+ }+ cookies := md.Get("cookie")+ if len(cookies) == 0 {+ return ""+ }+ refreshToken := auth.ExtractRefreshTokenFromCookie(cookies[0])+ if refreshToken == "" {+ return ""+ }+ claims, err := auth.ParseRefreshToken(refreshToken, []byte(secret))+ if err != nil {+ return ""+ }+ return claims.TokenID+}+func (s *APIV1Service) clearAuthCookies(ctx context.Context) error {// Clear refresh token cookierefreshCookie := s.buildRefreshTokenCookie(ctx, "", time.Time{})diff --git a/server/api/v1/memo_archive_import.go b/server/api/v1/memo_archive_import.goindex 1184a5f44..12227451f 100644--- a/server/api/v1/memo_archive_import.go+++ b/server/api/v1/memo_archive_import.go@@ -18,6 +18,7 @@ import ("github.com/usememos/memos/core/memoarchive""github.com/usememos/memos/core/memopayload"+ "github.com/usememos/memos/internal/ratelimit"v1pb "github.com/usememos/memos/proto/gen/api/v1"storepb "github.com/usememos/memos/proto/gen/store""github.com/usememos/memos/store"@@ -167,7 +168,11 @@ func (s *APIV1Service) ImportMemoArchive(ctx context.Context, user *store.User,if err := importer.importMemo(record); err != nil {importer.report.Failed++importer.report.Failures = append(importer.report.Failures, &v1pb.MemoImportIssue{Memo: record.UID, Message: err.Error()})+ continue}+ // An imported memo counts against the same write budget as one+ // created through CreateMemo, so an archive cannot bypass it.+ s.charge(ratelimit.ScopeWriteUser, userKey(user.ID), 1)}for _, written := range importer.written {if err := ctx.Err(); err != nil {@@ -429,40 +434,58 @@ func (i *memoArchiveImporter) importAttachments(record *memoarchive.Memo, currenfor _, attachment := range current {bound[attachment.UID] = struct{}{}}+ toBind := make([]*v1pb.Attachment, 0, len(record.Attachments))+ // created holds only attachments this run stored; a pre-existing+ // attachment that is merely re-bound is never discarded on failure.created := make([]*v1pb.Attachment, 0, len(record.Attachments))for index := range record.Attachments {entry := &record.Attachments[index]if _, ok := bound[entry.UID]; ok {continue}- name, err := i.importAttachment(entry)+ name, stored, err := i.importAttachment(entry)if err != nil {i.discardAttachments(created)return nil, errors.Wrapf(err, "attachment %s", entry.UID)}- created = append(created, &v1pb.Attachment{Name: name})+ attachment := &v1pb.Attachment{Name: name}+ toBind = append(toBind, attachment)+ if stored {+ created = append(created, attachment)+ // Stored bytes count against the same upload budget as an upload.+ i.service.charge(ratelimit.ScopeUploadUser, userKey(i.user.ID), 1)+ }}- return created, nil+ return toBind, nil}// importAttachment stores one attachment entry and returns the resource name-// to bind.-func (i *memoArchiveImporter) importAttachment(entry *memoarchive.Attachment) (string, error) {+// to bind, and whether this run stored a new attachment for it.+func (i *memoArchiveImporter) importAttachment(entry *memoarchive.Attachment) (string, bool, error) {mimeType, ok := normalizeMimeType(entry.Type)if !ok {- return "", errors.Errorf("invalid media type %q", entry.Type)+ return "", false, errors.Errorf("invalid media type %q", entry.Type)}if !validateFilename(entry.Filename) {- return "", errors.New("filename contains invalid characters")+ return "", false, errors.New("filename contains invalid characters")}uid, err := i.resolveAttachmentUID(entry)if err != nil {- return "", err+ return "", false, err}if uid == "" {// An identical unlinked attachment already belongs to the user.- return AttachmentNamePrefix + entry.UID, nil+ return AttachmentNamePrefix + entry.UID, false, nil}+ name, err := i.storeAttachment(entry, uid, mimeType)+ if err != nil {+ return "", false, err+ }+ return name, true, nil+}++// storeAttachment writes a new attachment for the entry under uid.+func (i *memoArchiveImporter) storeAttachment(entry *memoarchive.Attachment, uid, mimeType string) (string, error) {if entry.ExternalLink != "" {attachment, err := i.service.Store.CreateAttachment(i.ctx, &store.Attachment{UID: uid,diff --git a/server/api/v1/ratelimit.go b/server/api/v1/ratelimit.goindex a430660fd..0ecfb24cc 100644--- a/server/api/v1/ratelimit.go+++ b/server/api/v1/ratelimit.go@@ -2,6 +2,8 @@ package v1import ("context"+ "crypto/sha256"+ "encoding/hex""log/slog""math""net/http"@@ -14,6 +16,7 @@ import ("google.golang.org/protobuf/types/known/durationpb""github.com/usememos/memos/internal/clientip"+ "github.com/usememos/memos/internal/identifier""github.com/usememos/memos/internal/ratelimit""github.com/usememos/memos/server/auth")@@ -122,6 +125,18 @@ func userKey(userID int32) string {return strconv.Itoa(int(userID))}+// accountKey is the limiter key for a submitted account name. Names longer+// than any valid username are replaced by a digest, so the limiter stores a+// bounded key for an attacker-chosen string while still counting each+// distinct submission separately.+func accountKey(username string) string {+ if len(username) <= identifier.MaxUsernameLength {+ return username+ }+ sum := sha256.Sum256([]byte(username))+ return "sha256:" + hex.EncodeToString(sum[:])+}+// charge records cost units against scope and key.func (s *APIV1Service) charge(scope ratelimit.Scope, key string, cost int) {if s.RateLimiter == nil || key == "" {@@ -198,7 +213,7 @@ type signInAttempt struct {// reserveSignIn consumes the sign-in budgets for an attempt. It returns the// rate-limit error when either budget is spent; a refusal charges nothing.func (s *APIV1Service) reserveSignIn(clientIP, username string) (*signInAttempt, error) {- attempt := &signInAttempt{service: s, clientIP: clientIP, username: username}+ attempt := &signInAttempt{service: s, clientIP: clientIP, username: accountKey(username)}if err := s.throttleAndCharge(ratelimit.ScopeSignInIP, clientIP, 1); err != nil {return nil, err}diff --git a/server/api/v1/ratelimit_test.go b/server/api/v1/ratelimit_test.goindex aeeba750d..691fe3f3d 100644--- a/server/api/v1/ratelimit_test.go+++ b/server/api/v1/ratelimit_test.go@@ -1,6 +1,7 @@package v1import (+ "strings""testing""time"@@ -10,6 +11,7 @@ import ("google.golang.org/grpc/codes""google.golang.org/grpc/status"+ "github.com/usememos/memos/internal/identifier""github.com/usememos/memos/internal/ratelimit")@@ -85,3 +87,14 @@ func TestNewChallengeRequiredError(t *testing.T) {require.Equal(t, reasonChallengeRequired, info.Reason)require.Nil(t, rateLimitHTTPHeaders(st))}++func TestAccountKeyBoundsLength(t *testing.T) {+ require.Equal(t, "alice", accountKey("alice"))+ long := strings.Repeat("a", identifier.MaxUsernameLength+1)+ key := accountKey(long)+ require.True(t, strings.HasPrefix(key, "sha256:"))+ require.Len(t, key, len("sha256:")+64)+ // Distinct submissions stay distinct; the same submission maps to one key.+ require.NotEqual(t, key, accountKey(long+"b"))+ require.Equal(t, key, accountKey(long))+}diff --git a/server/api/v1/request_body_limit_test.go b/server/api/v1/request_body_limit_test.gonew file mode 100644index 000000000..baaf61eba--- /dev/null+++ b/server/api/v1/request_body_limit_test.go@@ -0,0 +1,26 @@+package v1++import (+ "testing"++ "github.com/stretchr/testify/require"+)++// Only procedures that carry file bytes inline keep the large body cap; every+// other request is bounded by the general cap so buffered bodies cannot be+// used to exhaust memory.+func TestRequestBodyLimitPerProcedure(t *testing.T) {+ require.EqualValues(t, uploadRequestLimit, requestBodyLimit(attachmentUploadProcedure))+ require.EqualValues(t, uploadRequestLimit, requestBodyLimit(importMemosProcedure))+ require.EqualValues(t, MaxAPIRequestBytes, requestBodyLimit("/memos.api.v1.AttachmentService/CreateAttachment"))+ require.EqualValues(t, MaxAPIRequestBytes, requestBodyLimit("/memos.api.v1.AIService/Transcribe"))+ for _, procedure := range []string{+ "/memos.api.v1.AuthService/SignIn",+ "/memos.api.v1.UserService/CreateUser",+ "/memos.api.v1.MemoService/CreateMemo",+ "/memos.api.v1.MemoService/ListMemos",+ } {+ require.EqualValues(t, maxGeneralRequestBytes, requestBodyLimit(procedure), procedure)+ }+ require.Less(t, int64(maxGeneralRequestBytes), int64(MaxAPIRequestBytes))+}diff --git a/server/api/v1/test/attachment_service_s3_test.go b/server/api/v1/test/attachment_service_s3_test.goindex a33017aab..109481670 100644--- a/server/api/v1/test/attachment_service_s3_test.go+++ b/server/api/v1/test/attachment_service_s3_test.go@@ -255,3 +255,42 @@ func upsertS3StorageSetting(ctx context.Context, t testing.TB, ts *TestService,})require.NoError(t, err)}++// Two uploads with the same filename under a path template that carries no+// random component must not overwrite each other's object.+func TestS3ObjectKeysStayUniqueWithoutUUIDTemplate(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()+ fake := fakes3.New(t, "flat")+ ctx := context.Background()+ storage := fakeStorage("flat-s3", "Flat", fake.Config("flat"))+ _, err := ts.Store.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{+ Key: storepb.InstanceSettingKey_STORAGE,+ Value: &storepb.InstanceSetting_StorageSetting{StorageSetting: &storepb.InstanceStorageSetting{+ FilepathTemplate: "files/{filename}", UploadSizeLimitMb: 30, Storages: []*storepb.Storage{storage}, DefaultStorageId: storage.Id,+ }},+ })+ require.NoError(t, err)++ keys := map[string]bool{}+ for i, username := range []string{"first-user", "second-user"} {+ user, err := ts.CreateRegularUser(ctx, username)+ require.NoError(t, err)+ userCtx := ts.CreateUserContext(ctx, user.ID)+ content := []byte("content of user " + username)+ created, err := ts.Service.CreateAttachment(userCtx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{+ Filename: "notes.txt", Type: "text/plain", Content: content,+ }})+ require.NoError(t, err)+ uid, err := apiv1.ExtractAttachmentUIDFromName(created.Name)+ require.NoError(t, err)+ row, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid})+ require.NoError(t, err)+ key := row.Payload.GetS3Object().GetKey()+ require.False(t, keys[key], "upload %d reused key %q", i, key)+ keys[key] = true+ stored, err := fake.GetObject("flat", key)+ require.NoError(t, err)+ require.Equal(t, content, stored)+ }+}diff --git a/server/api/v1/test/attachment_service_test.go b/server/api/v1/test/attachment_service_test.goindex a0300b844..ab43adf43 100644--- a/server/api/v1/test/attachment_service_test.go+++ b/server/api/v1/test/attachment_service_test.go@@ -960,3 +960,13 @@ func TestDeleteMotionMediaGroupChecksBeyondDefaultAttachmentPage(t *testing.T) {_, err = ts.Service.DeleteAttachment(userCtx, &v1pb.DeleteAttachmentRequest{Name: "attachments/" + video.UID})require.Equal(t, codes.FailedPrecondition, status.Code(err))}++func TestListAttachmentsRejectsNegativePageToken(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()+ ctx := context.Background()+ user, err := ts.CreateRegularUser(ctx, "pager")+ require.NoError(t, err)+ _, err = ts.Service.ListAttachments(ts.CreateUserContext(ctx, user.ID), &v1pb.ListAttachmentsRequest{PageToken: "-5"})+ require.Equal(t, codes.InvalidArgument, status.Code(err))+}diff --git a/server/api/v1/test/memo_archive_test.go b/server/api/v1/test/memo_archive_test.goindex c6630199e..78ebb9a0a 100644--- a/server/api/v1/test/memo_archive_test.go+++ b/server/api/v1/test/memo_archive_test.go@@ -5,6 +5,7 @@ import ("context""crypto/sha256""encoding/hex"+ "strconv""testing""time"@@ -15,7 +16,9 @@ import ("google.golang.org/protobuf/types/known/timestamppb""github.com/usememos/memos/core/memoarchive"+ "github.com/usememos/memos/internal/ratelimit"v1pb "github.com/usememos/memos/proto/gen/api/v1"+ storepb "github.com/usememos/memos/proto/gen/store"apiv1 "github.com/usememos/memos/server/api/v1""github.com/usememos/memos/store")@@ -527,3 +530,116 @@ func TestImportMemos(t *testing.T) {require.Equal(t, codes.NotFound, status.Code(err))})}++// buildImportArchive writes a one-memo archive whose attachments are given+// as (uid, filename, bytes). Sizes and digests are computed from the bytes.+func buildImportArchive(t *testing.T, username string, attachments []struct {+ uid, filename string+ content []byte+}) []byte {+ t.Helper()+ var buf bytes.Buffer+ writer := memoarchive.NewWriter(&buf, mustTime(t, "2026-04-01T00:00:00Z"))+ require.NoError(t, writer.WriteManifest(&memoarchive.Manifest{+ Format: memoarchive.Format, FormatVersion: memoarchive.FormatVersion,+ Generator: memoarchive.Generator{Name: "test", Version: "1"},+ ExportTime: "2026-04-01T00:00:00Z",+ Scope: memoarchive.Scope{Kind: memoarchive.ScopeKindUser, User: &memoarchive.ScopeUser{Username: username}},+ }))+ record := &memoarchive.Memo{+ UID: "importedmemo1", Creator: username, CreateTime: "2026-04-01T00:00:00Z", UpdateTime: "2026-04-01T00:00:00Z",+ State: "NORMAL", Visibility: "PRIVATE", ContentPath: memoarchive.ContentPath("importedmemo1"),+ }+ for _, attachment := range attachments {+ path := memoarchive.AttachmentPath(attachment.uid, attachment.filename)+ digest, size, err := writer.WriteAttachment(path, bytes.NewReader(attachment.content))+ require.NoError(t, err)+ record.Attachments = append(record.Attachments, memoarchive.Attachment{+ UID: attachment.uid, Filename: attachment.filename, Type: "application/octet-stream", Size: size, SHA256: digest, Path: path,+ CreateTime: "2026-04-01T00:00:00Z",+ })+ }+ require.NoError(t, writer.WriteMemo(record, []byte("imported memo")))+ require.NoError(t, writer.Close())+ return buf.Bytes()+}++// A memo that fails to import must not take a pre-existing attachment of the+// user with it: only attachments the run stored are discarded.+func TestImportMemosFailureKeepsPreexistingAttachment(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()+ t.Cleanup(ts.Service.CloseUploads)+ ctx := context.Background()+ _, err := ts.Store.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{+ Key: storepb.InstanceSettingKey_STORAGE,+ Value: &storepb.InstanceSetting_StorageSetting{StorageSetting: &storepb.InstanceStorageSetting{UploadSizeLimitMb: 1}},+ })+ require.NoError(t, err)+ user, err := ts.CreateRegularUser(ctx, "keeper")+ require.NoError(t, err)+ userCtx := ts.CreateUserContext(ctx, user.ID)++ existingContent := []byte("bytes the user already uploaded")+ existing, err := ts.Service.CreateAttachment(userCtx, &v1pb.CreateAttachmentRequest{+ AttachmentId: "keepme0001",+ Attachment: &v1pb.Attachment{Filename: "keep.bin", Type: "application/octet-stream", Content: existingContent},+ })+ require.NoError(t, err)++ archive := buildImportArchive(t, "keeper", []struct {+ uid, filename string+ content []byte+ }{+ {"keepme0001", "keep.bin", existingContent},+ {"toolarge01", "big.bin", bytes.Repeat([]byte("x"), 2<<20)},+ })+ response, err := ts.Service.ImportMemos(userCtx, &v1pb.ImportMemosRequest{+ Name: userName(user),+ Upload: &v1pb.ImportMemosRequest_Spec{Spec: &v1pb.ImportMemosSpec{TotalSize: int64(len(archive))}},+ Data: archive,+ FinishWrite: true,+ })+ require.NoError(t, err)+ report := response.GetReport()+ require.NotNil(t, report)+ require.Equal(t, int32(1), report.Failed)+ require.Zero(t, report.Created)++ kept, err := ts.Service.GetAttachment(userCtx, &v1pb.GetAttachmentRequest{Name: existing.Name})+ require.NoError(t, err, "the pre-existing attachment survives the failed import")+ require.Equal(t, existing.Name, kept.Name)+}++// Imported memos and stored attachments count against the same per-user+// write and upload budgets as the regular create paths.+func TestImportMemosChargesWriteAndUploadBudgets(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()+ t.Cleanup(ts.Service.CloseUploads)+ limiter := ratelimit.NewMemoryLimiter(ratelimit.DefaultPolicy())+ ts.Service.RateLimiter = limiter+ ctx := context.Background()+ user, err := ts.CreateRegularUser(ctx, "charged")+ require.NoError(t, err)+ userCtx := ts.CreateUserContext(ctx, user.ID)+ key := strconv.Itoa(int(user.ID))+ writeBefore := limiter.Allowed(ratelimit.ScopeWriteUser, key, 1).Remaining+ uploadBefore := limiter.Allowed(ratelimit.ScopeUploadUser, key, 1).Remaining++ archive := buildImportArchive(t, "charged", []struct {+ uid, filename string+ content []byte+ }{{"newfile001", "new.bin", []byte("fresh bytes")}})+ response, err := ts.Service.ImportMemos(userCtx, &v1pb.ImportMemosRequest{+ Name: userName(user),+ Upload: &v1pb.ImportMemosRequest_Spec{Spec: &v1pb.ImportMemosSpec{TotalSize: int64(len(archive))}},+ Data: archive,+ FinishWrite: true,+ })+ require.NoError(t, err)+ require.Equal(t, int32(1), response.GetReport().Created)++ require.Equal(t, writeBefore-1, limiter.Allowed(ratelimit.ScopeWriteUser, key, 1).Remaining)+ require.Equal(t, uploadBefore-1, limiter.Allowed(ratelimit.ScopeUploadUser, key, 1).Remaining)+}diff --git a/server/api/v1/test/user_service_password_test.go b/server/api/v1/test/user_service_password_test.gonew file mode 100644index 000000000..3ac4d7e07--- /dev/null+++ b/server/api/v1/test/user_service_password_test.go@@ -0,0 +1,110 @@+package test++import (+ "context"+ "strings"+ "testing"++ "github.com/stretchr/testify/require"+ "google.golang.org/grpc/codes"+ "google.golang.org/grpc/metadata"+ "google.golang.org/grpc/status"+ "google.golang.org/protobuf/types/known/fieldmaskpb"+ "google.golang.org/protobuf/types/known/timestamppb"++ v1pb "github.com/usememos/memos/proto/gen/api/v1"+ storepb "github.com/usememos/memos/proto/gen/store"+ "github.com/usememos/memos/server/auth"+ "github.com/usememos/memos/store"+)++func addSession(ctx context.Context, t *testing.T, ts *TestService, userID int32, tokenID string) {+ t.Helper()+ require.NoError(t, ts.Store.AddUserRefreshToken(ctx, userID, &storepb.RefreshTokensUserSetting_RefreshToken{+ TokenId: tokenID, CreatedAt: timestamppb.Now(),+ }))+}++func sessionIDs(ctx context.Context, t *testing.T, ts *TestService, userID int32) []string {+ t.Helper()+ tokens, err := ts.Store.GetUserRefreshTokens(ctx, userID)+ require.NoError(t, err)+ ids := make([]string, 0, len(tokens))+ for _, token := range tokens {+ ids = append(ids, token.TokenId)+ }+ return ids+}++func changePassword(ctx context.Context, ts *TestService, user *store.User, password string) error {+ _, err := ts.Service.UpdateUser(ctx, &v1pb.UpdateUserRequest{+ User: &v1pb.User{Name: "users/" + user.Username, Password: password},+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"password"}},+ })+ return err+}++// Changing a password ends every other session of the account; the browser+// session that made the change keeps working.+func TestUpdateUserPasswordRevokesOtherSessions(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()+ ctx := context.Background()+ user, err := ts.CreateRegularUser(ctx, "rotator")+ require.NoError(t, err)+ addSession(ctx, t, ts, user.ID, "current-browser")+ addSession(ctx, t, ts, user.ID, "stolen-session")+ addSession(ctx, t, ts, user.ID, "old-phone")++ refreshToken, _, err := auth.GenerateRefreshToken(user.ID, "current-browser", []byte(ts.Service.Secret))+ require.NoError(t, err)+ userCtx := metadata.NewIncomingContext(ts.CreateUserContext(ctx, user.ID), metadata.Pairs("cookie", auth.RefreshTokenCookieName+"="+refreshToken))++ require.NoError(t, changePassword(userCtx, ts, user, "new-password"))+ require.Equal(t, []string{"current-browser"}, sessionIDs(ctx, t, ts, user.ID))++ // Without a refresh cookie (an API token caller) every session is revoked.+ addSession(ctx, t, ts, user.ID, "another")+ require.NoError(t, changePassword(ts.CreateUserContext(ctx, user.ID), ts, user, "newer-password"))+ require.Empty(t, sessionIDs(ctx, t, ts, user.ID))+}++// An administrator resetting another account's password revokes all of that+// account's sessions, never the administrator's own.+func TestAdminPasswordResetRevokesTargetSessions(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()+ ctx := context.Background()+ admin, err := ts.CreateHostUser(ctx, "admin")+ require.NoError(t, err)+ target, err := ts.CreateRegularUser(ctx, "target")+ require.NoError(t, err)+ addSession(ctx, t, ts, admin.ID, "admin-browser")+ addSession(ctx, t, ts, target.ID, "target-browser")++ adminToken, _, err := auth.GenerateRefreshToken(admin.ID, "admin-browser", []byte(ts.Service.Secret))+ require.NoError(t, err)+ adminCtx := metadata.NewIncomingContext(ts.CreateUserContext(ctx, admin.ID), metadata.Pairs("cookie", auth.RefreshTokenCookieName+"="+adminToken))++ require.NoError(t, changePassword(adminCtx, ts, target, "reset-by-admin"))+ require.Empty(t, sessionIDs(ctx, t, ts, target.ID))+ require.Equal(t, []string{"admin-browser"}, sessionIDs(ctx, t, ts, admin.ID))+}++// The avatar size limit the web client applies is enforced by the server too.+func TestUpdateUserAvatarSizeBoundedServerSide(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()+ ctx := context.Background()+ user, err := ts.CreateRegularUser(ctx, "avatar")+ require.NoError(t, err)+ userCtx := ts.CreateUserContext(ctx, user.ID)++ oversized := "data:image/png;base64," + strings.Repeat("A", 3<<20)+ _, err = ts.Service.UpdateUser(userCtx, &v1pb.UpdateUserRequest{+ User: &v1pb.User{Name: "users/" + user.Username, AvatarUrl: oversized},+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"avatar_url"}},+ })+ require.Equal(t, codes.InvalidArgument, status.Code(err))+ require.Contains(t, err.Error(), "avatar exceeds")+}diff --git a/server/api/v1/user_service.go b/server/api/v1/user_service.goindex 5ae637415..2f1995875 100644--- a/server/api/v1/user_service.go+++ b/server/api/v1/user_service.go@@ -24,6 +24,15 @@ import (const maxBatchGetUsers = 100+const (+ // maxAvatarImageBytes is the largest avatar image a user may set. It+ // matches the limit the web client enforces before encoding the file.+ maxAvatarImageBytes = 2 << 20+ // maxAvatarDataURIBytes bounds the stored data URI: the image bytes+ // base64-encoded (4/3 expansion) plus the "data:<type>;base64," prefix.+ maxAvatarDataURIBytes = maxAvatarImageBytes/3*4 + 256+)+func validatePassword(password string) error {if password == "" {return errors.New("password must not be empty")@@ -359,6 +368,7 @@ func (s *APIV1Service) UpdateUser(ctx context.Context, request *v1pb.UpdateUserRif err != nil {return nil, status.Errorf(codes.Internal, "failed to get instance general setting: %v", err)}+ passwordChanged := falsefor _, field := range request.UpdateMask.Paths {switch field {case "username":@@ -383,6 +393,9 @@ func (s *APIV1Service) UpdateUser(ctx context.Context, request *v1pb.UpdateUserRcase "avatar_url":// Validate avatar MIME type to prevent XSS during uploadif request.User.AvatarUrl != "" {+ if len(request.User.AvatarUrl) > maxAvatarDataURIBytes {+ return nil, status.Errorf(codes.InvalidArgument, "avatar exceeds the maximum size of %d bytes", maxAvatarImageBytes)+ }imageType, _, err := extractImageInfo(request.User.AvatarUrl)if err != nil {return nil, status.Errorf(codes.InvalidArgument, "invalid avatar format: %v", err)@@ -419,6 +432,7 @@ func (s *APIV1Service) UpdateUser(ctx context.Context, request *v1pb.UpdateUserR}passwordHashStr := string(passwordHash)update.PasswordHash = &passwordHashStr+ passwordChanged = truecase "state":if currentUser.Role != store.RoleAdmin {return nil, status.Errorf(codes.PermissionDenied, "permission denied")@@ -437,6 +451,18 @@ func (s *APIV1Service) UpdateUser(ctx context.Context, request *v1pb.UpdateUserR}return nil, convertUserWriteError(err, "failed to update user")}+ if passwordChanged {+ // A new password ends every other session. The caller's own browser+ // session survives when they changed their own password; an admin+ // resetting another account revokes all of that account's sessions.+ keepTokenID := ""+ if currentUser.ID == user.ID {+ keepTokenID = currentRefreshTokenID(ctx, s.Secret)+ }+ if err := s.Store.RemoveUserRefreshTokensExcept(ctx, user.ID, keepTokenID); err != nil {+ slog.Warn("failed to revoke sessions after password change", "user_id", user.ID, "error", err)+ }+ }return convertUserFromStore(updatedUser, currentUser), nil}diff --git a/server/api/v1/user_service_memo_archive.go b/server/api/v1/user_service_memo_archive.goindex b785617cd..2f36e8a7e 100644--- a/server/api/v1/user_service_memo_archive.go+++ b/server/api/v1/user_service_memo_archive.go@@ -140,6 +140,11 @@ func (s *APIV1Service) finishMemoImport(ctx context.Context, user *store.User, ureturn status.Errorf(codes.InvalidArgument, "invalid memo archive: %v", err)}if request.ValidateOnly {+ // A plan can be requested again and again on the same staged archive,+ // each time re-parsing it in full, so it costs an archive unit too.+ if err := s.throttleAndCharge(ratelimit.ScopeArchiveUser, userKey(user.ID), 1); err != nil {+ return err+ }plan, err := s.PlanMemoArchiveImport(ctx, user, archive)if err != nil {slog.Error("memo archive plan failed", slog.Int("user", int(user.ID)), slog.Any("error", err))diff --git a/server/api/v1/v1.go b/server/api/v1/v1.goindex e15d2eeb1..7c270e20c 100644--- a/server/api/v1/v1.go+++ b/server/api/v1/v1.go@@ -29,13 +29,30 @@ import (// it derives its own limit from this constant to keep the two gates in lockstep.const MaxAPIRequestBytes = 256 << 20+// maxGeneralRequestBytes caps every procedure that does not carry file bytes.+// Request bodies are buffered in memory before they are parsed, so the cap is+// what bounds memory per in-flight request; it leaves ample room for the+// largest memo content and settings an instance can be configured to accept.+const maxGeneralRequestBytes = 16 << 20++// inlineContentProcedures carry a whole file in one request body and keep+// the large cap; the size of that content is checked again by the handler+// against the instance upload limit.+var inlineContentProcedures = map[string]struct{}{+ "/memos.api.v1.AttachmentService/CreateAttachment": {},+ "/memos.api.v1.AIService/Transcribe": {},+}+// requestBodyLimit returns the request body cap for a procedure. Chunked// uploads carry at most one chunk per call, so they get a much lower cap.func requestBodyLimit(procedure string) int64 {if procedure == attachmentUploadProcedure || procedure == importMemosProcedure {return uploadRequestLimit}- return MaxAPIRequestBytes+ if _, ok := inlineContentProcedures[procedure]; ok {+ return MaxAPIRequestBytes+ }+ return maxGeneralRequestBytes}type APIV1Service struct {diff --git a/server/fileserver/fileserver.go b/server/fileserver/fileserver.goindex 263ad634d..e7a945bf1 100644--- a/server/fileserver/fileserver.go+++ b/server/fileserver/fileserver.go@@ -21,6 +21,7 @@ import ("golang.org/x/sync/semaphore""github.com/usememos/memos/core/access"+ "github.com/usememos/memos/internal/imagelimit""github.com/usememos/memos/internal/motionphoto""github.com/usememos/memos/internal/profile"storepb "github.com/usememos/memos/proto/gen/store"@@ -47,6 +48,11 @@ const (// maxConcurrentThumbnails limits concurrent thumbnail generation to prevent memory exhaustion.maxConcurrentThumbnails = 3+ // thumbnailFailedMarkerSuffix names the empty file left next to a+ // thumbnail that could not be generated, so an image that fails to decode+ // is not decoded again on every request.+ thumbnailFailedMarkerSuffix = ".failed"+// cacheMaxAge is the max-age value for Cache-Control headers (1 hour).cacheMaxAge = "public, max-age=3600"@@ -89,6 +95,12 @@ var avatarAllowedTypes = map[string]bool{var errUseOriginalForThumbnail = errors.New("serve original image instead of metadata-stripping thumbnail")+// errThumbnailUnsupported marks an image the server will never thumbnail:+// one whose declared size exceeds the decode bound or whose bytes do not+// decode. Only these failures are remembered; a storage read error is+// transient and must be retried.+var errThumbnailUnsupported = errors.New("image cannot be thumbnailed")+// dataURIRegex parses data URI format: data:image/png;base64,iVBORw0KGgo...var dataURIRegex = regexp.MustCompile(`^data:(?P<type>[^;]+);base64,(?P<base64>.+)`)@@ -132,10 +144,10 @@ func (s *FileServerService) serveAttachmentFile(c *echo.Context) error {wantThumbnail := c.QueryParam("thumbnail") == "true"wantMotion := c.QueryParam("motion") == "true"- attachment, err := s.Store.GetAttachment(ctx, &store.FindAttachment{- UID: &uid,- GetBlob: true,- })+ // Authorize on metadata alone. Database-stored bytes are loaded only+ // after the read is permitted, so an unauthorized request never pulls a+ // blob out of the database.+ attachment, err := s.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid})if err != nil {return echo.NewHTTPError(http.StatusInternalServerError, "failed to get attachment").Wrap(err)}@@ -150,6 +162,15 @@ func (s *FileServerService) serveAttachmentFile(c *echo.Context) error {if readClass == access.MemoReadClassPublic {c.Response().Header().Set(echo.HeaderCacheControl, publicAttachmentCacheControl)}+ if attachment.StorageType != storepb.AttachmentStorageType_LOCAL && attachment.StorageType != storepb.AttachmentStorageType_S3 {+ attachment, err = s.Store.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID, GetBlob: true})+ if err != nil {+ return echo.NewHTTPError(http.StatusInternalServerError, "failed to get attachment").Wrap(err)+ }+ if attachment == nil {+ return echo.NewHTTPError(http.StatusNotFound, "attachment not found")+ }+ }if wantMotion {return s.serveMotionClip(c, attachment)@@ -401,6 +422,9 @@ func (s *FileServerService) getOrGenerateThumbnail(ctx context.Context, attachmeif blob, err := os.ReadFile(thumbnailPath); err == nil {return blob, nil}+ if _, err := os.Stat(thumbnailPath + thumbnailFailedMarkerSuffix); err == nil {+ return nil, errUseOriginalForThumbnail+ }useOriginal, err := s.shouldUseOriginalForThumbnail(ctx, attachment)if err != nil {@@ -420,8 +444,21 @@ func (s *FileServerService) getOrGenerateThumbnail(ctx context.Context, attachmeif blob, err := os.ReadFile(thumbnailPath); err == nil {return blob, nil}+ if _, err := os.Stat(thumbnailPath + thumbnailFailedMarkerSuffix); err == nil {+ return nil, errUseOriginalForThumbnail+ }- return s.generateThumbnail(ctx, attachment, thumbnailPath)+ blob, err := s.generateThumbnail(ctx, attachment, thumbnailPath)+ if errors.Is(err, errThumbnailUnsupported) && ctx.Err() == nil {+ // Remember the verdict so the next request serves the original+ // without decoding again. A canceled request is not a verdict on the+ // image. The marker is removed with the attachment's other derived+ // caches.+ if markerErr := os.WriteFile(thumbnailPath+thumbnailFailedMarkerSuffix, nil, 0644); markerErr != nil {+ slog.Warn("failed to record thumbnail failure", "error", markerErr)+ }+ }+ return blob, err}// getThumbnailPath returns the file path for a cached thumbnail.@@ -498,6 +535,14 @@ func hasThumbnailSensitiveMetadata(data []byte) bool {// generateThumbnail creates a new thumbnail and saves it to disk.func (s *FileServerService) generateThumbnail(ctx context.Context, attachment *store.Attachment, thumbnailPath string) ([]byte, error) {+ // Bound the decode before paying for it: the pixel count is read from+ // the header, and the upload path only enforces it for the formats it+ // re-encodes, so a stored image may still declare far more pixels than+ // the server is willing to allocate.+ if err := s.checkThumbnailSourceBounds(ctx, attachment); err != nil {+ return nil, err+ }+reader, err := s.getAttachmentReader(ctx, attachment)if err != nil {return nil, errors.Wrap(err, "failed to get attachment reader")@@ -506,7 +551,7 @@ func (s *FileServerService) generateThumbnail(ctx context.Context, attachment *simg, err := imaging.Decode(reader, imaging.AutoOrientation(true))if err != nil {- return nil, errors.Wrap(err, "failed to decode image")+ return nil, errors.Wrapf(errThumbnailUnsupported, "failed to decode image: %v", err)}width, height := img.Bounds().Dx(), img.Bounds().Dy()@@ -525,6 +570,20 @@ func (s *FileServerService) generateThumbnail(ctx context.Context, attachment *sreturn buf.Bytes(), nil}+// checkThumbnailSourceBounds reads the image header and refuses images whose+// declared dimensions exceed the decode budget.+func (s *FileServerService) checkThumbnailSourceBounds(ctx context.Context, attachment *store.Attachment) error {+ reader, err := s.getAttachmentReader(ctx, attachment)+ if err != nil {+ return errors.Wrap(err, "failed to open image for size probe")+ }+ defer reader.Close()+ if err := imagelimit.CheckReader(io.LimitReader(reader, thumbnailMetadataProbeSize)); err != nil {+ return errors.Wrapf(errThumbnailUnsupported, "thumbnail source exceeds decode bounds: %v", err)+ }+ return nil+}+// calculateThumbnailDimensions calculates the target dimensions for a thumbnail.// The largest dimension is constrained to thumbnailMaxSize while maintaining aspect ratio.// Small images are not enlarged.diff --git a/server/fileserver/fileserver_test.go b/server/fileserver/fileserver_test.goindex 0a04867ff..f960c5eb8 100644--- a/server/fileserver/fileserver_test.go+++ b/server/fileserver/fileserver_test.go@@ -12,6 +12,8 @@ import ("image/png""net/http""net/http/httptest"+ "os"+ "path/filepath""strings""testing""time"@@ -31,6 +33,7 @@ import (apiv1service "github.com/usememos/memos/server/api/v1""github.com/usememos/memos/server/auth""github.com/usememos/memos/store"+ "github.com/usememos/memos/store/db"teststore "github.com/usememos/memos/store/test")@@ -861,3 +864,164 @@ func newExpiredRefreshTokenCookie(ctx context.Context, t *testing.T, stores *storequire.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 *apiv1service.APIV1Service, username, filename, mimeType string, content []byte) *apiv1.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, &apiv1.CreateAttachmentRequest{Attachment: &apiv1.Attachment{+ Filename: filename, Type: mimeType, Content: content,+ }})+ require.NoError(t, err)+ _, err = svc.CreateMemo(creatorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{+ Content: "image memo", Visibility: apiv1.Visibility_PUBLIC, Attachments: []*apiv1.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 := echo.New()+ fs.RegisterRoutes(e)+ 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(echo.HeaderContentType))+ 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) (*apiv1service.APIV1Service, *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 := &apiv1service.APIV1Service{+ Secret: secret,+ Profile: testProfile,+ Store: testStore,+ MarkdownService: markdown.NewService(markdown.WithTagExtension()),+ SSEHub: apiv1service.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 := echo.New()+ fs.RegisterRoutes(e)+ 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(echo.HeaderContentType))+ 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, &apiv1.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()+ _, err := svc.Store.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)++ 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 := echo.New()+ fs.RegisterRoutes(e)+ 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(echo.HeaderContentType))+}diff --git a/server/server.go b/server/server.goindex 4d71f8366..17b30e830 100644--- a/server/server.go+++ b/server/server.go@@ -24,7 +24,17 @@ import ("github.com/usememos/memos/store")-const shutdownTimeout = 10 * time.Second+const (+ shutdownTimeout = 10 * time.Second++ // readHeaderTimeout bounds how long a client may take to send request+ // headers, so idle or slow connections cannot pin a worker forever. Bodies+ // and responses are not bounded here: uploads and SSE streams are+ // legitimately long, and the request context still ends on disconnect.+ readHeaderTimeout = 15 * time.Second+ // idleTimeout closes keep-alive connections that send nothing.+ idleTimeout = 2 * time.Minute+)type Server struct {Secret string@@ -117,7 +127,11 @@ func (s *Server) Start() error {}// Start Echo server directly (no cmux needed - all traffic is HTTP).- s.httpServer = &http.Server{Handler: s.echoServer}+ s.httpServer = &http.Server{+ Handler: s.echoServer,+ ReadHeaderTimeout: readHeaderTimeout,+ IdleTimeout: idleTimeout,+ }go func() {if err := s.httpServer.Serve(listener); err != nil && err != http.ErrServerClosed {slog.Error("failed to start echo server", "error", err)diff --git a/store/attachment.go b/store/attachment.goindex 2fa922c59..0d801ca6b 100644--- a/store/attachment.go+++ b/store/attachment.go@@ -381,8 +381,14 @@ func AttachmentNeedsInstanceStorageSetting(attachment *Attachment) bool {return attachment.Payload.GetS3Object() != nil}+// deleteAttachmentDerivedCaches removes every derived asset the file server+// may have written for the attachment: the current thumbnail, its failure+// marker, the pre-v2 thumbnail name, and the extracted motion clip. The names+// must match server/fileserver.func (s *Store) deleteAttachmentDerivedCaches(attachment *Attachment) {for _, cachePath := range []string{+ filepath.Join(s.profile.Data, thumbnailCacheFolder, attachment.UID+".v2.jpeg"),+ filepath.Join(s.profile.Data, thumbnailCacheFolder, attachment.UID+".v2.jpeg.failed"),filepath.Join(s.profile.Data, thumbnailCacheFolder, attachment.UID+".jpeg"),filepath.Join(s.profile.Data, motionCacheFolder, attachment.UID+".mp4"),} {diff --git a/store/db/sqlite/functions.go b/store/db/sqlite/functions.goindex 4e87f927a..b85b342e4 100644--- a/store/db/sqlite/functions.go+++ b/store/db/sqlite/functions.go@@ -8,6 +8,7 @@ import ("errors""regexp""sync"+ "sync/atomic""golang.org/x/text/cases"msqlite "modernc.org/sqlite"@@ -50,8 +51,16 @@ var (registerRegexpErr error// regexpCache memoizes compiled patterns; keys are pattern strings.regexpCache sync.Map+ // regexpCacheSize counts cached patterns so a stream of distinct+ // attacker-chosen patterns cannot grow the cache without bound.+ regexpCacheSize atomic.Int64)+// maxRegexpCacheEntries caps the compiled-pattern cache. When it is full the+// cache is cleared rather than evicted entry by entry; recompiling a pattern+// is cheap next to letting the cache grow unbounded.+const maxRegexpCacheEntries = 256+// ensureRegexpRegistered registers a Go-backed `regexp(pattern, value)` scalar// function so SQLite's `value REGEXP pattern` operator works (modernc.org/sqlite// has no built-in implementation). Patterns use Go's RE2 syntax. Registered once@@ -99,6 +108,12 @@ func compileRegexp(pattern string) (*regexp.Regexp, error) {if err != nil {return nil, err}- regexpCache.Store(pattern, re)+ if regexpCacheSize.Load() >= maxRegexpCacheEntries {+ regexpCache.Clear()+ regexpCacheSize.Store(0)+ }+ if _, loaded := regexpCache.LoadOrStore(pattern, re); !loaded {+ regexpCacheSize.Add(1)+ }return re, nil}diff --git a/store/db/sqlite/functions_test.go b/store/db/sqlite/functions_test.goindex 413708bea..87019eb5d 100644--- a/store/db/sqlite/functions_test.go+++ b/store/db/sqlite/functions_test.go@@ -1,6 +1,7 @@package sqliteimport (+ "fmt""testing""github.com/stretchr/testify/require"@@ -22,3 +23,16 @@ func TestRegexpFunctionMatches(t *testing.T) {_, err = compileRegexp(`(`)require.Error(t, err)}++func TestRegexpCacheStaysBounded(t *testing.T) {+ regexpCache.Clear()+ regexpCacheSize.Store(0)+ for i := range maxRegexpCacheEntries * 3 {+ _, err := compileRegexp(fmt.Sprintf(`^pattern-%d$`, i))+ require.NoError(t, err)+ require.LessOrEqual(t, regexpCacheSize.Load(), int64(maxRegexpCacheEntries))+ }+ count := 0+ regexpCache.Range(func(_, _ any) bool { count++; return true })+ require.LessOrEqual(t, count, maxRegexpCacheEntries)+}diff --git a/store/test/user_setting_refresh_prune_test.go b/store/test/user_setting_refresh_prune_test.gonew file mode 100644index 000000000..842dd3efe--- /dev/null+++ b/store/test/user_setting_refresh_prune_test.go@@ -0,0 +1,58 @@+package test++import (+ "context"+ "testing"+ "time"++ "github.com/stretchr/testify/require"+ "google.golang.org/protobuf/types/known/timestamppb"++ storepb "github.com/usememos/memos/proto/gen/store"+)++func TestUserSettingRefreshTokensPruneExpiredOnAdd(t *testing.T) {+ t.Parallel()+ ctx := context.Background()+ ts := NewTestingStore(ctx, t)+ defer ts.Close()+ user, err := createTestingHostUser(ctx, ts)+ require.NoError(t, err)++ expired := &storepb.RefreshTokensUserSetting_RefreshToken{TokenId: "expired", ExpiresAt: timestamppb.New(time.Now().Add(-time.Hour))}+ live := &storepb.RefreshTokensUserSetting_RefreshToken{TokenId: "live", ExpiresAt: timestamppb.New(time.Now().Add(time.Hour))}+ require.NoError(t, ts.AddUserRefreshToken(ctx, user.ID, expired))+ require.NoError(t, ts.AddUserRefreshToken(ctx, user.ID, live))+ require.NoError(t, ts.AddUserRefreshToken(ctx, user.ID, &storepb.RefreshTokensUserSetting_RefreshToken{TokenId: "newest"}))++ tokens, err := ts.GetUserRefreshTokens(ctx, user.ID)+ require.NoError(t, err)+ ids := []string{}+ for _, token := range tokens {+ ids = append(ids, token.TokenId)+ }+ require.Equal(t, []string{"live", "newest"}, ids)+}++func TestUserSettingRemoveRefreshTokensExcept(t *testing.T) {+ t.Parallel()+ ctx := context.Background()+ ts := NewTestingStore(ctx, t)+ defer ts.Close()+ user, err := createTestingHostUser(ctx, ts)+ require.NoError(t, err)+ for _, id := range []string{"a", "b", "c"} {+ require.NoError(t, ts.AddUserRefreshToken(ctx, user.ID, &storepb.RefreshTokensUserSetting_RefreshToken{TokenId: id}))+ }++ require.NoError(t, ts.RemoveUserRefreshTokensExcept(ctx, user.ID, "b"))+ tokens, err := ts.GetUserRefreshTokens(ctx, user.ID)+ require.NoError(t, err)+ require.Len(t, tokens, 1)+ require.Equal(t, "b", tokens[0].TokenId)++ require.NoError(t, ts.RemoveUserRefreshTokensExcept(ctx, user.ID, ""))+ tokens, err = ts.GetUserRefreshTokens(ctx, user.ID)+ require.NoError(t, err)+ require.Empty(t, tokens)+}diff --git a/store/user_setting.go b/store/user_setting.goindex dd7031577..a75b16127 100644--- a/store/user_setting.go+++ b/store/user_setting.go@@ -2,6 +2,7 @@ package storeimport ("context"+ "time""github.com/pkg/errors""google.golang.org/protobuf/encoding/protojson"@@ -170,7 +171,10 @@ func (s *Store) AddUserRefreshToken(ctx context.Context, userID int32, token *streturn err}- tokens = append(tokens, token)+ // Expired tokens can never authenticate again; drop them here so the+ // list is bounded by the tokens issued within one lifetime rather than+ // by every sign-in the account ever made.+ tokens = append(pruneExpiredRefreshTokens(tokens, time.Now()), token)_, err = s.UpsertUserSetting(ctx, &storepb.UserSetting{UserId: userID,@@ -184,6 +188,43 @@ func (s *Store) AddUserRefreshToken(ctx context.Context, userID int32, token *streturn err}+func pruneExpiredRefreshTokens(tokens []*storepb.RefreshTokensUserSetting_RefreshToken, now time.Time) []*storepb.RefreshTokensUserSetting_RefreshToken {+ live := make([]*storepb.RefreshTokensUserSetting_RefreshToken, 0, len(tokens))+ for _, token := range tokens {+ if token == nil || (token.ExpiresAt != nil && token.ExpiresAt.AsTime().Before(now)) {+ continue+ }+ live = append(live, token)+ }+ return live+}++// RemoveUserRefreshTokensExcept revokes every refresh token of the user other+// than keepTokenID. An empty keepTokenID revokes all of them.+func (s *Store) RemoveUserRefreshTokensExcept(ctx context.Context, userID int32, keepTokenID string) error {+ s.refreshTokenMu.Lock()+ defer s.refreshTokenMu.Unlock()++ existingTokens, err := s.GetUserRefreshTokens(ctx, userID)+ if err != nil {+ return err+ }+ kept := make([]*storepb.RefreshTokensUserSetting_RefreshToken, 0, 1)+ for _, token := range existingTokens {+ if keepTokenID != "" && token.TokenId == keepTokenID {+ kept = append(kept, token)+ }+ }+ _, err = s.UpsertUserSetting(ctx, &storepb.UserSetting{+ UserId: userID,+ Key: storepb.UserSetting_REFRESH_TOKENS,+ Value: &storepb.UserSetting_RefreshTokens{+ RefreshTokens: &storepb.RefreshTokensUserSetting{RefreshTokens: kept},+ },+ })+ return err+}+// RemoveUserRefreshToken removes a refresh token from the user.func (s *Store) RemoveUserRefreshToken(ctx context.Context, userID int32, tokenID string) error {s.refreshTokenMu.Lock()diff --git a/web/src/components/MemoContent/LinkMetadataCard.tsx b/web/src/components/MemoContent/LinkMetadataCard.tsxindex 36d2a329c..e63fe648c 100644--- a/web/src/components/MemoContent/LinkMetadataCard.tsx+++ b/web/src/components/MemoContent/LinkMetadataCard.tsx@@ -59,6 +59,7 @@ const LinkMetadataCard = ({ url, fallback, enabled = true }: LinkMetadataCardProclassName="h-full w-full object-cover transition-transform duration-200 group-hover:scale-[1.01]"loading="lazy"decoding="async"+ referrerPolicy="no-referrer"onError={() => setImageFailed(true)}/></span>diff --git a/web/src/components/MemoContent/constants.ts b/web/src/components/MemoContent/constants.tsindex b91efd8e1..faec6a24f 100644--- a/web/src/components/MemoContent/constants.ts+++ b/web/src/components/MemoContent/constants.ts@@ -57,7 +57,9 @@ export const SANITIZE_SCHEMA = {"loading",],},- tagNames: [...(defaultSchema.tagNames || []), "iframe"],+ // `picture`/`source` carry `srcSet`, which the https-only `src` rule below does not cover;+ // drop them so every remote image goes through the `img` `src` rule.+ tagNames: [...(defaultSchema.tagNames || []).filter((tag) => tag !== "picture" && tag !== "source"), "iframe"],protocols: {...defaultSchema.protocols,src: ["https"],diff --git a/web/src/components/MemoContent/markdown/Image.tsx b/web/src/components/MemoContent/markdown/Image.tsxindex ebcb58643..9e84e6e75 100644--- a/web/src/components/MemoContent/markdown/Image.tsx+++ b/web/src/components/MemoContent/markdown/Image.tsx@@ -16,6 +16,7 @@ export const Image = ({ className, alt, node: _node, height, width, style, ...pr{...props}loading="lazy"decoding="async"+ referrerPolicy="no-referrer"/>);};diff --git a/web/tests/memo-content-security.test.tsx b/web/tests/memo-content-security.test.tsxindex 7fd059dcf..cc108165f 100644--- a/web/tests/memo-content-security.test.tsx+++ b/web/tests/memo-content-security.test.tsx@@ -76,6 +76,17 @@ describe("trusted iframe providers", () => {expect(isTrustedIframeSrc("https://evil.example/embed/abc123")).toBe(false);});+ it("drops picture sources that would bypass the https-only image rule", () => {+ const html = renderMemoContent(+ '<picture><source srcset="http://tracker.example/a.png"><img src="https://img.example/a.png"></picture>',+ );++ expect(html).not.toMatch(/<picture/);+ expect(html).not.toMatch(/<source/);+ expect(html).not.toMatch(/tracker\.example/);+ expect(html).toMatch(/img\.example\/a\.png/);+ });+it("drops untrusted iframe embeds during rendering", () => {const trusted = renderMemoContent('<iframe src="https://www.youtube.com/embed/abc123" title="demo"></iframe>');const untrusted = renderMemoContent('<iframe src="https://evil.example/embed/abc123" title="demo"></iframe>');