Netpulse_SasS/server/internal/gitstore/mirror_test.go

package gitstore

import (
	"crypto/ed25519"
	"crypto/rand"
	"errors"
	"fmt"
	"net"
	"strings"
	"testing"

	"github.com/go-git/go-git/v5/plumbing/transport"
	cssh "golang.org/x/crypto/ssh"
)

// Токен не має витікати в текст помилки — ЖОДНИМ із трьох шляхів.
//
// Шлях перший: сам токен у повідомленні транспорту.
// Шлях другий: адреса з логіном усередині, яку go-git вкладає в помилку
// цілком.
// Шлях третій — найпідступніший: наш власний текст, зібраний із r.URL,
// у якому людина залишила токен, скопіювавши адресу з інструкції.
//
// Третій і був помилкою в першій редакції цього файлу: explain
// підставляв r.URL напряму, і повідомлення «сервер вимагає
// автентифікації для https://токен@forgejo/...» лягало б і в базу
// (mirror_last_error), і на екран, і в журнал.

const fakeToken = "ghp_0123456789abcdefghijklmnopqrstuvwxyz"

func TestScrubRemovesTokenFromError(t *testing.T) {
	err := Scrub(fmt.Errorf(
		`unexpected client error: unexpected requesting "https://x:%s@forgejo.example/np.git/info/refs" status code: 403`,
		fakeToken), fakeToken)

	if strings.Contains(err.Error(), fakeToken) {
		t.Fatalf("токен лишився в помилці: %s", err)
	}
	// Тут спрацювали обидві сітки одразу: заміна токена, а потім зняття
	// логіна з адреси разом із нею. Лишитись у тексті має читабельна
	// адреса — саме вона й пояснює, куди не поїхало.
	if !strings.Contains(err.Error(), "https://forgejo.example/np.git") {
		t.Errorf("адреса мала лишитись читабельною: %s", err)
	}

	// А коли токен стоїть не в адресі, від нього лишається позначка:
	// прибрати мовчки означало б зробити повідомлення незрозумілим.
	plain := Scrub(fmt.Errorf("token %s rejected by server", fakeToken), fakeToken)
	if strings.Contains(plain.Error(), fakeToken) {
		t.Fatalf("токен лишився: %s", plain)
	}
	if !strings.Contains(plain.Error(), "«секрет»") {
		t.Errorf("очікували заміну на «секрет», отримали %s", plain)
	}
}

// Логін в адресі прибирається навіть тоді, коли самого токена ми не
// знаємо: у полі URL може лежати чужий рядок, а Secret — порожній.
func TestScrubStripsUserInfoWithoutKnowingSecret(t *testing.T) {
	err := Scrub(errors.New(
		`Post "https://netpulse:s3cr3t-token-value@git.example/np.git/git-receive-pack": timeout`))

	if strings.Contains(err.Error(), "s3cr3t-token-value") {
		t.Fatalf("логін з адреси лишився: %s", err)
	}
	if !strings.Contains(err.Error(), "https://git.example/np.git") {
		t.Errorf("адреса має лишитись читабельною, отримали %s", err)
	}
}

// Наші власні пояснення збирають текст із r.URL — і саме там токен
// найлегше пронести повз Scrub, бо Secret у цьому випадку порожній.
func TestExplainNeverEchoesURLCredentials(t *testing.T) {
	r := Remote{URL: "https://netpulse:" + fakeToken + "@forgejo.example/np.git"}

	for name, in := range map[string]error{
		"потрібна автентифікація": transport.ErrAuthenticationRequired,
		"репозиторію немає":       transport.ErrRepositoryNotFound,
		"чужа помилка":            fmt.Errorf("dial tcp: %s", r.URL),
	} {
		got := r.explain(in)
		if strings.Contains(got.Error(), fakeToken) {
			t.Errorf("%s: токен просочився: %s", name, got)
		}
	}
}

// Приватний ключ у повідомленні — той самий клас витоку, що й токен,
// тільки багаторядковий.
func TestScrubRemovesPrivateKeyBody(t *testing.T) {
	key := "-----BEGIN OPENSSH PRIVATE KEY-----\nb3BlbnNzaC1rZXktdjEAAAAABG5vbmU\n-----END OPENSSH PRIVATE KEY-----"
	err := Scrub(fmt.Errorf("ssh: не вдалося розібрати %s", key), key)
	if strings.Contains(err.Error(), "b3BlbnNzaC1rZXktdjEAAAAABG5vbmU") {
		t.Fatalf("тіло ключа лишилось: %s", err)
	}
}

