/* Copyright 2017 - 2025 R. Thomas

* Copyright 2017 - 2025 Quarkslab

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

#include "ELF/json_internal.hpp"

#include "LIEF/ELF.hpp"

namespace LIEF {

namespace ELF {

void JsonVisitor::visit(const Binary& binary) {

JsonVisitor header_visitor;

header_visitor(binary.header());

// Sections

std::vector<json> sections;

for (const Section& section : binary.sections()) {

JsonVisitor visitor;

visitor(section);

sections.emplace_back(visitor.get());

}

// Segments

std::vector<json> segments;

for (const Segment& segment : binary.segments()) {

JsonVisitor visitor;

visitor(segment);

segments.emplace_back(visitor.get());

}

// Dynamic entries

std::vector<json> dynamic_entries;

for (const DynamicEntry& entry : binary.dynamic_entries()) {

JsonVisitor visitor;

entry.accept(visitor);

dynamic_entries.emplace_back(visitor.get());

}

// Dynamic symbols

std::vector<json> dynamic_symbols;

for (const Symbol& symbol : binary.dynamic_symbols()) {

JsonVisitor visitor;

visitor(symbol);

dynamic_symbols.emplace_back(visitor.get());

}

// Symtab symbols

std::vector<json> symtab_symbols;

for (const Symbol& symbol : binary.symtab_symbols()) {

JsonVisitor visitor;

visitor(symbol);

symtab_symbols.emplace_back(visitor.get());

}

// Dynamic relocations

std::vector<json> dynamic_relocations;

for (const Relocation& reloc : binary.dynamic_relocations()) {

JsonVisitor visitor;

visitor(reloc);

dynamic_relocations.emplace_back(visitor.get());

}

// pltgot relocations

std::vector<json> pltgot_relocations;

for (const Relocation& reloc : binary.pltgot_relocations()) {

JsonVisitor visitor;

visitor(reloc);

pltgot_relocations.emplace_back(visitor.get());

}

// Symbol version

std::vector<json> symbols_version;

for (const SymbolVersion& s : binary.symbols_version()) {

JsonVisitor visitor;

visitor(s);

symbols_version.emplace_back(visitor.get());

}

// Symbols version requirement

std::vector<json> symbols_version_requirement;

for (const SymbolVersionRequirement& s : binary.symbols_version_requirement()) {

JsonVisitor visitor;

visitor(s);

symbols_version_requirement.emplace_back(visitor.get());

}

// Symbols version definition

std::vector<json> symbols_version_definition;

for (const SymbolVersionDefinition& s : binary.symbols_version_definition()) {

JsonVisitor visitor;

visitor(s);

symbols_version_definition.emplace_back(visitor.get());

}

// Notes

std::vector<json> notes;

for (const Note& note : binary.notes()) {

JsonVisitor visitor;

visitor(note);

notes.emplace_back(visitor.get());

}

node_["entrypoint"] = binary.entrypoint();

node_["imagebase"] = binary.imagebase();

node_["virtual_size"] = binary.virtual_size();

node_["is_pie"] = binary.is_pie();

if (binary.has_interpreter()) {

node_["interpreter"] = binary.interpreter();

}

node_["header"] = header_visitor.get();

node_["sections"] = sections;

node_["segments"] = segments;

node_["dynamic_entries"] = dynamic_entries;

node_["dynamic_symbols"] = dynamic_symbols;

node_["symtab_symbols"] = symtab_symbols;

node_["dynamic_relocations"] = dynamic_relocations;

node_["pltgot_relocations"] = pltgot_relocations;

node_["symbols_version"] = symbols_version;

node_["symbols_version_requirement"] = symbols_version_requirement;

node_["symbols_version_definition"] = symbols_version_definition;

node_["notes"] = notes;

if (binary.use_gnu_hash()) {

JsonVisitor gnu_hash_visitor;

gnu_hash_visitor(*binary.gnu_hash());

node_["gnu_hash"] = gnu_hash_visitor.get();

}

if (binary.use_sysv_hash()) {

JsonVisitor sysv_hash_visitor;

sysv_hash_visitor(*binary.sysv_hash());

node_["sysv_hash"] = sysv_hash_visitor.get();

}

}

void JsonVisitor::visit(const Header& header) {

node_["file_type"] = to_string(header.file_type());

node_["machine_type"] = to_string(header.machine_type());

node_["object_file_version"] = to_string(header.object_file_version());

node_["entrypoint"] = header.entrypoint();

node_["program_headers_offset"] = header.program_headers_offset();

node_["section_headers_offset"] = header.section_headers_offset();

node_["processor_flag"] = header.processor_flag();

node_["header_size"] = header.header_size();

node_["program_header_size"] = header.program_header_size();

node_["processornumberof_segments_flag"] = header.numberof_segments();

node_["section_header_size"] = header.section_header_size();

node_["numberof_sections"] = header.numberof_sections();

node_["section_name_table_idx"] = header.section_name_table_idx();

node_["identity_class"] = to_string(header.identity_class());

node_["identity_data"] = to_string(header.identity_data());

node_["identity_version"] = to_string(header.identity_version());

node_["identity_os_abi"] = to_string(header.identity_os_abi());

node_["identity_abi_version"] = header.identity_abi_version();

}

void JsonVisitor::visit(const Section& section) {

std::vector<json> flags;

for (Section::FLAGS f : section.flags_list()) {

flags.emplace_back(to_string(f));

}

node_["name"] = section.name();

node_["virtual_address"] = section.virtual_address();

node_["size"] = section.size();

node_["offset"] = section.offset();

node_["alignment"] = section.alignment();

node_["information"] = section.information();

node_["entry_size"] = section.entry_size();

node_["link"] = section.link();

node_["type"] = to_string(section.type());

node_["flags"] = flags;

}

void JsonVisitor::visit(const Segment& segment) {

std::vector<json> sections;

for (const Section& section : segment.sections()) {

sections.emplace_back(section.name());

}

node_["type"] = to_string(segment.type());

node_["flags"] = static_cast<size_t>(segment.flags());

node_["file_offset"] = segment.file_offset();

node_["virtual_address"] = segment.virtual_address();

node_["physical_address"] = segment.physical_address();

node_["physical_size"] = segment.physical_size();

node_["virtual_size"] = segment.virtual_size();

node_["alignment"] = segment.alignment();

node_["sections"] = sections;

}

void JsonVisitor::visit(const DynamicEntry& entry) {

node_["tag"] = to_string(entry.tag());

node_["value"] = entry.value();

}

void JsonVisitor::visit(const DynamicEntryArray& entry) {

visit(static_cast<const DynamicEntry&>(entry));

node_["array"] = entry.array();

}

void JsonVisitor::visit(const DynamicEntryLibrary& entry) {

visit(static_cast<const DynamicEntry&>(entry));

node_["library"] = entry.name();

}

void JsonVisitor::visit(const DynamicEntryRpath& entry) {

visit(static_cast<const DynamicEntry&>(entry));

node_["rpath"] = entry.rpath();

}

void JsonVisitor::visit(const DynamicEntryRunPath& entry) {

visit(static_cast<const DynamicEntry&>(entry));

node_["runpath"] = entry.runpath();

}

void JsonVisitor::visit(const DynamicSharedObject& entry) {

visit(static_cast<const DynamicEntry&>(entry));

node_["library"] = entry.name();

}

void JsonVisitor::visit(const DynamicEntryFlags& entry) {

visit(static_cast<const DynamicEntry&>(entry));

const DynamicEntryFlags::flags_list_t& flags = entry.flags();

std::vector<std::string> flags_str;

flags_str.reserve(flags.size());

std::transform(

std::begin(flags), std::end(flags),

std::back_inserter(flags_str),

[] (DynamicEntryFlags::FLAG f) {

return to_string(f);

});

node_["flags"] = flags_str;

}

void JsonVisitor::visit(const Symbol& symbol) {

node_["type"] = to_string(symbol.type());

node_["binding"] = to_string(symbol.binding());

node_["information"] = symbol.information();

node_["other"] = symbol.other();

node_["value"] = symbol.value();

node_["size"] = symbol.size();

node_["name"] = symbol.name();

std::string sname = symbol.demangled_name();

if (sname.empty()) {

sname = symbol.name();

}

node_["demangled_name"] = sname;

}

void JsonVisitor::visit(const Relocation& relocation) {

std::string relocation_type = "NOT_TO_STRING";

std::string symbol_name;

std::string section_name;

const Symbol* s = relocation.symbol();

if (s != nullptr) {

symbol_name = s->demangled_name();

if (symbol_name.empty()) {

symbol_name = s->name();

}

}

const Section* reloc_sec = relocation.section();

if (reloc_sec != nullptr) {

section_name = reloc_sec->name();

}

relocation_type = to_string(relocation.type());

node_["symbol_name"] = symbol_name;

node_["address"] = relocation.address();

node_["type"] = relocation_type;

node_["section"] = section_name;

}

void JsonVisitor::visit(const SymbolVersion& sv) {

node_["value"] = sv.value();

if (sv.has_auxiliary_version()) {

node_["symbol_version_auxiliary"] = sv.symbol_version_auxiliary()->name();

}

}

void JsonVisitor::visit(const SymbolVersionRequirement& svr) {

std::vector<json> svar_json;

for (const SymbolVersionAuxRequirement& svar : svr.auxiliary_symbols()) {

JsonVisitor visitor;

visitor(svar);

svar_json.emplace_back(visitor.get());

}

node_["version"] = svr.version();

node_["name"] = svr.name();

node_["symbol_version_auxiliary_requirement"] = svar_json;

}

void JsonVisitor::visit(const SymbolVersionDefinition& svd) {

std::vector<json> sva_json;

for (const SymbolVersionAux& sva : svd.symbols_aux()) {

JsonVisitor visitor;

visitor(sva);

sva_json.emplace_back(visitor.get());

}

node_["version"] = svd.version();

node_["flags"] = svd.flags();

node_["hash"] = svd.hash();

node_["symbol_version_auxiliary"] = sva_json;

}

void JsonVisitor::visit(const SymbolVersionAux& sv) {

node_["name"] = sv.name();

}

void JsonVisitor::visit(const SymbolVersionAuxRequirement& svar) {

node_["hash"] = svar.hash();

node_["flags"] = svar.flags();

node_["other"] = svar.other();

}

void JsonVisitor::visit(const Note& note) {

node_["name"] = note.name();

node_["type"] = to_string(note.type());

node_["original_type"] = note.original_type();

}

void JsonVisitor::visit(const NoteAbi& note_abi) {

visit(static_cast<const Note&>(note_abi));

if (auto abi = note_abi.abi()) {

node_["abi"] = to_string(*abi);

}

if (auto version = note_abi.version()) {

node_["version"] = *version;

}

}

void JsonVisitor::visit(const NoteGnuProperty& note_prop) {

visit(static_cast<const Note&>(note_prop));

NoteGnuProperty::properties_t props = note_prop.properties();

std::vector<json> json_props;

json_props.reserve(props.size());

for (const std::unique_ptr<NoteGnuProperty::Property>& prop : props) {

json_props.push_back(to_string(prop->type()));

}

node_["properties"] = std::move(json_props);

}

void JsonVisitor::visit(const CorePrPsInfo& pinfo) {

visit(static_cast<const Note&>(pinfo));

auto info = pinfo.info();

if (!info) {

return;

}

node_["state"] = info->state;

node_["sname"] = info->sname;

node_["zombie"] = info->zombie;

node_["flag"] = info->flag;

node_["uid"] = info->uid;

node_["gid"] = info->gid;

node_["pid"] = info->pid;

node_["ppid"] = info->ppid;

node_["pgrp"] = info->pgrp;

node_["sid"] = info->sid;

node_["filename"] = info->filename_stripped();

node_["args"] = info->args_stripped();

}

void JsonVisitor::visit(const CorePrStatus& pstatus) {

visit(static_cast<const Note&>(pstatus));

const CorePrStatus::pr_status_t& status = pstatus.status();

node_["current_sig"] = status.cursig;

node_["sigpend"] = status.sigpend;

node_["sighold"] = status.sighold;

node_["pid"] = status.pid;

node_["ppid"] = status.ppid;

node_["pgrp"] = status.pgrp;

node_["sid"] = status.sid;

node_["sigpend"] = status.sigpend;

node_["utime"] = {

{"tv_sec", status.utime.sec},

{"tv_usec", status.utime.usec}

};

node_["stime"] = {

{"tv_sec", status.stime.sec},

{"tv_usec", status.stime.sec}

};

node_["stime"] = {

{"tv_sec", status.stime.sec},

{"tv_usec", status.stime.usec}

};

std::vector<uint64_t> reg_vals = pstatus.register_values();

if (!reg_vals.empty()) {

json regs;

switch (pstatus.architecture()) {

case ARCH::I386:

{

for (size_t i = 0; i < reg_vals.size(); ++i) {

regs[to_string(CorePrStatus::Registers::X86(i))] = reg_vals[i];

}

break;

}

case ARCH::X86_64:

{

for (size_t i = 0; i < reg_vals.size(); ++i) {

regs[to_string(CorePrStatus::Registers::X86_64(i))] = reg_vals[i];

}

break;

}

case ARCH::ARM:

{

for (size_t i = 0; i < reg_vals.size(); ++i) {

regs[to_string(CorePrStatus::Registers::ARM(i))] = reg_vals[i];

}

break;

}

case ARCH::AARCH64:

{

for (size_t i = 0; i < reg_vals.size(); ++i) {

regs[to_string(CorePrStatus::Registers::AARCH64(i))] = reg_vals[i];

}

break;

}

default:

{

regs = reg_vals;

}

}

node_["regs"] = regs;

}

}

void JsonVisitor::visit(const CoreAuxv& auxv) {

visit(static_cast<const Note&>(auxv));

std::vector<json> values;

const std::map<CoreAuxv::TYPE, uint64_t> aux_values = auxv.values();

for (const auto& [k, v] : aux_values) {

node_[to_string(k)] = v;

}

}

void JsonVisitor::visit(const CoreSigInfo& siginfo) {

visit(static_cast<const Note&>(siginfo));

if (auto signo = siginfo.signo()) {

node_["signo"] = *signo;

}

if (auto sigcode = siginfo.sigcode()) {

node_["sigcode"] = *sigcode;

}

if (auto sigerrno = siginfo.sigerrno()) {

node_["sigerrno"] = *sigerrno;

}

}

void JsonVisitor::visit(const CoreFile& file) {

visit(static_cast<const Note&>(file));

std::vector<json> files;

for (const CoreFile::entry_t& entry : file.files()) {

const json file = {

{"start", entry.start},

{"end", entry.end},

{"file_ofs", entry.file_ofs},

{"path", entry.path}

};

files.emplace_back(file);

}

node_["files"] = files;

node_["count"] = file.count();

}

void JsonVisitor::visit(const AndroidIdent& ident) {

visit(static_cast<const Note&>(ident));

node_["ndk_version"] = ident.ndk_version();

node_["sdk_verison"] = ident.sdk_version();

node_["ndk_build_number"] = ident.ndk_build_number();

}

void JsonVisitor::visit(const QNXStack& note) {

visit(static_cast<const Note&>(note));

node_["stack_size"] = note.stack_size();

node_["sdk_verison"] = note.stack_allocated();

node_["is_executable"] = note.is_executable();

}

void JsonVisitor::visit(const GnuHash& gnuhash) {

node_["nb_buckets"] = gnuhash.nb_buckets();

node_["symbol_index"] = gnuhash.symbol_index();

node_["shift2"] = gnuhash.shift2();

node_["maskwords"] = gnuhash.maskwords();

node_["bloom_filters"] = gnuhash.bloom_filters();

node_["buckets"] = gnuhash.buckets();

node_["hash_values"] = gnuhash.hash_values();

}

void JsonVisitor::visit(const SysvHash& sysvhash) {

node_["nbucket"] = sysvhash.nbucket();

node_["nchain"] = sysvhash.nchain();

node_["buckets"] = sysvhash.buckets();

node_["chains"] = sysvhash.chains();

}

} // namespace ELF

} // namespace LIEF