Skip to content

🎧 Your Personal Streaming Service

fix(artwork): only use image files as local artwork sources (#6180)

Deluan Quintão8b4125267eda
diff --git a/core/artwork/artwork.go b/core/artwork/artwork.go
index 663d06d25..e27fa118e 100644
--- a/core/artwork/artwork.go
+++ b/core/artwork/artwork.go
@@ -168,6 +168,11 @@ func (s *service) serveHash(ctx context.Context, artID model.ArtworkID, ia *mode
if !entityExists(ctx, s.ds, artID) {
return nil, ErrUnavailable
}
+ // Checked here, not in openOriginal: a resize-cache hit never opens the source.
+ if isFileBacked(ia.Source) && !model.IsImageFile(ia.SourcePath) {
+ log.Warn(ctx, "Artwork: Stored source is not an image file, re-resolving", "artID", artID, "path", ia.SourcePath)
+ return s.dangling(ctx, artID)
+ }
art, err := s.ds.Artwork(ctx).GetImage(ia.Hash)
if err != nil {
if errors.Is(err, model.ErrNotFound) {
diff --git a/core/artwork/artwork_test.go b/core/artwork/artwork_test.go
index 907b300de..8b35a872e 100644
--- a/core/artwork/artwork_test.go
+++ b/core/artwork/artwork_test.go
@@ -159,6 +159,53 @@ var _ = Describe("Artwork", func() {
Expect(readAll(img)).To(Equal(coverBytes))
})
+ It("treats a file-backed row pointing at a non-image file as dangling", func() {
+ dir := GinkgoT().TempDir()
+ secretPath := filepath.Join(dir, "config.ini")
+ Expect(os.WriteFile(secretPath, []byte("password=secret"), 0600)).To(Succeed())
+ Expect(artRepo.PutImage(&model.Artwork{Hash: "dddddddddddddddd", Mime: "image/jpeg"})).To(Succeed())
+ seedEntity("al", "alni")
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "al", ItemID: "alni", Hash: "dddddddddddddddd",
+ Source: "folder", SourcePath: secretPath, RefMtime: fileMtime(secretPath),
+ })).To(Succeed())
+
+ _, err := svc.Get(ctx, model.MustParseArtworkID("al-alni"), 0, false)
+ Expect(err).To(MatchError(ErrUnavailable))
+ Expect(queueRepo.Data[primaryKey("al", "alni")].Priority).To(Equal(model.ArtworkPriorityScan))
+ })
+
+ It("refuses a non-image file-backed row even when a resized copy is already cached", func() {
+ secret := []byte("password=secret")
+ dir := GinkgoT().TempDir()
+ secretPath := filepath.Join(dir, "config.ini")
+ Expect(os.WriteFile(secretPath, secret, 0600)).To(Succeed())
+ Expect(artRepo.PutImage(&model.Artwork{Hash: "eeeeeeeeeeeeeeee", Mime: "image/jpeg"})).To(Succeed())
+ seedEntity("al", "alnic")
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "al", ItemID: "alnic", Hash: "eeeeeeeeeeeeeeee",
+ Source: "folder", SourcePath: secretPath, RefMtime: fileMtime(secretPath),
+ })).To(Succeed())
+
+ // Older versions cached the raw bytes when the resize failed.
+ seed := func() (io.ReadCloser, error) { return io.NopCloser(bytes.NewReader(secret)), nil }
+ stream, err := imgCache.Get(ctx, &resizedItem{hash: "eeeeeeeeeeeeeeee", size: 100, open: seed, ffmpeg: ffm})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(io.ReadAll(stream)).To(Equal(secret))
+ Expect(stream.Close()).To(Succeed())
+ Eventually(func(g Gomega) {
+ s, err := imgCache.Get(ctx, &resizedItem{hash: "eeeeeeeeeeeeeeee", size: 100, ffmpeg: ffm,
+ open: func() (io.ReadCloser, error) { return nil, os.ErrNotExist }})
+ g.Expect(err).ToNot(HaveOccurred())
+ g.Expect(s.Cached).To(BeTrue())
+ _ = s.Close()
+ }).Should(Succeed())
+
+ _, err = svc.Get(ctx, model.MustParseArtworkID("al-alnic"), 100, false)
+ Expect(err).To(MatchError(ErrUnavailable))
+ Expect(queueRepo.Data[primaryKey("al", "alnic")].Priority).To(Equal(model.ArtworkPriorityScan))
+ })
+
It("treats a full-size mtime mismatch as dangling: unavailable, re-enqueued at Scan, state untouched", func() {
dir := GinkgoT().TempDir()
imgPath := filepath.Join(dir, "cover.jpg")
diff --git a/core/artwork/resolve.go b/core/artwork/resolve.go
index e7a2d3765..f4f3ef725 100644
--- a/core/artwork/resolve.go
+++ b/core/artwork/resolve.go
@@ -572,7 +572,7 @@ func resolveArtistFolderPattern(ctx context.Context, lib libraryView, artistFold
// resolveLocalFile opens an absolute path directly. A missing path is "no source"; any other
// open failure says nothing about whether the image exists.
func resolveLocalFile(path, source string) (resolution, bool) {
- if path == "" {
+ if path == "" || !model.IsImageFile(path) {
return resolution{}, false
}
f, err := os.Open(path)
diff --git a/core/artwork/resolve_test.go b/core/artwork/resolve_test.go
index 402a11363..da144d8e2 100644
--- a/core/artwork/resolve_test.go
+++ b/core/artwork/resolve_test.go
@@ -498,6 +498,23 @@ var _ = Describe("resolveItem", func() {
Expect(res.refMtime).To(BeNumerically(">", 0))
})
+ It("never opens a local ExternalImageURL that is not an image file", func() {
+ folderRepo.result = nil // no grid tiles, so only the local file could produce a reader
+ dir := GinkgoT().TempDir()
+ secretPath := filepath.Join(dir, "config.ini")
+ Expect(os.WriteFile(secretPath, []byte("password=secret"), 0600)).To(Succeed())
+
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "plni", Name: "Playlist", ExternalImageURL: secretPath}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}
+ ds.MockedPlaylist = plRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "plni"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.sourcePath).ToNot(Equal(secretPath))
+ })
+
It("routes ExternalImageURL through extGate and sets extError on transient failure", func() {
conf.Server.EnableM3UExternalAlbumArt = true
folderRepo.result = nil // no grid tiles, so the external failure is what surfaces
diff --git a/core/artwork/sources.go b/core/artwork/sources.go
index f2abf9da5..ae41acc48 100644
--- a/core/artwork/sources.go
+++ b/core/artwork/sources.go
@@ -37,7 +37,7 @@ func fromExternalFile(ctx context.Context, libFS fs.FS, files []string, pattern
log.Warn(ctx, "Artwork: Error matching cover art file to pattern", "pattern", pattern, "file", file)
continue
}
- if !match {
+ if !match || !model.IsImageFile(name) {
continue
}
f, err := libFS.Open(file)
diff --git a/core/artwork/sources_internal_test.go b/core/artwork/sources_internal_test.go
index 4282575a5..5f70b1cc5 100644
--- a/core/artwork/sources_internal_test.go
+++ b/core/artwork/sources_internal_test.go
@@ -48,6 +48,18 @@ var _ = Describe("fromExternalFile", func() {
Expect(b).To(Equal([]byte("a")))
Expect(path).To(Equal("a/cover.jpg"))
})
+
+ It("skips a matching file that is not an image", func() {
+ fsys := fstest.MapFS{
+ "a/cover.ini": &fstest.MapFile{Data: []byte("password=secret")},
+ "a/cover.jpg": &fstest.MapFile{Data: []byte("a")},
+ }
+ f := fromExternalFile(GinkgoT().Context(), fsys, []string{"a/cover.ini", "a/cover.jpg"}, "cover.*")
+ r, path, err := f()
+ Expect(err).ToNot(HaveOccurred())
+ defer r.Close()
+ Expect(path).To(Equal("a/cover.jpg"))
+ })
})
var _ = Describe("fromTag", func() {
diff --git a/core/playlists/import_test.go b/core/playlists/import_test.go
index 445561266..a90a703d9 100644
--- a/core/playlists/import_test.go
+++ b/core/playlists/import_test.go
@@ -236,6 +236,24 @@ var _ = Describe("Playlists - Import", func() {
Expect(pls.ExternalImageURL).To(BeEmpty())
})
+ It("rejects #EXTALBUMARTURL pointing at a non-image file inside the library", func() {
+ tmpDir := GinkgoT().TempDir()
+ Expect(os.WriteFile(filepath.Join(tmpDir, "config.ini"), []byte("password=secret"), 0600)).To(Succeed())
+
+ m3u := "#EXTALBUMARTURL:config.ini\ntest.mp3\n"
+ plsFile := filepath.Join(tmpDir, "test.m3u")
+ Expect(os.WriteFile(plsFile, []byte(m3u), 0600)).To(Succeed())
+
+ mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
+ ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
+
+ plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}
+ pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(pls.ExternalImageURL).To(BeEmpty())
+ })
+
It("ignores HTTP #EXTALBUMARTURL when EnableM3UExternalAlbumArt is false", func() {
conf.Server.EnableM3UExternalAlbumArt = false
@@ -1011,6 +1029,19 @@ var _ = Describe("Playlists - Import", func() {
Expect(pls.ExternalImageURL).To(BeEmpty())
})
+ DescribeTable("restricts a local #EXTALBUMARTURL to the owner's libraries",
+ func(imageURL, expected string) {
+ ctx = request.WithUser(ctx, model.User{ID: "123", Libraries: model.Libraries{{ID: 1, Path: "/music"}}})
+ repo.data = []string{"tests/test.mp3"}
+ m3u := "#EXTALBUMARTURL:" + imageURL + "\n/music/tests/test.mp3\n"
+ pls, err := ps.ImportM3U(ctx, strings.NewReader(m3u))
+ Expect(err).ToNot(HaveOccurred())
+ Expect(pls.ExternalImageURL).To(Equal(expected))
+ },
+ Entry("accepts a library the owner can access", "file:///music/cover.jpg", filepath.Clean("/music/cover.jpg")),
+ Entry("ignores a library the owner cannot access", "file:///new/cover.jpg", ""),
+ )
+
// Fullwidth characters (e.g., ABCD) are not handled by SQLite's NOCASE collation,
// so we need exact matching for non-ASCII characters.
It("matches fullwidth characters exactly (SQLite NOCASE limitation)", func() {
diff --git a/core/playlists/parse_m3u.go b/core/playlists/parse_m3u.go
index 286f2e420..b9cb154cb 100644
--- a/core/playlists/parse_m3u.go
+++ b/core/playlists/parse_m3u.go
@@ -14,6 +14,7 @@ import (
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
"github.com/navidrome/navidrome/utils/slice"
"golang.org/x/text/unicode/norm"
)
@@ -36,7 +37,8 @@ func (s *playlists) parseM3U(ctx context.Context, pls *model.Playlist, folder *m
continue
}
if after, ok := strings.CutPrefix(line, "#EXTALBUMARTURL:"); ok {
- pls.ExternalImageURL = resolveImageURL(after, folder, resolver.matcher)
+ owner, _ := request.UserFrom(ctx)
+ pls.ExternalImageURL = resolveImageURL(after, folder, resolver.matcher, owner)
continue
}
// Skip empty lines and extended info
@@ -286,7 +288,7 @@ func (r *pathResolver) resolvePaths(ctx context.Context, folder *model.Folder, l
// HTTP(S) URLs are stored as-is (gated by EnableM3UExternalAlbumArt).
// Local paths (file://, absolute, or relative) are resolved to an absolute path
// and validated against known library boundaries via matcher.
-func resolveImageURL(value string, folder *model.Folder, matcher *libraryMatcher) string {
+func resolveImageURL(value string, folder *model.Folder, matcher *libraryMatcher, owner model.User) string {
value = strings.TrimSpace(value)
if value == "" {
return ""
@@ -302,12 +304,13 @@ func resolveImageURL(value string, folder *model.Folder, matcher *libraryMatcher
// Resolve to local absolute path
localPath, ok := resolveLocalPath(value, folder)
- if !ok {
+ if !ok || !model.IsImageFile(localPath) {
return ""
}
- // Validate path is within a known library
- if libID, _ := matcher.findLibraryForPath(localPath); libID == 0 {
+ lib, ok := matcher.findLibrary(localPath)
+ // A playlist without a folder (API upload, or CLI import from outside all libraries) may only use the owner's libraries.
+ if !ok || (folder == nil && !owner.HasLibraryAccess(lib.ID)) {
return ""
}
return localPath
diff --git a/tests/init_tests.go b/tests/init_tests.go
index 902cf196d..eee4428a8 100644
--- a/tests/init_tests.go
+++ b/tests/init_tests.go
@@ -8,6 +8,7 @@ import (
"testing"
"github.com/navidrome/navidrome/conf"
+ _ "github.com/navidrome/navidrome/conf/mime" // registers mime_types.yaml, so tests see the same image types as the server
"github.com/navidrome/navidrome/log"
)