Netpulse_SasS/agent/internal/localfiles/localfiles_test.go

package localfiles

import (
	"context"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"testing"
)

func TestParsePolicyDirectives(t *testing.T) {
	p, err := ParsePolicy(strings.NewReader(`
# перелік
/etc/nginx/nginx.conf
/etc/nginx/conf.d/*.conf

!max-files 3
!max-file-bytes 1024
!allow-nonpublic
`))
	if err != nil {
		t.Fatal(err)
	}
	if len(p.Allow) != 2 {
		t.Fatalf("очікували 2 зразки, маємо %d", len(p.Allow))
	}
	if p.MaxFiles != 3 || p.MaxFileBytes != 1024 || !p.AllowNonPublic {
		t.Fatalf("директиви не застосувались: %+v", p)
	}
}

// Головна перевірка політики: широкий зразок не має проходити взагалі.
//
// «/etc/*» пишеться так само легко, як «/etc/nginx/nginx.conf», а
// коштує на кілька порядків більше — саме на такій описці й з'являється
// віддалене читання всього /etc.
func TestParsePolicyRejectsBroad(t *testing.T) {
	for _, bad := range []string{"/etc/*", "/*", "/*/*.conf", "etc/nginx.conf", "/etc/../etc/shadow"} {
		if _, err := ParsePolicy(strings.NewReader(bad)); err == nil {
			t.Errorf("зразок %q мав бути відхилений", bad)
		}
	}
	for _, good := range []string{"/etc/nginx/nginx.conf", "/etc/nginx/conf.d/*.conf", "/etc/hosts"} {
		if _, err := ParsePolicy(strings.NewReader(good)); err != nil {
			t.Errorf("зразок %q мав пройти: %v", good, err)
		}
	}
}

// Чорний перелік перекриває дозвіл завжди.
func TestDenied(t *testing.T) {
	deny := []string{
		"/etc/shadow",
		"/etc/gshadow",
		// Не лише за повним шляхом: у контейнері з примонтованим /etc
		// корінь інший, а файл той самий.
		"/hostetc/shadow",
		"/srv/backup/rootfs/etc/shadow",
		"/proc/self/mem",
		"/dev/mem",
		"/home/ops/.ssh/authorized_keys",
		"/etc/ssh/ssh_host_ed25519_key",
		"/etc/ssl/private/site.pem",
		"/srv/app/.env",
		"/var/lib/netpulse/identity.json",
		"/run/secrets/db_password",
	}
	for _, p := range deny {
		if Denied(p) == "" {
			t.Errorf("%s мав бути заборонений", p)
		}
	}
	allow := []string{
		"/etc/nginx/nginx.conf",
		"/etc/network/interfaces",
		"/etc/postfix/main.cf",
		"/etc/hosts",
		"/etc/ssh/sshd_config",
	}
	for _, p := range allow {
		if r := Denied(p); r != "" {
			t.Errorf("%s заборонений даремно: %s", p, r)
		}
	}
}

func TestLimitsNarrowOnly(t *testing.T) {
	base := Limits{MaxFileBytes: 100, MaxFiles: 10, MaxTotalBytes: 1000}

	got := base.Narrow(Limits{MaxFileBytes: 50, MaxFiles: 0, MaxTotalBytes: 9999})
	if got.MaxFileBytes != 50 {
		t.Errorf("звуження не спрацювало: %d", got.MaxFileBytes)
	}
	if got.MaxFiles != 10 {
		t.Errorf("нуль мав означати «не звужую», маємо %d", got.MaxFiles)
	}
	if got.MaxTotalBytes != 1000 {
		t.Errorf("сервер розширив стелю до %d — цього не мало статись", got.MaxTotalBytes)
	}
}

func TestNotText(t *testing.T) {
	if notText([]byte("server {\n}\n")) != "" {
		t.Error("текст визнано не текстом")
	}
	if notText(nil) == "" {
		t.Error("порожній файл мав бути відхилений")
	}
	if notText([]byte{'a', 0, 'b'}) == "" {
		t.Error("двійковий файл мав бути відхилений")
	}
	if notText([]byte{0xff, 0xfe, 0xfd}) == "" {
		t.Error("не-UTF8 мав бути відхилений")
	}
}

