183 lines
7.6 KiB
Go
183 lines
7.6 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
const discoveryFixture = `{"playabilityStatus":{"status":"OK"},"streamingData":{"serverAbrStreamingUrl":"https://rr16---sn-n8v7znsz.googlevideo.com/videoplayback?signature=SECRET"}}`
|
|
|
|
func discoveryArgs() []string {
|
|
return []string{"--video-id", "dQw4w9WgXcQ", "--proxy", "socks5://localhost:1080"}
|
|
}
|
|
|
|
func TestDiscoverYoutubeSuccess(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
called := false
|
|
runner := func(ctx context.Context, args []string, out, diagnostics io.Writer) error {
|
|
called = true
|
|
if _, ok := ctx.Deadline(); !ok {
|
|
t.Error("request must have a deadline")
|
|
}
|
|
prefix := []string{"--disable", "--silent", "--show-error", "--fail", "--max-time", "30", "--noproxy", "", "--proxy", "socks5://localhost:1080", "--user-agent", playerUserAgent, "--json"}
|
|
if len(args) != len(prefix)+2 || !reflect.DeepEqual(args[:len(prefix)], prefix) || args[len(args)-1] != playerURL {
|
|
t.Fatalf("unexpected curl arguments: %q", args)
|
|
}
|
|
var payload struct {
|
|
VideoID string `json:"videoId"`
|
|
Context struct {
|
|
Client struct {
|
|
ClientName string `json:"clientName"`
|
|
ClientVersion string `json:"clientVersion"`
|
|
AndroidSDKVersion int `json:"androidSdkVersion"`
|
|
UserAgent string `json:"userAgent"`
|
|
OSName string `json:"osName"`
|
|
OSVersion string `json:"osVersion"`
|
|
} `json:"client"`
|
|
} `json:"context"`
|
|
}
|
|
if err := json.Unmarshal([]byte(args[len(prefix)]), &payload); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
client := payload.Context.Client
|
|
if payload.VideoID != "dQw4w9WgXcQ" || client.ClientName != "ANDROID" || client.ClientVersion != "21.02.35" ||
|
|
client.AndroidSDKVersion != 30 || client.UserAgent != playerUserAgent || client.OSName != "Android" || client.OSVersion != "11" {
|
|
t.Fatal("unexpected player payload")
|
|
}
|
|
io.WriteString(diagnostics, "SECRET signed URL must not be printed")
|
|
_, err := io.WriteString(out, discoveryFixture)
|
|
return err
|
|
}
|
|
if code := discoverYoutube(discoveryArgs(), &stdout, &stderr, runner); code != 0 {
|
|
t.Fatalf("code %d: %s", code, &stderr)
|
|
}
|
|
if !called || stderr.Len() != 0 || stdout.String() != "{\"videoId\":\"dQw4w9WgXcQ\",\"hostnames\":[\"rr16---sn-n8v7znsz.googlevideo.com\"]}\n" {
|
|
t.Fatalf("unexpected output: stdout=%q stderr=%q", &stdout, &stderr)
|
|
}
|
|
}
|
|
|
|
func TestDiscoverYoutubeInvalidArgs(t *testing.T) {
|
|
tests := [][]string{
|
|
nil, {"--video-id", "dQw4w9WgXcQ"}, {"--proxy", "socks5://localhost:1080"},
|
|
{"--video-id", "short", "--proxy", "socks5://localhost:1080"},
|
|
{"--video-id", "dQw4w9WgXc!", "--proxy", "socks5://localhost:1080"},
|
|
{"--SECRET", "SECRET"}, append(discoveryArgs(), "SECRET"),
|
|
}
|
|
for _, proxy := range []string{
|
|
"http://localhost:1080", "socks5h://localhost:1080", "socks5://user:SECRET@localhost:1080",
|
|
"socks5://:1080", "socks5://localhost", "socks5://localhost:0", "socks5://localhost:65536",
|
|
"socks5://localhost:bad", "socks5://localhost:1080/path", "socks5://localhost:1080?SECRET",
|
|
"socks5://localhost:1080#SECRET", "socks5://bad_host:1080", "socks5://localhost:1080?",
|
|
} {
|
|
tests = append(tests, []string{"--video-id", "dQw4w9WgXcQ", "--proxy", proxy})
|
|
}
|
|
for _, args := range tests {
|
|
var stdout, stderr bytes.Buffer
|
|
runner := func(context.Context, []string, io.Writer, io.Writer) error {
|
|
t.Fatal("invalid arguments must not invoke curl")
|
|
return nil
|
|
}
|
|
if code := discoverYoutube(args, &stdout, &stderr, runner); code != 2 || stdout.Len() != 0 || stderr.Len() == 0 {
|
|
t.Errorf("args %q: code=%d stdout=%q stderr=%q", args, code, &stdout, &stderr)
|
|
}
|
|
if strings.Contains(stderr.String(), "SECRET") || strings.Contains(stderr.String(), "localhost") {
|
|
t.Error("argument leaked")
|
|
}
|
|
}
|
|
for _, proxy := range []string{"socks5://localhost:1080", "socks5://127.0.0.1:1080", "socks5://[::1]:1080", "socks5://proxy.example:1080"} {
|
|
if !validDiscoveryProxy(proxy) {
|
|
t.Errorf("valid proxy rejected: %s", proxy)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPlayerHostnameFailsClosed(t *testing.T) {
|
|
fixtures := []string{
|
|
`SECRET`, `{} trailing SECRET`, `null`, `{}`, `{"playabilityStatus":{"status":"LOGIN_REQUIRED","reason":"SECRET"}}`,
|
|
`{"playabilityStatus":{"status":"OK"}}`, `{"playabilityStatus":{"status":"OK"},"streamingData":null}`,
|
|
}
|
|
for _, rawURL := range []string{
|
|
"", "http://rr.googlevideo.com/?SECRET", "//rr.googlevideo.com/?SECRET", "https://googlevideo.com/?SECRET",
|
|
"https://evilgooglevideo.com/?SECRET", "https://rr.googlevideo.com.evil.test/?SECRET",
|
|
"https://user:SECRET@rr.googlevideo.com/", "https://rr..googlevideo.com/?SECRET",
|
|
"https://-rr.googlevideo.com/?SECRET", "https://rr.googlevideo.com./?SECRET",
|
|
"https://rr.googlevideo.com:80/?SECRET", "https://rr.googlevideo.com:/?SECRET", "https://%SECRET",
|
|
} {
|
|
encoded, _ := json.Marshal(rawURL)
|
|
fixtures = append(fixtures, `{"playabilityStatus":{"status":"OK"},"streamingData":{"serverAbrStreamingUrl":`+string(encoded)+`}}`)
|
|
}
|
|
for _, fixture := range fixtures {
|
|
var stdout, stderr bytes.Buffer
|
|
runner := func(_ context.Context, _ []string, out, diagnostics io.Writer) error {
|
|
io.WriteString(diagnostics, "SECRET")
|
|
_, err := io.WriteString(out, fixture)
|
|
return err
|
|
}
|
|
if code := discoverYoutube(discoveryArgs(), &stdout, &stderr, runner); code != 1 || stdout.Len() != 0 || stderr.Len() == 0 {
|
|
t.Errorf("fixture %q: code=%d stdout=%q stderr=%q", fixture, code, &stdout, &stderr)
|
|
}
|
|
if strings.Contains(stderr.String(), "SECRET") || strings.Contains(stderr.String(), "https://") {
|
|
t.Error("response leaked")
|
|
}
|
|
}
|
|
upper := strings.Replace(discoveryFixture, "rr16---sn-n8v7znsz.googlevideo.com", "RR16---SN-N8V7ZNSZ.GOOGLEVIDEO.COM:443", 1)
|
|
if host, err := playerHostname([]byte(upper)); err != nil || host != "rr16---sn-n8v7znsz.googlevideo.com" {
|
|
t.Fatalf("hostname normalization: %q %v", host, err)
|
|
}
|
|
}
|
|
|
|
func TestDiscoverYoutubeRequestFailures(t *testing.T) {
|
|
for _, mode := range []string{"runner", "stdout limit", "stderr limit", "write result"} {
|
|
t.Run(mode, func(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
runner := func(_ context.Context, _ []string, out, diagnostics io.Writer) error {
|
|
switch mode {
|
|
case "runner":
|
|
io.WriteString(out, discoveryFixture)
|
|
io.WriteString(diagnostics, "https://signed.example/?SECRET")
|
|
return errors.New("SECRET socks5://user:password@localhost:1080")
|
|
case "stdout limit":
|
|
// Ignore the write error to ensure the command still fails closed.
|
|
out.Write(bytes.Repeat([]byte("S"), playerResponseLimit+1))
|
|
case "stderr limit":
|
|
diagnostics.Write(bytes.Repeat([]byte("S"), (64<<10)+1))
|
|
}
|
|
_, err := io.WriteString(out, discoveryFixture)
|
|
return err
|
|
}
|
|
var dest io.Writer = &stdout
|
|
if mode == "write result" {
|
|
dest = failingWriter{}
|
|
}
|
|
if code := discoverYoutube(discoveryArgs(), dest, &stderr, runner); code != 1 || stdout.Len() != 0 || stderr.Len() == 0 {
|
|
t.Fatalf("code=%d stdout=%q stderr=%q", code, &stdout, &stderr)
|
|
}
|
|
for _, forbidden := range []string{"SECRET", "https://", "password", "localhost"} {
|
|
if strings.Contains(stderr.String(), forbidden) {
|
|
t.Errorf("leaked %s", forbidden)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPlayerOutputBound(t *testing.T) {
|
|
var dst bytes.Buffer
|
|
w := &playerBoundedWriter{dst: &dst, limit: 4}
|
|
if n, err := w.Write([]byte("1234")); n != 4 || err != nil {
|
|
t.Fatal("exact limit must be accepted")
|
|
}
|
|
if n, err := w.Write([]byte("5")); n != 0 || err == nil || !w.exceeded || dst.String() != "1234" {
|
|
t.Fatal("overflow must not be retained")
|
|
}
|
|
if _, err := playerHostname(bytes.Repeat([]byte(" "), playerResponseLimit+1)); err == nil {
|
|
t.Fatal("oversized parser input accepted")
|
|
}
|
|
}
|