decrypt_test.go

package main

import (
	"encoding/json"
	"errors"
	"os"
	"path/filepath"
	"testing"
)

// TestDecryptPackInner_NoContentsJSON verifies the upfront validation:
// pointing decrypt at a non-pack directory now returns errPackNoManifest,
// which humanize translates into "isn't a valid resource pack" instead
// of a bare "open: no such file" error.
func TestDecryptPackInner_NoContentsJSON(t *testing.T) {
	empty := t.TempDir()
	_, err := decryptPackInner(empty, testMasterKey, t.TempDir())
	if err == nil {
		t.Fatal("expected error from empty pack dir, got nil")
	}
	if !errors.Is(err, errPackNoManifest) {
		t.Errorf("err = %v, want chain to include errPackNoManifest", err)
	}
}

func TestDecryptContentsJSON(t *testing.T) {
	contents := contentsFile{
		Content: []contentsEntry{
			{Path: "textures/block.png", Key: "KEYKEYKEYKEYKEYKEYKEYKEYKEYKEY32"},
			{Path: "manifest.json", Key: ""},
		},
	}
	payload, _ := json.Marshal(contents)

	ciphertext := mustEncrypt(t, payload, []byte(testMasterKey))

	header := make([]byte, contentsHeaderSize)
	data := append(header, ciphertext...)

	result, err := decryptContentsJSON(data, testMasterKey)
	if err != nil {
		t.Fatalf("decryptContentsJSON error: %v", err)
	}
	if len(result.Content) != 2 {
		t.Fatalf("expected 2 entries, got %d", len(result.Content))
	}
	if result.Content[0].Path != "textures/block.png" {
		t.Errorf("entry[0].Path = %q, want %q", result.Content[0].Path, "textures/block.png")
	}
	if result.Content[0].Key != "KEYKEYKEYKEYKEYKEYKEYKEYKEYKEY32" {
		t.Errorf("entry[0].Key = %q", result.Content[0].Key)
	}
}

func TestDecryptContentsJSON_TooSmall(t *testing.T) {
	_, err := decryptContentsJSON(make([]byte, 100), testMasterKey)
	if err == nil {
		t.Error("expected error for data smaller than 256 bytes")
	}
}

func TestDecryptContentsJSON_InvalidJSON(t *testing.T) {
	garbage := mustEncrypt(t, []byte("not json {{{"), []byte(testMasterKey))
	header := make([]byte, contentsHeaderSize)
	data := append(header, garbage...)

	_, err := decryptContentsJSON(data, testMasterKey)
	if err == nil {
		t.Error("expected error for invalid JSON")
	}
}

// TestDecryptContentsJSON_WrongKey is the most common real-world failure:
// CFB8 is unauthenticated, so a wrong key yields garbage; the only guard is
// the JSON unmarshal, which must surface as errPackWrongKey.
func TestDecryptContentsJSON_WrongKey(t *testing.T) {
	payload, _ := json.Marshal(contentsFile{Content: []contentsEntry{{Path: "a.txt"}}})
	ciphertext := mustEncrypt(t, payload, []byte(testMasterKey))
	data := append(make([]byte, contentsHeaderSize), ciphertext...)

	_, err := decryptContentsJSON(data, "ZYXWVUTSRQPONMLKJIHGFEDCBA654321") // valid length, wrong key
	if !errors.Is(err, errPackWrongKey) {
		t.Fatalf("err = %v, want chain to include errPackWrongKey", err)
	}
}

// TestDecryptContentsJSON_BadKeyLen: a wrong-length key (a truncated or typo'd
// paste) reports errPackBadKeyLen rather than errPackWrongKey, so the user is
// told the length is off instead of being pointed at the wrong pack's key.
func TestDecryptContentsJSON_BadKeyLen(t *testing.T) {
	data := make([]byte, contentsHeaderSize+16)
	_, err := decryptContentsJSON(data, "tooShort")
	if !errors.Is(err, errPackBadKeyLen) {
		t.Fatalf("err = %v, want chain to include errPackBadKeyLen", err)
	}
}

// TestDecryptPackFiles_PathEscapeSkipped pins the zip-slip guard: a malicious
// contents.json entry pointing outside outDir must be skipped, not written.
func TestDecryptPackFiles_PathEscapeSkipped(t *testing.T) {
	tmp := t.TempDir()
	packDir := filepath.Join(tmp, "pack")
	outDir := filepath.Join(tmp, "out")
	os.MkdirAll(packDir, 0o755)
	os.MkdirAll(outDir, 0o755)
	os.WriteFile(filepath.Join(packDir, "safe.txt"), []byte("ok"), 0o644)

	stats := decryptPackFiles(packDir, outDir, []contentsEntry{
		{Path: "../escape.txt", Key: ""},
		{Path: "safe.txt", Key: ""},
	})

	if _, err := os.Stat(filepath.Join(tmp, "escape.txt")); !os.IsNotExist(err) {
		t.Fatalf("path-escaping entry was written outside outDir (err=%v)", err)
	}
	if _, err := os.Stat(filepath.Join(outDir, "safe.txt")); err != nil {
		t.Fatalf("safe file should still be written: %v", err)
	}
	if stats.errors != 1 {
		t.Errorf("escaping entry should count as 1 error, got %d", stats.errors)
	}
}

