fix(streaming): open files through os.Root and tighten token parsing
- fix: open the audio file through os.Root with O_NONBLOCK. A FIFO under a stored path used to block the request forever in open(2) before the regular-file check could run; now it is refused immediately - fix: os.Root also removes the gap between checking the path and opening it, so a symlink swapped in at the last moment cannot leave the library (absolute symlinks are refused even when they point back inside) - fix(api): only "Authorization: Bearer <token>" is accepted again. The query token change had made a bare token in the header pass on every route - fix(config): library.roots must be absolute paths; a relative root made every stream fail and depended on the directory sondad started in - test: FIFO and symlink-to-FIFO without hanging, bare and non-Bearer headers on a normal route and on the stream route, relative roots
This commit is contained in:
parent
49f1051b3f
commit
def20731be
10 changed files with 179 additions and 37 deletions
|
|
@ -2,6 +2,7 @@ package httpapi
|
|||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strconv"
|
||||
"testing"
|
||||
)
|
||||
|
|
@ -320,3 +321,34 @@ func TestAdminCanStartScan(t *testing.T) {
|
|||
t.Errorf("starts = %d", scan.starts)
|
||||
}
|
||||
}
|
||||
|
||||
// Only "Authorization: Bearer <token>" is accepted. A bare token must not pass.
|
||||
func TestAuthorizationHeaderMustUseTheBearerScheme(t *testing.T) {
|
||||
h := newTestAPI(t)
|
||||
tok := registerAndLogin(t, h)
|
||||
|
||||
for name, header := range map[string]string{
|
||||
"bare token": tok,
|
||||
"basic scheme": "Basic " + tok,
|
||||
"lowercase": "bearer " + tok,
|
||||
"token scheme": "Token " + tok,
|
||||
"empty bearer": "Bearer ",
|
||||
"bearer no gap": "Bearer" + tok,
|
||||
} {
|
||||
req := httptest.NewRequest("GET", "/api/v1/auth/me", nil)
|
||||
req.Header.Set("Authorization", header)
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, req)
|
||||
if rec.Code != http.StatusUnauthorized {
|
||||
t.Errorf("%s: status %d, want 401", name, rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
req := httptest.NewRequest("GET", "/api/v1/auth/me", nil)
|
||||
req.Header.Set("Authorization", "Bearer "+tok)
|
||||
rec := httptest.NewRecorder()
|
||||
h.ServeHTTP(rec, req)
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Errorf("proper Bearer header: %d", rec.Code)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -87,7 +87,12 @@ func requireAuth(tokens tokenParser, allowQuery bool) gin.HandlerFunc {
|
|||
return func(c *gin.Context) {
|
||||
token := ""
|
||||
if header := c.GetHeader("Authorization"); header != "" {
|
||||
token, _ = strings.CutPrefix(header, "Bearer ")
|
||||
var ok bool
|
||||
if token, ok = strings.CutPrefix(header, "Bearer "); !ok {
|
||||
// Any other scheme, or a bare token, is not accepted.
|
||||
writeError(c, http.StatusUnauthorized, "unauthorized", "missing bearer token")
|
||||
return
|
||||
}
|
||||
} else if allowQuery {
|
||||
token = c.Query("access_token")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -83,6 +83,17 @@ func TestStreamRequiresAuth(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
// A header that is present but not a Bearer token is not rescued by the query.
|
||||
func TestStreamIgnoresQueryTokenWhenAnyAuthorizationHeaderIsPresent(t *testing.T) {
|
||||
f := newStreamFixture(t)
|
||||
for _, header := range []string{f.token, "Basic " + f.token, "Token x"} {
|
||||
rec := f.get(t, "GET", "/api/v1/tracks/1/stream?access_token="+f.token, map[string]string{"Authorization": header})
|
||||
if rec.Code != http.StatusUnauthorized {
|
||||
t.Errorf("Authorization %.12q... with a valid query token: %d, want 401", header, rec.Code)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestStreamAcceptsHeaderAndQueryToken(t *testing.T) {
|
||||
f := newStreamFixture(t)
|
||||
if rec := f.get(t, "GET", "/api/v1/tracks/1/stream", f.auth()); rec.Code != http.StatusOK {
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ import (
|
|||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"time"
|
||||
|
||||
"github.com/pelletier/go-toml/v2"
|
||||
|
|
@ -172,6 +173,12 @@ func (c Config) Validate() error {
|
|||
errs = append(errs, errors.New("library.roots needs at least one directory"))
|
||||
}
|
||||
for _, root := range c.Library.Roots {
|
||||
if !filepath.IsAbs(root) {
|
||||
// Roots are stored with every indexed file and used to serve it:
|
||||
// a relative one would depend on the directory sondad starts in.
|
||||
errs = append(errs, fmt.Errorf("library.roots: %q must be an absolute path", root))
|
||||
continue
|
||||
}
|
||||
info, err := os.Stat(root)
|
||||
switch {
|
||||
case err != nil:
|
||||
|
|
|
|||
|
|
@ -127,6 +127,7 @@ func TestValidate(t *testing.T) {
|
|||
{"ok", func(c *Config) {}, ""},
|
||||
{"no roots", func(c *Config) { c.Library.Roots = nil }, "library.roots"},
|
||||
{"root missing", func(c *Config) { c.Library.Roots = []string{filepath.Join(good, "nope")} }, "library.roots"},
|
||||
{"relative root", func(c *Config) { c.Library.Roots = []string{"music"} }, "absolute"},
|
||||
{"root is file", func(c *Config) { c.Library.Roots = []string{file} }, "not a directory"},
|
||||
{"bad env", func(c *Config) { c.Log.Env = "staging" }, "log.env"},
|
||||
{"empty listen", func(c *Config) { c.Server.Listen = "" }, "server.listen"},
|
||||
|
|
|
|||
52
internal/streaming/fifo_unix_test.go
Normal file
52
internal/streaming/fifo_unix_test.go
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
//go:build unix
|
||||
|
||||
package streaming
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"syscall"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Opening a named pipe blocks forever until a writer shows up, so a FIFO must
|
||||
// be refused without ever blocking the request.
|
||||
func TestOpenRefusesFIFOsWithoutHanging(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
if err := syscall.Mkfifo(filepath.Join(root, "pipe.mp3"), 0o644); err != nil {
|
||||
t.Skip("cannot create a FIFO:", err)
|
||||
}
|
||||
if err := os.Symlink("pipe.mp3", filepath.Join(root, "pipelink.mp3")); err != nil {
|
||||
t.Skip("symlinks not supported:", err)
|
||||
}
|
||||
|
||||
for _, rel := range []string{"pipe.mp3", "pipelink.mp3"} {
|
||||
s := service(root, map[int64]File{1: {Root: root, RelPath: rel}})
|
||||
|
||||
type result struct {
|
||||
st *Stream
|
||||
err error
|
||||
}
|
||||
done := make(chan result, 1)
|
||||
go func() {
|
||||
st, err := s.Open(context.Background(), 1)
|
||||
done <- result{st, err}
|
||||
}()
|
||||
|
||||
select {
|
||||
case r := <-done:
|
||||
if r.err == nil {
|
||||
r.st.Close()
|
||||
t.Fatalf("%s: a FIFO was opened as a stream", rel)
|
||||
}
|
||||
if !errors.Is(r.err, ErrUnsafePath) {
|
||||
t.Errorf("%s: err = %v, want ErrUnsafePath", rel, r.err)
|
||||
}
|
||||
case <-time.After(3 * time.Second):
|
||||
t.Fatalf("%s: Open blocked on a FIFO", rel)
|
||||
}
|
||||
}
|
||||
}
|
||||
5
internal/streaming/open_other.go
Normal file
5
internal/streaming/open_other.go
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
//go:build !unix
|
||||
|
||||
package streaming
|
||||
|
||||
const nonBlock = 0
|
||||
9
internal/streaming/open_unix.go
Normal file
9
internal/streaming/open_unix.go
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
//go:build unix
|
||||
|
||||
package streaming
|
||||
|
||||
import "syscall"
|
||||
|
||||
// nonBlock makes open(2) on a FIFO return immediately instead of waiting for a
|
||||
// writer. It changes nothing for regular files.
|
||||
const nonBlock = syscall.O_NONBLOCK
|
||||
|
|
@ -1,8 +1,9 @@
|
|||
// Package streaming opens audio files for playback.
|
||||
//
|
||||
// The only job here is to turn a track id into an open, verified file. Every
|
||||
// path is checked against the configured library roots before it is opened, so
|
||||
// a bad database row or a swapped symlink can never expose files outside them.
|
||||
// The only job here is to turn a track id into an open, verified file. The
|
||||
// stored path is treated as untrusted: it must belong to a configured library
|
||||
// root, and the file is opened through os.Root so that nothing, not even a
|
||||
// symlink swapped in at the last moment, can lead outside that root.
|
||||
package streaming
|
||||
|
||||
import (
|
||||
|
|
@ -51,7 +52,7 @@ func (s *Stream) Close() error { return s.File.Close() }
|
|||
// Service opens tracks for playback.
|
||||
type Service struct {
|
||||
source Source
|
||||
roots []string // cleaned, absolute
|
||||
roots []string // cleaned; config validation requires them to be absolute
|
||||
}
|
||||
|
||||
// NewService builds a Service. Only files under the given roots can be opened.
|
||||
|
|
@ -65,23 +66,42 @@ func NewService(source Source, roots []string) *Service {
|
|||
|
||||
// Open returns the audio file of a track, after verifying that it is a regular
|
||||
// file inside one of the configured roots.
|
||||
//
|
||||
// The file is opened through an os.Root, which refuses to leave the root at
|
||||
// open time: a symlink swapped in after any earlier check cannot escape, and
|
||||
// there is no gap between "check the path" and "open the file".
|
||||
func (s *Service) Open(ctx context.Context, trackID int64) (*Stream, error) {
|
||||
f, err := s.source.PlayableFile(ctx, trackID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
path, err := s.resolve(f)
|
||||
rel, err := s.validate(f)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
file, err := os.Open(path)
|
||||
root, err := os.OpenRoot(filepath.Clean(f.Root))
|
||||
if errors.Is(err, fs.ErrNotExist) {
|
||||
return nil, ErrFileMissing
|
||||
return nil, ErrFileMissing // volume not mounted
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("open library root: %w", err)
|
||||
}
|
||||
defer root.Close() // files already opened stay valid
|
||||
|
||||
// O_NONBLOCK so that a FIFO cannot hang the request: opening one would
|
||||
// otherwise block until a writer appears.
|
||||
file, err := root.OpenFile(rel, os.O_RDONLY|nonBlock, 0)
|
||||
switch {
|
||||
case errors.Is(err, fs.ErrNotExist):
|
||||
return nil, ErrFileMissing
|
||||
case err != nil && strings.Contains(err.Error(), "path escapes from parent"):
|
||||
// os.Root has no exported error for this case.
|
||||
return nil, fmt.Errorf("%w: symlink leaves the library", ErrUnsafePath)
|
||||
case err != nil:
|
||||
return nil, fmt.Errorf("open audio file: %w", err)
|
||||
}
|
||||
|
||||
// Check what was actually opened, not what the path looked like earlier.
|
||||
info, err := file.Stat()
|
||||
if err != nil {
|
||||
|
|
@ -95,15 +115,15 @@ func (s *Service) Open(ctx context.Context, trackID int64) (*Stream, error) {
|
|||
|
||||
return &Stream{
|
||||
File: file,
|
||||
Name: filepath.Base(path),
|
||||
Name: filepath.Base(rel),
|
||||
ModTime: info.ModTime(),
|
||||
ContentType: contentType(path),
|
||||
ContentType: contentType(rel),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// resolve returns the real path of f, or ErrUnsafePath if it is not strictly
|
||||
// inside a configured root once every symlink has been followed.
|
||||
func (s *Service) resolve(f File) (string, error) {
|
||||
// validate checks the stored root and relative path and returns the cleaned
|
||||
// relative path to open under the root.
|
||||
func (s *Service) validate(f File) (string, error) {
|
||||
root := filepath.Clean(f.Root)
|
||||
if !filepath.IsAbs(root) || !s.allowed(root) {
|
||||
return "", fmt.Errorf("%w: root is not a configured library root", ErrUnsafePath)
|
||||
|
|
@ -117,27 +137,7 @@ func (s *Service) resolve(f File) (string, error) {
|
|||
if rel == "." || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
|
||||
return "", fmt.Errorf("%w: path escapes the root", ErrUnsafePath)
|
||||
}
|
||||
|
||||
// The root itself may be a symlink (for example /srv/music -> /mnt/nas),
|
||||
// so compare real paths on both sides.
|
||||
realRoot, err := filepath.EvalSymlinks(root)
|
||||
if err != nil {
|
||||
if errors.Is(err, fs.ErrNotExist) {
|
||||
return "", ErrFileMissing // volume not mounted
|
||||
}
|
||||
return "", fmt.Errorf("resolve root: %w", err)
|
||||
}
|
||||
realFull, err := filepath.EvalSymlinks(filepath.Join(root, rel))
|
||||
if err != nil {
|
||||
if errors.Is(err, fs.ErrNotExist) {
|
||||
return "", ErrFileMissing
|
||||
}
|
||||
return "", fmt.Errorf("resolve path: %w", err)
|
||||
}
|
||||
if !strings.HasPrefix(realFull, realRoot+string(filepath.Separator)) {
|
||||
return "", fmt.Errorf("%w: symlink leaves the library", ErrUnsafePath)
|
||||
}
|
||||
return realFull, nil
|
||||
return rel, nil
|
||||
}
|
||||
|
||||
func (s *Service) allowed(root string) bool {
|
||||
|
|
|
|||
|
|
@ -168,7 +168,24 @@ func TestOpenRejectsSymlinkEscapingTheRoot(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestOpenAllowsSymlinkThatStaysInsideTheRoot(t *testing.T) {
|
||||
func TestOpenAllowsRelativeSymlinkThatStaysInsideTheRoot(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
write(t, filepath.Join(root, "real/song.mp3"), "ok")
|
||||
if err := os.Symlink("real", filepath.Join(root, "alias")); err != nil {
|
||||
t.Skip("symlinks not supported:", err)
|
||||
}
|
||||
s := service(root, map[int64]File{1: {Root: root, RelPath: "alias/song.mp3"}})
|
||||
st, err := s.Open(context.Background(), 1)
|
||||
if err != nil {
|
||||
t.Fatalf("relative symlink inside the root rejected: %v", err)
|
||||
}
|
||||
st.Close()
|
||||
}
|
||||
|
||||
// os.Root refuses absolute symlink targets even when they point back inside the
|
||||
// root. The scanner never indexes through a symlink, so this only costs files
|
||||
// that were linked in after the scan, and it keeps the rule simple and safe.
|
||||
func TestOpenRefusesAbsoluteSymlinksEvenInsideTheRoot(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
write(t, filepath.Join(root, "real/song.mp3"), "ok")
|
||||
if err := os.Symlink(filepath.Join(root, "real"), filepath.Join(root, "alias")); err != nil {
|
||||
|
|
@ -176,10 +193,13 @@ func TestOpenAllowsSymlinkThatStaysInsideTheRoot(t *testing.T) {
|
|||
}
|
||||
s := service(root, map[int64]File{1: {Root: root, RelPath: "alias/song.mp3"}})
|
||||
st, err := s.Open(context.Background(), 1)
|
||||
if err != nil {
|
||||
t.Fatalf("symlink inside the root rejected: %v", err)
|
||||
if err == nil {
|
||||
st.Close()
|
||||
t.Fatal("an absolute symlink was followed")
|
||||
}
|
||||
if !errors.Is(err, ErrUnsafePath) {
|
||||
t.Errorf("err = %v, want ErrUnsafePath", err)
|
||||
}
|
||||
st.Close()
|
||||
}
|
||||
|
||||
func TestOpenAcceptsASymlinkedRoot(t *testing.T) {
|
||||
|
|
|
|||
Loading…
Reference in a new issue