Home /Modules/decompiler/main.cpp

main.cpp

decompiler/cli/main.cpp · 206 line(s) · c

#include "sleela/decompiler/decompiler.hpp"
#include "sleela/decompiler/errors.hpp"
#include "sleela/decompiler/output.hpp"
#include "sleela/decompiler/destination.hpp"
#include <fstream>
#include <iostream>
#include <limits>
#include <string>

namespace {
using sleela::decompiler::DecompilerError;
using sleela::decompiler::ErrorCode;

void usage() {
    std::cerr << "usage:\n"
              << "  sleela-decompiler <inspect|disassemble|cfg|functions> <file> [length] [--thumb|--arm]\n"
              << "  sleela-decompiler decompile <file> --output <java|sleela|c|c++> [--header] [--file <path>] [--to <uri>] [--content-type <t>] [length]\n"
              << "    --to accepts file:/path, ftp://[user:pass@]host[:port]/path, http://host[:port]/path (POST),\n"
              << "         http+put://host[:port]/path, or sftp://[user@]host[:port]/path (IPv4, IPv6 in [brackets], or DNS)\n";
}

std::size_t parse_length(const std::string& text) {
    if (text.empty()) throw DecompilerError(ErrorCode::InvalidArtifact, "length cannot be empty", 0, 0, "cli");
    std::size_t pos = 0;
    unsigned long long value = 0;
    try {
        value = std::stoull(text, &pos, 0);
    } catch (const std::exception&) {
        throw DecompilerError(ErrorCode::InvalidArtifact, "invalid length: " + text, 0, 0, "cli");
    }
    if (pos != text.size() || value > std::numeric_limits<std::size_t>::max()) {
        throw DecompilerError(ErrorCode::InvalidArtifact, "invalid length: " + text, 0, 0, "cli");
    }
    return static_cast<std::size_t>(value);
}

sleela::decompiler::SourceLanguage parse_language(const std::string& s) {
    using L = sleela::decompiler::SourceLanguage;
    if (s == "java") return L::Java;
    if (s == "sleela" || s == "sl") return L::Sleela;
    if (s == "c") return L::C;
    if (s == "c++" || s == "cpp") return L::CPlusPlus;
    throw DecompilerError(ErrorCode::OutputFailure, "unsupported output language: " + s, 0, 0, "cli");
}
}

