sonda/internal/federation/peer_test.go
tgiachi 7f38ae038e feat(federation): play a friend's music and show its covers through this server
A listener can now play the music of a friend from the web app.

- GET /friends/{friend}/tracks/{id}/stream and /friends/{friend}/albums/{id}/cover,
  in the group that accepts the access token in the query, like the local ones.
  This server asks the friend with a signed request and passes the bytes on,
  forwarding Range and the conditional headers, so a player can seek. The
  friend sees this server and never the listener.
- Only audio (for a stream) and a JPEG (for a cover) are passed on, with a
  fixed set of headers: Content-Type, Content-Length, Content-Range,
  Accept-Ranges, Last-Modified and ETag. Anything else a friend sends, or
  what a listener's request carries (cookies, authorization), is not passed
  either way, so a friend cannot make this server serve anything else.
- The client of friends can open a streaming answer: no limit on its whole
  length, one only on its beginning, no redirect followed, and it ends when
  the listener leaves.
- The player holds a friend's track next to the local ones. It streams
  through this server, shows the friend's cover, links to the music of the
  friend and not to a local page, is told apart from a local track with the
  same id, and is never reported as a listen: it does not feed taste.
- The songs of a friend have play buttons, the albums their covers.
- OpenAPI paths, contract test, and two real servers checked end to end: the
  bytes of the file arrive unchanged, with ranges, and a song plays in a
  browser from the friend's server through the other one.
2026-11-13 16:11:59 +01:00

409 lines
15 KiB
Go