// Короткий секрет не замінюється: інакше випадковий підрядок перетворив
// би повідомлення на кашу.
func TestScrubIgnoresShortSecrets(t *testing.T) {
	err := Scrub(errors.New("connection to git refused"), "git")
	if err.Error() != "connection to git refused" {
		t.Fatalf("коротке значення не мало замінюватись: %s", err)
	}
}

// --- ключ хоста -------------------------------------------------------

func newHostKey(t *testing.T) (cssh.Signer, string) {
	t.Helper()
	_, priv, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		t.Fatal(err)
	}
	signer, err := cssh.NewSignerFromKey(priv)
	if err != nil {
		t.Fatal(err)
	}
	line := strings.TrimSpace(string(cssh.MarshalAuthorizedKey(signer.PublicKey())))
	return signer, line
}

func TestPinnedHostKeyAcceptsOnlyPinned(t *testing.T) {
	ours, line := newHostKey(t)
	other, _ := newHostKey(t)

	cb, algos, err := pinnedHostKey(line)
	if err != nil {
		t.Fatal(err)
	}
	if len(algos) == 0 || algos[0] != cssh.KeyAlgoED25519 {
		t.Errorf("алгоритм ключа має бути закріплений, отримали %v", algos)
	}
	addr := &net.TCPAddr{IP: net.IPv4(10, 0, 0, 1), Port: 22}

	if err := cb("git.example:22", addr, ours.PublicKey()); err != nil {
		t.Fatalf("закріплений ключ мав пройти: %v", err)
	}
	err = cb("git.example:22", addr, other.PublicKey())
	if err == nil {
		t.Fatal("чужий ключ пройшов перевірку")
	}
	// Повідомлення має нести обидва відбитки: людині треба звірити те,
	// що вона бачить, із тим, що показує сервер, а не гадати.
	if !strings.Contains(err.Error(), "SHA256:") {
		t.Errorf("у помилці немає відбитка: %v", err)
	}
}

// Без закріпленого ключа push по SSH не збирається взагалі. Це і є
// рішення, протилежне до того, що ухвалено для мережевого заліза.
func TestSSHRefusesWithoutPinnedHostKey(t *testing.T) {
	r := Remote{
		URL:    "ssh://git@forgejo.example/np/configs.git",
		Secret: "-----BEGIN OPENSSH PRIVATE KEY-----\nx\n-----END OPENSSH PRIVATE KEY-----",
	}
	if _, err := r.authMethod(); !errors.Is(err, ErrHostKeyUnset) {
		t.Fatalf("очікували ErrHostKeyUnset, отримали %v", err)
	}
}

// --- адреси -----------------------------------------------------------

func TestValidateRemoteURL(t *testing.T) {
	ok := []string{
		"https://forgejo.example/np/configs.git",
		"ssh://git@forgejo.example:2222/np/configs.git",
		"git@github.com:np/configs.git",
		// http всередину мережі — типовий самостійно піднятий Forgejo.
		"http://127.0.0.1:3000/np/configs.git",
		"http://10.8.0.5/np/configs.git",
	}
	for _, u := range ok {
		if err := ValidateRemoteURL(u); err != nil {
			t.Errorf("%s мала пройти: %v", u, err)
		}
	}

	bad := map[string]error{
		"":                        ErrNoRemoteURL,
		"file:///var/lib/x.git":   ErrUnsupportedTr,
		"/var/lib/netpulse/x.git": ErrUnsupportedTr,
		// Відкритий http назовні везе ключі й хеші паролів як є.
		"http://8.8.8.8/np/configs.git": ErrPlainHTTP,
	}
	for u, want := range bad {
		if err := ValidateRemoteURL(u); !errors.Is(err, want) {
			t.Errorf("%q: очікували %v, отримали %v", u, want, err)
		}
	}
}

func TestRedactURL(t *testing.T) {
	got := RedactURL("https://netpulse:" + fakeToken + "@forgejo.example/np.git")
	if strings.Contains(got, fakeToken) {
		t.Fatalf("токен лишився: %s", got)
	}
	if got != "https://forgejo.example/np.git" {
		t.Errorf("отримали %s", got)
	}
}