Program.cs

using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using WxAppUnpacker.Core;

namespace WxAppUnpacker;

internal static class Program
{
    private const string Salts = "saltiest";
    private const string IvString = "the iv: 16 bytes";
    private const int Pbkdf2Iterations = 1000;
    private const int KeySize = 32;

    private static async Task<int> Main(string[] args)
    {
        Console.OutputEncoding = Encoding.UTF8;

        if (args.Length == 0)
        {
            PrintHelp();
            return 1;
        }

        try
        {
            return args[0].ToLowerInvariant() switch
            {
                "decrypt" => await HandleDecrypt(args.Skip(1).ToArray()),
                "unpack" => await HandleUnpack(args.Skip(1).ToArray()),
                "auto" => await HandleAuto(args.Skip(1).ToArray()),
                "--help" or "-h" or "help" => PrintAndReturn(0),
                _ => PrintUnknownAndReturn(args[0])
            };
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Error: {ex.Message}");
            return 1;
        }
    }

    private static int PrintAndReturn(int exitCode)
    {
        PrintHelp();
        return exitCode;
    }

    private static int PrintUnknownAndReturn(string command)
    {
        Console.Error.WriteLine($"Unknown command: {command}");
        PrintHelp();
        return 1;
    }

    private static void PrintHelp()
    {
        Console.WriteLine(
            """
            WxAppUnpacker

            Usage:
              WxAppUnpacker <command> [options]

            Commands:
              auto <input> [options]       Decrypt if needed, then extract and reconstruct
              decrypt <input> <output>     Decrypt an encrypted wxapkg
              unpack <input> [options]     Unpack a decrypted wxapkg into raw and reconstructed output

            Options:
              -o, --output <dir>           Output directory
              --wxid <wxid>                Mini program wxid
              -k, --keep                   Keep raw artifacts even after verified reconstruction
              -v, --verbose                Show detailed errors
              -h, --help                   Show this help

            Notes:
              unpack rejects encrypted V1MMWX input
              auto requires --wxid for encrypted input unless it can infer Applet/<wxid>/ from the path
              incomplete stages preserve raw artifacts instead of emitting fake source files

            Examples:
              WxAppUnpacker auto __APP__.wxapkg -o ./output --wxid wx1234567890abcd
              WxAppUnpacker decrypt __APP__.wxapkg decrypted.wxapkg --wxid wx1234567890abcd
              WxAppUnpacker unpack decrypted.wxapkg -o ./output
            """);
    }

    private static async Task<int> HandleDecrypt(string[] args)
    {
        if (args.Length < 2)
        {
            Console.Error.WriteLine("decrypt requires <input> and <output>.");
            return 1;
        }

        string inputFile = args[0];
        string outputFile = args[1];
        string? wxid = null;
        bool verbose = false;

        for (int index = 2; index < args.Length; index++)
        {
            if (args[index] == "--wxid" && index + 1 < args.Length)
            {
                wxid = args[++index];
            }
            else if (args[index] is "-v" or "--verbose")
            {
                verbose = true;
            }
        }

        return await DecryptFile(inputFile, outputFile, wxid, verbose) ? 0 : 1;
    }

    private static async Task<int> HandleUnpack(string[] args)
    {
        string? inputFile = null;
        string? outputDir = null;
        bool keep = false;
        bool verbose = false;

        for (int index = 0; index < args.Length; index++)
        {
            switch (args[index])
            {
                case "-o":
                case "--output":
                    if (index + 1 < args.Length)
                    {
                        outputDir = args[++index];
                    }
                    break;
                case "-k":
                case "--keep":
                    keep = true;
                    break;
                case "-v":
                case "--verbose":
                    verbose = true;
                    break;
                default:
                    if (!args[index].StartsWith("-", StringComparison.Ordinal))
                    {
                        inputFile = args[index];
                    }
                    break;
            }
        }

        if (string.IsNullOrWhiteSpace(inputFile))
        {
            Console.Error.WriteLine("unpack requires an input file.");
            return 1;
        }

        return await UnpackFile(inputFile, outputDir, keep, verbose) ? 0 : 1;
    }

    private static async Task<int> HandleAuto(string[] args)
    {
        string? inputFile = null;
        string? outputDir = null;
        string? wxid = null;
        bool keep = false;
        bool verbose = false;

        for (int index = 0; index < args.Length; index++)
        {
            switch (args[index])
            {
                case "-o":
                case "--output":
                    if (index + 1 < args.Length)
                    {
                        outputDir = args[++index];
                    }
                    break;
                case "--wxid":
                    if (index + 1 < args.Length)
                    {
                        wxid = args[++index];
                    }
                    break;
                case "-k":
                case "--keep":
                    keep = true;
                    break;
                case "-v":
                case "--verbose":
                    verbose = true;
                    break;
                default:
                    if (!args[index].StartsWith("-", StringComparison.Ordinal))
                    {
                        inputFile = args[index];
                    }
                    break;
            }
        }

        if (string.IsNullOrWhiteSpace(inputFile))
        {
            Console.Error.WriteLine("auto requires an input file.");
            return 1;
        }

        return await AutoProcess(inputFile, outputDir, wxid, keep, verbose) ? 0 : 1;
    }