int main(int argc, char** argv) {
    if (argc < 3) { usage(); return 2; }
    try {
        const std::string command = argv[1];
        auto a = sleela::decompiler::Artifact::open(argv[2]);

        if (command == "decompile") {
            sleela::decompiler::SourceLanguage language = sleela::decompiler::SourceLanguage::CPlusPlus;
            std::string output_file;
            std::string destination_uri;
            std::string content_type = "text/plain";
            std::size_t length = 4096;
            bool want_header = false;
            for (int i = 3; i < argc; ++i) {
                const std::string arg = argv[i];
                if (arg == "--output") {
                    if (++i >= argc) { usage(); return 2; }
                    language = parse_language(argv[i]);
                } else if (arg == "--file") {
                    if (++i >= argc) { usage(); return 2; }
                    output_file = argv[i];
                } else if (arg == "--to") {
                    if (++i >= argc) { usage(); return 2; }
                    destination_uri = argv[i];
                } else if (arg == "--content-type") {
                    if (++i >= argc) { usage(); return 2; }
                    content_type = argv[i];
                } else if (arg == "--header") {
                    want_header = true;
                } else if (arg == "--help") {
                    usage();
                    return 0;
                } else if (arg == "--version") {
                    std::cout << "Slecompiler 1.0.0\n";
                    return 0;
                } else if (arg.size() && arg[0] != '-') {
                    length = parse_length(arg);
                } else {
                    usage();
                    return 2;
                }
            }
            // Begin at the first executable section so the reconstruction describes real code.
            std::uint64_t at = 0;
            for (const auto& s : a.interfaces().sections) {
                const bool exec = (s.flags & 0x4u) != 0 || s.name == ".text" || s.name == "__text";
                if (exec && s.file_offset != 0) { at = s.file_offset; break; }
            }
            auto ins = sleela::decompiler::Decoder{}.decode(a, at, length);
            auto cfg = sleela::decompiler::Analyzer{}.build_cfg(ins);
            auto funcs = sleela::decompiler::Analyzer{}.recover_function_candidates(a, cfg);
            auto module = sleela::decompiler::Lifter{}.lift(a, ins, cfg, funcs);
            sleela::decompiler::DecompilationOptions options{language, "decompiled"};
            auto source = want_header
                ? sleela::decompiler::SourceEmitter::emit_header(a, funcs, options)
                : sleela::decompiler::SourceEmitter::emit(a, ins, cfg, funcs, module, options);
            // Destination precedence: --to (network/local adapter) overrides --file, which
            // overrides stdout. The adapter transmits already-produced output only.
            if (!destination_uri.empty()) {
                sleela::decompiler::Destination dest;
                std::string perr;
                if (!sleela::decompiler::parse_destination(destination_uri, dest, perr))
                    throw DecompilerError(ErrorCode::OutputFailure, "invalid --to destination: " + perr, 0, 0, "output");
                dest.content_type = content_type;
                const auto res = sleela::decompiler::deliver(dest, source);
                std::cerr << "destination: " << sleela::decompiler::destination_kind_name(dest.kind);
                if (!res.resolved_address.empty()) std::cerr << " (" << res.resolved_address << ")";
                std::cerr << "\n" << res.message << "\n";
                if (!res.ok)
                    throw DecompilerError(ErrorCode::OutputFailure, "delivery failed: " + res.message, 0, 0, "output");
            } else if (output_file.empty()) {
                std::cout << source;
            } else {
                std::ofstream out(output_file, std::ios::binary);
                if (!out) throw DecompilerError(ErrorCode::OutputFailure, "cannot open output file: " + output_file, 0, 0, "output");
                out << source;
                if (!out) throw DecompilerError(ErrorCode::OutputFailure, "cannot write output file: " + output_file, 0, 0, "output");
            }
            return 0;
        }

        if (command == "--help" || command == "-h") {
            usage();
            return 0;
        }
        if (command == "--version") {
            std::cout << "Slecompiler 1.0.0\n";
            return 0;
        }

        std::cout << "name=" << a.name() << "\nsize=" << a.size()
                  << "\nformat=" << static_cast<int>(a.format())
                  << "\nsha256=" << a.sha256() << "\n";

        if (command == "inspect") {
            std::cout << "architecture=" << static_cast<int>(a.architecture())
                      << "\nartifact_class=" << static_cast<int>(a.artifact_class()) << "\n";
            const auto& ni = a.interfaces();
            std::cout << "sections=" << ni.sections.size()
                      << " symbols=" << ni.symbols.size()
                      << " imports=" << ni.imports.size()
                      << " exports=" << ni.exports.size()
                      << " relocations=" << ni.relocations.size()
                      << " archive_members=" << ni.archive_members.size() << "\n";
            const auto& lm = a.library_metadata();
            if (!lm.soname.empty()) std::cout << "soname=" << lm.soname << "\n";
            for (const auto& n : lm.needed_libraries) std::cout << "needs=" << n << "\n";
            if (!lm.build_id.empty()) std::cout << "build_id=" << lm.build_id << "\n";
            const auto& km = a.kernel_module_metadata();
            if (!km.module_name.empty()) std::cout << "module=" << km.module_name << "\n";
            if (!km.vermagic.empty()) std::cout << "vermagic=" << km.vermagic << "\n";
            if (!km.license.empty()) std::cout << "module_license=" << km.license << "\n";
            return 0;
        }

        if (command == "disassemble" || command == "cfg" || command == "functions") {
            // Optional flags may appear alongside the positional [length]. --thumb selects
            // the ARM Thumb (T32) instruction set; the ARM default remains A32.
            std::size_t length = 64;
            auto mode = sleela::decompiler::DecodeMode::Auto;
            for (int k = 3; k < argc; ++k) {
                const std::string arg = argv[k];
                if (arg == "--thumb") mode = sleela::decompiler::DecodeMode::ArmThumb;
                else if (arg == "--arm") mode = sleela::decompiler::DecodeMode::ArmA32;
                else if (!arg.empty() && arg[0] != '-') length = parse_length(arg);
                else { usage(); return 2; }
            }
            // Prefer the first executable section (SHF_EXECINSTR, or a ".text" name) so the
            // linear sweep starts in real code rather than container-header bytes. Falls back
            // to file offset 0 when no executable section is identified.
            std::uint64_t at = 0;
            for (const auto& s : a.interfaces().sections) {
                const bool exec = (s.flags & 0x4u) != 0 || s.name == ".text" || s.name == "__text";
                if (exec && s.file_offset != 0) { at = s.file_offset; break; }
            }
            auto ins = sleela::decompiler::Decoder{}.decode(a, at, length, mode);
            auto cfg = sleela::decompiler::Analyzer{}.build_cfg(ins);
            if (command == "disassemble")
                for (const auto& i : ins) std::cout << std::hex << i.address << ": " << (i.text.empty() ? i.mnemonic : i.text) << "\n";
            else if (command == "cfg")
                for (const auto& e : cfg.edges) std::cout << e.from << " -> " << e.to << "\n";
            else
                for (const auto& s : sleela::decompiler::Analyzer{}.recover_function_candidates(a, cfg))
                    std::cout << s.name << " @ " << std::hex << s.address << "\n";
            return 0;
        }

        usage();
        return 2;
    } catch (const DecompilerError& e) {
        std::cerr << error_code_name(e.code()) << ": " << e.what();
        if (!e.stage().empty()) std::cerr << " [stage=" << e.stage() << "]";
        std::cerr << "\n";
        return 1;
    } catch (const std::exception& e) {
        std::cerr << "InternalError: " << e.what() << "\n";
        return 1;
    }
}