// Збір цілком: справжні файли на диску, справжні права, справжні
// посилання. Саме тут ловиться те, чого не видно в юніт-перевірках.
func TestCollect(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("права доступу перевіряються лише на unix")
	}
	// Каталог розкриваємо одразу: на деяких системах /tmp сам є
	// посиланням, і тоді перевірка «ціль посилання теж дозволена»
	// відхилила б геть усе — не через помилку в коді, а через оточення.
	dir, err := filepath.EvalSymlinks(t.TempDir())
	if err != nil {
		t.Fatal(err)
	}
	etc := filepath.Join(dir, "etc", "app")
	if err := os.MkdirAll(etc, 0o755); err != nil {
		t.Fatal(err)
	}

	write := func(name, body string, mode os.FileMode) string {
		p := filepath.Join(etc, name)
		if err := os.WriteFile(p, []byte(body), mode); err != nil {
			t.Fatal(err)
		}
		if err := os.Chmod(p, mode); err != nil {
			t.Fatal(err)
		}
		return p
	}

	write("main.conf", "listen 80;\n", 0o644)
	write("extra.conf", "gzip on;\n", 0o644)
	// Закритий для «інших» — має бути пропущений, як /etc/shadow.
	write("private.conf", "password = hunter2\n", 0o600)
	// Двійковий — теж пропуск.
	write("blob.conf", "a\x00b\n", 0o644)

	pol := &Policy{
		Allow:         []string{filepath.Join(etc, "*.conf")},
		MaxFileBytes:  1 << 20,
		MaxFiles:      10,
		MaxTotalBytes: 1 << 20,
	}

	res, err := Collect(context.Background(), pol, Limits{}, "test-host")
	if err != nil {
		t.Fatal(err)
	}
	if len(res.Files) != 2 {
		t.Fatalf("очікували 2 файли, зібрано %d (%s)", len(res.Files), res.Report)
	}
	if len(res.Skips) != 2 {
		t.Fatalf("очікували 2 пропуски, маємо %d (%s)", len(res.Skips), res.Report)
	}
	body := string(res.Body)
	if strings.Contains(body, "hunter2") {
		t.Fatal("файл, закритий для читання всіма, потрапив у набір")
	}
	if !strings.Contains(body, "listen 80;") || !strings.Contains(body, "test-host") {
		t.Fatalf("у наборі бракує вмісту або відбитка машини:\n%s", body)
	}

	// Другий збір без змін на диску мусить дати той самий байт-у-байт
	// набір: інакше кожен нічний бекап створював би коміт «змін немає».
	again, err := Collect(context.Background(), pol, Limits{}, "test-host")
	if err != nil {
		t.Fatal(err)
	}
	if string(again.Body) != body {
		t.Fatal("повторний збір дав інший вміст — кожен бекап виглядав би зміною")
	}
}

// Посилання за межі дозволеного не читається.
//
// Найтонше місце всієї перевірки: без нього рядок «/etc/app/*.conf» у
// політиці означав би «будь-що, на що з цього каталогу вкаже посилання».
func TestCollectRefusesSymlinkEscape(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("символьні посилання на windows потребують окремих прав")
	}
	dir, err := filepath.EvalSymlinks(t.TempDir())
	if err != nil {
		t.Fatal(err)
	}
	etc := filepath.Join(dir, "etc")
	secret := filepath.Join(dir, "secret")
	for _, d := range []string{etc, secret} {
		if err := os.MkdirAll(d, 0o755); err != nil {
			t.Fatal(err)
		}
	}
	// Ім'я цілі навмисно «нешкідливе»: назви на кшталт shadow ловить
	// чорний перелік, і перевірка мовчки перестала б перевіряти саме те,
	// заради чого написана, — заборону виходу за межі дозволеного.
	if err := os.WriteFile(filepath.Join(secret, "db.conf"), []byte("password=1\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	if err := os.Symlink(filepath.Join(secret, "db.conf"), filepath.Join(etc, "sneaky.conf")); err != nil {
		t.Fatal(err)
	}

	pol := &Policy{
		Allow:         []string{filepath.Join(etc, "*.conf")},
		MaxFileBytes:  1 << 20,
		MaxFiles:      10,
		MaxTotalBytes: 1 << 20,
	}
	res, cerr := Collect(context.Background(), pol, Limits{}, "test-host")
	if cerr == nil && len(res.Files) > 0 {
		t.Fatal("посилання за межі дозволеного прочиталось")
	}
	if len(res.Skips) != 1 || !strings.Contains(res.Skips[0].Reason, "за межі") {
		t.Fatalf("очікували пропуск із поясненням, маємо %+v", res.Skips)
	}
}

// Порожній набір у сховище не йде — та сама думка, що й у
// ncmx.looksLikeConfig: зібране, що не схоже на конфіг, не зберігається.
func TestCollectRefusesEmptySet(t *testing.T) {
	dir := t.TempDir()
	pol := &Policy{
		Allow:         []string{filepath.Join(dir, "etc", "nothing.conf")},
		MaxFileBytes:  1 << 20,
		MaxFiles:      10,
		MaxTotalBytes: 1 << 20,
	}
	if _, err := Collect(context.Background(), pol, Limits{}, "h"); err == nil {
		t.Fatal("порожній набір мав дати відмову")
	}
}

func TestLoadPolicyMissingFile(t *testing.T) {
	_, err := LoadPolicy(filepath.Join(t.TempDir(), "files.conf"))
	if err == nil || !strings.Contains(err.Error(), "не дозволено") {
		t.Fatalf("відсутній перелік мав дати ErrNoPolicy, маємо %v", err)
	}
}