main.go

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"
)

type Config struct {
	APIKey   string
	BaseURL  string
	Override bool
	Workers  int
}

type UploadResponse struct {
	Success  bool   `json:"success"`
	Message  string `json:"message"`
	DecodeID int    `json:"decode_id"`
	Preview  bool   `json:"preview"`
}

type StatusResponse struct {
	Success  bool   `json:"success"`
	Status   string `json:"status"`
	Message  string `json:"message"`
	DecodeID int    `json:"decode_id"`
}

type Client struct {
	config     Config
	httpClient *http.Client
}

func NewClient(config Config) *Client {
	return &Client{
		config:     config,
		httpClient: &http.Client{Timeout: 120 * time.Second},
	}
}

func (c *Client) Upload(filePath string) (*UploadResponse, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	var buf bytes.Buffer
	writer := multipart.NewWriter(&buf)

	part, err := writer.CreateFormFile("file", filepath.Base(filePath))
	if err != nil {
		return nil, err
	}

	if _, err := io.Copy(part, file); err != nil {
		return nil, err
	}
	writer.Close()

	req, err := http.NewRequest("POST", c.config.BaseURL+"/accounts/upload/", &buf)
	if err != nil {
		return nil, err
	}

	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("X-API-Key", c.config.APIKey)

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	if resp.StatusCode == 401 {
		return nil, fmt.Errorf("invalid API key")
	}

	var result UploadResponse
	if err := json.Unmarshal(body, &result); err != nil {
		return nil, fmt.Errorf("invalid response: %s", string(body))
	}

	return &result, nil
}

func (c *Client) Status(decodeID int) (*StatusResponse, error) {
	url := fmt.Sprintf("%s/accounts/decode/%d/status/", c.config.BaseURL, decodeID)

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("X-API-Key", c.config.APIKey)

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var result StatusResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return nil, err
	}

	return &result, nil
}

func (c *Client) Download(decodeID int) ([]byte, error) {
	url := fmt.Sprintf("%s/accounts/decode/%d/download/", c.config.BaseURL, decodeID)

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("X-API-Key", c.config.APIKey)

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	return io.ReadAll(resp.Body)
}

func (c *Client) Decode(filePath string) ([]byte, error) {
	upload, err := c.Upload(filePath)
	if err != nil {
		return nil, err
	}

	if !upload.Success {
		if upload.Preview {
			return nil, fmt.Errorf("no credits: %s", upload.Message)
		}
		return nil, fmt.Errorf("upload failed: %s", upload.Message)
	}

	for {
		status, err := c.Status(upload.DecodeID)
		if err != nil {
			return nil, err
		}

		switch status.Status {
		case "success":
			return c.Download(upload.DecodeID)
		case "failed":
			return nil, fmt.Errorf("decode failed: %s", status.Message)
		case "pending":
			time.Sleep(500 * time.Millisecond)
		default:
			return nil, fmt.Errorf("unknown status: %s", status.Status)
		}
	}
}

func isIonCubeEncoded(filePath string) bool {
	file, err := os.Open(filePath)
	if err != nil {
		return false
	}
	defer file.Close()

	buf := make([]byte, 200)
	n, err := file.Read(buf)
	if err != nil || n == 0 {
		return false
	}

	content := strings.ToLower(string(buf[:n]))
	return strings.Contains(content, "ioncube") ||
		strings.Contains(content, "<?php //0") ||
		strings.Contains(content, "sg_load")
}

func findPHPFiles(path string) ([]string, error) {
	info, err := os.Stat(path)
	if err != nil {
		return nil, err
	}

	if !info.IsDir() {
		if strings.HasSuffix(strings.ToLower(path), ".php") {
			return []string{path}, nil
		}
		return nil, fmt.Errorf("not a PHP file: %s", path)
	}

	var files []string
	err = filepath.Walk(path, func(p string, info os.FileInfo, err error) error {
		if err != nil {
			return nil
		}
		if !info.IsDir() && strings.HasSuffix(strings.ToLower(p), ".php") {
			files = append(files, p)
		}
		return nil
	})

	return files, err
}