    private static async Task<bool> DecryptFile(string inputFile, string outputFile, string? wxid, bool verbose)
    {
        try
        {
            if (!File.Exists(inputFile))
            {
                Console.Error.WriteLine($"Input file does not exist: {inputFile}");
                return false;
            }

            byte[] source = await File.ReadAllBytesAsync(inputFile);
            string magic = Encoding.UTF8.GetString(source.Take(6).ToArray());

            Console.WriteLine($"Input: {inputFile}");
            Console.WriteLine($"Size: {FormatFileSize(source.Length)}");
            Console.WriteLine($"Magic: {magic}");

            if (magic != "V1MMWX")
            {
                await File.WriteAllBytesAsync(outputFile, source);
                Console.WriteLine($"Not encrypted. Copied to: {outputFile}");
                return true;
            }

            wxid ??= ExtractWxidFromPath(inputFile);
            if (string.IsNullOrWhiteSpace(wxid))
            {
                Console.Error.WriteLine("Could not infer wxid. Pass --wxid explicitly.");
                return false;
            }

            byte[] decrypted = Decrypt(source, wxid);
            await File.WriteAllBytesAsync(outputFile, decrypted);

            Console.WriteLine($"wxid: {wxid}");
            Console.WriteLine($"Decrypted to: {outputFile}");
            Console.WriteLine($"Output size: {FormatFileSize(decrypted.Length)}");
            return true;
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Decrypt failed: {ex.Message}");
            if (verbose)
            {
                Console.Error.WriteLine(ex.StackTrace);
            }

            return false;
        }
    }

    private static byte[] Decrypt(byte[] source, string wxid)
    {
        byte[] key = PBKDF2(wxid, Salts);
        byte[] encryptedHeader = source.Skip(6).Take(1024).ToArray();
        byte[] decryptedHeader = AESDecrypt(encryptedHeader, key);

        int xorKey = Asc(wxid.Substring(wxid.Length - 2, 1));
        byte[] remainingData = source.Skip(1030).ToArray();

        var output = new List<byte>(decryptedHeader.Take(1023));
        foreach (byte value in remainingData)
        {
            output.Add((byte)(value ^ xorKey));
        }

        return output.ToArray();
    }

    private static byte[] AESDecrypt(byte[] inputData, byte[] key)
    {
        byte[] iv = Encoding.UTF8.GetBytes(IvString);

        using var aes = Aes.Create();
        aes.Key = key;
        aes.IV = iv;
        aes.Mode = CipherMode.CBC;
        aes.Padding = PaddingMode.None;

        byte[] output = new byte[inputData.Length];
        using var ms = new MemoryStream(inputData);
        using var cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Read);
        int bytesRead = cs.Read(output, 0, output.Length);
        if (bytesRead != output.Length)
        {
            throw new InvalidOperationException("Incomplete AES decrypt read.");
        }