// TestProcessFile_WrongKeyNoValidation documents the unauthenticated-cipher
// contract: a wrong per-file key writes garbage with no error. A future
// user-supplied-key feature would need to add validation - this is the tripwire.
func TestProcessFile_WrongKeyNoValidation(t *testing.T) {
	tmp := t.TempDir()
	src := filepath.Join(tmp, "src")
	os.MkdirAll(src, 0o755)
	plaintext := []byte("the original secret bytes here!!")
	ciphertext := mustEncrypt(t, plaintext, []byte(testMasterKey))
	os.WriteFile(filepath.Join(src, "data.bin"), ciphertext, 0o644)

	entry := contentsEntry{Path: "data.bin", Key: "ZYXWVUTSRQPONMLKJIHGFEDCBA654321"}
	dec, err := processFile(entry, filepath.Join(src, "data.bin"), filepath.Join(tmp, "out", "data.bin"))
	if err != nil || !dec {
		t.Fatalf("wrong key should still report decrypted with no error: dec=%v err=%v", dec, err)
	}
	got, _ := os.ReadFile(filepath.Join(tmp, "out", "data.bin"))
	if len(got) == 0 || string(got) == string(plaintext) {
		t.Errorf("expected non-empty garbage differing from plaintext, got %q", got)
	}
}

func TestDecryptContentsJSON_TrailingNulls(t *testing.T) {
	contents := contentsFile{Content: []contentsEntry{{Path: "a.txt", Key: ""}}}
	payload, _ := json.Marshal(contents)
	payload = append(payload, 0, 0, 0, '\n', ' ')

	ciphertext := mustEncrypt(t, payload, []byte(testMasterKey))
	header := make([]byte, contentsHeaderSize)
	data := append(header, ciphertext...)

	result, err := decryptContentsJSON(data, testMasterKey)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(result.Content) != 1 {
		t.Errorf("expected 1 entry, got %d", len(result.Content))
	}
}

func TestDecryptAll_DefaultOutBase(t *testing.T) {
	cases := []struct {
		cacheDir string
		want     string
	}{
		{".", "decrypted"},
		{"./", "decrypted"},
		{"/", "decrypted"},
		{"./packs", "./packs_decrypted"},
		{"./packs/", "./packs_decrypted"},
		{"my_packs", "my_packs_decrypted"},
	}
	for _, tc := range cases {
		t.Run(tc.cacheDir, func(t *testing.T) {
			got := defaultDecryptOutBase(tc.cacheDir)
			if got != tc.want {
				t.Errorf("defaultDecryptOutBase(%q) = %q, want %q", tc.cacheDir, got, tc.want)
			}
		})
	}
}

func TestProcessFile_CopyPlain(t *testing.T) {
	tmp := t.TempDir()
	srcDir := filepath.Join(tmp, "src")
	dstDir := filepath.Join(tmp, "dst")
	os.MkdirAll(srcDir, 0755)

	os.WriteFile(filepath.Join(srcDir, "readme.txt"), []byte("hello world"), 0644)

	entry := contentsEntry{Path: "readme.txt", Key: ""}

	decrypted, err := processFile(entry, filepath.Join(srcDir, "readme.txt"), filepath.Join(dstDir, "readme.txt"))
	if err != nil {
		t.Fatalf("processFile error: %v", err)
	}
	if decrypted {
		t.Error("plain file should not be reported as decrypted")
	}

	got, _ := os.ReadFile(filepath.Join(dstDir, "readme.txt"))
	if string(got) != "hello world" {
		t.Errorf("got %q, want %q", got, "hello world")
	}
}

func TestProcessFile_DecryptEncrypted(t *testing.T) {
	tmp := t.TempDir()
	srcDir := filepath.Join(tmp, "src")
	dstDir := filepath.Join(tmp, "dst")
	os.MkdirAll(srcDir, 0755)

	fileKey := "ZYXWVUTSRQPONMLKJIHGFEDCBA654321"
	plaintext := []byte(`{"type":"texture","data":"abc"}`)
	ciphertext := mustEncrypt(t, plaintext, []byte(fileKey))
	os.WriteFile(filepath.Join(srcDir, "data.json"), ciphertext, 0644)

	entry := contentsEntry{Path: "data.json", Key: fileKey}

	decrypted, err := processFile(entry, filepath.Join(srcDir, "data.json"), filepath.Join(dstDir, "data.json"))
	if err != nil {
		t.Fatalf("processFile error: %v", err)
	}
	if !decrypted {
		t.Error("encrypted file should be reported as decrypted")
	}

	got, _ := os.ReadFile(filepath.Join(dstDir, "data.json"))
	if string(got) != string(plaintext) {
		t.Errorf("got %q, want %q", got, plaintext)
	}
}