type Result struct {
	File    string
	Success bool
	Message string
}

func processFiles(files []string, client *Client, override bool, workers int) []Result {
	jobs := make(chan string, len(files))
	results := make(chan Result, len(files))

	var wg sync.WaitGroup
	for i := 0; i < workers; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for file := range jobs {
				result := Result{File: file}

				if !isIonCubeEncoded(file) {
					result.Success = true
					result.Message = "skipped (not encoded)"
					results <- result
					continue
				}

				decoded, err := client.Decode(file)
				if err != nil {
					result.Message = err.Error()
					results <- result
					continue
				}

				result.Success = true
				if override {
					if err := os.WriteFile(file, decoded, 0644); err != nil {
						result.Success = false
						result.Message = fmt.Sprintf("write error: %v", err)
					} else {
						result.Message = "decoded and overwritten"
					}
				} else {
					ext := filepath.Ext(file)
					base := strings.TrimSuffix(file, ext)
					outFile := base + "_decoded" + ext
					if err := os.WriteFile(outFile, decoded, 0644); err != nil {
						result.Success = false
						result.Message = fmt.Sprintf("write error: %v", err)
					} else {
						result.Message = fmt.Sprintf("saved to %s", outFile)
					}
				}

				results <- result
			}
		}()
	}

	for _, file := range files {
		jobs <- file
	}
	close(jobs)

	go func() {
		wg.Wait()
		close(results)
	}()

	var allResults []Result
	for r := range results {
		allResults = append(allResults, r)
		status := "✓"
		if !r.Success {
			status = "✗"
		}
		fmt.Printf("%s %s: %s\n", status, r.File, r.Message)
	}

	return allResults
}

func main() {
	apiKey := flag.String("k", "", "API key (account number)")
	baseURL := flag.String("u", "https://console.decodephp.io", "Base API URL")
	override := flag.Bool("o", false, "Override original files")
	workers := flag.Int("w", 4, "Number of concurrent workers")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage: %s [options] <file-or-directory>\n\nOptions:\n", os.Args[0])
		flag.PrintDefaults()
	}

	flag.Parse()

	if *apiKey == "" {
		*apiKey = os.Getenv("IONCUBE_API_KEY")
	}

	if *apiKey == "" {
		fmt.Fprintln(os.Stderr, "Error: API key required (-k or IONCUBE_API_KEY env)")
		os.Exit(1)
	}

	if len(*apiKey) != 16 {
		fmt.Fprintln(os.Stderr, "Error: API key must be 16 digits")
		os.Exit(1)
	}

	if flag.NArg() < 1 {
		fmt.Fprintln(os.Stderr, "Error: file or directory path required")
		flag.Usage()
		os.Exit(1)
	}

	path := flag.Arg(0)
	files, err := findPHPFiles(path)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
		os.Exit(1)
	}

	if len(files) == 0 {
		fmt.Fprintln(os.Stderr, "No PHP files found")
		os.Exit(0)
	}

	fmt.Printf("Found %d PHP file(s)\n\n", len(files))

	config := Config{
		APIKey:   *apiKey,
		BaseURL:  strings.TrimSuffix(*baseURL, "/"),
		Override: *override,
		Workers:  *workers,
	}

	client := NewClient(config)
	results := processFiles(files, client, *override, *workers)

	var success, failed, skipped int
	for _, r := range results {
		if r.Success {
			if strings.Contains(r.Message, "skipped") {
				skipped++
			} else {
				success++
			}
		} else {
			failed++
		}
	}

	fmt.Printf("\nDone: %d decoded, %d skipped, %d failed\n", success, skipped, failed)

	if failed > 0 {
		os.Exit(1)
	}
}