        return output;
    }

    private static byte[] PBKDF2(string wxid, string salts)
    {
        return Rfc2898DeriveBytes.Pbkdf2(
            Encoding.UTF8.GetBytes(wxid),
            Encoding.UTF8.GetBytes(salts),
            Pbkdf2Iterations,
            HashAlgorithmName.SHA1,
            KeySize);
    }

    private static int Asc(string value)
    {
        if (value.Length != 1)
        {
            throw new InvalidOperationException("Asc expects a single character.");
        }

        return Encoding.ASCII.GetBytes(value)[0];
    }

    private static string? ExtractWxidFromPath(string path)
    {
        Match match = Regex.Match(path, @"Applet[\\/]([^\\/]+)[\\/]", RegexOptions.IgnoreCase);
        return match.Success ? match.Groups[1].Value : null;
    }

    private static async Task<bool> UnpackFile(string inputFile, string? outputDir, bool keep, bool verbose)
    {
        try
        {
            if (!File.Exists(inputFile))
            {
                Console.Error.WriteLine($"Input file does not exist: {inputFile}");
                return false;
            }

            byte[] header = new byte[6];
            await using (var fs = new FileStream(inputFile, FileMode.Open, FileAccess.Read))
            {
                await fs.ReadExactlyAsync(header.AsMemory(0, 6));
            }

            if (Encoding.UTF8.GetString(header) == "V1MMWX")
            {
                Console.Error.WriteLine("The file is still encrypted. Use `auto` or `decrypt` first.");
                return false;
            }

            outputDir ??= Path.Combine(
                Path.GetDirectoryName(inputFile) ?? Environment.CurrentDirectory,
                Path.GetFileNameWithoutExtension(inputFile));

            Console.WriteLine($"Input: {inputFile}");
            Console.WriteLine($"Output: {outputDir}");

            byte[] data = await File.ReadAllBytesAsync(inputFile);
            WxapkgHeader headerInfo = WxapkgUnpacker.ParseHeader(data);

            Console.WriteLine($"Files: {headerInfo.Files.Count}");
            Console.WriteLine("Extracting raw files...");
            await WxapkgUnpacker.ExtractFiles(data, headerInfo, outputDir);
            Console.WriteLine("Raw extraction complete.");

            Console.WriteLine("Reconstructing source tree...");
            ReconstructionRunResult reconstruction = await ReconstructionPipeline.RunAsync(
                outputDir,
                headerInfo.Files,
                keep);

            PrintReconstructionSummary(reconstruction);

            Console.WriteLine($"Finished: {outputDir}");
            return true;
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Unpack failed: {ex.Message}");
            if (verbose)
            {
                Console.Error.WriteLine(ex.StackTrace);
            }

            return false;
        }
    }

    private static void PrintReconstructionSummary(ReconstructionRunResult reconstruction)
    {
        foreach (var stage in reconstruction.Stages)
        {
            Console.WriteLine(
                $"{stage.StageName}: created {stage.CreatedFiles.Count}, " +
                $"warnings {stage.Warnings.Count}, failures {stage.Failures.Count}, " +
                $"preserved raw {stage.PreservedSourceArtifacts.Count}");
        }

        if (reconstruction.Warnings.Any())
        {
            Console.WriteLine("Warnings:");
            foreach (string warning in reconstruction.Warnings)
            {
                Console.WriteLine($"  - {warning}");
            }
        }

        if (reconstruction.Failures.Any())
        {
            Console.WriteLine("Failures:");
            foreach (var failure in reconstruction.Failures)
            {
                string target = failure.OutputPath ?? failure.SourcePath ?? "(unknown)";
                Console.WriteLine($"  - {target}: {failure.Message}");
            }
        }
    }

    private static async Task<bool> AutoProcess(string inputFile, string? outputDir, string? wxid, bool keep, bool verbose)
    {
        try
        {
            if (!File.Exists(inputFile))
            {
                Console.Error.WriteLine($"Input file does not exist: {inputFile}");
                return false;
            }

            byte[] header = new byte[6];
            await using (var fs = new FileStream(inputFile, FileMode.Open, FileAccess.Read))
            {
                await fs.ReadExactlyAsync(header.AsMemory(0, 6));
            }

            string magic = Encoding.UTF8.GetString(header);
            string tempDecryptedFile = Path.Combine(
                Path.GetTempPath(),
                $"decrypted_{Guid.NewGuid():N}_{Path.GetFileName(inputFile)}");

            try
            {
                if (magic == "V1MMWX")
                {
                    wxid ??= ExtractWxidFromPath(inputFile);
                    if (string.IsNullOrWhiteSpace(wxid))
                    {
                        Console.Error.WriteLine("Could not infer wxid for encrypted input. Pass --wxid explicitly.");
                        return false;
                    }

                    Console.WriteLine("Encrypted package detected. Decrypting first...");
                    if (!await DecryptFile(inputFile, tempDecryptedFile, wxid, verbose))
                    {
                        return false;
                    }

                    Console.WriteLine("Decrypt complete. Unpacking...");
                    return await UnpackFile(tempDecryptedFile, outputDir, keep, verbose);
                }

                Console.WriteLine("Package is not encrypted. Unpacking directly...");
                return await UnpackFile(inputFile, outputDir, keep, verbose);
            }
            finally
            {
                if (!keep && File.Exists(tempDecryptedFile))
                {
                    try
                    {
                        File.Delete(tempDecryptedFile);
                    }
                    catch
                    {
                        // Ignore temp cleanup failures.
                    }
                }
            }
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Auto mode failed: {ex.Message}");
            if (verbose)
            {
                Console.Error.WriteLine(ex.StackTrace);
            }

            return false;
        }
    }

    private static string FormatFileSize(long bytes)
    {
        string[] sizes = ["B", "KB", "MB", "GB"];
        int order = 0;
        double size = bytes;

        while (size >= 1024 && order < sizes.Length - 1)
        {
            order++;
            size /= 1024;
        }

        return $"{size:0.##} {sizes[order]}";
    }
}