Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

5.2 KB
Raw Blame
package loopback

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"testing"
	"time"
)

func TestConnectDiscoveryDoesNotGrantNativeAccess(t *testing.T) {
	server := startTestServer(t, "")
	server.SetConnectURL("http://127.0.0.1:18990/client")
	endpoint := server.Endpoint()
	for _, test := range []struct {
		method, path, origin string
		status               int
	}{
		{"GET", "/connect-discovery", testOrigin, 200},
		{"OPTIONS", "/connect-discovery", testOrigin, 204},
		{"POST", "/connect-discovery", testOrigin, 405},
		{"GET", "/connect-discovery", "null", 403},
		{"GET", "/connect-discovery", "", 403},
		{"GET", "/connect-discovery", testOrigin + "/path", 403},
		{"GET", "/health", testOrigin, 403},
		{"GET", "/control", testOrigin, 403},
		{"GET", "/quality-preference", testOrigin, 403},
	} {
		request, _ := http.NewRequest(test.method, endpoint.URL+test.path, nil)
		request.Header.Set("Origin", test.origin)
		request.Header.Set("Access-Control-Request-Private-Network", "true")
		response, err := http.DefaultClient.Do(request)
		if err != nil {
			t.Fatal(err)
		}
		if response.StatusCode != test.status {
			t.Fatalf("%+v: status %d", test, response.StatusCode)
		}
		if test.status == 200 {
			var body map[string]any
			if err := json.NewDecoder(response.Body).Decode(&body); err != nil {
				t.Fatal(err)
			}
			if len(body) != 5 || body["connectURL"] != "http://127.0.0.1:18990/client" ||
				body["instanceToken"] != endpoint.InstanceToken || body["service"] != ServiceName {
				t.Fatalf("discovery exposed more than process identity and approval address: %v", body)
			}
		}
		response.Body.Close()
	}
}

type retiringControl struct {
	*testControlSession
	finish <-chan struct{}
}

func (session *retiringControl) Close() error {
	_ = session.testControlSession.Close()
	<-session.finish
	return nil
}

func TestSiteRevocationPreservesUnrelatedSessions(t *testing.T) {
	for _, test := range []struct {
		otherOrigin string
		remove      bool
	}{{"", false}, {"https://keep.example", false}, {"https://keep.example", true}} {
		t.Run(fmt.Sprintf("%s/remove=%v", test.otherOrigin, test.remove), func(t *testing.T) {
			otherOrigin := test.otherOrigin
			finish := make(chan struct{})
			defer close(finish)
			created := make(chan *testControlSession, 2)
			server := startTestServerWithOptions(t, Options{AllowedOrigins: []string{testOrigin, "https://keep.example"}, NewControl: func() ControlSession {
				session := &testControlSession{events: make(chan any), closed: make(chan struct{})}
				created <- session
				return &retiringControl{session, finish}
			}})
			endpoint := server.Endpoint()
			old := dialControl(t, endpoint, endpoint.InstanceToken, testOrigin)
			defer old.CloseNow()
			writeControl(t, old, requestJSON("old_hello", "hello"))
			var ready controlMessage
			readControl(t, old, &ready)
			oldSession := <-created
			if otherOrigin == "" {
				otherOrigin = endpoint.URL
			}
			local := dialControl(t, endpoint, endpoint.InstanceToken, otherOrigin)
			defer local.CloseNow()
			writeControl(t, local, requestJSON("local_hello", "hello"))
			readControl(t, local, &ready)
			localSession := <-created

			done := make(chan error, 1)
			go func() {
				if test.remove {
					done <- server.RemoveAllowedOrigin(testOrigin)
				} else {
					done <- server.SetAllowedOrigins([]string{"https://next.example", "https://keep.example"})
				}
			}()
			select {
			case <-oldSession.closed:
			case <-time.After(time.Second):
				t.Fatal("revoked session did not start retirement")
			}
			select {
			case err := <-done:
				t.Fatalf("permission reported ready before cleanup: %v", err)
			default:
			}
			select {
			case <-localSession.closed:
				t.Fatal("unrelated session was closed")
			default:
			}
			writeControl(t, local, requestJSON("local_ping", "ping"))
			readControl(t, local, &ready)
			if ready.Type != "pong" {
				t.Fatal("retained session was interrupted")
			}
			// A stuck media owner must not hang consent forever or restore old permission.
			select {
			case err := <-done:
				if err == nil {
					t.Fatal("stuck cleanup was reported as successful")
				}
			case <-time.After(3 * time.Second):
				t.Fatal("permission retirement was unbounded")
			}
			response := doHealthRequest(t, endpoint, endpoint.Host, testOrigin)
			response.Body.Close()
			if response.StatusCode != 403 {
				t.Fatal("timeout restored the revoked origin")
			}
		})
	}
}

func TestPendingHandshakeCannotSurviveOriginReplacement(t *testing.T) {
	server := startTestServer(t, testOrigin)
	claim := server.claimConnection(testOrigin)
	if claim == nil {
		t.Fatal("initial claim failed")
	}
	defer server.releaseConnection(claim)
	done := make(chan error, 1)
	go func() { done <- server.SetAllowedOrigins(nil) }()
	select {
	case <-claim.ctx.Done():
	case <-time.After(time.Second):
		t.Fatal("pending upgrade was not cancelled")
	}
	// Regrant the same origin before its old handshake returns.
	server.mu.Lock()
	server.allowedOrigins = []string{testOrigin}
	server.mu.Unlock()
	if server.setConnection(claim, nil) {
		t.Fatal("old generation regained permission")
	}
	// Cancellation of the App also bounds an already pending permission change.
	server.cancel()
	if err := <-done; err == nil || claim.ctx.Err() != context.Canceled {
		t.Fatal("cancelled change reported ready")
	}
}