func TestProcessFile_ManifestCopiedPlain(t *testing.T) {
	tmp := t.TempDir()
	srcDir := filepath.Join(tmp, "src")
	dstDir := filepath.Join(tmp, "dst")
	os.MkdirAll(srcDir, 0755)

	manifest := `{"format_version":2,"header":{"uuid":"abc"}}`
	os.WriteFile(filepath.Join(srcDir, "manifest.json"), []byte(manifest), 0644)

	entry := contentsEntry{Path: "manifest.json", Key: "some-key-that-should-be-ignored!"}

	decrypted, err := processFile(entry, filepath.Join(srcDir, "manifest.json"), filepath.Join(dstDir, "manifest.json"))
	if err != nil {
		t.Fatalf("processFile error: %v", err)
	}
	if decrypted {
		t.Error("manifest.json should be copied plain, not reported as decrypted")
	}

	got, _ := os.ReadFile(filepath.Join(dstDir, "manifest.json"))
	if string(got) != manifest {
		t.Errorf("manifest.json should be copied verbatim, got %q", got)
	}
}

func TestProcessFile_DirectoryMarker(t *testing.T) {
	tmp := t.TempDir()
	srcDir := filepath.Join(tmp, "src")
	dstDir := filepath.Join(tmp, "dst")
	os.MkdirAll(filepath.Join(srcDir, "items"), 0755)
	os.WriteFile(filepath.Join(srcDir, "items", "child.json"), []byte("{}"), 0644)

	entry := contentsEntry{Path: "items", Key: ""}

	decrypted, err := processFile(entry, filepath.Join(srcDir, "items"), filepath.Join(dstDir, "items"))
	if err != nil {
		t.Fatalf("processFile should treat directory marker as no-op, got error: %v", err)
	}
	if decrypted {
		t.Error("directory marker should not be reported as decrypted")
	}

	info, err := os.Stat(filepath.Join(dstDir, "items"))
	if err != nil {
		t.Fatalf("expected dst directory to be created: %v", err)
	}
	if !info.IsDir() {
		t.Error("dst path should be a directory")
	}
}

func TestCopyPackIcon(t *testing.T) {
	tmp := t.TempDir()
	srcDir := filepath.Join(tmp, "src")
	dstDir := filepath.Join(tmp, "dst")
	os.MkdirAll(srcDir, 0755)
	os.MkdirAll(dstDir, 0755)

	os.WriteFile(filepath.Join(srcDir, "pack_icon.png"), []byte("PNG_DATA"), 0644)

	err := copyIfMissing(srcDir, dstDir, packIconPNG)
	if err != nil {
		t.Fatalf("copyIfMissing error: %v", err)
	}

	got, _ := os.ReadFile(filepath.Join(dstDir, "pack_icon.png"))
	if string(got) != "PNG_DATA" {
		t.Errorf("got %q, want %q", got, "PNG_DATA")
	}
}

func TestCopyPackIcon_AlreadyExists(t *testing.T) {
	tmp := t.TempDir()
	srcDir := filepath.Join(tmp, "src")
	dstDir := filepath.Join(tmp, "dst")
	os.MkdirAll(srcDir, 0755)
	os.MkdirAll(dstDir, 0755)

	os.WriteFile(filepath.Join(srcDir, "pack_icon.png"), []byte("NEW"), 0644)
	os.WriteFile(filepath.Join(dstDir, "pack_icon.png"), []byte("OLD"), 0644)

	copyIfMissing(srcDir, dstDir, packIconPNG)

	got, _ := os.ReadFile(filepath.Join(dstDir, "pack_icon.png"))
	if string(got) != "OLD" {
		t.Error("should not overwrite existing icon")
	}
}

func TestCopyPackIcon_NoIcon(t *testing.T) {
	tmp := t.TempDir()
	err := copyIfMissing(filepath.Join(tmp, "src"), filepath.Join(tmp, "dst"), packIconPNG)
	if err != nil {
		t.Errorf("expected nil error when no icon exists, got %v", err)
	}
}

// TestCopyIfMissing_Manifest: a manifest absent from contents.json must
// still land in the decrypted pack so it stays loadable.
func TestCopyIfMissing_Manifest(t *testing.T) {
	tmp := t.TempDir()
	src := filepath.Join(tmp, "src")
	dst := filepath.Join(tmp, "dst")
	os.MkdirAll(src, 0755)
	os.MkdirAll(dst, 0755)
	os.WriteFile(filepath.Join(src, manifestJSON), []byte(`{"header":{}}`), 0644)

	if err := copyIfMissing(src, dst, manifestJSON); err != nil {
		t.Fatalf("copyIfMissing: %v", err)
	}
	got, _ := os.ReadFile(filepath.Join(dst, manifestJSON))
	if string(got) != `{"header":{}}` {
		t.Errorf("manifest not copied: got %q", got)
	}
}