237 lines
7.8 KiB
Go
237 lines
7.8 KiB
Go
//go:build darwin || linux
|
|
|
|
package server
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/pipeline"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// newTestTerminals is one server process's terminal manager over store.
|
|
func newTestTerminals(t *testing.T, store *pipeline.Store) (*terminalManager, context.CancelFunc) {
|
|
t.Helper()
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
m := newTerminalManager(ctx, store)
|
|
m.recover(ctx)
|
|
t.Cleanup(func() { cancel(); m.Wait() })
|
|
return m, cancel
|
|
}
|
|
|
|
// waitTerminalOutput polls a terminal's retained output until it contains
|
|
// want.
|
|
func waitTerminalOutput(t *testing.T, m *terminalManager, id, want string) protocol.TerminalRecord {
|
|
t.Helper()
|
|
deadline := time.Now().Add(10 * time.Second)
|
|
for {
|
|
record, err := m.Output(context.Background(), id, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if strings.Contains(record.Output, want) {
|
|
return record
|
|
}
|
|
if time.Now().After(deadline) {
|
|
t.Fatalf("output of %s never contained %q: %q", id, want, record.Output)
|
|
}
|
|
time.Sleep(50 * time.Millisecond)
|
|
}
|
|
}
|
|
|
|
// waitTerminalStatus polls the list until terminal id has status.
|
|
func waitTerminalStatus(t *testing.T, m *terminalManager, id, status string) protocol.TerminalRecord {
|
|
t.Helper()
|
|
deadline := time.Now().Add(10 * time.Second)
|
|
for {
|
|
list, err := m.List(context.Background())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, record := range list {
|
|
if record.ID == id && record.Status == status {
|
|
return record
|
|
}
|
|
}
|
|
if time.Now().After(deadline) {
|
|
t.Fatalf("terminal %s never became %s: %+v", id, status, list)
|
|
}
|
|
time.Sleep(50 * time.Millisecond)
|
|
}
|
|
}
|
|
|
|
// The login command is su for the server's own account on macOS and Linux
|
|
// (su looked up in each one's usual directories); a root server, a missing
|
|
// su and other systems are refused.
|
|
func TestTerminalLoginCommandPerOS(t *testing.T) {
|
|
dir := "/home/a/it's here"
|
|
for _, goos := range []string{"darwin", "linux"} {
|
|
args, err := terminalLoginArgs(goos, 501, "/usr/bin/su", "alan", dir)
|
|
if err != nil {
|
|
t.Fatalf("%s: %v", goos, err)
|
|
}
|
|
want := []string{"/usr/bin/su", "-l", "alan", "-c", `printf '\033]6973;pipelines-login\007'; cd '/home/a/it'\''s here' || cd; exec "$SHELL" -l`}
|
|
if strings.Join(args, "\x00") != strings.Join(want, "\x00") {
|
|
t.Fatalf("%s args = %q", goos, args)
|
|
}
|
|
}
|
|
if terminalSuDirs["darwin"][0] != "/usr/bin" || strings.Join(terminalSuDirs["linux"], ":") != "/bin:/usr/bin" {
|
|
t.Fatalf("su directories = %v", terminalSuDirs)
|
|
}
|
|
refusals := map[string]struct {
|
|
goos string
|
|
euid int
|
|
su, user string
|
|
wantPhrase string
|
|
}{
|
|
"root": {"linux", 0, "/bin/su", "root", "runs as root"},
|
|
"no su": {"darwin", 501, "", "alan", "su is not installed"},
|
|
"no user": {"linux", 1000, "/bin/su", "", "no user name"},
|
|
"windows": {"windows", 1000, "su", "alan", "does not support on windows"},
|
|
"freebsd": {"freebsd", 1000, "/usr/bin/su", "alan", "does not support on freebsd"},
|
|
}
|
|
for name, c := range refusals {
|
|
if _, err := terminalLoginArgs(c.goos, c.euid, c.su, c.user, dir); err == nil || !strings.Contains(err.Error(), c.wantPhrase) {
|
|
t.Fatalf("%s: err = %v", name, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Without su on PATH or in the usual directories the server refuses to
|
|
// open a terminal (no unauthenticated fallback) and lists nothing.
|
|
func TestTerminalRefusedWithoutSu(t *testing.T) {
|
|
if os.Geteuid() == 0 {
|
|
t.Skip("runs as root")
|
|
}
|
|
terminalHome(t)
|
|
empty := t.TempDir()
|
|
t.Setenv("PATH", empty)
|
|
original := terminalSuDirs
|
|
terminalSuDirs = map[string][]string{"darwin": {empty}, "linux": {empty}}
|
|
t.Cleanup(func() { terminalSuDirs = original })
|
|
if found := findTerminalSu("darwin"); found != "" {
|
|
t.Fatalf("found su %q", found)
|
|
}
|
|
m, _ := newTestTerminals(t, newOperatorStore(t))
|
|
if _, err := m.Open(context.Background(), "", "", 0, 0); err == nil || !strings.Contains(err.Error(), "su is not installed") {
|
|
t.Fatalf("open without su = %v", err)
|
|
}
|
|
if list, _ := m.List(context.Background()); len(list) != 0 {
|
|
t.Fatalf("list = %+v", list)
|
|
}
|
|
fakeTerminalSu(t)
|
|
if found := findTerminalSu("linux"); !strings.HasSuffix(found, "/su") || filepath.Dir(found) == empty {
|
|
t.Fatalf("fake su = %q", found)
|
|
}
|
|
}
|
|
|
|
// A new terminal shows the login prompt in a real PTY and runs su, not a
|
|
// shell or tmux; a wrong password ends it with a clear reason, the right
|
|
// one gives a shell in the start folder.
|
|
func TestTerminalShowsLoginPrompt(t *testing.T) {
|
|
home := terminalHome(t)
|
|
sub := filepath.Join(home, "sub dir")
|
|
if err := os.Mkdir(sub, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m, _ := newTestTerminals(t, newOperatorStore(t))
|
|
wrong, err := m.Open(context.Background(), "", "", 0, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !strings.HasSuffix(strings.Fields(wrong.Shell)[0], "/su") || strings.Contains(wrong.Shell, "tmux") {
|
|
t.Fatalf("shell = %q", wrong.Shell)
|
|
}
|
|
if raw, _ := json.Marshal(wrong); strings.Contains(string(raw), "tmux") {
|
|
t.Fatalf("record mentions tmux: %s", raw)
|
|
}
|
|
if out, _ := m.Output(context.Background(), wrong.ID, 0); !strings.Contains(out.Output, "Password:") {
|
|
t.Fatalf("output = %q", out.Output)
|
|
}
|
|
if err := m.Input(wrong.ID, "not-it\r"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ended := waitTerminalStatus(t, m, wrong.ID, protocol.TerminalExited)
|
|
if ended.Reason != terminalLoginFailedReason || ended.ExitCode == nil || *ended.ExitCode != 1 {
|
|
t.Fatalf("wrong password = %+v", ended)
|
|
}
|
|
waitTerminalOutput(t, m, wrong.ID, "Authentication failed")
|
|
|
|
right, err := m.Open(context.Background(), "", "~/sub dir", 0, 0)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := m.Input(right.ID, fakeSuPassword+"\r"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := m.Input(right.ID, "pwd; echo in-$((6*7))\r"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
out := waitTerminalOutput(t, m, right.ID, "in-42")
|
|
if !strings.Contains(out.Output, sub) || strings.Contains(out.Output, fakeSuPassword) {
|
|
t.Fatalf("output = %q", out.Output)
|
|
}
|
|
if p := m.process(right.ID); p == nil || !loggedIn(p) {
|
|
t.Fatal("the login was not recorded")
|
|
}
|
|
}
|
|
|
|
func loggedIn(p *terminalProcess) bool {
|
|
login, _ := p.loginState()
|
|
return login.loggedIn
|
|
}
|
|
|
|
// The watch sees the prompt across reads, the marker after it as a login,
|
|
// and the marker before any prompt as an unprompted login.
|
|
func TestTerminalLoginWatch(t *testing.T) {
|
|
var w terminalLoginWatch
|
|
if w.feed([]byte("Pass")) || !w.feed([]byte("word:")) || !w.prompted || w.loggedIn {
|
|
t.Fatalf("prompt = %+v", w)
|
|
}
|
|
if !w.feed(append([]byte("\r\n"), terminalLoginMarker...)) || !w.loggedIn || w.unprompted {
|
|
t.Fatalf("login = %+v", w)
|
|
}
|
|
if w.feed([]byte("password")) {
|
|
t.Fatal("output after the login is not watched")
|
|
}
|
|
var bare terminalLoginWatch
|
|
bare.feed(append(append([]byte("motd\r\n"), terminalLoginMarker...), "change your password"...))
|
|
if !bare.loggedIn || !bare.unprompted || bare.prompted {
|
|
t.Fatalf("unprompted = %+v", bare)
|
|
}
|
|
}
|
|
|
|
// A login that never asks for a password is refused and never listed: one
|
|
// that opens a shell at once (an account without a password), one that
|
|
// stays silent, one that fails without a terminal.
|
|
func TestTerminalRefusesUnpromptedLogin(t *testing.T) {
|
|
terminalHome(t)
|
|
m, _ := newTestTerminals(t, newOperatorStore(t))
|
|
m.promptWait = 500 * time.Millisecond
|
|
for mode, phrase := range map[string]string{
|
|
"noprompt": "without asking for a password",
|
|
"silent": "did not ask for a password",
|
|
"notty": "su: must be run from a terminal",
|
|
} {
|
|
t.Setenv("FAKE_SU_MODE", mode)
|
|
if record, err := m.Open(context.Background(), "", "", 0, 0); err == nil || !strings.Contains(err.Error(), phrase) {
|
|
t.Fatalf("%s: open = %+v, %v", mode, record, err)
|
|
}
|
|
}
|
|
if list, _ := m.List(context.Background()); len(list) != 0 {
|
|
t.Fatalf("list = %+v", list)
|
|
}
|
|
m.mu.Lock()
|
|
running := m.runningLocked()
|
|
m.mu.Unlock()
|
|
if running != 0 {
|
|
t.Fatalf("%d refused terminals still running", running)
|
|
}
|
|
}
|