🎧 Your Personal Streaming Service
Go airsonicmadsonicmedia-servermusicmusic-servernavidromeopensubsonicraspberry-piself-hostedstreamerstreaming-apistreaming-audiosubsonicsubsonic-server
feat(subsonic): OpenSubsonic API key authentication (#6219)
Deluan Quintão4cdffd5633e0
diff --git a/consts/consts.go b/consts/consts.goindex 7228299c6..9bdac9125 100644--- a/consts/consts.go+++ b/consts/consts.go@@ -49,6 +49,7 @@ const (DefaultEncryptionKey = "just for obfuscation"PasswordsEncryptedKey = "PasswordsEncryptedKey"PasswordAutogenPrefix = "__NAVIDROME_AUTOGEN__" //nolint:gosec+ APIKeyPrefix = "nds_"DevInitialUserName = "admin"DevInitialName = "Dev Admin"diff --git a/core/players.go b/core/players.goindex e03d8caa2..6fe86fd70 100644--- a/core/players.go+++ b/core/players.go@@ -17,6 +17,7 @@ import (type Players interface {Get(ctx context.Context, playerId string) (*model.Player, error)Register(ctx context.Context, id, client, userAgent, ip string) (*model.Player, *model.Transcoding, error)+ Touch(ctx context.Context, plr model.Player, client, userAgent, ip string) (*model.Player, *model.Transcoding, error)}func NewPlayers(ds model.DataStore) Players {@@ -33,7 +34,6 @@ type players struct {func (p *players) Register(ctx context.Context, playerID, client, userAgent, ip string) (*model.Player, *model.Transcoding, error) {var plr *model.Player- var trc *model.Transcodingvar err erroruser, _ := request.UserFrom(ctx)if playerID != "" {@@ -58,7 +58,21 @@ func (p *players) Register(ctx context.Context, playerID, client, userAgent, iplog.Info(ctx, "Registering new player", "id", plr.ID, "client", client, "username", username, "type", userAgent)}}- plr.Name = fmt.Sprintf("%s [%s]", client, userAgent)+ if !plr.HasAPIKey {+ plr.Name = fmt.Sprintf("%s [%s]", client, userAgent)+ }+ return p.refresh(ctx, plr, userAgent, ip)+}++// Touch refreshes a player that the request already identified (by API key), without guessing or renaming it.+func (p *players) Touch(ctx context.Context, plr model.Player, client, userAgent, ip string) (*model.Player, *model.Transcoding, error) {+ if plr.Client == "" {+ plr.Client = client+ }+ return p.refresh(ctx, &plr, userAgent, ip)+}++func (p *players) refresh(ctx context.Context, plr *model.Player, userAgent, ip string) (*model.Player, *model.Transcoding, error) {plr.UserAgent = userAgentplr.IP = ipplr.LastSeen = time.Now()@@ -66,14 +80,14 @@ func (p *players) Register(ctx context.Context, playerID, client, userAgent, ipctx, cancel := context.WithTimeout(ctx, time.Second)defer cancel()- err = p.ds.Player().Put(ctx, plr)- if err != nil {- log.Warn(ctx, "Could not save player", "id", plr.ID, "client", client, "username", username, "type", userAgent, err)+ if err := p.ds.Player().Put(ctx, plr); err != nil {+ log.Warn(ctx, "Could not save player", "id", plr.ID, "client", plr.Client, "username", userName(ctx), "type", plr.UserAgent, err)}})- if plr.TranscodingId != "" {- trc, err = p.ds.Transcoding().Get(ctx, plr.TranscodingId)+ if plr.TranscodingId == "" {+ return plr, nil, nil}+ trc, err := p.ds.Transcoding().Get(ctx, plr.TranscodingId)return plr, trc, err}diff --git a/core/players_test.go b/core/players_test.goindex 302d63157..e452c52ba 100644--- a/core/players_test.go+++ b/core/players_test.go@@ -114,6 +114,15 @@ var _ = Describe("Players", func() {Expect(trc.ID).To(Equal("1"))})+ It("does not rename a player that has an API key", func() {+ plr := &model.Player{ID: "123", Name: "My Phone", Client: "client", UserId: "userid", HasAPIKey: true}+ repo.add(plr)+ p, _, err := players.Register(ctx, "123", "client", "chrome", "1.2.3.4")+ Expect(err).ToNot(HaveOccurred())+ Expect(p.ID).To(Equal("123"))+ Expect(p.Name).To(Equal("My Phone"))+ })+Context("bad username casing", func() {ctx := log.NewContext(context.TODO())ctx = request.WithUser(ctx, model.User{ID: "userid", UserName: "Johndoe"})@@ -130,6 +139,34 @@ var _ = Describe("Players", func() {})})})++ Describe("Touch", func() {+ It("records usage but keeps the name and client", func() {+ plr := model.Player{ID: "123", Name: "My Phone", Client: "Symfonium", UserId: "userid", HasAPIKey: true}+ p, trc, err := players.Touch(ctx, plr, "OtherClient", "android", "1.2.3.4")+ Expect(err).ToNot(HaveOccurred())+ Expect(p.Name).To(Equal("My Phone"))+ Expect(p.Client).To(Equal("Symfonium"))+ Expect(p.UserAgent).To(Equal("android"))+ Expect(p.IP).To(Equal("1.2.3.4"))+ Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))+ Expect(repo.lastSaved).To(Equal(p))+ Expect(trc).To(BeNil())+ })++ It("fills in the client on first use", func() {+ p, _, err := players.Touch(ctx, model.Player{ID: "123", Name: "Manual", UserId: "userid"}, "Symfonium", "android", "1.2.3.4")+ Expect(err).ToNot(HaveOccurred())+ Expect(p.Client).To(Equal("Symfonium"))+ })++ It("returns the player's transcoding", func() {+ p, trc, err := players.Touch(ctx, model.Player{ID: "123", UserId: "userid", TranscodingId: "1"}, "c", "ua", "1.2.3.4")+ Expect(err).ToNot(HaveOccurred())+ Expect(p.ID).To(Equal("123"))+ Expect(trc.ID).To(Equal("1"))+ })+ })})type mockPlayerRepository struct {diff --git a/db/migrations/20260924010054_add_player_api_key_hash.sql b/db/migrations/20260924010054_add_player_api_key_hash.sqlnew file mode 100644index 000000000..bbc4cf4d9--- /dev/null+++ b/db/migrations/20260924010054_add_player_api_key_hash.sql@@ -0,0 +1,8 @@+-- +goose Up+-- +goose StatementBegin+alter table player add column api_key_hash varchar default null;+create unique index if not exists player_api_key_hash on player(api_key_hash);+-- +goose StatementEnd++-- +goose Down+SELECT 1;diff --git a/model/player.go b/model/player.goindex 2e4484a10..c03058419 100644--- a/model/player.go+++ b/model/player.go@@ -21,6 +21,8 @@ type Player struct {MaxBitRate int `structs:"max_bit_rate" json:"maxBitRate"`ReportRealPath bool `structs:"report_real_path" json:"reportRealPath"`ScrobbleEnabled bool `structs:"scrobble_enabled" json:"scrobbleEnabled"`+ HasAPIKey bool `structs:"-" db:"has_api_key" json:"hasApiKey"`+ APIKey *string `structs:"-" json:"apiKey,omitempty"`}type Players []Player@@ -33,4 +35,6 @@ type PlayerRepository interface {Put(ctx context.Context, p *Player) errorCountAll(ctx context.Context, options ...QueryOptions) (int64, error)CountByClient(ctx context.Context, options ...QueryOptions) (map[string]int64, error)+ FindByAPIKey(ctx context.Context, key string) (*Player, error)+ SetAPIKey(ctx context.Context, playerID, key string) error}diff --git a/persistence/player_repository.go b/persistence/player_repository.goindex e46a8d82d..ba5d26794 100644--- a/persistence/player_repository.go+++ b/persistence/player_repository.go@@ -2,10 +2,16 @@ package persistenceimport ("context"+ "crypto/sha256"+ "encoding/hex"+ "regexp"+ "strings". "github.com/Masterminds/squirrel""github.com/deluan/rest"+ "github.com/navidrome/navidrome/consts""github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/model/id""github.com/pocketbase/dbx")@@ -17,7 +23,8 @@ func NewPlayerRepository(db dbx.Builder) model.PlayerRepository {r := &playerRepository{}r.db = dbr.registerModel(&model.Player{}, map[string]filterFunc{- "name": containsFilter("player.name"),+ "name": containsFilter("player.name"),+ "hasapikey": hasAPIKeyFilter,})r.setSortMappings(map[string]string{"user_name": "username", //TODO rename all user_name and userName to username@@ -25,6 +32,13 @@ func NewPlayerRepository(db dbx.Builder) model.PlayerRepository {return r}+func hasAPIKeyFilter(_ string, value any) Sqlizer {+ if v, _ := value.(string); strings.EqualFold(v, "true") {+ return NotEq{"player.api_key_hash": nil}+ }+ return Eq{"player.api_key_hash": nil}+}+func (r *playerRepository) Put(ctx context.Context, p *model.Player) error {_, err := r.put(ctx, p.ID, p)return err@@ -32,7 +46,7 @@ func (r *playerRepository) Put(ctx context.Context, p *model.Player) error {func (r *playerRepository) selectPlayer(ctx context.Context, options ...model.QueryOptions) SelectBuilder {return r.newSelect(ctx, options...).- Columns("player.*").+ Columns("player.*", "player.api_key_hash is not null as has_api_key").Join("user ON player.user_id = user.id").Columns("user.user_name username")}@@ -103,32 +117,115 @@ func (r *playerRepository) ReadAll(ctx context.Context, options ...rest.QueryOptreturn res, err}-// isPermitted authorizes creating a new record, based on the owner declared in the request body.-// This is only safe for inserts: there is no stored row yet, and a non-admin may only create a-// player they own. Updates must not use this (the body owner is attacker-controlled); they go-// through updateOwned, which authorizes against the persisted user_id in the WHERE clause.-func (r *playerRepository) isPermitted(ctx context.Context, p *model.Player) bool {- u := loggedUser(ctx)- return u.IsAdmin || p.UserId == u.ID+var apiKeyFormat = regexp.MustCompile(`^` + consts.APIKeyPrefix + `[0-9A-Za-z]{22}$`)++func apiKeyValidationError(msg string) error {+ return &rest.ValidationError{Errors: map[string]string{"apiKey": msg}}+}++func validateAPIKey(key string) error {+ if !apiKeyFormat.MatchString(key) {+ return apiKeyValidationError("resources.player.validation.apiKeyFormat")+ }+ return nil}func (r *playerRepository) Save(ctx context.Context, t *model.Player) (string, error) {- if !r.isPermitted(ctx, t) {+ u := loggedUser(ctx)+ if t.UserId == "" && u.ID != invalidUserId {+ t.UserId = u.ID+ }+ if t.UserId != u.ID {return "", rest.ErrPermissionDenied}- return r.put(ctx, "", t) // Save only creates; edits go through the owner-scoped Update+ // Hand-made players are only reachable through a key, so one is required+ if t.APIKey == nil || *t.APIKey == "" {+ return "", apiKeyValidationError("ra.validation.required")+ }+ if err := validateAPIKey(*t.APIKey); err != nil {+ return "", err+ }+ values, err := toSQLArgs(t)+ if err != nil {+ return "", err+ }+ // Save only creates, so the key hash goes in the same INSERT and the unique index settles races+ values["id"] = id.NewRandom()+ values["api_key_hash"] = hashAPIKey(*t.APIKey)+ _, err = r.executeSQL(ctx, Insert(r.tableName).SetMap(values))+ if isUniqueViolation(err) {+ return "", apiKeyValidationError("ra.validation.unique")+ }+ if err != nil {+ return "", err+ }+ return values["id"].(string), nil}func (r *playerRepository) Update(ctx context.Context, id string, entity model.Player, cols ...string) error {t := &entityt.ID = id- return r.updateOwned(ctx, id, t, cols...)+ if t.APIKey == nil {+ return r.updateOwned(ctx, id, t, cols...)+ }+ // The key and the other columns are two writes; commit both or neither+ return r.inTx(func(tx *playerRepository) error {+ if err := tx.SetAPIKey(ctx, id, *t.APIKey); err != nil {+ return err+ }+ return tx.updateOwned(ctx, id, t, cols...)+ })+}++func (r *playerRepository) inTx(block func(tx *playerRepository) error) error {+ conn, ok := r.db.(*dbx.DB)+ if !ok {+ return block(r) // already inside a transaction+ }+ return conn.Transactional(func(tx *dbx.Tx) error {+ return block(NewPlayerRepository(tx).(*playerRepository))+ })}func (r *playerRepository) Delete(ctx context.Context, ids ...string) error {return r.deleteOwnedAll(ctx, ids...)}+// Keys are long random strings, not user-chosen passwords, so a fast unsalted hash is enough and keeps lookups indexed.+func hashAPIKey(key string) string {+ sum := sha256.Sum256([]byte(key))+ return hex.EncodeToString(sum[:])+}++func (r *playerRepository) FindByAPIKey(ctx context.Context, key string) (*model.Player, error) {+ sel := r.selectPlayer(ctx).Where(Eq{"player.api_key_hash": hashAPIKey(key)})+ var res model.Player+ if err := r.queryOne(ctx, sel, &res); err != nil {+ return nil, err+ }+ return &res, nil+}++// SetAPIKey stores the key's hash, or revokes it when key is empty. Setting is owner-only, even for+// admins, so nobody can mint a login for someone else.+func (r *playerRepository) SetAPIKey(ctx context.Context, playerID, key string) error {+ if key == "" {+ return r.updateOwnedRow(ctx, playerID, ownerOrAdmin, map[string]any{"api_key_hash": nil})+ }+ if err := validateAPIKey(key); err != nil {+ return err+ }+ err := r.updateOwnedRow(ctx, playerID, ownerOnly, map[string]any{"api_key_hash": hashAPIKey(key)})+ if isUniqueViolation(err) {+ return apiKeyValidationError("ra.validation.unique")+ }+ return err+}++func isUniqueViolation(err error) bool {+ return err != nil && strings.Contains(err.Error(), "UNIQUE constraint failed")+}+var _ model.PlayerRepository = (*playerRepository)(nil)var _ rest.Repository[model.Player] = (*playerRepository)(nil)var _ rest.Persistable[model.Player] = (*playerRepository)(nil)diff --git a/persistence/player_repository_test.go b/persistence/player_repository_test.goindex f12f3e74e..69afa9556 100644--- a/persistence/player_repository_test.go+++ b/persistence/player_repository_test.go@@ -2,6 +2,7 @@ package persistenceimport ("context"+ "errors""github.com/deluan/rest""github.com/navidrome/navidrome/log"@@ -12,6 +13,14 @@ import ("github.com/pocketbase/dbx")+const testAPIKey = "nds_0123456789abcdefghijkl"++func expectAPIKeyError(err error, msg string) {+ var verr *rest.ValidationError+ ExpectWithOffset(1, errors.As(err, &verr)).To(BeTrue())+ ExpectWithOffset(1, verr.Errors).To(HaveKeyWithValue("apiKey", msg))+}+var _ = Describe("PlayerRepository", func() {var adminRepo *playerRepositoryvar database *dbx.DB@@ -178,11 +187,12 @@ var _ = Describe("PlayerRepository", func() {clone := playerclone.ID = ""clone.IP = "192.168.1.1"+ clone.APIKey = new(testAPIKey)id, err := repo.Save(repoCtx, &clone)if clone.UserId == "" {Expect(err).To(HaveOccurred())- } else if !admin && player.Username == adminPlayer1.Username {+ } else if player.UserId != userPlayer.UserId {Expect(err).To(Equal(rest.ErrPermissionDenied))clone.UserId = ""} else {@@ -202,12 +212,13 @@ var _ = Describe("PlayerRepository", func() {} else {Expect(count).To(Equal(baseCount + 1))Expect(err).To(BeNil())+ clone.APIKey = nil+ clone.HasAPIKey = trueExpect(*newItem).To(Equal(clone))}},Entry("same user", userPlayer),Entry("other item", otherPlayer),- Entry("fake item", model.Player{}),)})@@ -251,6 +262,259 @@ var _ = Describe("PlayerRepository", func() {Entry("regular context", false, model.Players{regularPlayer}, regularPlayer, adminPlayer1),)+ Describe("API keys", func() {+ const key = testAPIKey+ const otherKey = "nds_ABCDEFGHIJKLMNOPQRSTUV"+ var ownerCtx, otherCtx context.Context++ BeforeEach(func() {+ ownerCtx = request.WithUser(log.NewContext(GinkgoT().Context()), regularUser)+ otherCtx = request.WithUser(log.NewContext(GinkgoT().Context()), thirdUser)+ })++ storedHash := func(id string) string {+ var row struct {+ Hash string `db:"api_key_hash"`+ }+ Expect(database.NewQuery("select coalesce(api_key_hash, '') as api_key_hash from player where id = {:id}").+ Bind(dbx.Params{"id": id}).One(&row)).To(Succeed())+ return row.Hash+ }++ Describe("SetAPIKey", func() {+ It("stores only the hash and finds the player by the key", func() {+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, key)).To(Succeed())++ Expect(storedHash(regularPlayer.ID)).To(Equal(hashAPIKey(key)))+ plr, err := adminRepo.FindByAPIKey(ctx, key)+ Expect(err).ToNot(HaveOccurred())+ Expect(plr.ID).To(Equal(regularPlayer.ID))+ Expect(plr.HasAPIKey).To(BeTrue())+ Expect(plr.APIKey).To(BeNil())+ })++ It("replaces the previous key", func() {+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, key)).To(Succeed())+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, otherKey)).To(Succeed())++ _, err := adminRepo.FindByAPIKey(ctx, key)+ Expect(err).To(MatchError(model.ErrNotFound))+ _, err = adminRepo.FindByAPIKey(ctx, otherKey)+ Expect(err).ToNot(HaveOccurred())+ })++ DescribeTable("rejects malformed keys",+ func(bad string) {+ err := adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, bad)+ expectAPIKeyError(err, "resources.player.validation.apiKeyFormat")+ Expect(storedHash(regularPlayer.ID)).To(BeEmpty())+ },+ Entry("no prefix", "0123456789abcdefghijklmn"),+ Entry("too short", "nds_short"),+ Entry("too long", key+"x"),+ Entry("bad chars", "nds_0123456789abcdefghij-!"),+ )++ It("revokes with an empty key, by the owner or an admin", func() {+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, key)).To(Succeed())+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, "")).To(Succeed())+ Expect(storedHash(regularPlayer.ID)).To(BeEmpty())++ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, key)).To(Succeed())+ Expect(adminRepo.SetAPIKey(ctx, regularPlayer.ID, "")).To(Succeed())+ Expect(storedHash(regularPlayer.ID)).To(BeEmpty())+ })++ It("accepts revoking a player that has no key", func() {+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, "")).To(Succeed())+ })++ It("does not let an admin set a key on another user's player", func() {+ Expect(adminRepo.SetAPIKey(ctx, regularPlayer.ID, key)).To(MatchError(rest.ErrPermissionDenied))+ Expect(storedHash(regularPlayer.ID)).To(BeEmpty())+ })++ It("does not let another user set or revoke", func() {+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, key)).To(Succeed())+ Expect(adminRepo.SetAPIKey(otherCtx, regularPlayer.ID, otherKey)).To(MatchError(rest.ErrPermissionDenied))+ Expect(adminRepo.SetAPIKey(otherCtx, regularPlayer.ID, "")).To(MatchError(rest.ErrPermissionDenied))+ Expect(storedHash(regularPlayer.ID)).To(Equal(hashAPIKey(key)))+ })++ It("returns not found for a missing player", func() {+ Expect(adminRepo.SetAPIKey(ownerCtx, "missing", key)).To(MatchError(rest.ErrNotFound))+ Expect(adminRepo.SetAPIKey(ownerCtx, "missing", "")).To(MatchError(rest.ErrNotFound))+ })++ It("does not find unknown or empty keys", func() {+ _, err := adminRepo.FindByAPIKey(ctx, otherKey)+ Expect(err).To(MatchError(model.ErrNotFound))+ _, err = adminRepo.FindByAPIKey(ctx, "")+ Expect(err).To(MatchError(model.ErrNotFound))+ })++ It("drops the key with the player", func() {+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, key)).To(Succeed())+ Expect(adminRepo.Delete(ownerCtx, regularPlayer.ID)).To(Succeed())+ _, err := adminRepo.FindByAPIKey(ctx, key)+ Expect(err).To(MatchError(model.ErrNotFound))+ })+ })++ Describe("hasApiKey filter", func() {+ BeforeEach(func() {+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, key)).To(Succeed())+ })++ filtered := func(value string) []string {+ res, err := adminRepo.ReadAll(ctx, rest.QueryOptions{Filters: map[string]any{"hasApiKey": value}})+ Expect(err).ToNot(HaveOccurred())+ var ids []string+ for _, p := range res {+ ids = append(ids, p.ID)+ }+ return ids+ }++ It("lists only players with a key", func() {+ Expect(filtered("true")).To(ConsistOf(regularPlayer.ID))+ count, err := adminRepo.Count(ctx, rest.QueryOptions{Filters: map[string]any{"hasApiKey": "true"}})+ Expect(err).ToNot(HaveOccurred())+ Expect(count).To(Equal(int64(1)))+ })++ It("lists only players without a key", func() {+ Expect(filtered("false")).To(ConsistOf(adminPlayer1.ID, adminPlayer2.ID))+ })+ })++ Describe("Save (create)", func() {+ It("creates the player with the key, owned by the logged-in user", func() {+ id, err := adminRepo.Save(ownerCtx, &model.Player{Name: "Manual player", APIKey: new(key)})+ Expect(err).ToNot(HaveOccurred())++ plr, err := adminRepo.FindByAPIKey(ctx, key)+ Expect(err).ToNot(HaveOccurred())+ Expect(plr.ID).To(Equal(id))+ Expect(plr.UserId).To(Equal(regularUser.ID))+ })++ It("requires a key", func() {+ count, _ := adminRepo.CountAll(ctx)+ _, err := adminRepo.Save(ownerCtx, &model.Player{Name: "No key"})+ expectAPIKeyError(err, "ra.validation.required")++ _, err = adminRepo.Save(ownerCtx, &model.Player{Name: "Empty key", APIKey: new("")})+ expectAPIKeyError(err, "ra.validation.required")+ Expect(adminRepo.CountAll(ctx)).To(Equal(count))+ })++ It("rejects a malformed key without creating the player", func() {+ count, _ := adminRepo.CountAll(ctx)+ _, err := adminRepo.Save(ownerCtx, &model.Player{Name: "Bad", APIKey: new("nds_bad")})+ expectAPIKeyError(err, "resources.player.validation.apiKeyFormat")+ Expect(adminRepo.CountAll(ctx)).To(Equal(count))+ })++ It("does not let an admin create a keyed player for another user", func() {+ count, _ := adminRepo.CountAll(ctx)+ _, err := adminRepo.Save(ctx, &model.Player{Name: "For someone", UserId: regularUser.ID, APIKey: new(key)})+ Expect(err).To(MatchError(rest.ErrPermissionDenied))+ _, err = adminRepo.Save(ctx, &model.Player{Name: "For someone", UserId: regularUser.ID})+ Expect(err).To(MatchError(rest.ErrPermissionDenied))+ Expect(adminRepo.CountAll(ctx)).To(Equal(count))+ })++ It("rejects a key already used by another player without creating the player", func() {+ Expect(adminRepo.SetAPIKey(ctx, adminPlayer1.ID, key)).To(Succeed())+ count, _ := adminRepo.CountAll(ctx)+ _, err := adminRepo.Save(ownerCtx, &model.Player{Name: "Duplicate", APIKey: new(key)})+ expectAPIKeyError(err, "ra.validation.unique")+ Expect(adminRepo.CountAll(ctx)).To(Equal(count))+ })+ })++ Describe("Update (edit)", func() {+ It("rolls back the key change when the rest of the edit fails", func() {+ _, err := database.NewQuery(`create trigger fail_player_rename before update of name on player+ when new.name = 'boom' begin select raise(abort, 'boom'); end`).Execute()+ Expect(err).ToNot(HaveOccurred())+ DeferCleanup(func() {+ _, _ = database.NewQuery("drop trigger if exists fail_player_rename").Execute()+ })++ plr := regularPlayer+ plr.Name = "boom"+ plr.APIKey = new(key)+ Expect(adminRepo.Update(ownerCtx, plr.ID, plr, "name", "apiKey")).ToNot(Succeed())+ Expect(storedHash(regularPlayer.ID)).To(BeEmpty())+ })++ It("keeps the key when apiKey is absent (a normal edit)", func() {+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, key)).To(Succeed())++ plr := regularPlayer+ plr.Name = "Renamed"+ Expect(adminRepo.Update(ownerCtx, plr.ID, plr, "name", "hasApiKey")).To(Succeed())+ Expect(adminRepo.Update(ownerCtx, plr.ID, plr)).To(Succeed())++ found, err := adminRepo.FindByAPIKey(ctx, key)+ Expect(err).ToNot(HaveOccurred())+ Expect(found.Name).To(Equal("Renamed"))+ })++ It("sets a new key when apiKey has a value", func() {+ plr := regularPlayer+ plr.APIKey = new(key)+ Expect(adminRepo.Update(ownerCtx, plr.ID, plr, "name", "apiKey")).To(Succeed())+ Expect(storedHash(regularPlayer.ID)).To(Equal(hashAPIKey(key)))+ })++ It("revokes the key when apiKey is empty", func() {+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, key)).To(Succeed())+ plr := regularPlayer+ plr.APIKey = new("")+ Expect(adminRepo.Update(ownerCtx, plr.ID, plr, "apiKey")).To(Succeed())+ Expect(storedHash(regularPlayer.ID)).To(BeEmpty())+ })++ It("lets an admin edit another user's keyed player without touching the key", func() {+ Expect(adminRepo.SetAPIKey(ownerCtx, regularPlayer.ID, key)).To(Succeed())+ plr := regularPlayer+ plr.MaxBitRate = 192+ Expect(adminRepo.Update(ctx, plr.ID, plr, "maxBitRate", "hasApiKey")).To(Succeed())+ Expect(storedHash(regularPlayer.ID)).To(Equal(hashAPIKey(key)))+ })++ It("refuses an admin setting a key on another user's player and leaves other columns alone", func() {+ plr := regularPlayer+ plr.Name = "Hijacked"+ plr.APIKey = new(key)+ Expect(adminRepo.Update(ctx, plr.ID, plr, "name", "apiKey")).To(MatchError(rest.ErrPermissionDenied))++ got, err := adminRepo.Get(ctx, regularPlayer.ID)+ Expect(err).ToNot(HaveOccurred())+ Expect(got.Name).To(Equal(regularPlayer.Name))+ Expect(storedHash(regularPlayer.ID)).To(BeEmpty())+ })++ It("refuses a key already used by another player and leaves other columns alone", func() {+ Expect(adminRepo.SetAPIKey(ctx, adminPlayer1.ID, key)).To(Succeed())+ plr := regularPlayer+ plr.Name = "Renamed"+ plr.APIKey = new(key)+ err := adminRepo.Update(ownerCtx, plr.ID, plr, "name", "apiKey")+ expectAPIKeyError(err, "ra.validation.unique")++ got, err := adminRepo.Get(ctx, regularPlayer.ID)+ Expect(err).ToNot(HaveOccurred())+ Expect(got.Name).To(Equal(regularPlayer.Name))+ Expect(storedHash(regularPlayer.ID)).To(BeEmpty())+ Expect(storedHash(adminPlayer1.ID)).To(Equal(hashAPIKey(key)))+ })+ })+ })+Describe("Ownership enforcement (cross-tenant write protection)", func() {var regularRepo *playerRepositoryvar regularCtx context.Context@@ -287,6 +551,7 @@ var _ = Describe("PlayerRepository", func() {Name: "HIJACKED",UserId: regularUser.ID,ReportRealPath: true,+ APIKey: new(testAPIKey),}id, err := regularRepo.Save(regularCtx, &spoofed)diff --git a/persistence/sql_base_repository.go b/persistence/sql_base_repository.goindex be88156d8..03cc6a01b 100644--- a/persistence/sql_base_repository.go+++ b/persistence/sql_base_repository.go@@ -85,6 +85,22 @@ func (r sqlRepository) addRestriction(ctx context.Context, sql ...Sqlizer) Sqlizreturn s}+// writeAccess says who may change a row in a table with a user_id column.+type writeAccess int++const (+ ownerOrAdmin writeAccess = iota // admins may write any row+ ownerOnly // even admins may only write their own rows+)++// ownedRow matches the row rowID only if the logged-in user may write it under access.+func (r sqlRepository) ownedRow(ctx context.Context, rowID string, access writeAccess) Sqlizer {+ if access == ownerOnly {+ return And{Eq{"id": rowID}, Eq{"user_id": loggedUser(ctx).ID}}+ }+ return r.addRestriction(ctx, Eq{"id": rowID})+}+func (r *sqlRepository) registerModel(instance any, filters map[string]filterFunc) {if r.tableName == "" {r.tableName = strings.TrimPrefix(reflect.TypeOf(instance).String(), "*model.")@@ -494,15 +510,12 @@ func (r sqlRepository) updateOwned(ctx context.Context, id string, m any, colsTo}updateValues := filterUpdateValues(values, id, colsToUpdate...)delete(updateValues, "user_id") // ownership is immutable on update- update := Update(r.tableName).Where(r.addRestriction(ctx, Eq{"id": id})).SetMap(updateValues)- count, err := r.executeSQL(ctx, update)- if err != nil {- return err- }- if count == 0 {- return r.classifyOwnedWriteMiss(ctx, id)- }- return nil+ return r.updateOwnedRow(ctx, id, ownerOrAdmin, updateValues)+}++// updateOwnedRow sets values on the row rowID if the logged-in user may write it under access.+func (r sqlRepository) updateOwnedRow(ctx context.Context, rowID string, access writeAccess, values map[string]any) error {+ return r.runRowWrite(ctx, rowID, Update(r.tableName).SetMap(values).Where(r.ownedRow(ctx, rowID, access)))}// deleteOwned performs an atomic, ownership-restricted delete of the row identified by id, for@@ -511,12 +524,17 @@ func (r sqlRepository) updateOwned(ctx context.Context, id string, m any, colsTo// does not match and is left untouched. The failure path mirrors updateOwned (see// classifyOwnedWriteMiss), so there is no TOCTOU on the delete.func (r sqlRepository) deleteOwned(ctx context.Context, id string) error {- count, err := r.executeSQL(ctx, Delete(r.tableName).Where(r.addRestriction(ctx, Eq{"id": id})))+ return r.runRowWrite(ctx, id, Delete(r.tableName).Where(r.ownedRow(ctx, id, ownerOrAdmin)))+}++// runRowWrite executes q, a write already filtered by ownedRow(rowID, …), and classifies a miss.+func (r sqlRepository) runRowWrite(ctx context.Context, rowID string, q Sqlizer) error {+ count, err := r.executeSQL(ctx, q)if err != nil {return err}if count == 0 {- return r.classifyOwnedWriteMiss(ctx, id)+ return r.classifyOwnedWriteMiss(ctx, rowID)}return nil}diff --git a/persistence/sql_base_repository_test.go b/persistence/sql_base_repository_test.goindex 33a8140f8..4b42e7f1d 100644--- a/persistence/sql_base_repository_test.go+++ b/persistence/sql_base_repository_test.go@@ -19,6 +19,26 @@ var _ = Describe("sqlRepository", func() {r.tableName = "table"})+ Describe("ownedRow", func() {+ DescribeTable("matches the row, limited to what the logged-in user may write",+ func(user model.User, access writeAccess, expectedSQL string, expectedArgs ...any) {+ userCtx := request.WithUser(GinkgoT().Context(), user)+ sql, args, err := r.ownedRow(userCtx, "row-1", access).ToSql()+ Expect(err).ToNot(HaveOccurred())+ Expect(sql).To(Equal(expectedSQL))+ Expect(args).To(Equal(expectedArgs))+ },+ Entry("admin, ownerOrAdmin: any row", model.User{ID: "admin", IsAdmin: true}, ownerOrAdmin,+ "(id = ?)", "row-1"),+ Entry("regular, ownerOrAdmin: own rows", model.User{ID: "user"}, ownerOrAdmin,+ "(id = ? AND user_id = ?)", "row-1", "user"),+ Entry("admin, ownerOnly: own rows", model.User{ID: "admin", IsAdmin: true}, ownerOnly,+ "(id = ? AND user_id = ?)", "row-1", "admin"),+ Entry("regular, ownerOnly: own rows", model.User{ID: "user"}, ownerOnly,+ "(id = ? AND user_id = ?)", "row-1", "user"),+ )+ })+Describe("applyOptions", func() {var sq squirrel.SelectBuilderBeforeEach(func() {diff --git a/resources/i18n/pt-br.json b/resources/i18n/pt-br.jsonindex 6fcde56ca..f0d8a0e06 100644--- a/resources/i18n/pt-br.json+++ b/resources/i18n/pt-br.json@@ -182,6 +182,7 @@},"player": {"name": "Tocador |||| Tocadores",+ "menuName": "Tocadores e chaves de API","fields": {"name": "Nome","transcodingId": "Conversão",@@ -190,7 +191,29 @@"userName": "Usuário","lastSeen": "Últ. acesso","reportRealPath": "Use paths reais",- "scrobbleEnabled": "Enviar scrobbles para serviços externos"+ "scrobbleEnabled": "Enviar scrobbles para serviços externos",+ "hasApiKey": "Chave de API"+ },+ "actions": {+ "generateApiKey": "Gerar chave de API",+ "regenerateApiKey": "Gerar nova",+ "revokeApiKey": "Revogar",+ "copyApiKey": "Copiar"+ },+ "message": {+ "apiKeyActive": "Este tocador tem uma chave de API. Use-a no seu app como chave de API, ou como senha se o app não usar autenticação por token.",+ "apiKeyNone": "Sem chave de API. Gere uma para conectar um app a este tocador.",+ "apiKeyNoneOther": "Sem chave de API.",+ "apiKeyPending": "Copie esta chave agora. Ela será salva quando você clicar em Salvar e não será exibida novamente.",+ "apiKeyRevokePending": "A chave de API será removida quando você salvar.",+ "deleteWithKeyTitle": "Excluir tocador",+ "deleteWithKeyContent": "Este tocador tem uma chave de API. Os apps que a usam vão parar de funcionar."+ },+ "notifications": {+ "apiKeyCopied": "Chave de API copiada para o clipboard"+ },+ "validation": {+ "apiKeyFormat": "Formato de chave de API inválido"}},"transcoding": {diff --git a/server/subsonic/api.go b/server/subsonic/api.goindex deedc46c7..fe724741c 100644--- a/server/subsonic/api.go+++ b/server/subsonic/api.go@@ -107,6 +107,7 @@ func (api *Router) routes() http.Handler {r.Use(getPlayer(api.players))h(r, "ping", api.Ping)h(r, "getLicense", api.GetLicense)+ h(r, "tokenInfo", api.TokenInfo)})r.Group(func(r chi.Router) {r.Use(getPlayer(api.players))diff --git a/server/subsonic/e2e/subsonic_apikey_test.go b/server/subsonic/e2e/subsonic_apikey_test.gonew file mode 100644index 000000000..bb263c15d--- /dev/null+++ b/server/subsonic/e2e/subsonic_apikey_test.go@@ -0,0 +1,54 @@+package e2e++import (+ "net/http/httptest"+ "net/url"++ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/model/request"+ "github.com/navidrome/navidrome/server/subsonic/responses"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++var _ = Describe("API key authentication", func() {+ var key string++ BeforeEach(func() {+ setupTestDB()+ userCtx := request.WithUser(ctx, regularUser)+ player := &model.Player{ID: "apikey-player", Name: "Phone", UserId: regularUser.ID, Client: "test-client"}+ Expect(ds.Player().Put(userCtx, player)).To(Succeed())+ key = "nds_0123456789abcdefghijkl"+ Expect(ds.Player().SetAPIKey(userCtx, player.ID, key)).To(Succeed())+ })++ doKeyReq := func(endpoint, apiKey string) *responses.Subsonic {+ q := url.Values{"apiKey": {apiKey}, "v": {"1.16.1"}, "c": {"test-client"}, "f": {"json"}}+ w := httptest.NewRecorder()+ router.ServeHTTP(w, httptest.NewRequest("GET", "/"+endpoint+"?"+q.Encode(), nil))+ return parseJSONResponse(w)+ }++ It("authenticates ping with only the key", func() {+ resp := doKeyReq("ping", key)++ Expect(resp.Status).To(Equal(responses.StatusOK))+ })++ It("reports the key owner in tokenInfo", func() {+ resp := doKeyReq("tokenInfo", key)++ Expect(resp.Status).To(Equal(responses.StatusOK))+ Expect(resp.TokenInfo).ToNot(BeNil())+ Expect(resp.TokenInfo.Username).To(Equal(regularUser.UserName))+ })++ It("rejects an unknown key with error 44", func() {+ resp := doKeyReq("ping", "nds_unknown")++ Expect(resp.Status).To(Equal(responses.StatusFailed))+ Expect(resp.Error).ToNot(BeNil())+ Expect(resp.Error.Code).To(Equal(int32(44)))+ })+})diff --git a/server/subsonic/middlewares.go b/server/subsonic/middlewares.goindex 6617661a9..fdb4af28d 100644--- a/server/subsonic/middlewares.go+++ b/server/subsonic/middlewares.go@@ -65,14 +65,15 @@ func checkRequiredParameters(next http.Handler) http.Handler {return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {var requiredParameters []string+ p := req.Params(r)username, _ := fromInternalOrProxyAuth(r)- if username != "" {+ apiKey, _ := p.String("apiKey")+ if username != "" || apiKey != "" {requiredParameters = []string{"v", "c"}} else {requiredParameters = []string{"u", "v", "c"}}- p := req.Params(r)for _, param := range requiredParameters {if _, err := p.String(param); err != nil {log.Warn(r, err)@@ -104,10 +105,14 @@ func authenticate(ds model.DataStore) func(next http.Handler) http.Handler {ctx := r.Context()var usr *model.User+ var keyPlayer *model.Playervar err error+ p := req.Params(r)+ apiKey, _ := p.String("apiKey")username, isInternalAuth := fromInternalOrProxyAuth(r)- if username != "" {+ switch {+ case username != "":authType := If(isInternalAuth, "internal", "reverse-proxy")usr, err = ds.User().FindByUsername(ctx, username)if errors.Is(err, context.Canceled) {@@ -119,8 +124,16 @@ func authenticate(ds model.DataStore) func(next http.Handler) http.Handler {} else if err != nil {log.Error(ctx, "API: Error authenticating username", "auth", authType, "username", username, "remoteAddr", r.RemoteAddr, err)}- } else {- p := req.Params(r)+ case apiKey != "":+ usr, keyPlayer, err = authenticateAPIKey(ctx, ds, limiter, r, apiKey)+ if err != nil {+ if ctx.Err() == nil {+ sendError(w, r, err)+ }+ return+ }+ ctx = request.WithUsername(ctx, usr.UserName)+ default:username, _ := p.String("u")pass, _ := p.String("p")token, _ := p.String("t")@@ -142,6 +155,9 @@ func authenticate(ds model.DataStore) func(next http.Handler) http.Handler {usr, err = ds.User().FindByUsernameWithPassword(ctx, username)if err == nil {err = validateCredentials(usr, pass, token, salt, jwt)+ if errors.Is(err, model.ErrInvalidAuth) && pass != "" && jwt == "" {+ keyPlayer, err = playerFromPasswordKey(ctx, ds, usr, pass)+ }}invalidLogin := errors.Is(err, model.ErrNotFound) || errors.Is(err, model.ErrInvalidAuth)slot.release(invalidLogin)@@ -162,11 +178,77 @@ func authenticate(ds model.DataStore) func(next http.Handler) http.Handler {}ctx = request.WithUser(ctx, *usr)+ if keyPlayer != nil {+ ctx = request.WithPlayer(ctx, *keyPlayer)+ }next.ServeHTTP(w, r.WithContext(ctx))})}}+var apiKeyConflicts = []string{"u", "p", "t", "s", "jwt"}++func authenticateAPIKey(ctx context.Context, ds model.DataStore, limiter *authLimiter, r *http.Request, key string) (*model.User, *model.Player, error) {+ query := r.URL.Query()+ for _, param := range apiKeyConflicts {+ if query.Has(param) {+ log.Warn(ctx, "API: apiKey sent with other credentials", "auth", "apikey", "param", param, "remoteAddr", r.RemoteAddr)+ return nil, nil, newError(responses.ErrorMultipleAuthMechanismsProvided)+ }+ }++ // Per key, so a stale key on one device cannot lock out valid keys sharing the IP+ slot, allowed := limiter.acquire(ctx, "apikey\x00"+server.ClientIP(r)+"\x00"+key)+ if !allowed {+ if err := ctx.Err(); err != nil {+ return nil, nil, err+ }+ log.Warn(ctx, "API: Too many failed API key attempts", "auth", "apikey", "remoteAddr", r.RemoteAddr)+ return nil, nil, newError(responses.ErrorInvalidAPIKey)+ }++ player, err := ds.Player().FindByAPIKey(ctx, key)+ var usr *model.User+ if err == nil {+ usr, err = ds.User().Get(ctx, player.UserId)+ }+ slot.release(errors.Is(err, model.ErrNotFound))+ switch {+ case errors.Is(err, context.Canceled):+ return nil, nil, err+ case errors.Is(err, model.ErrNotFound):+ log.Warn(ctx, "API: Invalid API key", "auth", "apikey", "remoteAddr", r.RemoteAddr)+ return nil, nil, newError(responses.ErrorInvalidAPIKey)+ case err != nil:+ log.Error(ctx, "API: Error authenticating API key", "auth", "apikey", "remoteAddr", r.RemoteAddr, err)+ return nil, nil, newError(responses.ErrorAuthenticationFail)+ }+ return usr, player, nil+}++// playerFromPasswordKey lets clients that only have a password field log in with an API key.+// It returns ErrInvalidAuth when pass is not a key of usr, so only real failures skip the limiter count.+func playerFromPasswordKey(ctx context.Context, ds model.DataStore, usr *model.User, pass string) (*model.Player, error) {+ key := decodePassword(pass)+ if !strings.HasPrefix(key, consts.APIKeyPrefix) {+ return nil, model.ErrInvalidAuth+ }+ plr, err := ds.Player().FindByAPIKey(ctx, key)+ if errors.Is(err, model.ErrNotFound) || (err == nil && plr.UserId != usr.ID) {+ return nil, model.ErrInvalidAuth+ }+ return plr, err+}++func decodePassword(pass string) string {+ if strings.HasPrefix(pass, "enc:") {+ if dec, err := hex.DecodeString(pass[4:]); err == nil {+ return string(dec)+ }+ }+ return pass+}+func adminOnly(next http.Handler) http.Handler {return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {loggedUser, ok := request.UserFrom(r.Context())@@ -194,12 +276,7 @@ func validateCredentials(user *model.User, pass, token, salt, jwt string) errorclaims.Subject == user.UserName &&auth.CheckClaims(claims, *user, auth.AudienceSubsonic) == nilcase pass != "":- if strings.HasPrefix(pass, "enc:") {- if dec, err := hex.DecodeString(pass[4:]); err == nil {- pass = string(dec)- }- }- valid = pass == user.Password+ valid = decodePassword(pass) == user.Passwordcase token != "":t := fmt.Sprintf("%x", md5.Sum([]byte(user.Password+salt)))valid = t == token@@ -217,12 +294,20 @@ func getPlayer(players core.Players) func(next http.Handler) http.Handler {ctx := r.Context()userName, _ := request.UsernameFrom(ctx)client, _ := request.ClientFrom(ctx)- playerId := playerIDFromCookie(r, userName)ip, _, _ := net.SplitHostPort(r.RemoteAddr)userAgent := canonicalUserAgent(r)- player, trc, err := players.Register(ctx, playerId, client, userAgent, ip)++ var player *model.Player+ var trc *model.Transcoding+ var err error+ keyPlayer, boundByKey := request.PlayerFrom(ctx)+ if boundByKey {+ player, trc, err = players.Touch(ctx, keyPlayer, client, userAgent, ip)+ } else {+ player, trc, err = players.Register(ctx, playerIDFromCookie(r, userName), client, userAgent, ip)+ }if err != nil {- log.Error(ctx, "Could not register player", "username", userName, "client", client, err)+ log.Error(ctx, "Could not resolve player", "username", userName, "client", client, err)} else {ctx = request.WithPlayer(ctx, *player)if trc != nil {@@ -230,6 +315,11 @@ func getPlayer(players core.Players) func(next http.Handler) http.Handler {}r = r.WithContext(ctx)+ // A key already identifies the player, so the cookie would only add a second, weaker signal+ if boundByKey {+ next.ServeHTTP(w, r)+ return+ }cookie := &http.Cookie{ //nolint:gosec // Secure omitted: Navidrome may run over plain HTTPName: playerIDCookieName(userName),Value: player.ID,diff --git a/server/subsonic/middlewares_test.go b/server/subsonic/middlewares_test.goindex 0879ee540..b3ad972b7 100644--- a/server/subsonic/middlewares_test.go+++ b/server/subsonic/middlewares_test.go@@ -3,6 +3,7 @@ package subsonicimport ("context""crypto/md5"+ "encoding/hex""errors""fmt""net/http"@@ -119,6 +120,14 @@ var _ = Describe("Middlewares", func() {Expect(next.called).To(BeTrue())})+ It("does not require u when apiKey is present", func() {+ r := newGetRequest("apiKey=nds_abc", "v=1.15", "c=test")+ cp := checkRequiredParameters(next)+ cp.ServeHTTP(w, r)++ Expect(next.called).To(BeTrue())+ })+It("fails when user is missing", func() {r := newGetRequest("v=1.15", "c=test")cp := checkRequiredParameters(next)@@ -311,6 +320,101 @@ var _ = Describe("Middlewares", func() {})})+ When("using API key authentication", func() {+ var key string+ serve := func(params ...string) {+ authenticate(ds)(next).ServeHTTP(w, newGetRequest(params...))+ }++ BeforeEach(func() {+ usr, err := ds.User().FindByUsername(ctx, "admin")+ Expect(err).ToNot(HaveOccurred())+ Expect(ds.Player().Put(ctx, &model.Player{ID: "player-1", Name: "My Phone", UserId: usr.ID, Client: "Symfonium"})).To(Succeed())+ key = "nds_0123456789abcdefghijkl"+ Expect(ds.Player().SetAPIKey(ctx, "player-1", key)).To(Succeed())+ })++ It("authenticates the owner and binds the key's player", func() {+ serve("apiKey=" + key)++ Expect(next.called).To(BeTrue())+ user, _ := request.UserFrom(next.req.Context())+ Expect(user.UserName).To(Equal("admin"))+ username, _ := request.UsernameFrom(next.req.Context())+ Expect(username).To(Equal("admin"))+ player, ok := request.PlayerFrom(next.req.Context())+ Expect(ok).To(BeTrue())+ Expect(player.ID).To(Equal("player-1"))+ })++ It("accepts the key in a POST form body", func() {+ r := newPostRequest("", "apiKey="+key)+ cp := postFormToQueryParams(authenticate(ds)(next))+ cp.ServeHTTP(w, r)++ Expect(next.called).To(BeTrue())+ player, _ := request.PlayerFrom(next.req.Context())+ Expect(player.ID).To(Equal("player-1"))+ })++ It("rejects an unknown key with error 44", func() {+ serve("apiKey=nds_unknown")++ Expect(w.Body.String()).To(ContainSubstring(`code="44"`))+ Expect(next.called).To(BeFalse())+ })++ DescribeTable("rejects apiKey mixed with other credentials with error 43",+ func(extra string) {+ serve("apiKey="+key, extra)++ Expect(w.Body.String()).To(ContainSubstring(`code="43"`))+ Expect(next.called).To(BeFalse())+ },+ Entry("u", "u=admin"),+ Entry("p", "p=wordpass"),+ Entry("t", "t=abc"),+ Entry("s", "s=abc"),+ Entry("jwt", "jwt=abc"),+ Entry("empty u", "u="),+ Entry("empty p", "p="),+ )++ Context("key sent as the password", func() {+ It("authenticates and binds the key's player", func() {+ serve("u=admin", "p="+key)++ Expect(next.called).To(BeTrue())+ player, ok := request.PlayerFrom(next.req.Context())+ Expect(ok).To(BeTrue())+ Expect(player.ID).To(Equal("player-1"))+ })++ It("accepts the hex-encoded form", func() {+ serve("u=admin", "p=enc:"+hex.EncodeToString([]byte(key)))++ Expect(next.called).To(BeTrue())+ })++ It("still accepts a real password that starts with the key prefix", func() {+ Expect(ds.User().Put(ctx, &model.User{UserName: "prefixed", NewPassword: "nds_secret"})).To(Succeed())+ serve("u=prefixed", "p=nds_secret")++ Expect(next.called).To(BeTrue())+ _, ok := request.PlayerFrom(next.req.Context())+ Expect(ok).To(BeFalse())+ })++ It("rejects another user's key with error 40", func() {+ Expect(ds.User().Put(ctx, &model.User{UserName: "other", NewPassword: "pw"})).To(Succeed())+ serve("u=other", "p="+key)++ Expect(w.Body.String()).To(ContainSubstring(`code="40"`))+ Expect(next.called).To(BeFalse())+ })+ })+ })+When("failed attempts reach AuthRequestLimit", func() {var cp http.Handler@@ -376,6 +480,21 @@ var _ = Describe("Middlewares", func() {Expect(next.called).To(BeTrue())})+ It("does not count server errors when a key is sent as the password", func() {+ usr, _ := ds.User().FindByUsername(ctx, "admin")+ playerRepo := ds.Player().(*tests.MockPlayerRepo)+ Expect(playerRepo.Put(ctx, &model.Player{ID: "player-1", UserId: usr.ID})).To(Succeed())+ key := "nds_0123456789abcdefghijkl"+ Expect(playerRepo.SetAPIKey(ctx, "player-1", key)).To(Succeed())++ playerRepo.Error = errors.New("db down")+ failTimes(5, "u=admin", "p="+key)+ playerRepo.Error = nil++ serve(newGetRequest("u=admin", "p="+key))+ Expect(next.called).To(BeTrue())+ })+It("does not block other usernames from the same IP", func() {_ = ds.User().Put(ctx, &model.User{UserName: "other", NewPassword: "otherpass"})failTimes(3, "u=admin", "p=WRONG")@@ -405,6 +524,25 @@ var _ = Describe("Middlewares", func() {Expect(next.called).To(BeTrue())})+ It("throttles a repeated bad key without locking out valid keys from the same IP", func() {+ usr, _ := ds.User().FindByUsername(ctx, "admin")+ playerRepo := ds.Player().(*tests.MockPlayerRepo)+ Expect(playerRepo.Put(ctx, &model.Player{ID: "player-1", UserId: usr.ID})).To(Succeed())+ key := "nds_0123456789abcdefghijkl"+ Expect(playerRepo.SetAPIKey(ctx, "player-1", key)).To(Succeed())++ for range 3 {+ Expect(serve(newGetRequest("apiKey=nds_bad")).Body.String()).To(ContainSubstring(`code="44"`))+ }+ playerRepo.APIKeys["nds_bad"] = "player-1"+ rec := serve(newGetRequest("apiKey=nds_bad"))+ Expect(next.called).To(BeFalse())+ Expect(rec.Body.String()).To(ContainSubstring(`code="44"`))++ serve(newGetRequest("apiKey=" + key))+ Expect(next.called).To(BeTrue())+ })+It("is disabled when AuthRequestLimit is 0", func() {conf.Server.AuthRequestLimit = 0cp = authenticate(ds)(next)@@ -532,6 +670,24 @@ var _ = Describe("Middlewares", func() {Expect(cookieStr).To(BeEmpty())})+ Context("player bound by an API key", func() {+ BeforeEach(func() {+ r = r.WithContext(request.WithPlayer(r.Context(), model.Player{ID: "keyed"}))+ gp := getPlayer(mockedPlayers)(next)+ gp.ServeHTTP(w, r)+ })++ It("uses the key's player", func() {+ Expect(mockedPlayers.touched).To(BeTrue())+ player, _ := request.PlayerFrom(next.req.Context())+ Expect(player.ID).To(Equal("keyed"))+ })++ It("does not set the player cookie", func() {+ Expect(w.Header().Get("Set-Cookie")).To(BeEmpty())+ })+ })+Context("PlayerId specified in Cookies", func() {BeforeEach(func() {cookie := &http.Cookie{@@ -712,6 +868,12 @@ func (mh *mockHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {type mockPlayers struct {core.Playerstranscoding *model.Transcoding+ touched bool+}++func (mp *mockPlayers) Touch(_ context.Context, plr model.Player, _, _, _ string) (*model.Player, *model.Transcoding, error) {+ mp.touched = true+ return &plr, mp.transcoding, nil}func (mp *mockPlayers) Get(ctx context.Context, playerId string) (*model.Player, error) {diff --git a/server/subsonic/opensubsonic.go b/server/subsonic/opensubsonic.goindex 2b2a31bf3..21c407039 100644--- a/server/subsonic/opensubsonic.go+++ b/server/subsonic/opensubsonic.go@@ -16,6 +16,7 @@ func (api *Router) GetOpenSubsonicExtensions(_ *http.Request) (*responses.Subson{Name: "transcoding", Versions: []int32{1}},{Name: "playbackReport", Versions: []int32{1}},{Name: "topSongsByArtistId", Versions: []int32{1}},+ {Name: "apiKeyAuthentication", Versions: []int32{1}},}if api.sonic != nil && api.sonic.HasProvider() {extensions = append(extensions, responses.OpenSubsonicExtension{diff --git a/server/subsonic/opensubsonic_test.go b/server/subsonic/opensubsonic_test.goindex 2615a652d..8740c9971 100644--- a/server/subsonic/opensubsonic_test.go+++ b/server/subsonic/opensubsonic_test.go@@ -44,7 +44,7 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {router = subsonic.New(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)})- It("should return the base 6 OpenSubsonicExtensions without sonicSimilarity", func() {+ It("should return the base 8 OpenSubsonicExtensions without sonicSimilarity", func() {router.ServeHTTP(w, r)// Make sure the endpoint is public, by not passing any authentication@@ -55,7 +55,7 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {err := json.Unmarshal(w.Body.Bytes(), &response)Expect(err).NotTo(HaveOccurred())Expect(*response.Subsonic.OpenSubsonicExtensions).To(SatisfyAll(- HaveLen(7),+ HaveLen(8),ContainElement(responses.OpenSubsonicExtension{Name: "transcodeOffset", Versions: []int32{1}}),ContainElement(responses.OpenSubsonicExtension{Name: "formPost", Versions: []int32{1}}),ContainElement(responses.OpenSubsonicExtension{Name: "songLyrics", Versions: []int32{1, 2}}),@@ -63,6 +63,7 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {ContainElement(responses.OpenSubsonicExtension{Name: "transcoding", Versions: []int32{1}}),ContainElement(responses.OpenSubsonicExtension{Name: "playbackReport", Versions: []int32{1}}),ContainElement(responses.OpenSubsonicExtension{Name: "topSongsByArtistId", Versions: []int32{1}}),+ ContainElement(responses.OpenSubsonicExtension{Name: "apiKeyAuthentication", Versions: []int32{1}}),))Expect(*response.Subsonic.OpenSubsonicExtensions).NotTo(ContainElement(responses.OpenSubsonicExtension{Name: "sonicSimilarity", Versions: []int32{1}}),@@ -76,7 +77,7 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {router = subsonic.New(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, sonicService)})- It("should return 7 extensions including sonicSimilarity", func() {+ It("should return 9 extensions including sonicSimilarity", func() {router.ServeHTTP(w, r)Expect(w.Code).To(Equal(http.StatusOK))@@ -86,7 +87,7 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {err := json.Unmarshal(w.Body.Bytes(), &response)Expect(err).NotTo(HaveOccurred())Expect(*response.Subsonic.OpenSubsonicExtensions).To(SatisfyAll(- HaveLen(8),+ HaveLen(9),ContainElement(responses.OpenSubsonicExtension{Name: "transcodeOffset", Versions: []int32{1}}),ContainElement(responses.OpenSubsonicExtension{Name: "formPost", Versions: []int32{1}}),ContainElement(responses.OpenSubsonicExtension{Name: "songLyrics", Versions: []int32{1, 2}}),@@ -95,6 +96,7 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {ContainElement(responses.OpenSubsonicExtension{Name: "playbackReport", Versions: []int32{1}}),ContainElement(responses.OpenSubsonicExtension{Name: "sonicSimilarity", Versions: []int32{1}}),ContainElement(responses.OpenSubsonicExtension{Name: "topSongsByArtistId", Versions: []int32{1}}),+ ContainElement(responses.OpenSubsonicExtension{Name: "apiKeyAuthentication", Versions: []int32{1}}),))})})diff --git a/server/subsonic/responses/.snapshots/Responses TokenInfo should match .JSON b/server/subsonic/responses/.snapshots/Responses TokenInfo should match .JSONnew file mode 100644index 000000000..f2e251f49--- /dev/null+++ b/server/subsonic/responses/.snapshots/Responses TokenInfo should match .JSON@@ -0,0 +1,10 @@+{+ "status": "ok",+ "version": "1.16.1",+ "type": "navidrome",+ "serverVersion": "v0.55.0",+ "openSubsonic": true,+ "tokenInfo": {+ "username": "deluan"+ }+}diff --git a/server/subsonic/responses/.snapshots/Responses TokenInfo should match .XML b/server/subsonic/responses/.snapshots/Responses TokenInfo should match .XMLnew file mode 100644index 000000000..7ea786bb9--- /dev/null+++ b/server/subsonic/responses/.snapshots/Responses TokenInfo should match .XML@@ -0,0 +1,3 @@+<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1" type="navidrome" serverVersion="v0.55.0" openSubsonic="true">+ <tokenInfo username="deluan"></tokenInfo>+</subsonic-response>diff --git a/server/subsonic/responses/errors.go b/server/subsonic/responses/errors.goindex 42e5427b3..9c9dd10f6 100644--- a/server/subsonic/responses/errors.go+++ b/server/subsonic/responses/errors.go@@ -1,25 +1,29 @@package responsesconst (- ErrorGeneric int32 = 0- ErrorMissingParameter int32 = 10- ErrorClientTooOld int32 = 20- ErrorServerTooOld int32 = 30- ErrorAuthenticationFail int32 = 40- ErrorAuthorizationFail int32 = 50- ErrorTrialExpired int32 = 60- ErrorDataNotFound int32 = 70+ ErrorGeneric int32 = 0+ ErrorMissingParameter int32 = 10+ ErrorClientTooOld int32 = 20+ ErrorServerTooOld int32 = 30+ ErrorAuthenticationFail int32 = 40+ ErrorMultipleAuthMechanismsProvided int32 = 43+ ErrorInvalidAPIKey int32 = 44+ ErrorAuthorizationFail int32 = 50+ ErrorTrialExpired int32 = 60+ ErrorDataNotFound int32 = 70)-var errors = map[int32]string{- ErrorGeneric: "A generic error",- ErrorMissingParameter: "Required parameter is missing",- ErrorClientTooOld: "Incompatible Subsonic REST protocol version. Client must upgrade",- ErrorServerTooOld: "Incompatible Subsonic REST protocol version. Server must upgrade",- ErrorAuthenticationFail: "Wrong username or password",- ErrorAuthorizationFail: "User is not authorized for the given operation",- ErrorTrialExpired: "The trial period for the Subsonic server is over. Please upgrade to Subsonic Premium. Visit subsonic.org for details",- ErrorDataNotFound: "The requested data was not found",+var errors = map[int32]string{ //nolint:gosec // G101 false positive: error messages, not credentials+ ErrorGeneric: "A generic error",+ ErrorMissingParameter: "Required parameter is missing",+ ErrorClientTooOld: "Incompatible Subsonic REST protocol version. Client must upgrade",+ ErrorServerTooOld: "Incompatible Subsonic REST protocol version. Server must upgrade",+ ErrorAuthenticationFail: "Wrong username or password",+ ErrorMultipleAuthMechanismsProvided: "Multiple conflicting authentication mechanisms provided",+ ErrorInvalidAPIKey: "Invalid API key",+ ErrorAuthorizationFail: "User is not authorized for the given operation",+ ErrorTrialExpired: "The trial period for the Subsonic server is over. Please upgrade to Subsonic Premium. Visit subsonic.org for details",+ ErrorDataNotFound: "The requested data was not found",}func ErrorMsg(code int32) string {diff --git a/server/subsonic/responses/responses.go b/server/subsonic/responses/responses.goindex 252eee4c6..51d0020b2 100644--- a/server/subsonic/responses/responses.go+++ b/server/subsonic/responses/responses.go@@ -63,6 +63,7 @@ type Subsonic struct {PlayQueueByIndex *PlayQueueByIndex `xml:"playQueueByIndex,omitempty" json:"playQueueByIndex,omitempty"`TranscodeDecision *TranscodeDecision `xml:"transcodeDecision,omitempty" json:"transcodeDecision,omitempty"`SonicMatches *Array[SonicMatch] `xml:"sonicMatch,omitempty" json:"sonicMatch,omitempty"`+ TokenInfo *TokenInfo `xml:"tokenInfo,omitempty" json:"tokenInfo,omitempty"`}const (@@ -596,6 +597,10 @@ type OpenSubsonicExtension struct {type OpenSubsonicExtensions []OpenSubsonicExtension+type TokenInfo struct {+ Username string `xml:"username,attr" json:"username"`+}+type ItemGenre struct {Name string `xml:"name,attr" json:"name"`}diff --git a/server/subsonic/responses/responses_test.go b/server/subsonic/responses/responses_test.goindex 586e46b63..027ac11d5 100644--- a/server/subsonic/responses/responses_test.go+++ b/server/subsonic/responses/responses_test.go@@ -1015,6 +1015,20 @@ var _ = Describe("Responses", func() {})})+ Describe("TokenInfo", func() {+ BeforeEach(func() {+ response.OpenSubsonic = true+ response.TokenInfo = &TokenInfo{Username: "deluan"}+ })++ It("should match .XML", func() {+ Expect(xml.MarshalIndent(response, "", " ")).To(MatchSnapshot())+ })+ It("should match .JSON", func() {+ Expect(json.MarshalIndent(response, "", " ")).To(MatchSnapshot())+ })+ })+Describe("InternetRadioStations", func() {BeforeEach(func() {response.InternetRadioStations = &InternetRadioStations{}diff --git a/server/subsonic/system.go b/server/subsonic/system.goindex e14099942..4a59e7898 100644--- a/server/subsonic/system.go+++ b/server/subsonic/system.go@@ -3,6 +3,7 @@ package subsonicimport ("net/http"+ "github.com/navidrome/navidrome/model/request""github.com/navidrome/navidrome/server/subsonic/responses")@@ -15,3 +16,10 @@ func (api *Router) GetLicense(_ *http.Request) (*responses.Subsonic, error) {response.License = &responses.License{Valid: true}return response, nil}++func (api *Router) TokenInfo(r *http.Request) (*responses.Subsonic, error) {+ user, _ := request.UserFrom(r.Context())+ response := newResponse()+ response.TokenInfo = &responses.TokenInfo{Username: user.UserName}+ return response, nil+}diff --git a/server/subsonic/system_test.go b/server/subsonic/system_test.gonew file mode 100644index 000000000..a8c85238e--- /dev/null+++ b/server/subsonic/system_test.go@@ -0,0 +1,23 @@+package subsonic++import (+ "net/http/httptest"++ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/model/request"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++var _ = Describe("TokenInfo", func() {+ It("returns the authenticated username", func() {+ api := &Router{}+ r := httptest.NewRequest("GET", "/tokenInfo", nil)+ r = r.WithContext(request.WithUser(r.Context(), model.User{UserName: "deluan"}))++ resp, err := api.TokenInfo(r)++ Expect(err).ToNot(HaveOccurred())+ Expect(resp.TokenInfo.Username).To(Equal("deluan"))+ })+})diff --git a/tests/mock_data_store.go b/tests/mock_data_store.goindex db798eece..a5e4126cf 100644--- a/tests/mock_data_store.go+++ b/tests/mock_data_store.go@@ -228,7 +228,7 @@ func (db *MockDataStore) Player() model.PlayerRepository {if db.RealDS != nil {return db.RealDS.Player()}- db.MockedPlayer = struct{ model.PlayerRepository }{}+ db.MockedPlayer = CreateMockPlayerRepo()return db.MockedPlayer}diff --git a/tests/mock_player_repo.go b/tests/mock_player_repo.gonew file mode 100644index 000000000..56835f0cc--- /dev/null+++ b/tests/mock_player_repo.go@@ -0,0 +1,75 @@+package tests++import (+ "context"+ "maps"+ "slices"++ "github.com/navidrome/navidrome/model"+ "github.com/navidrome/navidrome/model/id"+)++func CreateMockPlayerRepo() *MockPlayerRepo {+ return &MockPlayerRepo{Data: map[string]*model.Player{}, APIKeys: map[string]string{}}+}++// MockPlayerRepo keeps API keys in plaintext (key -> player ID); hashing belongs to the real repository.+type MockPlayerRepo struct {+ model.PlayerRepository+ Error error+ Data map[string]*model.Player+ APIKeys map[string]string+}++func (m *MockPlayerRepo) Get(_ context.Context, id string) (*model.Player, error) {+ if m.Error != nil {+ return nil, m.Error+ }+ p, ok := m.Data[id]+ if !ok {+ return nil, model.ErrNotFound+ }+ cp := *p+ cp.HasAPIKey = slices.Contains(slices.Collect(maps.Values(m.APIKeys)), id)+ return &cp, nil+}++func (m *MockPlayerRepo) Put(_ context.Context, p *model.Player) error {+ if m.Error != nil {+ return m.Error+ }+ if p.ID == "" {+ p.ID = id.NewRandom()+ }+ cp := *p+ m.Data[p.ID] = &cp+ return nil+}++func (m *MockPlayerRepo) FindByAPIKey(ctx context.Context, key string) (*model.Player, error) {+ if m.Error != nil {+ return nil, m.Error+ }+ if playerID, ok := m.APIKeys[key]; ok {+ return m.Get(ctx, playerID)+ }+ return nil, model.ErrNotFound+}++func (m *MockPlayerRepo) SetAPIKey(_ context.Context, playerID, key string) error {+ if m.Error != nil {+ return m.Error+ }+ if _, ok := m.Data[playerID]; !ok {+ return model.ErrNotFound+ }+ m.removeKeys(playerID)+ if key != "" {+ m.APIKeys[key] = playerID+ }+ return nil+}++func (m *MockPlayerRepo) removeKeys(playerID string) {+ maps.DeleteFunc(m.APIKeys, func(_ string, v string) bool { return v == playerID })+}diff --git a/ui/src/App.jsx b/ui/src/App.jsxindex d10aa5a33..4de369394 100644--- a/ui/src/App.jsx+++ b/ui/src/App.jsx@@ -141,7 +141,7 @@ const Admin = (props) => {<Resourcename="player"{...player}- options={{ subMenu: 'settings' }}+ options={{ subMenu: 'settings', label: 'resources.player.menuName' }}/>,permissions === 'admin' ? (<Resourcediff --git a/ui/src/dataProvider/wrapperDataProvider.js b/ui/src/dataProvider/wrapperDataProvider.jsindex f0e44ce1d..7de20bcce 100644--- a/ui/src/dataProvider/wrapperDataProvider.js+++ b/ui/src/dataProvider/wrapperDataProvider.js@@ -148,6 +148,12 @@ const updateUser = async (params) => {return userResponse}+// ra-data-json-server merges the request body into the result; re-read so the plaintext key is never cached+const createPlayer = async (resource, params) => {+ const { data } = await dataProvider.create(resource, params)+ return dataProvider.getOne(resource, { id: data.id })+}+const wrapperDataProvider = {...dataProvider,getList: (resource, params) => {@@ -194,6 +200,9 @@ const wrapperDataProvider = {return createUser(params)}const [r, p] = mapResource(resource, params)+ if (resource === 'player') {+ return createPlayer(r, p)+ }return dataProvider.create(r, p)},delete: (resource, params) => {diff --git a/ui/src/dataProvider/wrapperDataProvider.test.js b/ui/src/dataProvider/wrapperDataProvider.test.jsindex 4225a5a54..1c33aad5d 100644--- a/ui/src/dataProvider/wrapperDataProvider.test.js+++ b/ui/src/dataProvider/wrapperDataProvider.test.js@@ -88,6 +88,21 @@ describe('wrapperDataProvider', () => {})})+ describe('create player', () => {+ it('returns the server record, never the plaintext API key', async () => {+ const data = { name: 'Phone', apiKey: 'nds_0123456789abcdefghijkl' }+ const saved = { id: 'p1', name: 'Phone', hasApiKey: true, userId: 'u1' }+ mockProvider.create.mockResolvedValue({ data: { ...data, id: 'p1' } })+ mockProvider.getOne.mockResolvedValue({ data: saved })++ const result = await wrapperDataProvider.create('player', { data })++ expect(mockProvider.create).toHaveBeenCalledWith('player', { data })+ expect(mockProvider.getOne).toHaveBeenCalledWith('player', { id: 'p1' })+ expect(result.data).toEqual(saved)+ })+ })+describe('refreshMetadata', () => {it('posts to the album metadata refresh endpoint', () => {mockHttpClient.mockResolvedValue({ json: {} })diff --git a/ui/src/i18n/en.json b/ui/src/i18n/en.jsonindex f5af05b7b..851b47ee3 100644--- a/ui/src/i18n/en.json+++ b/ui/src/i18n/en.json@@ -182,6 +182,7 @@},"player": {"name": "Player |||| Players",+ "menuName": "Players & API keys","fields": {"name": "Name","transcodingId": "Transcoding",@@ -190,7 +191,29 @@"userName": "Username","lastSeen": "Last Seen At","reportRealPath": "Report Real Path",- "scrobbleEnabled": "Send Scrobbles to external services"+ "scrobbleEnabled": "Send Scrobbles to external services",+ "hasApiKey": "API Key"+ },+ "actions": {+ "generateApiKey": "Generate API key",+ "regenerateApiKey": "Regenerate",+ "revokeApiKey": "Revoke",+ "copyApiKey": "Copy"+ },+ "message": {+ "apiKeyActive": "This player has an API key. Use it in your app as the API key, or as the password if the app does not use token authentication.",+ "apiKeyNone": "No API key. Generate one to connect an app to this player.",+ "apiKeyNoneOther": "No API key.",+ "apiKeyPending": "Copy this key now. It is saved when you click Save and will not be shown again.",+ "apiKeyRevokePending": "The API key will be removed when you save.",+ "deleteWithKeyTitle": "Delete player",+ "deleteWithKeyContent": "This player has an API key. Apps using it will stop working."+ },+ "notifications": {+ "apiKeyCopied": "API key copied to clipboard"+ },+ "validation": {+ "apiKeyFormat": "Invalid API key format"}},"transcoding": {diff --git a/ui/src/layout/AppBar.jsx b/ui/src/layout/AppBar.jsxindex 7de111e67..460d33bb9 100644--- a/ui/src/layout/AppBar.jsx+++ b/ui/src/layout/AppBar.jsx@@ -102,9 +102,11 @@ const CustomUserMenu = ({ onClick, ...rest }) => {}const renderSettingsMenuItemLink = (resource, id) => {- const label = translate(`resources.${resource.name}.name`, {- smart_count: id ? 1 : 2,- })+ const label = resource.options.label+ ? translate(resource.options.label)+ : translate(`resources.${resource.name}.name`, {+ smart_count: id ? 1 : 2,+ })const link = id ? `/${resource.name}/${id}` : `/${resource.name}`return (<MenuItemLinkdiff --git a/ui/src/layout/AppBar.test.jsx b/ui/src/layout/AppBar.test.jsxindex 7c8cd3dcd..cc5ef781d 100644--- a/ui/src/layout/AppBar.test.jsx+++ b/ui/src/layout/AppBar.test.jsx@@ -9,11 +9,14 @@ import config from '../config'let store+const mocks = vi.hoisted(() => ({ resources: [] }))+vi.mock('react-admin', () => ({AppBar: ({ userMenu }) => <div data-testid="appbar">{userMenu}</div>,+ MenuItemLink: ({ primaryText }) => <div>{primaryText}</div>,useTranslate: () => (x) => x,usePermissions: () => ({ permissions: 'admin' }),- getResources: () => [],+ getResources: () => mocks.resources,}))vi.mock('./NowPlayingPanel', () => ({@@ -41,6 +44,7 @@ describe('<AppBar />', () => {config.devActivityPanel = trueconfig.enableNowPlaying = trueconfig.enableQuickConnect = false+ mocks.resources = []store = createStore(combineReducers({ activity: activityReducer }), {activity: { nowPlayingCount: 0 },})@@ -84,4 +88,22 @@ describe('<AppBar />', () => {expect(screen.queryAllByText('menu.quickConnect.name')).toHaveLength(0)expect(screen.queryAllByText('menu.about')).not.toHaveLength(0)})++ it('uses the resource label for settings items when set', () => {+ mocks.resources = [+ {+ name: 'player',+ hasList: true,+ options: { subMenu: 'settings', label: 'resources.player.menuName' },+ },+ { name: 'transcoding', hasList: true, options: { subMenu: 'settings' } },+ ]+ render(+ <Provider store={store}>+ <AppBar />+ </Provider>,+ )+ expect(screen.getByText('resources.player.menuName')).toBeInTheDocument()+ expect(screen.getByText('resources.transcoding.name')).toBeInTheDocument()+ })})diff --git a/ui/src/player/ApiKeyInput.jsx b/ui/src/player/ApiKeyInput.jsxnew file mode 100644index 000000000..1f2dd1ed2--- /dev/null+++ b/ui/src/player/ApiKeyInput.jsx@@ -0,0 +1,107 @@+import React from 'react'+import PropTypes from 'prop-types'+import { useInput, useNotify, useTranslate } from 'react-admin'+import { Button, TextField } from '@material-ui/core'+import { FaKey } from 'react-icons/fa'+import { MdContentCopy, MdDelete, MdRefresh } from 'react-icons/md'+import { isWritable } from '../common/playlistUtils'+import { generateApiKey } from './apiKey'++const identity = (v) => v+const MASK = '•'.repeat(26)++const ApiKeyInput = ({ record, isCreate, fullWidth, className, ...props }) => {+ const translate = useTranslate()+ const notify = useNotify()+ // Identity format/parse keep "" (revoke) distinct from undefined (untouched)+ const {+ input: { value, onChange },+ meta: { error, touched },+ } = useInput({ ...props, format: identity, parse: identity })++ const isOwner = isCreate || record?.userId === localStorage.getItem('userId')+ const pending = !!value+ const revoking = value === '' && !!record?.hasApiKey+ const saved = value == null && !!record?.hasApiKey+ const hasKey = pending || saved++ const copy = () => {+ const fallback = () =>+ prompt(translate('message.shareCopyToClipboard'), value)+ if (navigator.clipboard && window.isSecureContext) {+ navigator.clipboard+ .writeText(value)+ .then(+ () => notify('resources.player.notifications.apiKeyCopied'),+ fallback,+ )+ } else {+ fallback()+ }+ }++ const helperText = pending+ ? 'resources.player.message.apiKeyPending'+ : revoking+ ? 'resources.player.message.apiKeyRevokePending'+ : saved+ ? 'resources.player.message.apiKeyActive'+ : isOwner+ ? 'resources.player.message.apiKeyNone'+ : 'resources.player.message.apiKeyNoneOther'++ return (+ <div>+ <TextField+ label={translate('resources.player.fields.hasApiKey')}+ value={pending ? value : saved ? MASK : ''}+ variant="outlined"+ margin="dense"+ fullWidth={fullWidth}+ className={className}+ // Monospace keeps the whole key visible in a standard-width input+ inputProps={{+ style: { fontFamily: 'monospace', fontSize: '0.875rem' },+ }}+ InputProps={{ readOnly: true }}+ error={!!(touched && error)}+ helperText={translate(touched && error ? error : helperText)}+ />+ <div>+ {pending && (+ <Button startIcon={<MdContentCopy />} onClick={copy}>+ {translate('resources.player.actions.copyApiKey')}+ </Button>+ )}+ {isOwner && (+ <Button+ startIcon={hasKey ? <MdRefresh /> : <FaKey />}+ onClick={() => onChange(generateApiKey())}+ >+ {translate(+ hasKey+ ? 'resources.player.actions.regenerateApiKey'+ : 'resources.player.actions.generateApiKey',+ )}+ </Button>+ )}+ {saved && isWritable(record?.userId) && (+ <Button startIcon={<MdDelete />} onClick={() => onChange('')}>+ {translate('resources.player.actions.revokeApiKey')}+ </Button>+ )}+ </div>+ </div>+ )+}++ApiKeyInput.propTypes = {+ source: PropTypes.string.isRequired,+ record: PropTypes.object,+ isCreate: PropTypes.bool,+ fullWidth: PropTypes.bool,+ className: PropTypes.string,+ validate: PropTypes.oneOfType([PropTypes.func, PropTypes.array]),+}++export default ApiKeyInputdiff --git a/ui/src/player/ApiKeyInput.test.jsx b/ui/src/player/ApiKeyInput.test.jsxnew file mode 100644index 000000000..dd4269d6e--- /dev/null+++ b/ui/src/player/ApiKeyInput.test.jsx@@ -0,0 +1,172 @@+import * as React from 'react'+import { render, screen, fireEvent, waitFor } from '@testing-library/react'+import { Form } from 'react-final-form'+import { describe, it, expect, vi, beforeEach } from 'vitest'+import ApiKeyInput from './ApiKeyInput'++const hooks = vi.hoisted(() => ({ notify: vi.fn() }))+const KEY = 'nds_0123456789abcdefghijkl'+const KEY_FORMAT = /^nds_[0-9A-Za-z]{22}$/++vi.mock('react-admin', async () => {+ const actual = await vi.importActual('react-admin')+ return {+ ...actual,+ useNotify: () => hooks.notify,+ useTranslate: () => (key) => key,+ }+})++const renderInput = ({+ record,+ initialValues = {},+ isCreate = false,+ fullWidth,+}) => {+ let values+ const utils = render(+ <Form+ onSubmit={() => {}}+ initialValues={initialValues}+ render={({ values: v }) => {+ values = v+ return (+ <ApiKeyInput+ source="apiKey"+ record={record}+ isCreate={isCreate}+ fullWidth={fullWidth}+ />+ )+ }}+ />,+ )+ return { ...utils, values: () => values }+}++const text = (key) => screen.queryByText(key)++describe('ApiKeyInput', () => {+ beforeEach(() => {+ vi.clearAllMocks()+ localStorage.setItem('userId', 'owner')+ localStorage.setItem('role', 'regular')+ })++ it('shows a pending key with copy and regenerate on create', () => {+ const { values } = renderInput({+ record: {},+ isCreate: true,+ initialValues: { apiKey: KEY },+ })+ expect(screen.getByDisplayValue(KEY)).toBeInTheDocument()+ expect(text('resources.player.message.apiKeyPending')).toBeInTheDocument()+ expect(+ screen.getByRole('button', {+ name: 'resources.player.actions.copyApiKey',+ }),+ ).toBeInTheDocument()+ expect(+ text('resources.player.actions.revokeApiKey'),+ ).not.toBeInTheDocument()++ fireEvent.click(+ screen.getByText('resources.player.actions.regenerateApiKey'),+ )+ expect(values().apiKey).toMatch(KEY_FORMAT)+ expect(values().apiKey).not.toBe(KEY)+ })++ it('masks a saved key and lets the owner regenerate or revoke', () => {+ const { values } = renderInput({+ record: { id: 'p1', userId: 'owner', hasApiKey: true },+ })+ expect(screen.queryByDisplayValue(/^nds_/)).not.toBeInTheDocument()+ expect(text('resources.player.message.apiKeyActive')).toBeInTheDocument()+ expect(+ text('resources.player.actions.regenerateApiKey'),+ ).toBeInTheDocument()++ fireEvent.click(screen.getByText('resources.player.actions.revokeApiKey'))+ expect(values().apiKey).toBe('')+ expect(+ text('resources.player.message.apiKeyRevokePending'),+ ).toBeInTheDocument()+ expect(text('resources.player.actions.generateApiKey')).toBeInTheDocument()+ })++ it('lets the owner generate a key when there is none', () => {+ const { values } = renderInput({+ record: { id: 'p1', userId: 'owner', hasApiKey: false },+ })+ expect(values().apiKey).toBeUndefined()+ expect(text('resources.player.message.apiKeyNone')).toBeInTheDocument()++ fireEvent.click(screen.getByText('resources.player.actions.generateApiKey'))+ expect(values().apiKey).toMatch(KEY_FORMAT)+ expect(text('resources.player.message.apiKeyPending')).toBeInTheDocument()+ })++ it('lets an admin revoke but not set a key on another user player', () => {+ localStorage.setItem('role', 'admin')+ renderInput({ record: { id: 'p1', userId: 'someone', hasApiKey: true } })+ expect(+ text('resources.player.actions.regenerateApiKey'),+ ).not.toBeInTheDocument()+ expect(text('resources.player.actions.revokeApiKey')).toBeInTheDocument()+ })++ it('falls back to a prompt when the clipboard write fails', async () => {+ vi.stubGlobal('isSecureContext', true)+ vi.stubGlobal('prompt', vi.fn())+ Object.defineProperty(navigator, 'clipboard', {+ configurable: true,+ value: { writeText: vi.fn().mockRejectedValue(new Error('denied')) },+ })+ try {+ renderInput({+ record: {},+ isCreate: true,+ initialValues: { apiKey: KEY },+ })+ fireEvent.click(+ screen.getByRole('button', {+ name: 'resources.player.actions.copyApiKey',+ }),+ )+ await waitFor(() =>+ expect(window.prompt).toHaveBeenCalledWith(+ 'message.shareCopyToClipboard',+ KEY,+ ),+ )+ expect(hooks.notify).not.toHaveBeenCalled()+ } finally {+ vi.unstubAllGlobals()+ delete navigator.clipboard+ }+ })++ it('shows a neutral message to an admin viewing another user player with no key', () => {+ localStorage.setItem('role', 'admin')+ renderInput({ record: { id: 'p1', userId: 'someone', hasApiKey: false } })+ expect(text('resources.player.message.apiKeyNoneOther')).toBeInTheDocument()+ expect(text('resources.player.message.apiKeyNone')).not.toBeInTheDocument()+ expect(screen.queryAllByRole('button')).toHaveLength(0)+ })++ it('shows no actions to another regular user', () => {+ renderInput({ record: { id: 'p1', userId: 'someone', hasApiKey: true } })+ expect(screen.queryAllByRole('button')).toHaveLength(0)+ })++ it('is not full width unless asked', () => {+ const record = { id: 'p1', userId: 'owner', hasApiKey: true }+ const { container, unmount } = renderInput({ record })+ expect(container.querySelector('.MuiFormControl-fullWidth')).toBeNull()+ unmount()++ const { container: wide } = renderInput({ record, fullWidth: true })+ expect(wide.querySelector('.MuiFormControl-fullWidth')).not.toBeNull()+ })+})diff --git a/ui/src/player/PlayerCreate.jsx b/ui/src/player/PlayerCreate.jsxnew file mode 100644index 000000000..bf02cde1b--- /dev/null+++ b/ui/src/player/PlayerCreate.jsx@@ -0,0 +1,33 @@+import React, { useMemo } from 'react'+import { Create, SimpleForm, required, useTranslate } from 'react-admin'+import { Title } from '../common'+import { playerInputs } from './playerInputs'+import ApiKeyInput from './ApiKeyInput'+import { generateApiKey } from './apiKey'++const PlayerCreateTitle = () => {+ const translate = useTranslate()+ const resourceName = translate('resources.player.name', { smart_count: 1 })+ return (+ <Title subTitle={translate('ra.page.create', { name: resourceName })} />+ )+}++const PlayerCreate = (props) => {+ // Memoized so re-renders don't swap the key the user may have already copied+ const initialValues = useMemo(() => ({ apiKey: generateApiKey() }), [])+ return (+ <Create title={<PlayerCreateTitle />} {...props}>+ <SimpleForm+ variant="outlined"+ redirect="list"+ initialValues={initialValues}+ >+ {playerInputs()}+ <ApiKeyInput source="apiKey" isCreate validate={required()} />+ </SimpleForm>+ </Create>+ )+}++export default PlayerCreatediff --git a/ui/src/player/PlayerCreate.test.jsx b/ui/src/player/PlayerCreate.test.jsxnew file mode 100644index 000000000..dc1f817db--- /dev/null+++ b/ui/src/player/PlayerCreate.test.jsx@@ -0,0 +1,47 @@+import * as React from 'react'+import { render } from '@testing-library/react'+import { describe, it, expect, vi, beforeEach } from 'vitest'+import PlayerCreate from './PlayerCreate'+import ApiKeyInput from './ApiKeyInput'++const hooks = vi.hoisted(() => ({ forms: [] }))++vi.mock('react-admin', async () => {+ const actual = await vi.importActual('react-admin')+ return {+ ...actual,+ Create: ({ children }) => children,+ SimpleForm: (props) => {+ hooks.forms.push(props)+ return null+ },+ }+})++describe('PlayerCreate', () => {+ beforeEach(() => {+ hooks.forms = []+ })++ it('pre-fills one generated API key that survives re-renders', () => {+ const { rerender } = render(<PlayerCreate resource="player" />)+ rerender(<PlayerCreate resource="player" />)++ const [first, second] = hooks.forms.map((f) => f.initialValues)+ expect(hooks.forms).toHaveLength(2)+ expect(first.apiKey).toMatch(/^nds_[0-9A-Za-z]{22}$/)+ expect(second).toBe(first)+ })++ it('requires the API key', () => {+ render(<PlayerCreate resource="player" />)++ const input = React.Children.toArray(hooks.forms[0].children).find(+ (child) => child.type === ApiKeyInput,+ )+ expect(input.props.source).toBe('apiKey')+ expect(input.props.isCreate).toBe(true)+ expect(input.props.validate('')).toBeTruthy()+ expect(input.props.validate('nds_0123456789abcdefghijkl')).toBeUndefined()+ })+})diff --git a/ui/src/player/PlayerEdit.jsx b/ui/src/player/PlayerEdit.jsxindex 1826500bd..08f389698 100644--- a/ui/src/player/PlayerEdit.jsx+++ b/ui/src/player/PlayerEdit.jsx@@ -1,17 +1,17 @@import {- TextInput,- BooleanInput,TextField,Edit,- required,SimpleForm,- SelectInput,- ReferenceInput,useTranslate,+ DeleteButton,+ DeleteWithConfirmButton,+ SaveButton,+ Toolbar,} from 'react-admin'+import { makeStyles } from '@material-ui/core/styles'import { Title } from '../common'-import config from '../config'-import { BITRATE_CHOICES } from '../consts'+import ApiKeyInput from './ApiKeyInput'+import { playerInputs } from './playerInputs'const PlayerTitle = ({ record }) => {const translate = useTranslate()@@ -19,24 +19,35 @@ const PlayerTitle = ({ record }) => {return <Title subTitle={`${resourceName} ${record ? record.name : ''}`} />}+const useToolbarStyles = makeStyles({+ toolbar: {+ display: 'flex',+ justifyContent: 'space-between',+ },+})++const PlayerEditToolbar = (props) => (+ <Toolbar {...props} classes={useToolbarStyles()}>+ <SaveButton />+ {props.record?.hasApiKey ? (+ <DeleteWithConfirmButton+ mutationMode="pessimistic"+ confirmTitle="resources.player.message.deleteWithKeyTitle"+ confirmContent="resources.player.message.deleteWithKeyContent"+ />+ ) : (+ <DeleteButton />+ )}+ </Toolbar>+)+const PlayerEdit = (props) => (- <Edit title={<PlayerTitle />} {...props}>- <SimpleForm variant={'outlined'}>- <TextInput source="name" validate={[required()]} />- <ReferenceInput- source="transcodingId"- reference="transcoding"- sort={{ field: 'name', order: 'ASC' }}- >- <SelectInput source="name" resettable />- </ReferenceInput>- <SelectInput source="maxBitRate" resettable choices={BITRATE_CHOICES} />- <BooleanInput source="reportRealPath" fullWidth />- {(config.lastFMEnabled || config.listenBrainzEnabled) && (- <BooleanInput source="scrobbleEnabled" fullWidth />- )}+ <Edit title={<PlayerTitle />} mutationMode="pessimistic" {...props}>+ <SimpleForm variant={'outlined'} toolbar={<PlayerEditToolbar />}>+ {playerInputs()}<TextField source="client" /><TextField source="userName" />+ <ApiKeyInput source="apiKey" /></SimpleForm></Edit>)diff --git a/ui/src/player/PlayerEdit.test.jsx b/ui/src/player/PlayerEdit.test.jsxnew file mode 100644index 000000000..38fa2cc8e--- /dev/null+++ b/ui/src/player/PlayerEdit.test.jsx@@ -0,0 +1,25 @@+import * as React from 'react'+import { render } from '@testing-library/react'+import { describe, it, expect, vi } from 'vitest'+import PlayerEdit from './PlayerEdit'++const hooks = vi.hoisted(() => ({ editProps: null }))++vi.mock('react-admin', async () => {+ const actual = await vi.importActual('react-admin')+ return {+ ...actual,+ Edit: (props) => {+ hooks.editProps = props+ return null+ },+ }+})++describe('PlayerEdit', () => {+ // An optimistic or undoable save would put the new key in react-admin's cache+ it('saves pessimistically', () => {+ render(<PlayerEdit resource="player" id="p1" />)+ expect(hooks.editProps.mutationMode).toBe('pessimistic')+ })+})diff --git a/ui/src/player/PlayerList.jsx b/ui/src/player/PlayerList.jsxindex a2b009bad..c7bd32570 100644--- a/ui/src/player/PlayerList.jsx+++ b/ui/src/player/PlayerList.jsx@@ -2,18 +2,20 @@ import React from 'react'import {Datagrid,TextField,- DateField,FunctionField,ReferenceField,Filter,SearchInput,+ NullableBooleanInput,} from 'react-admin'import { useMediaQuery } from '@material-ui/core'-import { SimpleList, List } from '../common'+import { FaKey } from 'react-icons/fa'+import { SimpleList, List, DateField } from '../common'const PlayerFilter = (props) => (<Filter {...props} variant={'outlined'}><SearchInput id="search" source="name" alwaysOn />+ <NullableBooleanInput source="hasApiKey" alwaysOn /></Filter>)@@ -30,7 +32,11 @@ const PlayerList = ({ permissions, ...props }) => {<SimpleListprimaryText={(r) => r.name}secondaryText={(r) => r.userName}- tertiaryText={(r) => (r.maxBitRate ? r.maxBitRate : '-')}+ tertiaryText={(r) => (+ <>+ {r.hasApiKey && <FaKey />} {r.maxBitRate ? r.maxBitRate : '-'}+ </>+ )}/>) : (<Datagrid rowClick="edit">@@ -43,6 +49,11 @@ const PlayerList = ({ permissions, ...props }) => {source="maxBitRate"render={(r) => (r.maxBitRate ? r.maxBitRate : '-')}/>+ <FunctionField+ source="hasApiKey"+ sortable={false}+ render={(r) => (r.hasApiKey ? <FaKey /> : null)}+ /><DateField source="lastSeen" showTime sortByOrder={'DESC'} /></Datagrid>)}diff --git a/ui/src/player/apiKey.js b/ui/src/player/apiKey.jsnew file mode 100644index 000000000..27d683052--- /dev/null+++ b/ui/src/player/apiKey.js@@ -0,0 +1,15 @@+const API_KEY_PREFIX = 'nds_'+const ALPHABET =+ '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'+const KEY_LENGTH = 22++// Bytes >= 248 are dropped so every character is equally likely (248 = 4 * 62).+export const generateApiKey = () => {+ let key = ''+ while (key.length < KEY_LENGTH) {+ for (const b of window.crypto.getRandomValues(new Uint8Array(32))) {+ if (b < 248 && key.length < KEY_LENGTH) key += ALPHABET[b % 62]+ }+ }+ return API_KEY_PREFIX + key+}diff --git a/ui/src/player/apiKey.test.js b/ui/src/player/apiKey.test.jsnew file mode 100644index 000000000..4c41871e7--- /dev/null+++ b/ui/src/player/apiKey.test.js@@ -0,0 +1,15 @@+import { describe, it, expect } from 'vitest'+import { generateApiKey } from './apiKey'++describe('generateApiKey', () => {+ it('returns the prefix plus 22 base62 characters', () => {+ for (let i = 0; i < 50; i++) {+ expect(generateApiKey()).toMatch(/^nds_[0-9A-Za-z]{22}$/)+ }+ })++ it('returns a different key each time', () => {+ const keys = new Set(Array.from({ length: 100 }, generateApiKey))+ expect(keys.size).toBe(100)+ })+})diff --git a/ui/src/player/index.js b/ui/src/player/index.jsindex aaa3d58d7..c28cfa414 100644--- a/ui/src/player/index.js+++ b/ui/src/player/index.js@@ -1,9 +1,11 @@import { BsFillMusicPlayerFill } from 'react-icons/bs'import PlayerList from './PlayerList'import PlayerEdit from './PlayerEdit'+import PlayerCreate from './PlayerCreate'export default {list: PlayerList,edit: PlayerEdit,+ create: PlayerCreate,icon: BsFillMusicPlayerFill,}diff --git a/ui/src/player/playerInputs.jsx b/ui/src/player/playerInputs.jsxnew file mode 100644index 000000000..a8b719a81--- /dev/null+++ b/ui/src/player/playerInputs.jsx@@ -0,0 +1,34 @@+import React from 'react'+import {+ BooleanInput,+ ReferenceInput,+ SelectInput,+ TextInput,+ required,+} from 'react-admin'+import config from '../config'+import { BITRATE_CHOICES } from '../consts'++// Returned as an array, not a component, so SimpleForm still injects its props into each input.+export const playerInputs = () =>+ [+ <TextInput key="name" source="name" validate={[required()]} />,+ <ReferenceInput+ key="transcodingId"+ source="transcodingId"+ reference="transcoding"+ sort={{ field: 'name', order: 'ASC' }}+ >+ <SelectInput source="name" resettable />+ </ReferenceInput>,+ <SelectInput+ key="maxBitRate"+ source="maxBitRate"+ resettable+ choices={BITRATE_CHOICES}+ />,+ <BooleanInput key="reportRealPath" source="reportRealPath" fullWidth />,+ (config.lastFMEnabled || config.listenBrainzEnabled) && (+ <BooleanInput key="scrobbleEnabled" source="scrobbleEnabled" fullWidth />+ ),+ ].filter(Boolean)