package federation
import (
"context"
"crypto/ed25519"
"errors"
"net/http"
"strconv"
"strings"
"testing"
"time"
)
// pairedServers makes two servers that are friends: b used an invite of a, and a approved. It returns a, its store,
// b's key pair and the id of b among a's friends.
func pairedServers(t *testing.T) (a *Service, aStore *memStore, ck *clock, bPub ed25519.PublicKey, bPriv ed25519.PrivateKey, bID int64) {
t.Helper()
ctx := context.Background()
a, aStore, ck = newServer(t, "Anna", "https://anna.example.org", nil)
b, bStore, _ := newServer(t, "Bruno", "https://bruno.example.org", &direct{to: a})
inv, _ := a.CreateInvite(ctx)
if _, err := b.Redeem(ctx, inv.Text); err != nil {
t.Fatal(err)
}
list, _ := aStore.Friends(ctx)
if _, err := a.Approve(ctx, list[0].ID); err != nil {
t.Fatal(err)
}
return a, aStore, ck, bStore.settings.PublicKey, bStore.settings.PrivateKey, list[0].ID
}
func signedBy(priv ed25519.PrivateKey, pub ed25519.PublicKey, now time.Time, uri, nonce string) Signed {
h := Sign(priv, "GET", uri, now, nonce)
return Signed{KeyID: KeyID(pub), Date: h.Date, Nonce: nonce, Signature: h.Signature, Method: "GET", URI: uri}
}
func TestAFriendThatSignsProperlyIsAuthenticated(t *testing.T) {
a, _, ck, pub, priv, id := pairedServers(t)
got, err := a.Authenticate(context.Background(), signedBy(priv, pub, ck.t, "/api/v1/peer/artists?limit=5", "nonce-0123456789ab"))
if err != nil || got.ID != id || got.Name != "Bruno" || got.State != Active {
t.Fatalf("Authenticate = %+v, %v", got, err)
}
}
func TestAuthenticationRefusesWhatIsNotProperlySigned(t *testing.T) {
ctx := context.Background()
a, _, ck, pub, priv, _ := pairedServers(t)
good := signedBy(priv, pub, ck.t, "/api/v1/peer/artists", "nonce-0123456789ab")
stranger, strangerPriv, _ := ed25519.GenerateKey(nil)
tamper := func(f func(*Signed)) Signed { s := good; f(&s); return s }
for name, in := range map[string]Signed{
"nothing": {},
"another path": tamper(func(s *Signed) { s.URI = "/api/v1/peer/albums" }),
"another query": tamper(func(s *Signed) { s.URI = "/api/v1/peer/artists?limit=1" }),
"another method": tamper(func(s *Signed) { s.Method = "POST" }),
"another nonce": tamper(func(s *Signed) { s.Nonce = "nonce-ffffffffffff" }),
"a short nonce": signedBy(priv, pub, ck.t, "/api/v1/peer/artists", "short"),
"a nonce with spaces": signedBy(priv, pub, ck.t, "/api/v1/peer/artists", "nonce with spaces!!"),
"a damaged signature": tamper(func(s *Signed) { s.Signature = "AAAA" }),
"no signature": tamper(func(s *Signed) { s.Signature = "" }),
"a key that is no friend": signedBy(strangerPriv, stranger, ck.t, "/api/v1/peer/artists", "nonce-0123456789ab"),
"a bad key id": tamper(func(s *Signed) { s.KeyID = "xyz" }),
"a date that is no date": tamper(func(s *Signed) { s.Date = "yesterday" }),
"too old": signedBy(priv, pub, ck.t.Add(-3*time.Minute), "/api/v1/peer/artists", "nonce-0123456789ab"),
"from the future": signedBy(priv, pub, ck.t.Add(3*time.Minute), "/api/v1/peer/artists", "nonce-0123456789ab"),
} {
if _, err := a.Authenticate(ctx, in); !errors.Is(err, ErrUnauthorized) {
t.Errorf("%s: err = %v, want ErrUnauthorized", name, err)
}
}
// None of those used the nonce up: the good request still works.
if _, err := a.Authenticate(ctx, good); err != nil {
t.Errorf("the good request after the bad ones: %v", err)
}
}
func TestAnAnswerToTheSameRequestIsNotGivenTwice(t *testing.T) {
ctx := context.Background()
a, _, ck, pub, priv, _ := pairedServers(t)
req := signedBy(priv, pub, ck.t, "/api/v1/peer/artists", "nonce-0123456789ab")
if _, err := a.Authenticate(ctx, req); err != nil {
t.Fatal(err)
}
if _, err := a.Authenticate(ctx, req); !errors.Is(err, ErrUnauthorized) {
t.Errorf("replay = %v, want ErrUnauthorized", err)
}
// Once the window has passed the request is too old anyway, and the nonce is forgotten.
ck.t = ck.t.Add(10 * time.Minute)
if _, err := a.Authenticate(ctx, req); !errors.Is(err, ErrUnauthorized) {
t.Errorf("replay after the window = %v, want ErrUnauthorized", err)
}
if n := len(a.seen); n != 0 {
// Cleaned the next time one is added.
a.remember("k", "n", ck.t)
if len(a.seen) != 1 {
t.Errorf("seen nonces = %d, want the old ones forgotten", len(a.seen))
}
}
}
func TestOnlyApprovedFriendsAreAnswered(t *testing.T) {
ctx := context.Background()
a, aStore, ck, pub, priv, id := pairedServers(t)
// Not on, nothing is answered.
off := false
if _, err := a.Update(ctx, Patch{Enabled: &off}); err != nil {
t.Fatal(err)
}
if _, err := a.Authenticate(ctx, signedBy(priv, pub, ck.t, "/x", "nonce-0123456789ab")); !errors.Is(err, ErrOff) {
t.Errorf("while off: %v, want ErrOff", err)
}
on := true
_, _ = a.Update(ctx, Patch{Enabled: &on})
// A request that is waiting for approval is told so, once its signature is known to be good.
aStore.friends[0].State = Incoming
if _, err := a.Authenticate(ctx, signedBy(priv, pub, ck.t, "/x", "nonce-aaaaaaaaaaaa")); !errors.Is(err, ErrNotApproved) {
t.Errorf("incoming: %v, want ErrNotApproved", err)
}
// A friend that was removed is a stranger.
if err := a.Remove(ctx, id); err != nil {
t.Fatal(err)
}
if _, err := a.Authenticate(ctx, signedBy(priv, pub, ck.t, "/x", "nonce-bbbbbbbbbbbb")); !errors.Is(err, ErrUnauthorized) {
t.Errorf("removed: %v, want ErrUnauthorized", err)
}
}
func TestAServerThatApprovedUsMayCallBeforeWeHeardIt(t *testing.T) {
// b pasted an invite: for b, a is outgoing. When a calls b it has approved (it would not call otherwise),
// so b answers and the friendship is active from then on.
ctx := context.Background()
a, aStore, ck, _, _, _ := pairedServers(t)
b, bStore, _ := newServer(t, "Carla", "https://carla.example.org", &direct{to: a})
inv, _ := a.CreateInvite(ctx)
if _, err := b.Redeem(ctx, inv.Text); err != nil {
t.Fatal(err)
}
b.now = ck.now
list, _ := aStore.Friends(ctx)
_, _ = a.Approve(ctx, list[len(list)-1].ID)
aPub, aPriv := aStore.settings.PublicKey, aStore.settings.PrivateKey
if st, _ := bStore.Friends(ctx); st[0].State != Outgoing {
t.Fatalf("b's friend = %+v", st)
}
got, err := b.Authenticate(ctx, signedBy(aPriv, aPub, ck.t, "/x", "nonce-0123456789ab"))
if err != nil || got.State != Active {
t.Fatalf("Authenticate = %+v, %v", got, err)
}
if st, _ := bStore.Friends(ctx); st[0].State != Active || st[0].ApprovedAt.IsZero() {
t.Errorf("b's friend after the call = %+v", st)
}
}
func TestStreamsAreLimitedForEachFriend(t *testing.T) {
ctx := context.Background()
a, _, _, _, _, id := pairedServers(t)
var open []*Stream
for i := 0; i < DefaultMaxStreams; i++ {
s, err := a.StartStream(ctx, id)
if err != nil {
t.Fatalf("stream %d: %v", i, err)
}
open = append(open, s)
}
if _, err := a.StartStream(ctx, id); !errors.Is(err, ErrTooManyStreams) {
t.Fatalf("one too many = %v, want ErrTooManyStreams", err)
}
// Another friend has its own allowance.
if s, err := a.StartStream(ctx, id+1); err != nil {
t.Errorf("another friend: %v", err)
} else {
s.Close()
}
open[0].Close()
open[0].Close() // closing twice frees only one place
s, err := a.StartStream(ctx, id)
if err != nil {
t.Fatalf("after one ended: %v", err)
}
if _, err := a.StartStream(ctx, id); !errors.Is(err, ErrTooManyStreams) {
t.Errorf("a double Close freed two places: %v", err)
}
s.Close()
// The limit is the admin's to set.
two := 2
if _, err := a.Update(ctx, Patch{MaxStreams: &two}); err != nil {
t.Fatal(err)
}
for _, o := range open[1:] {
o.Close()
}
x, _ := a.StartStream(ctx, id)
y, _ := a.StartStream(ctx, id)
if _, err := a.StartStream(ctx, id); !errors.Is(err, ErrTooManyStreams) {
t.Errorf("limit 2: %v, want ErrTooManyStreams", err)
}
x.Close()
y.Close()
}
func TestTheBytesOfAFriendAreSpacedOutOverTime(t *testing.T) {
ctx := context.Background()
a, _, ck, _, _, id := pairedServers(t)
var slept time.Duration
a.sleep = func(_ context.Context, d time.Duration) error { slept += d; ck.t = ck.t.Add(d); return nil }
kib := 1024 // one MiB a second
if _, err := a.Update(ctx, Patch{MaxKiBPerSec: &kib}); err != nil {
t.Fatal(err)
}
s, err := a.StartStream(ctx, id)
if err != nil {
t.Fatal(err)
}
defer s.Close()
for i := 0; i < 64; i++ { // 4 MiB in chunks of 64 KiB
if err := s.Wait(ctx, 64<<10); err != nil {
t.Fatal(err)
}
}
// 4 MiB at 1 MiB/s is 4 s, less the short burst that is let through at once.
if slept < 3500*time.Millisecond || slept > 4*time.Second {
t.Errorf("slept %v for 4 MiB at 1 MiB/s", slept)
}
// Two streams of one friend share the allowance.
slept = 0
s2, _ := a.StartStream(ctx, id)
defer s2.Close()
for i := 0; i < 16; i++ {
_ = s.Wait(ctx, 64<<10)
_ = s2.Wait(ctx, 64<<10)
}
if slept < 1500*time.Millisecond {
t.Errorf("two streams slept %v for 2 MiB: they must share one allowance", slept)
}
// 0 means no limit.
zero := 0
_, _ = a.Update(ctx, Patch{MaxKiBPerSec: &zero})
s3, _ := a.StartStream(ctx, id)
defer s3.Close()
slept = 0
for i := 0; i < 64; i++ {
_ = s3.Wait(ctx, 64<<10)
}
if slept != 0 {
t.Errorf("no limit slept %v", slept)
}
}
func TestTheLimitsAreChecked(t *testing.T) {
ctx := context.Background()
s := NewService(newMemStore(), nil)
for name, p := range map[string]Patch{
"no streams": {MaxStreams: ptr(0)},
"too many": {MaxStreams: ptr(21)},
"a trickle": {MaxKiBPerSec: ptr(10)},
"negative": {MaxKiBPerSec: ptr(-1)},
"a flood": {MaxKiBPerSec: ptr(200000)},
} {
if _, err := s.Update(ctx, p); !errors.Is(err, ErrInvalidInput) {
t.Errorf("%s: err = %v, want ErrInvalidInput", name, err)
}
}
st, err := s.Update(ctx, Patch{MaxStreams: ptr(5), MaxKiBPerSec: ptr(512)})
if err != nil || st.MaxStreams != 5 || st.MaxKiBPerSec != 512 {
t.Errorf("Update = %+v, %v", st, err)
}
if def, _ := NewService(newMemStore(), nil).Status(ctx); def.MaxStreams != DefaultMaxStreams || def.MaxKiBPerSec != DefaultMaxKiBPerSec {
t.Errorf("defaults = %d and %d", def.MaxStreams, def.MaxKiBPerSec)
}
}
func ptr(n int) *int { return &n }
func TestTheRequestsOfFriendsAreKeptAndOldOnesDropped(t *testing.T) {
ctx := context.Background()
a, aStore, ck, _, _, id := pairedServers(t)
for i := 0; i < 3; i++ {
a.Record(ctx, FriendRequest{FriendID: id, Route: "/api/v1/peer/tracks/:id/stream", Status: 200, Bytes: int64(100 * (i + 1))})
ck.t = ck.t.Add(time.Minute)
}
got, err := a.Requests(ctx)
if err != nil || len(got) != 3 {
t.Fatalf("Requests = %+v, %v", got, err)
}
if got[0].Bytes != 300 || got[0].FriendName != "Bruno" || got[0].Route == "" || got[2].Bytes != 100 {
t.Errorf("newest first, with the friend's name: %+v", got)
}
// Rows older than a week go, on a later write (every 100th).
ck.t = ck.t.Add(8 * 24 * time.Hour)
for i := 0; i < requestPruneEvery; i++ {
a.Record(ctx, FriendRequest{FriendID: id, Route: "/api/v1/peer/info", Status: 200})
}
for _, r := range aStore.requests {
if ck.t.Sub(r.At) > requestKeep {
t.Errorf("a request from %v is still kept", r.At)
}
}
got, _ = a.Requests(ctx)
if len(got) == 0 || len(got) > requestsShown {
t.Errorf("Requests shows %d rows, want 1 to %d", len(got), requestsShown)
}
}
// fakeRemote answers a signed call as a script says.
type fakeRemote struct {
info Info
err error
got Auth
addr string
}
func (f *fakeRemote) Pair(context.Context, string, PairRequest) (PairReply, error) {
return PairReply{}, errors.New("not used")
}
func (f *fakeRemote) Get(context.Context, string, string, Auth) (int, []byte, error) {
return 0, nil, errors.New("not used")
}
func (f *fakeRemote) Open(context.Context, string, string, Auth, http.Header) (*http.Response, error) {
return nil, errors.New("not used")
}
func (f *fakeRemote) Info(_ context.Context, addr string, auth Auth) (Info, error) {
f.got, f.addr = auth, addr
return f.info, f.err
}
func TestAServerThatPastedAnInviteLearnsWhenTheOtherApproved(t *testing.T) {
ctx := context.Background()
a, _, _ := newServer(t, "Anna", "https://anna.example.org", nil)
remote := &fakeRemote{}
b, bStore, _ := newServer(t, "Bruno", "https://bruno.example.org", &direct{to: a})
inv, _ := a.CreateInvite(ctx)
mine, err := b.Redeem(ctx, inv.Text)
if err != nil {
t.Fatal(err)
}
b.remote = remote
// Anna has not approved yet: the answer is "not yet", and the friend stays as it is.
remote.err = ErrNotApproved
got, err := b.Check(ctx, mine.ID)
if !errors.Is(err, ErrNotApproved) || got.State != Outgoing {
t.Fatalf("before approval: %+v, %v", got, err)
}
if remote.addr != "https://anna.example.org" || remote.got.KeyID != KeyID(bStore.settings.PublicKey) || len(remote.got.Key) != ed25519.PrivateKeySize {
t.Errorf("the call was made to %q with %+v: it must be signed by this server's key", remote.addr, remote.got.KeyID)
}
// Anna approved: the first answer makes it active.
remote.err, remote.info = nil, Info{Name: "Anna", SharedLibraries: 2}
got, err = b.Check(ctx, mine.ID)
if err != nil || got.State != Active || got.ApprovedAt.IsZero() {
t.Fatalf("after approval: %+v, %v", got, err)
}
// And again once it is active: nothing changes, nothing breaks.
if again, err := b.Check(ctx, mine.ID); err != nil || again.State != Active {
t.Errorf("second check: %+v, %v", again, err)
}
// A server that cannot be asked is not a verdict.
remote.err = ErrUnreachable
if _, err := b.Check(ctx, mine.ID); !errors.Is(err, ErrUnreachable) {
t.Errorf("unreachable: %v", err)
}
if st, _ := bStore.Friends(ctx); st[0].State != Active {
t.Errorf("an unreachable server changed the state to %v", st[0].State)
}
if _, err := b.Check(ctx, 999); !errors.Is(err, ErrFriendMissing) {
t.Errorf("unknown friend: %v", err)
}
}
func TestAnIncomingRequestIsNotSomethingToCheck(t *testing.T) {
ctx := context.Background()
a, aStore, _ := newServer(t, "Anna", "https://anna.example.org", nil)
a.remote = &fakeRemote{}
pub, _, _ := ed25519.GenerateKey(nil)
f, _ := aStore.AddFriend(ctx, Friend{Name: "B", Address: "https://b.example.org", PublicKey: pub, State: Incoming})
if _, err := a.Check(ctx, f.ID); !errors.Is(err, ErrWrongState) {
t.Errorf("Check of an incoming friend = %v, want ErrWrongState", err)
}
}
func TestSignAndVerifyAgree(t *testing.T) {
pub, priv, _ := ed25519.GenerateKey(nil)
now := time.Unix(1_700_000_000, 0)
h := Sign(priv, "GET", "/api/v1/peer/info", now, "n-0123456789abcdef")
if h.Date != strconv.FormatInt(now.Unix(), 10) || !strings.HasPrefix(h.Nonce, "n-") && h.Nonce == "" {
t.Errorf("headers = %+v", h)
}
if !verify(pub, "GET", "/api/v1/peer/info", h.Date, "n-0123456789abcdef", h.Signature) {
t.Error("a signature does not verify")
}
if verify(pub, "GET", "/api/v1/peer/other", h.Date, "n-0123456789abcdef", h.Signature) {
t.Error("a signature verifies for another path")
}
}