QuasarApp/LIEF
4
0
Fork 0
mirror of https://github.com/QuasarApp/LIEF.git synced 2025-04-28 13:24:32 +00:00
Code Issues Projects Releases Wiki Activity

Enhance Python binding

Browse Source
This commit is contained in:
Romain Thomas 2018-06-08 14:58:00 +02:00
parent 3cdfb29612
commit 33a2af4b18
92 changed files with 903 additions and 379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/python/MachO/CMakeLists.txt
View File

@ -32,7 +32,7 @@ set(LIEF_PYTHON_MACHO_SRC
"${CMAKE_CURRENT_LIST_DIR}/objects/pyDataCodeEntry.cpp"
"${CMAKE_CURRENT_LIST_DIR}/objects/pySubFramework.cpp"
"${CMAKE_CURRENT_LIST_DIR}/objects/pyDyldEnvironment.cpp"
"${CMAKE_CURRENT_LIST_DIR}/pyMachOStructures.cpp"
"${CMAKE_CURRENT_LIST_DIR}/pyEnums.cpp"
)
set(LIEF_PYTHON_MACHO_HDR

11
api/python/MachO/objects/pyBinary.cpp
View File

@ -22,13 +22,18 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using no_const_getter = T (Binary::*)(void);
template<class T, class P>
using no_const_func = T (Binary::*)(P);
void init_MachO_Binary_class(py::module& m) {
template<>
void create<Binary>(py::module& m) {
py::class_<Binary, LIEF::Binary>(m, "Binary")
@ -321,6 +326,8 @@ void init_MachO_Binary_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/MachO/objects/pyBindingInfo.cpp
View File

@ -23,6 +23,10 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (BindingInfo::*)(void) const;
@ -30,7 +34,8 @@ template<class T>
using setter_t = void (BindingInfo::*)(T);
void init_MachO_BindingInfo_class(py::module& m) {
template<>
void create<BindingInfo>(py::module& m) {
py::class_<BindingInfo, LIEF::Object>(m, "BindingInfo")
@ -119,3 +124,6 @@ void init_MachO_BindingInfo_class(py::module& m) {
});
}
}
}

9
api/python/MachO/objects/pyCodeSignature.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (CodeSignature::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (CodeSignature::*)(T);
void init_MachO_CodeSignature_class(py::module& m) {
template<>
void create<CodeSignature>(py::module& m) {
py::class_<CodeSignature, LoadCommand>(m, "CodeSignature")
@ -62,3 +66,6 @@ void init_MachO_CodeSignature_class(py::module& m) {
});
}
}
}

9
api/python/MachO/objects/pyDataCodeEntry.cpp
View File

@ -28,6 +28,9 @@
#define PY_ENUM(x) LIEF::MachO::to_string(x), x
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (DataCodeEntry::*)(void) const;
@ -35,7 +38,8 @@ template<class T>
using setter_t = void (DataCodeEntry::*)(T);
void init_MachO_DataCodeEntry_class(py::module& m) {
template<>
void create<DataCodeEntry>(py::module& m) {
py::class_<DataCodeEntry, LIEF::Object> cls(m, "DataCodeEntry");
@ -84,3 +88,6 @@ void init_MachO_DataCodeEntry_class(py::module& m) {
.value(PY_ENUM(DataCodeEntry::TYPES::ABS_JUMP_TABLE_32));
}
}
}

9
api/python/MachO/objects/pyDataInCode.cpp
View File

@ -23,6 +23,10 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (DataInCode::*)(void) const;
@ -30,7 +34,8 @@ template<class T>
using setter_t = void (DataInCode::*)(T);
void init_MachO_DataInCode_class(py::module& m) {
template<>
void create<DataInCode>(py::module& m) {
// Init Iterator
init_ref_iterator<DataInCode::it_entries>(m);
@ -74,3 +79,5 @@ void init_MachO_DataInCode_class(py::module& m) {
});
}
}
}

9
api/python/MachO/objects/pyDyldEnvironment.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (DyldEnvironment::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (DyldEnvironment::*)(T);
void init_MachO_DyldEnvironment_class(py::module& m) {
template<>
void create<DyldEnvironment>(py::module& m) {
py::class_<DyldEnvironment, LoadCommand>(m, "DyldEnvironment")
@ -57,3 +61,6 @@ void init_MachO_DyldEnvironment_class(py::module& m) {
});
}
}
}

10
api/python/MachO/objects/pyDyldInfo.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (DyldInfo::*)(void) const;
@ -32,7 +35,9 @@ using setter_t = void (DyldInfo::*)(T);
template<class T>
using no_const_getter = T (DyldInfo::*)(void);
void init_MachO_DyldInfo_class(py::module& m) {
template<>
void create<DyldInfo>(py::module& m) {
py::class_<DyldInfo, LoadCommand>(m, "DyldInfo")
@ -277,3 +282,6 @@ void init_MachO_DyldInfo_class(py::module& m) {
});
}
}
}

10
api/python/MachO/objects/pyDylibCommand.cpp
View File

@ -23,6 +23,10 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (DylibCommand::*)(void) const;
@ -30,7 +34,8 @@ template<class T>
using setter_t = void (DylibCommand::*)(T);
void init_MachO_DylibCommand_class(py::module& m) {
template<>
void create<DylibCommand>(py::module& m) {
py::class_<DylibCommand, LoadCommand>(m, "DylibCommand")
.def_property("name",
@ -76,3 +81,6 @@ void init_MachO_DylibCommand_class(py::module& m) {
});
}
}
}

9
api/python/MachO/objects/pyDylinker.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (DylinkerCommand::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (DylinkerCommand::*)(T);
void init_MachO_DylinkerCommand_class(py::module& m) {
template<>
void create<DylinkerCommand>(py::module& m) {
py::class_<DylinkerCommand, LoadCommand>(m, "DylinkerCommand")
.def_property("name",
@ -57,3 +61,6 @@ void init_MachO_DylinkerCommand_class(py::module& m) {
});
}
}
}

10
api/python/MachO/objects/pyDynamicSymbolCommand.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (DynamicSymbolCommand::*)(void) const;
@ -32,7 +35,9 @@ using setter_t = void (DynamicSymbolCommand::*)(T);
template<class T>
using no_const_getter = T (DynamicSymbolCommand::*)(void);
void init_MachO_DynamicSymbolCommand_class(py::module& m) {
template<>
void create<DynamicSymbolCommand>(py::module& m) {
py::class_<DynamicSymbolCommand, LoadCommand>(m, "DynamicSymbolCommand")
@ -192,3 +197,6 @@ void init_MachO_DynamicSymbolCommand_class(py::module& m) {
});
}
}
}

9
api/python/MachO/objects/pyExportInfo.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (ExportInfo::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (ExportInfo::*)(T);
void init_MachO_ExportInfo_class(py::module& m) {
template<>
void create<ExportInfo>(py::module& m) {
py::class_<ExportInfo, LIEF::Object>(m, "ExportInfo")
@ -75,3 +79,6 @@ void init_MachO_ExportInfo_class(py::module& m) {
});
}
}
}

8
api/python/MachO/objects/pyFatBinary.cpp
View File

@ -20,7 +20,11 @@
#include "pyMachO.hpp"
void init_MachO_FatBinary_class(py::module& m) {
namespace LIEF {
namespace MachO {
template<>
void create<FatBinary>(py::module& m) {
py::class_<FatBinary>(m, "FatBinary")
@ -59,3 +63,5 @@ void init_MachO_FatBinary_class(py::module& m) {
}
}
}

9
api/python/MachO/objects/pyFunctionStarts.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (FunctionStarts::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (FunctionStarts::*)(T);
void init_MachO_FunctionStarts_class(py::module& m) {
template<>
void create<FunctionStarts>(py::module& m) {
py::class_<FunctionStarts, LoadCommand>(m, "FunctionStarts")
@ -78,3 +82,6 @@ void init_MachO_FunctionStarts_class(py::module& m) {
});
}
}
}

10
api/python/MachO/objects/pyHeader.cpp
View File

@ -21,13 +21,18 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (Header::*)(void) const;
template<class T>
using setter_t = void (Header::*)(T);
void init_MachO_Header_class(py::module& m) {
template<>
void create<Header>(py::module& m) {
py::class_<Header, LIEF::Object>(m, "Header")
.def(py::init<>())
@ -118,3 +123,6 @@ void init_MachO_Header_class(py::module& m) {
return str;
});
}
}
}

10
api/python/MachO/objects/pyLoadCommand.cpp
View File

@ -21,6 +21,8 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (LoadCommand::*)(void) const;
@ -28,7 +30,9 @@ using getter_t = T (LoadCommand::*)(void) const;
template<class T>
using setter_t = void (LoadCommand::*)(T);
void init_MachO_LoadCommand_class(py::module& m) {
template<>
void create<LoadCommand>(py::module& m) {
py::class_<LoadCommand, LIEF::Object>(m, "LoadCommand")
.def(py::init<>())
@ -70,3 +74,7 @@ void init_MachO_LoadCommand_class(py::module& m) {
return str;
});
}
}
}

9
api/python/MachO/objects/pyMainCommand.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (MainCommand::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (MainCommand::*)(T);
void init_MachO_MainCommand_class(py::module& m) {
template<>
void create<MainCommand>(py::module& m) {
py::class_<MainCommand, LoadCommand>(m, "MainCommand")
@ -65,3 +69,6 @@ void init_MachO_MainCommand_class(py::module& m) {
});
}
}
}

9
api/python/MachO/objects/pyParser.cpp
View File

@ -20,7 +20,11 @@
#include "pyMachO.hpp"
void init_MachO_Parser_class(py::module& m) {
namespace LIEF {
namespace MachO {
template<>
void create<Parser>(py::module& m) {
// Parser (Parser)
m.def("parse",
@ -81,6 +85,7 @@ void init_MachO_Parser_class(py::module& m) {
"name"_a = "",
"config"_a = ParserConfig::quick(),
py::return_value_policy::take_ownership);
}
}
}

14
api/python/MachO/objects/pyParserConfig.cpp
View File

@ -19,7 +19,11 @@
#include "pyMachO.hpp"
void init_MachO_ParserConfig_class(py::module& m) {
namespace LIEF {
namespace MachO {
template<>
void create<ParserConfig>(py::module& m) {
py::class_<ParserConfig>(m, "ParserConfig", "Configuration of MachO's parser")
.def(py::init<>())
@ -36,11 +40,7 @@ void init_MachO_ParserConfig_class(py::module& m) {
.def_property_readonly_static("quick",
[] (py::object /* self */) { return ParserConfig::quick(); },
"");
}
}
}

9
api/python/MachO/objects/pyRPathCommand.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (RPathCommand::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (RPathCommand::*)(T);
void init_MachO_RPathCommand_class(py::module& m) {
template<>
void create<RPathCommand>(py::module& m) {
py::class_<RPathCommand, LoadCommand>(m, "RPathCommand")
@ -59,3 +63,6 @@ void init_MachO_RPathCommand_class(py::module& m) {
});
}
}
}

9
api/python/MachO/objects/pyRelocation.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (Relocation::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (Relocation::*)(T);
void init_MachO_Relocation_class(py::module& m) {
template<>
void create<Relocation>(py::module& m) {
py::class_<Relocation, LIEF::Relocation>(m, "Relocation")
@ -133,3 +137,6 @@ void init_MachO_Relocation_class(py::module& m) {
});
}
}
}

9
api/python/MachO/objects/pyRelocationDyld.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (RelocationDyld::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (RelocationDyld::*)(T);
void init_MachO_RelocationDyld_class(py::module& m) {
template<>
void create<RelocationDyld>(py::module& m) {
py::class_<RelocationDyld, Relocation>(m, "RelocationDyld")
@ -51,3 +55,6 @@ void init_MachO_RelocationDyld_class(py::module& m) {
});
}
}
}

9
api/python/MachO/objects/pyRelocationObject.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (RelocationObject::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (RelocationObject::*)(T);
void init_MachO_RelocationObject_class(py::module& m) {
template<>
void create<RelocationObject>(py::module& m) {
py::class_<RelocationObject, Relocation>(m, "RelocationObject")
@ -69,3 +73,6 @@ void init_MachO_RelocationObject_class(py::module& m) {
});
}
}
}

10
api/python/MachO/objects/pySection.cpp
View File

@ -21,7 +21,8 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (Section::*)(void) const;
@ -32,7 +33,9 @@ using setter_t = void (Section::*)(T);
template<class T>
using no_const_getter = T (Section::*)(void);
void init_MachO_Section_class(py::module& m) {
template<>
void create<Section>(py::module& m) {
py::class_<Section, LIEF::Section>(m, "Section")
.def(py::init<>())
@ -82,5 +85,6 @@ void init_MachO_Section_class(py::module& m) {
}
}
}

9
api/python/MachO/objects/pySegmentCommand.cpp
View File

@ -22,6 +22,9 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (SegmentCommand::*)(void) const;
@ -31,7 +34,9 @@ using setter_t = void (SegmentCommand::*)(T);
template<class T>
using no_const_getter = T (SegmentCommand::*)(void);
void init_MachO_SegmentCommand_class(py::module& m) {
template<>
void create<SegmentCommand>(py::module& m) {
py::class_<SegmentCommand, LoadCommand>(m, "SegmentCommand")
.def(py::init<>())
@ -128,5 +133,7 @@ void init_MachO_SegmentCommand_class(py::module& m) {
}
}
}

8
api/python/MachO/objects/pySegmentSplitInfo.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (SegmentSplitInfo::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (SegmentSplitInfo::*)(T);
void init_MachO_SegmentSplitInfo_class(py::module& m) {
template<>
void create<SegmentSplitInfo>(py::module& m) {
py::class_<SegmentSplitInfo, LoadCommand>(m, "SegmentSplitInfo")
@ -60,5 +64,7 @@ void init_MachO_SegmentSplitInfo_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

8
api/python/MachO/objects/pySourceVersion.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (SourceVersion::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (SourceVersion::*)(T);
void init_MachO_SourceVersion_class(py::module& m) {
template<>
void create<SourceVersion>(py::module& m) {
py::class_<SourceVersion, LoadCommand>(m, "SourceVersion")
@ -57,5 +61,7 @@ void init_MachO_SourceVersion_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

9
api/python/MachO/objects/pySubFramework.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (SubFramework::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (SubFramework::*)(T);
void init_MachO_SubFramework_class(py::module& m) {
template<>
void create<SubFramework>(py::module& m) {
py::class_<SubFramework, LoadCommand>(m, "SubFramework")
@ -57,3 +61,6 @@ void init_MachO_SubFramework_class(py::module& m) {
});
}
}
}

9
api/python/MachO/objects/pySymbol.cpp
View File

@ -21,6 +21,8 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (Symbol::*)(void) const;
@ -28,7 +30,9 @@ using getter_t = T (Symbol::*)(void) const;
template<class T>
using setter_t = void (Symbol::*)(T);
void init_MachO_Symbol_class(py::module& m) {
template<>
void create<Symbol>(py::module& m) {
py::class_<Symbol, LIEF::Symbol>(m, "Symbol")
.def(py::init<>())
@ -95,5 +99,8 @@ void init_MachO_Symbol_class(py::module& m) {
}
}
}

8
api/python/MachO/objects/pySymbolCommand.cpp
View File

@ -21,6 +21,8 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (SymbolCommand::*)(void) const;
@ -28,7 +30,9 @@ using getter_t = T (SymbolCommand::*)(void) const;
template<class T>
using setter_t = void (SymbolCommand::*)(T);
void init_MachO_SymbolCommand_class(py::module& m) {
template<>
void create<SymbolCommand>(py::module& m) {
py::class_<SymbolCommand, LoadCommand>(m, "SymbolCommand")
.def(py::init<>())
@ -72,5 +76,7 @@ void init_MachO_SymbolCommand_class(py::module& m) {
}
}
}

10
api/python/MachO/objects/pyThreadCommand.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (ThreadCommand::*)(void) const;
@ -30,7 +33,9 @@ template<class T>
using setter_t = void (ThreadCommand::*)(T);
void init_MachO_ThreadCommand_class(py::module& m) {
template<>
void create<ThreadCommand>(py::module& m) {
py::class_<ThreadCommand, LoadCommand>(m, "ThreadCommand")
@ -76,3 +81,6 @@ void init_MachO_ThreadCommand_class(py::module& m) {
});
}
}
}

8
api/python/MachO/objects/pyUUID.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (UUIDCommand::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (UUIDCommand::*)(T);
void init_MachO_UUIDCommand_class(py::module& m) {
template<>
void create<UUIDCommand>(py::module& m) {
py::class_<UUIDCommand, LoadCommand>(m, "UUIDCommand")
@ -57,5 +61,7 @@ void init_MachO_UUIDCommand_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

9
api/python/MachO/objects/pyVersionMin.cpp
View File

@ -23,6 +23,9 @@
#include "pyMachO.hpp"
namespace LIEF {
namespace MachO {
template<class T>
using getter_t = T (VersionMin::*)(void) const;
@ -30,7 +33,8 @@ template<class T>
using setter_t = void (VersionMin::*)(T);
void init_MachO_VersionMin_class(py::module& m) {
template<>
void create<VersionMin>(py::module& m) {
py::class_<VersionMin, LoadCommand>(m, "VersionMin")
@ -66,3 +70,6 @@ void init_MachO_VersionMin_class(py::module& m) {
});
}
}
}

18
api/python/MachO/pyMachOStructures.cpp → api/python/MachO/pyEnums.cpp
View File

@ -20,7 +20,10 @@
#define PY_ENUM(x) LIEF::MachO::to_string(x), x
void init_MachO_Structures_enum(py::module& m) {
namespace LIEF {
namespace MachO {
void init_enums(py::module& m) {
LIEF::enum_<LIEF::MachO::CPU_TYPES>(m, "CPU_TYPES")
.value(PY_ENUM(LIEF::MachO::CPU_TYPES::CPU_TYPE_ANY))
@ -301,16 +304,7 @@ void init_MachO_Structures_enum(py::module& m) {
.value(PY_ENUM(LIEF::MachO::SYMBOL_ORIGINS::SYM_ORIGIN_UNKNOWN))
.value(PY_ENUM(LIEF::MachO::SYMBOL_ORIGINS::SYM_ORIGIN_DYLD_EXPORT))
.value(PY_ENUM(LIEF::MachO::SYMBOL_ORIGINS::SYM_ORIGIN_LC_SYMTAB));
}
}
}

87
api/python/MachO/pyMachO.cpp
View File

@ -17,47 +17,52 @@
#include "pyMachO.hpp"
//
// MachO modules
//
void init_MachO_module(py::module& m) {
namespace LIEF {
namespace MachO {
void init_python_module(py::module& m) {
py::module LIEF_MachO_module = m.def_submodule("MachO", "Python API for MachO");
// Objects
init_MachO_ParserConfig_class(LIEF_MachO_module);
init_MachO_Parser_class(LIEF_MachO_module);
init_MachO_FatBinary_class(LIEF_MachO_module);
init_MachO_Binary_class(LIEF_MachO_module);
init_MachO_Header_class(LIEF_MachO_module);
init_MachO_LoadCommand_class(LIEF_MachO_module);
init_MachO_DylibCommand_class(LIEF_MachO_module);
init_MachO_SegmentCommand_class(LIEF_MachO_module);
init_MachO_Section_class(LIEF_MachO_module);
init_MachO_Symbol_class(LIEF_MachO_module);
init_MachO_SymbolCommand_class(LIEF_MachO_module);
init_MachO_UUIDCommand_class(LIEF_MachO_module);
init_MachO_MainCommand_class(LIEF_MachO_module);
init_MachO_DylinkerCommand_class(LIEF_MachO_module);
init_MachO_DyldInfo_class(LIEF_MachO_module);
init_MachO_FunctionStarts_class(LIEF_MachO_module);
init_MachO_SourceVersion_class(LIEF_MachO_module);
init_MachO_VersionMin_class(LIEF_MachO_module);
init_MachO_Relocation_class(LIEF_MachO_module);
init_MachO_RelocationObject_class(LIEF_MachO_module);
init_MachO_RelocationDyld_class(LIEF_MachO_module);
init_MachO_BindingInfo_class(LIEF_MachO_module);
init_MachO_ExportInfo_class(LIEF_MachO_module);
init_MachO_ThreadCommand_class(LIEF_MachO_module);
init_MachO_RPathCommand_class(LIEF_MachO_module);
init_MachO_DynamicSymbolCommand_class(LIEF_MachO_module);
init_MachO_CodeSignature_class(LIEF_MachO_module);
init_MachO_SegmentSplitInfo_class(LIEF_MachO_module);
init_MachO_SubFramework_class(LIEF_MachO_module);
init_MachO_DyldEnvironment_class(LIEF_MachO_module);
init_MachO_DataInCode_class(LIEF_MachO_module);
init_MachO_DataCodeEntry_class(LIEF_MachO_module);
// Enums
init_MachO_Structures_enum(LIEF_MachO_module);
init_enums(LIEF_MachO_module);
init_objects(LIEF_MachO_module);
}
void init_objects(py::module& m) {
CREATE(ParserConfig, m);
CREATE(Parser, m);
CREATE(FatBinary, m);
CREATE(Binary, m);
CREATE(Header, m);
CREATE(LoadCommand, m);
CREATE(UUIDCommand, m);
CREATE(SymbolCommand, m);
CREATE(SegmentCommand, m);
CREATE(Section, m);
CREATE(MainCommand, m);
CREATE(DynamicSymbolCommand, m);
CREATE(DylinkerCommand, m);
CREATE(DylibCommand, m);
CREATE(ThreadCommand, m);
CREATE(RPathCommand, m);
CREATE(Symbol, m);
CREATE(Relocation, m);
CREATE(RelocationObject, m);
CREATE(RelocationDyld, m);
CREATE(BindingInfo, m);
CREATE(ExportInfo, m);
CREATE(FunctionStarts, m);
CREATE(CodeSignature, m);
CREATE(DataInCode, m);
CREATE(DataCodeEntry, m);
CREATE(SourceVersion, m);
CREATE(VersionMin, m);
CREATE(SegmentSplitInfo, m);
CREATE(SubFramework, m);
CREATE(DyldEnvironment, m);
}
}
}

93
api/python/MachO/pyMachO.hpp
View File

@ -20,47 +20,68 @@
#include "LIEF/MachO/Binary.hpp"
#include "LIEF/MachO/Builder.hpp"
#include <pybind11/pybind11.h>
#include <pybind11/stl_bind.h>
#include "pyLIEF.hpp"
using namespace LIEF::MachO;
#define SPECIALIZE_CREATE(X) \
template<> \
void create<X>(py::module&)
PYBIND11_MAKE_OPAQUE(std::vector<Binary*>)
#define CREATE(X,Y) create<X>(Y)
void init_MachO_ParserConfig_class(py::module&);
void init_MachO_Parser_class(py::module&);
void init_MachO_FatBinary_class(py::module&);
void init_MachO_Binary_class(py::module&);
void init_MachO_Header_class(py::module&);
void init_MachO_LoadCommand_class(py::module&);
void init_MachO_DylibCommand_class(py::module&);
void init_MachO_SegmentCommand_class(py::module&);
void init_MachO_Section_class(py::module&);
void init_MachO_Symbol_class(py::module&);
void init_MachO_SymbolCommand_class(py::module&);
void init_MachO_UUIDCommand_class(py::module&);
void init_MachO_MainCommand_class(py::module&);
void init_MachO_DylinkerCommand_class(py::module&);
void init_MachO_DyldInfo_class(py::module&);
void init_MachO_FunctionStarts_class(py::module&);
void init_MachO_SourceVersion_class(py::module&);
void init_MachO_VersionMin_class(py::module&);
void init_MachO_Relocation_class(py::module&);
void init_MachO_RelocationObject_class(py::module&);
void init_MachO_RelocationDyld_class(py::module&);
void init_MachO_BindingInfo_class(py::module&);
void init_MachO_ExportInfo_class(py::module&);
void init_MachO_ThreadCommand_class(py::module&);
void init_MachO_RPathCommand_class(py::module&);
void init_MachO_DynamicSymbolCommand_class(py::module&);
void init_MachO_CodeSignature_class(py::module&);
void init_MachO_DataInCode_class(py::module&);
void init_MachO_DataCodeEntry_class(py::module&);
void init_MachO_SegmentSplitInfo_class(py::module&);
void init_MachO_SubFramework_class(py::module&);
void init_MachO_DyldEnvironment_class(py::module&);
// Enums
void init_MachO_Structures_enum(py::module&);
namespace LIEF {
namespace MachO {
template<class T>
void create(py::module&);
void init_python_module(py::module& m);
void init_objects(py::module&);
void init_enums(py::module&);
SPECIALIZE_CREATE(Parser);
SPECIALIZE_CREATE(ParserConfig);
SPECIALIZE_CREATE(FatBinary);
SPECIALIZE_CREATE(Binary);
SPECIALIZE_CREATE(Header);
SPECIALIZE_CREATE(LoadCommand);
SPECIALIZE_CREATE(UUIDCommand);
SPECIALIZE_CREATE(SymbolCommand);
SPECIALIZE_CREATE(SegmentCommand);
SPECIALIZE_CREATE(Section);
SPECIALIZE_CREATE(MainCommand);
SPECIALIZE_CREATE(DynamicSymbolCommand);
SPECIALIZE_CREATE(DylinkerCommand);
SPECIALIZE_CREATE(DylibCommand);
SPECIALIZE_CREATE(ThreadCommand);
SPECIALIZE_CREATE(RPathCommand);
SPECIALIZE_CREATE(Symbol);
SPECIALIZE_CREATE(Relocation);
SPECIALIZE_CREATE(RelocationObject);
SPECIALIZE_CREATE(RelocationDyld);
SPECIALIZE_CREATE(BindingInfo);
SPECIALIZE_CREATE(ExportInfo);
SPECIALIZE_CREATE(FunctionStarts);
SPECIALIZE_CREATE(CodeSignature);
SPECIALIZE_CREATE(DataInCode);
SPECIALIZE_CREATE(DataCodeEntry);
SPECIALIZE_CREATE(SourceVersion);
SPECIALIZE_CREATE(VersionMin);
SPECIALIZE_CREATE(SegmentSplitInfo);
SPECIALIZE_CREATE(SubFramework);
SPECIALIZE_CREATE(DyldEnvironment);
}
}
// Opaque containers
PYBIND11_MAKE_OPAQUE(std::vector<LIEF::MachO::Binary*>)
#endif

3
api/python/PE/CMakeLists.txt
View File

@ -1,6 +1,5 @@
set(LIEF_PYTHON_PE_SRC
"${CMAKE_CURRENT_LIST_DIR}/pyUtils.cpp"
"${CMAKE_CURRENT_LIST_DIR}/objects/init_load_configurations.cpp"
"${CMAKE_CURRENT_LIST_DIR}/objects/pyResourceNode.cpp"
"${CMAKE_CURRENT_LIST_DIR}/objects/pyResourceData.cpp"
@ -44,7 +43,7 @@ set(LIEF_PYTHON_PE_SRC
"${CMAKE_CURRENT_LIST_DIR}/objects/pyImportEntry.cpp"
"${CMAKE_CURRENT_LIST_DIR}/objects/pySymbol.cpp"
"${CMAKE_CURRENT_LIST_DIR}/objects/pyTLS.cpp"
"${CMAKE_CURRENT_LIST_DIR}/pyPEStructures.cpp"
"${CMAKE_CURRENT_LIST_DIR}/pyEnums.cpp"
"${CMAKE_CURRENT_LIST_DIR}/pyPE.cpp"
)

10
api/python/PE/objects/LoadConfigurations/pyLoadConfiguration.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (LoadConfiguration::*)(void) const;
template<class T>
using setter_t = void (LoadConfiguration::*)(T);
void init_PE_LoadConfiguration_class(py::module& m) {
template<>
void create<LoadConfiguration>(py::module& m) {
py::class_<LoadConfiguration, LIEF::Object>(m, "LoadConfiguration",
"Class modeling the default PE's ``LoadConfiguration``\n\n"
"It's the base class for any future version of the structure"
@ -147,6 +152,7 @@ void init_PE_LoadConfiguration_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/LoadConfigurations/pyLoadConfigurationV0.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (LoadConfigurationV0::*)(void) const;
template<class T>
using setter_t = void (LoadConfigurationV0::*)(T);
void init_PE_LoadConfigurationV0_class(py::module& m) {
template<>
void create<LoadConfigurationV0>(py::module& m) {
py::class_<LoadConfigurationV0, LoadConfiguration>(m, "LoadConfigurationV0",
"" RST_CLASS_REF(lief.PE.LoadConfiguration) " enhanced with SEH. \n\n"
"It is associated with the " RST_CLASS_REF(lief.PE.WIN_VERSION) ": "
@ -62,6 +67,7 @@ void init_PE_LoadConfigurationV0_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/LoadConfigurations/pyLoadConfigurationV1.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (LoadConfigurationV1::*)(void) const;
template<class T>
using setter_t = void (LoadConfigurationV1::*)(T);
void init_PE_LoadConfigurationV1_class(py::module& m) {
template<>
void create<LoadConfigurationV1>(py::module& m) {
py::class_<LoadConfigurationV1, LoadConfigurationV0>(m, "LoadConfigurationV1",
"" RST_CLASS_REF(lief.PE.LoadConfigurationV0) " enhanced with *Control Flow Guard*. \n\n"
"It is associated with the " RST_CLASS_REF(lief.PE.WIN_VERSION) ": "
@ -91,6 +96,7 @@ void init_PE_LoadConfigurationV1_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/LoadConfigurations/pyLoadConfigurationV2.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (LoadConfigurationV2::*)(void) const;
template<class T>
using setter_t = void (LoadConfigurationV2::*)(T);
void init_PE_LoadConfigurationV2_class(py::module& m) {
template<>
void create<LoadConfigurationV2>(py::module& m) {
py::class_<LoadConfigurationV2, LoadConfigurationV1>(m, "LoadConfigurationV2",
"" RST_CLASS_REF(lief.PE.LoadConfigurationV1) " enhanced with *code integrity*. \n\n"
"It is associated with the " RST_CLASS_REF(lief.PE.WIN_VERSION) ": "
@ -55,6 +60,7 @@ void init_PE_LoadConfigurationV2_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/LoadConfigurations/pyLoadConfigurationV3.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (LoadConfigurationV3::*)(void) const;
template<class T>
using setter_t = void (LoadConfigurationV3::*)(T);
void init_PE_LoadConfigurationV3_class(py::module& m) {
template<>
void create<LoadConfigurationV3>(py::module& m) {
py::class_<LoadConfigurationV3, LoadConfigurationV2>(m, "LoadConfigurationV3",
"" RST_CLASS_REF(lief.PE.LoadConfigurationV2) " with Control Flow Guard improved. \n\n"
"It is associated with the " RST_CLASS_REF(lief.PE.WIN_VERSION) ": "
@ -70,6 +75,7 @@ void init_PE_LoadConfigurationV3_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/LoadConfigurations/pyLoadConfigurationV4.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (LoadConfigurationV4::*)(void) const;
template<class T>
using setter_t = void (LoadConfigurationV4::*)(T);
void init_PE_LoadConfigurationV4_class(py::module& m) {
template<>
void create<LoadConfigurationV4>(py::module& m) {
py::class_<LoadConfigurationV4, LoadConfigurationV3>(m, "LoadConfigurationV4",
"" RST_CLASS_REF(lief.PE.LoadConfigurationV3) " enhanced with:\n\n"
"\t\t * Kind of dynamic relocations\n\n"
@ -62,6 +67,7 @@ void init_PE_LoadConfigurationV4_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/LoadConfigurations/pyLoadConfigurationV5.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (LoadConfigurationV5::*)(void) const;
template<class T>
using setter_t = void (LoadConfigurationV5::*)(T);
void init_PE_LoadConfigurationV5_class(py::module& m) {
template<>
void create<LoadConfigurationV5>(py::module& m) {
py::class_<LoadConfigurationV5, LoadConfigurationV4>(m, "LoadConfigurationV5",
"" RST_CLASS_REF(lief.PE.LoadConfigurationV4) " enhanced with Return Flow Guard. \n\n"
"It is associated with the " RST_CLASS_REF(lief.PE.WIN_VERSION) ": "
@ -76,6 +81,7 @@ void init_PE_LoadConfigurationV5_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/LoadConfigurations/pyLoadConfigurationV6.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (LoadConfigurationV6::*)(void) const;
template<class T>
using setter_t = void (LoadConfigurationV6::*)(T);
void init_PE_LoadConfigurationV6_class(py::module& m) {
template<>
void create<LoadConfigurationV6>(py::module& m) {
py::class_<LoadConfigurationV6, LoadConfigurationV5>(m, "LoadConfigurationV6",
"" RST_CLASS_REF(lief.PE.LoadConfigurationV5) " enhanced with Hotpatch and improved RFG. \n\n"
"It is associated with the " RST_CLASS_REF(lief.PE.WIN_VERSION) ": "
@ -61,6 +66,7 @@ void init_PE_LoadConfigurationV6_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/LoadConfigurations/pyLoadConfigurationV7.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (LoadConfigurationV7::*)(void) const;
template<class T>
using setter_t = void (LoadConfigurationV7::*)(T);
void init_PE_LoadConfigurationV7_class(py::module& m) {
template<>
void create<LoadConfigurationV7>(py::module& m) {
py::class_<LoadConfigurationV7, LoadConfigurationV6>(m, "LoadConfigurationV7")
.def(py::init<>())
@ -57,6 +62,7 @@ void init_PE_LoadConfigurationV7_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

27
api/python/PE/objects/init_load_configurations.cpp
View File

@ -1,27 +0,0 @@
/* Copyright 2017 R. Thomas
* Copyright 2017 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 "pyPE.hpp"
void init_PE_load_configurations(py::module& m) {
init_PE_LoadConfiguration_class(m);
init_PE_LoadConfigurationV0_class(m);
init_PE_LoadConfigurationV1_class(m);
init_PE_LoadConfigurationV2_class(m);
init_PE_LoadConfigurationV3_class(m);
init_PE_LoadConfigurationV4_class(m);
init_PE_LoadConfigurationV5_class(m);
init_PE_LoadConfigurationV6_class(m);
init_PE_LoadConfigurationV7_class(m);
}

10
api/python/PE/objects/pyBinary.cpp
View File

@ -20,6 +20,8 @@
#include "pyPE.hpp"
namespace LIEF {
namespace PE {
template<class T, class P>
using no_const_func = T (Binary::*)(P);
@ -33,7 +35,10 @@ using getter_t = T (Binary::*)(void) const;
template<class T>
using setter_t = void (Binary::*)(T);
void init_PE_Binary_class(py::module& m) {
template<>
void create<Binary>(py::module& m) {
py::class_<Binary, LIEF::Binary>(m, "Binary")
.def(py::init<const std::string &, PE_TYPE>())
@ -287,3 +292,6 @@ void init_PE_Binary_class(py::module& m) {
});
}
}
}

10
api/python/PE/objects/pyBuilder.cpp
View File

@ -21,7 +21,12 @@
#include <sstream>
void init_PE_Builder_class(py::module& m) {
namespace LIEF {
namespace PE {
template<>
void create<Builder>(py::module& m) {
py::class_<Builder>(m, "Builder")
.def(py::init<Binary*>(),
"Constructor that takes a " RST_CLASS_REF(lief.PE.Binary) "",
@ -94,6 +99,7 @@ void init_PE_Builder_class(py::module& m) {
return str;
});
}
}
}

10
api/python/PE/objects/pyCodeIntegrity.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (CodeIntegrity::*)(void) const;
template<class T>
using setter_t = void (CodeIntegrity::*)(T);
void init_PE_CodeIntegrity_class(py::module& m) {
template<>
void create<CodeIntegrity>(py::module& m) {
py::class_<CodeIntegrity, LIEF::Object>(m, "CodeIntegrity")
.def(py::init<>())
@ -67,6 +72,7 @@ void init_PE_CodeIntegrity_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/pyCodeView.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (CodeView::*)(void) const;
template<class T>
using setter_t = void (CodeView::*)(T);
void init_PE_CodeView_class(py::module& m) {
template<>
void create<CodeView>(py::module& m) {
py::class_<CodeView, LIEF::Object>(m, "CodeView")
.def_property_readonly("cv_signature",
static_cast<getter_t<CODE_VIEW_SIGNATURES>>(&CodeView::cv_signature),
@ -46,6 +51,7 @@ void init_PE_CodeView_class(py::module& m) {
stream << cv;
return stream.str();
});
}
}
}

10
api/python/PE/objects/pyCodeViewPDB.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (CodeViewPDB::*)(void) const;
template<class T>
using setter_t = void (CodeViewPDB::*)(T);
void init_PE_CodeViewPDB_class(py::module& m) {
template<>
void create<CodeViewPDB>(py::module& m) {
py::class_<CodeViewPDB, CodeView>(m, "CodeViewPDB")
.def(py::init<>())
@ -56,6 +61,7 @@ void init_PE_CodeViewPDB_class(py::module& m) {
stream << cv;
return stream.str();
});
}
}
}

10
api/python/PE/objects/pyDataDirectory.cpp
View File

@ -21,13 +21,18 @@
#include "pyPE.hpp"
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (DataDirectory::*)(void) const;
template<class T>
using setter_t = void (DataDirectory::*)(T);
void init_PE_DataDirectory_class(py::module& m) {
template<>
void create<DataDirectory>(py::module& m) {
py::class_<DataDirectory, LIEF::Object>(m, "DataDirectory")
.def(py::init<>())
.def_property("rva",
@ -68,6 +73,7 @@ void init_PE_DataDirectory_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/pyDebug.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (Debug::*)(void) const;
template<class T>
using setter_t = void (Debug::*)(T);
void init_PE_Debug_class(py::module& m) {
template<>
void create<Debug>(py::module& m) {
py::class_<Debug, LIEF::Object>(m, "Debug")
.def(py::init<>())
@ -96,6 +101,7 @@ void init_PE_Debug_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/pyDosHeader.cpp
View File

@ -21,6 +21,9 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_abs_t = T (DosHeader::*)(void) const;
@ -30,7 +33,9 @@ using setter_abs_t = void (DosHeader::*)(T);
using getter_t = getter_abs_t<uint16_t>;
using setter_t = setter_abs_t<uint16_t>;
void init_PE_DosHeader_class(py::module& m) {
template<>
void create<DosHeader>(py::module& m) {
py::class_<DosHeader, LIEF::Object>(m, "DosHeader")
.def(py::init<>())
.def_property("magic",
@ -117,6 +122,7 @@ void init_PE_DosHeader_class(py::module& m) {
return str;
});
}
}
}

10
api/python/PE/objects/pyExport.cpp
View File

@ -21,6 +21,9 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (Export::*)(void) const;
@ -30,7 +33,9 @@ using setter_t = void (Export::*)(T);
template<class T>
using no_const_getter = T (Export::*)(void);
void init_PE_Export_class(py::module& m) {
template<>
void create<Export>(py::module& m) {
py::class_<Export, LIEF::Object>(m, "Export")
.def(py::init<>())
@ -79,6 +84,7 @@ void init_PE_Export_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

11
api/python/PE/objects/pyExportEntry.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ExportEntry::*)(void) const;
template<class T>
using setter_t = void (ExportEntry::*)(T);
void init_PE_ExportEntry_class(py::module& m) {
template<>
void create<ExportEntry>(py::module& m) {
py::class_<ExportEntry, LIEF::Object>(m, "ExportEntry")
.def(py::init<>())
@ -63,6 +68,6 @@ void init_PE_ExportEntry_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

11
api/python/PE/objects/pyHeader.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (Header::*)(void) const;
template<class T>
using setter_t = void (Header::*)(T);
void init_PE_Header_class(py::module& m) {
template<>
void create<Header>(py::module& m) {
py::class_<Header, LIEF::Object>(m, "Header")
.def(py::init<>())
@ -112,6 +117,6 @@ void init_PE_Header_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

11
api/python/PE/objects/pyImport.cpp
View File

@ -21,6 +21,9 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (Import::*)(void) const;
@ -33,7 +36,9 @@ using no_const_getter = T (Import::*)(void);
template<class T, class P>
using no_const_func = T (Import::*)(P);
void init_PE_Import_class(py::module& m) {
template<>
void create<Import>(py::module& m) {
py::class_<Import, LIEF::Object>(m, "Import")
.def(py::init<>(),
"Default constructor with a library name")
@ -117,6 +122,6 @@ void init_PE_Import_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

11
api/python/PE/objects/pyImportEntry.cpp
View File

@ -22,13 +22,18 @@
#include "pyPE.hpp"
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ImportEntry::*)(void) const;
template<class T>
using setter_t = void (ImportEntry::*)(T);
void init_PE_ImportEntry_class(py::module& m) {
template<>
void create<ImportEntry>(py::module& m) {
py::class_<ImportEntry, LIEF::Object>(m, "ImportEntry")
.def(py::init<>())
@ -88,6 +93,6 @@ void init_PE_ImportEntry_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

11
api/python/PE/objects/pyOptionalHeader.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (OptionalHeader::*)(void) const;
template<class T>
using setter_t = void (OptionalHeader::*)(T);
void init_PE_OptionalHeader_class(py::module& m) {
template<>
void create<OptionalHeader>(py::module& m) {
py::class_<OptionalHeader, LIEF::Object>(m, "OptionalHeader")
.def(py::init<>())
.def_property("magic",
@ -289,6 +294,6 @@ void init_PE_OptionalHeader_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

9
api/python/PE/objects/pyParser.cpp
View File

@ -19,7 +19,11 @@
#include <string>
void init_PE_Parser_class(py::module& m) {
namespace LIEF {
namespace PE {
template<>
void create<Parser>(py::module& m) {
m.def("parse",
static_cast<std::unique_ptr<Binary> (*) (const std::string&)>(&Parser::parse),
@ -71,3 +75,6 @@ void init_PE_Parser_class(py::module& m) {
"name"_a = "",
py::return_value_policy::take_ownership);
}
}
}

10
api/python/PE/objects/pyRelocation.cpp
View File

@ -21,6 +21,9 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (Relocation::*)(void) const;
@ -30,7 +33,8 @@ using setter_t = void (Relocation::*)(T);
template<class T>
using it_t = T (Relocation::*)(void);
void init_PE_Relocation_class(py::module& m) {
template<>
void create<Relocation>(py::module& m) {
py::class_<Relocation, LIEF::Object>(m, "Relocation")
.def(py::init<>())
@ -62,6 +66,6 @@ void init_PE_Relocation_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/pyRelocationEntry.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (RelocationEntry::*)(void) const;
template<class T>
using setter_t = void (RelocationEntry::*)(T);
void init_PE_RelocationEntry_class(py::module& m) {
template<>
void create<RelocationEntry>(py::module& m) {
py::class_<RelocationEntry, LIEF::Relocation>(m, "RelocationEntry")
.def(py::init<>())
@ -65,6 +70,7 @@ void init_PE_RelocationEntry_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/pyResourceData.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ResourceData::*)(void) const;
template<class T>
using setter_t = void (ResourceData::*)(T);
void init_PE_ResourceData_class(py::module& m) {
template<>
void create<ResourceData>(py::module& m) {
py::class_<ResourceData, ResourceNode>(m, "ResourceData")
.def(py::init<>(),
"Default constructor")
@ -72,3 +77,6 @@ void init_PE_ResourceData_class(py::module& m) {
return str;
});
}
}
}

9
api/python/PE/objects/pyResourceDirectory.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ResourceDirectory::*)(void) const;
template<class T>
using setter_t = void (ResourceDirectory::*)(T);
void init_PE_ResourceDirectory_class(py::module& m) {
template<>
void create<ResourceDirectory>(py::module& m) {
py::class_<ResourceDirectory, ResourceNode>(m, "ResourceDirectory")
.def(py::init<>(),
"Default constructor")
@ -85,5 +90,7 @@ void init_PE_ResourceDirectory_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

11
api/python/PE/objects/pyResourceNode.cpp
View File

@ -22,13 +22,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ResourceNode::*)(void) const;
template<class T>
using setter_t = void (ResourceNode::*)(T);
void init_PE_ResourceNode_class(py::module& m) {
template<>
void create<ResourceNode>(py::module& m) {
py::class_<ResourceNode, LIEF::Object>(m, "ResourceNode")
.def_property("id",
@ -103,7 +108,7 @@ void init_PE_ResourceNode_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

8
api/python/PE/objects/pyResourcesManager.cpp
View File

@ -21,6 +21,8 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ResourcesManager::*)(void) const;
@ -31,7 +33,9 @@ using setter_t = void (ResourcesManager::*)(T);
template<class T, class P>
using no_const_func = T (ResourcesManager::*)(P);
void init_PE_ResourcesManager_class(py::module& m) {
template<>
void create<ResourcesManager>(py::module& m) {
py::class_<ResourcesManager, LIEF::Object>(m, "ResourcesManager",
"The Resource Manager provides an enhanced API to manipulate the resource tree")
@ -115,4 +119,6 @@ void init_PE_ResourcesManager_class(py::module& m) {
return str;
});
}
}
}

11
api/python/PE/objects/pyRichEntry.cpp
View File

@ -21,13 +21,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (RichEntry::*)(void) const;
template<class T>
using setter_t = void (RichEntry::*)(T);
void init_PE_RichEntry_class(py::module& m) {
template<>
void create<RichEntry>(py::module& m) {
py::class_<RichEntry, LIEF::Object>(m, "RichEntry")
.def(py::init<>())
.def(py::init<uint16_t, uint16_t, uint32_t>(),
@ -66,7 +71,7 @@ void init_PE_RichEntry_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

11
api/python/PE/objects/pyRichHeader.cpp
View File

@ -21,6 +21,9 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (RichHeader::*)(void) const;
@ -30,7 +33,9 @@ using setter_t = void (RichHeader::*)(T);
template<class T>
using no_const_getter = T (RichHeader::*)(void);
void init_PE_RichHeader_class(py::module& m) {
template<>
void create<RichHeader>(py::module& m) {
py::class_<RichHeader>(m, "RichHeader")
.def(py::init<>())
.def_property("key",
@ -70,7 +75,7 @@ void init_PE_RichHeader_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/pySection.cpp
View File

@ -22,13 +22,18 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (Section::*)(void) const;
template<class T>
using setter_t = void (Section::*)(T);
void init_PE_Section_class(py::module& m) {
template<>
void create<Section>(py::module& m) {
py::class_<Section, LIEF::Section>(m, "Section")
.def(py::init<>())
.def(py::init<const std::vector<uint8_t>&, const std::string&, uint32_t>(),
@ -119,6 +124,7 @@ void init_PE_Section_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/pySymbol.cpp
View File

@ -21,6 +21,9 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (Symbol::*)(void) const;
@ -30,7 +33,9 @@ using setter_t = void (Symbol::*)(T);
template<class T>
using no_const_getter = T (Symbol::*)(void);
void init_PE_Symbol_class(py::module& m) {
template<>
void create<Symbol>(py::module& m) {
py::class_<Symbol, LIEF::Symbol>(m, "Symbol")
.def(py::init<>())
@ -82,6 +87,7 @@ void init_PE_Symbol_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/pyTLS.cpp
View File

@ -21,6 +21,9 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (TLS::*)(void) const;
@ -30,7 +33,9 @@ using setter_t = void (TLS::*)(T);
template<class T>
using no_const_getter = T (TLS::*)(void);
void init_PE_TLS_class(py::module& m) {
template<>
void create<TLS>(py::module& m) {
py::class_<TLS, LIEF::Object>(m, "TLS")
.def(py::init<>(),
"Default constructor")
@ -124,6 +129,7 @@ void init_PE_TLS_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

10
api/python/PE/objects/resources/pyLangCodeItem.cpp
View File

@ -22,13 +22,18 @@
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (LangCodeItem::*)(void) const;
template<class T>
using setter_t = void (LangCodeItem::*)(T);
void init_PE_LangCodeItem_class(py::module& m) {
template<>
void create<LangCodeItem>(py::module& m) {
py::class_<LangCodeItem, LIEF::Object>(m, "LangCodeItem",
"Class which modelize the childs of the " RST_CLASS_REF(lief.PE.ResourceStringFileInfo) "\n\n"
"See: https://msdn.microsoft.com/fr-fr/library/windows/desktop/ms646992(v=vs.85).aspx")
@ -89,3 +94,6 @@ void init_PE_LangCodeItem_class(py::module& m) {
});
}
}
}

10
api/python/PE/objects/resources/pyResourceDialog.cpp
View File

@ -22,13 +22,18 @@
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ResourceDialog::*)(void) const;
template<class T>
using setter_t = void (ResourceDialog::*)(T);
void init_PE_ResourcesDialog_class(py::module& m) {
template<>
void create<ResourceDialog>(py::module& m) {
py::class_<ResourceDialog, LIEF::Object>(m, "ResourceDialog")
.def_property_readonly("is_extended",
@ -156,3 +161,6 @@ void init_PE_ResourcesDialog_class(py::module& m) {
});
}
}
}

9
api/python/PE/objects/resources/pyResourceDialogItem.cpp
View File

@ -21,6 +21,8 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ResourceDialogItem::*)(void) const;
@ -28,7 +30,9 @@ using getter_t = T (ResourceDialogItem::*)(void) const;
template<class T>
using setter_t = void (ResourceDialogItem::*)(T);
void init_PE_ResourcesDialogItem_class(py::module& m) {
template<>
void create<ResourceDialogItem>(py::module& m) {
py::class_<ResourceDialogItem, LIEF::Object>(m, "ResourceDialogItem")
.def_property_readonly("is_extended",
@ -89,3 +93,6 @@ void init_PE_ResourcesDialogItem_class(py::module& m) {
});
}
}
}

10
api/python/PE/objects/resources/pyResourceFixedFileInfo.cpp
View File

@ -22,13 +22,18 @@
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ResourceFixedFileInfo::*)(void) const;
template<class T>
using setter_t = void (ResourceFixedFileInfo::*)(T);
void init_PE_ResourceFixedFileInfo_class(py::module& m) {
template<>
void create<ResourceFixedFileInfo>(py::module& m) {
py::class_<ResourceFixedFileInfo, LIEF::Object>(m, "ResourceFixedFileInfo",
"Modelization of the `VS_FIXEDFILEINFO <https://msdn.microsoft.com/en-us/library/windows/desktop/ms646997(v=vs.85).aspx>`_")
@ -126,3 +131,6 @@ void init_PE_ResourceFixedFileInfo_class(py::module& m) {
});
}
}
}

9
api/python/PE/objects/resources/pyResourceIcon.cpp
View File

@ -21,6 +21,8 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ResourceIcon::*)(void) const;
@ -28,7 +30,9 @@ using getter_t = T (ResourceIcon::*)(void) const;
template<class T>
using setter_t = void (ResourceIcon::*)(T);
void init_PE_ResourcesIcon_class(py::module& m) {
template<>
void create<ResourceIcon>(py::module& m) {
py::class_<ResourceIcon, LIEF::Object>(m, "ResourceIcon")
.def(py::init<const std::string&>(),
"Constructor that takes a icon path as input",
@ -104,3 +108,6 @@ void init_PE_ResourcesIcon_class(py::module& m) {
});
}
}
}

9
api/python/PE/objects/resources/pyResourceStringFileInfo.cpp
View File

@ -21,6 +21,8 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ResourceStringFileInfo::*)(void) const;
@ -28,7 +30,9 @@ using getter_t = T (ResourceStringFileInfo::*)(void) const;
template<class T>
using setter_t = void (ResourceStringFileInfo::*)(T);
void init_PE_ResourceStringFileInfo_class(py::module& m) {
template<>
void create<ResourceStringFileInfo>(py::module& m) {
py::class_<ResourceStringFileInfo, LIEF::Object>(m, "ResourceStringFileInfo",
"Modelization of the ``StringFileInfo`` structure\n\n"
"See: https://msdn.microsoft.com/fr-fr/library/windows/desktop/ms646989(v=vs.85).aspx")
@ -69,3 +73,6 @@ void init_PE_ResourceStringFileInfo_class(py::module& m) {
});
}
}
}

9
api/python/PE/objects/resources/pyResourceVarFileInfo.cpp
View File

@ -21,6 +21,8 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ResourceVarFileInfo::*)(void) const;
@ -28,7 +30,9 @@ using getter_t = T (ResourceVarFileInfo::*)(void) const;
template<class T>
using setter_t = void (ResourceVarFileInfo::*)(T);
void init_PE_ResourceVarFileInfo_class(py::module& m) {
template<>
void create<ResourceVarFileInfo>(py::module& m) {
py::class_<ResourceVarFileInfo, LIEF::Object>(m, "ResourceVarFileInfo",
"This object describes information about languages supported by the application")
@ -69,3 +73,6 @@ void init_PE_ResourceVarFileInfo_class(py::module& m) {
});
}
}
}

9
api/python/PE/objects/resources/pyResourceVersion.cpp
View File

@ -21,6 +21,8 @@
#include <string>
#include <sstream>
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ResourceVersion::*)(void) const;
@ -28,7 +30,9 @@ using getter_t = T (ResourceVersion::*)(void) const;
template<class T>
using setter_t = void (ResourceVersion::*)(T);
void init_PE_ResourceVersion_class(py::module& m) {
template<>
void create<ResourceVersion>(py::module& m) {
py::class_<ResourceVersion, LIEF::Object>(m, "ResourceVersion",
"Modelization of the data associated with the ``RT_VERSION`` entry\n"
"See: `VS_VERSIONINFO <https://msdn.microsoft.com/en-us/library/windows/desktop/ms647001(v=vs.85).aspx>`_")
@ -104,3 +108,6 @@ void init_PE_ResourceVersion_class(py::module& m) {
});
}
}
}

9
api/python/PE/objects/signature/pyAuthenticatedAttributes.cpp
View File

@ -23,6 +23,8 @@
#include "pyPE.hpp"
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (AuthenticatedAttributes::*)(void) const;
@ -31,7 +33,8 @@ template<class T>
using setter_t = void (AuthenticatedAttributes::*)(T);
void init_PE_AuthenticatedAttributes_class(py::module& m) {
template<>
void create<AuthenticatedAttributes>(py::module& m) {
py::class_<AuthenticatedAttributes, LIEF::Object>(m, "AuthenticatedAttributes")
@ -63,6 +66,8 @@ void init_PE_AuthenticatedAttributes_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

9
api/python/PE/objects/signature/pyContentInfo.cpp
View File

@ -21,6 +21,8 @@
#include "pyPE.hpp"
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (ContentInfo::*)(void) const;
@ -29,7 +31,8 @@ template<class T>
using setter_t = void (ContentInfo::*)(T);
void init_PE_ContentInfo_class(py::module& m) {
template<>
void create<ContentInfo>(py::module& m) {
py::class_<ContentInfo, LIEF::Object>(m, "ContentInfo")
@ -58,6 +61,8 @@ void init_PE_ContentInfo_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

9
api/python/PE/objects/signature/pySignature.cpp
View File

@ -21,6 +21,8 @@
#include "pyPE.hpp"
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (Signature::*)(void) const;
@ -29,7 +31,8 @@ template<class T>
using setter_t = void (Signature::*)(T);
void init_PE_Signature_class(py::module& m) {
template<>
void create<Signature>(py::module& m) {
py::class_<Signature, LIEF::Object>(m, "Signature")
@ -73,6 +76,8 @@ void init_PE_Signature_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

8
api/python/PE/objects/signature/pySignerInfo.cpp
View File

@ -21,6 +21,8 @@
#include "pyPE.hpp"
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (SignerInfo::*)(void) const;
@ -29,7 +31,8 @@ template<class T>
using setter_t = void (SignerInfo::*)(T);
void init_PE_SignerInfo_class(py::module& m) {
template<>
void create<SignerInfo>(py::module& m) {
py::class_<SignerInfo, LIEF::Object>(m, "SignerInfo")
@ -70,3 +73,6 @@ void init_PE_SignerInfo_class(py::module& m) {
}
}
}

9
api/python/PE/objects/signature/pyx509.cpp
View File

@ -21,6 +21,8 @@
#include "pyPE.hpp"
namespace LIEF {
namespace PE {
template<class T>
using getter_t = T (x509::*)(void) const;
@ -29,7 +31,8 @@ template<class T>
using setter_t = void (x509::*)(T);
void init_PE_x509_class(py::module& m) {
template<>
void create<x509>(py::module& m) {
py::class_<x509, LIEF::Object>(m, "x509")
@ -78,6 +81,8 @@ void init_PE_x509_class(py::module& m) {
std::string str = stream.str();
return str;
});
}
}
}

8
api/python/PE/pyPEStructures.cpp → api/python/PE/pyEnums.cpp
View File

@ -20,8 +20,11 @@
#define PY_ENUM(x) LIEF::PE::to_string(x), x
namespace LIEF {
namespace PE {
void init_PE_Structures_enum(py::module& m) {
void init_enums(py::module& m) {
LIEF::enum_<LIEF::PE::PE_TYPE>(m, "PE_TYPE")
.value(PY_ENUM(LIEF::PE::PE_TYPE::PE32))
@ -904,3 +907,6 @@ void init_PE_Structures_enum(py::module& m) {
.value(PY_ENUM(LIEF::PE::CODE_VIEW_SIGNATURES::CVS_CV_50))
.value(PY_ENUM(LIEF::PE::CODE_VIEW_SIGNATURES::CVS_CV_41));
}
}
}

122
api/python/PE/pyPE.cpp
View File

@ -17,72 +17,78 @@
#include "pyPE.hpp"
//
// PE modules
//
void init_PE_module(py::module& m) {
namespace LIEF {
namespace PE {
void init_python_module(py::module& m) {
py::module LIEF_PE_module = m.def_submodule("PE", "Python API for PE");
init_enums(LIEF_PE_module);
init_objects(LIEF_PE_module);
init_utils(LIEF_PE_module);
LIEF_PE_module.def("oid_to_string",
&oid_to_string,
"Convert an OID to a human-readable string");
// Enums
init_PE_Structures_enum(LIEF_PE_module);
// utils
init_PE_utils(LIEF_PE_module);
// Objects
init_PE_Parser_class(LIEF_PE_module);
init_PE_Binary_class(LIEF_PE_module);
init_PE_DataDirectory_class(LIEF_PE_module);
init_PE_Header_class(LIEF_PE_module);
init_PE_DosHeader_class(LIEF_PE_module);
init_PE_RichHeader_class(LIEF_PE_module);
init_PE_RichEntry_class(LIEF_PE_module);
init_PE_OptionalHeader_class(LIEF_PE_module);
init_PE_Section_class(LIEF_PE_module);
init_PE_Import_class(LIEF_PE_module);
init_PE_ImportEntry_class(LIEF_PE_module);
init_PE_TLS_class(LIEF_PE_module);
init_PE_Symbol_class(LIEF_PE_module);
init_PE_Relocation_class(LIEF_PE_module);
init_PE_RelocationEntry_class(LIEF_PE_module);
init_PE_Export_class(LIEF_PE_module);
init_PE_ExportEntry_class(LIEF_PE_module);
init_PE_Builder_class(LIEF_PE_module);
init_PE_Debug_class(LIEF_PE_module);
init_PE_CodeView_class(LIEF_PE_module);
init_PE_CodeViewPDB_class(LIEF_PE_module);
init_PE_CodeIntegrity_class(LIEF_PE_module);
init_PE_load_configurations(LIEF_PE_module);
init_PE_Signature_class(LIEF_PE_module);
init_PE_ContentInfo_class(LIEF_PE_module);
init_PE_x509_class(LIEF_PE_module);
init_PE_SignerInfo_class(LIEF_PE_module);
init_PE_AuthenticatedAttributes_class(LIEF_PE_module);
init_PE_ResourceNode_class(LIEF_PE_module);
init_PE_ResourceData_class(LIEF_PE_module);
init_PE_ResourceDirectory_class(LIEF_PE_module);
init_PE_ResourcesIcon_class(LIEF_PE_module);
init_PE_ResourceVersion_class(LIEF_PE_module);
init_PE_ResourceFixedFileInfo_class(LIEF_PE_module);
init_PE_ResourceVarFileInfo_class(LIEF_PE_module);
init_PE_ResourceStringFileInfo_class(LIEF_PE_module);
init_PE_LangCodeItem_class(LIEF_PE_module);
init_PE_ResourcesDialog_class(LIEF_PE_module);
init_PE_ResourcesDialogItem_class(LIEF_PE_module);
init_PE_ResourcesManager_class(LIEF_PE_module);
// Opaque containers
py::bind_vector<std::vector<LangCodeItem>>(m, "ListLangCodeItem");
py::bind_map<dict_langcode_item>(m, "DictStringVersion");
}
void init_objects(py::module& m) {
CREATE(Parser, m);
CREATE(Binary, m);
CREATE(DosHeader, m);
CREATE(Header, m);
CREATE(OptionalHeader, m);
CREATE(RichHeader, m);
CREATE(RichEntry, m);
CREATE(DataDirectory, m);
CREATE(Section, m);
CREATE(Relocation, m);
CREATE(RelocationEntry, m);
CREATE(Export, m);
CREATE(ExportEntry, m);
CREATE(TLS, m);
CREATE(Symbol, m);
CREATE(Debug, m);
CREATE(CodeView, m);
CREATE(CodeViewPDB, m);
CREATE(Import, m);
CREATE(ImportEntry, m);
CREATE(ResourcesManager, m);
CREATE(ResourceNode, m);
CREATE(ResourceData, m);
CREATE(ResourceDirectory, m);
CREATE(ResourceVersion, m);
CREATE(ResourceStringFileInfo, m);
CREATE(ResourceFixedFileInfo, m);
CREATE(ResourceVarFileInfo, m);
CREATE(LangCodeItem, m);
CREATE(ResourceIcon, m);
CREATE(ResourceDialog, m);
CREATE(ResourceDialogItem, m);
CREATE(Signature, m);
CREATE(x509, m);
CREATE(SignerInfo, m);
CREATE(ContentInfo, m);
CREATE(AuthenticatedAttributes, m);
CREATE(CodeIntegrity, m);
CREATE(LoadConfiguration, m);
CREATE(LoadConfigurationV0, m);
CREATE(LoadConfigurationV1, m);
CREATE(LoadConfigurationV2, m);
CREATE(LoadConfigurationV3, m);
CREATE(LoadConfigurationV4, m);
CREATE(LoadConfigurationV5, m);
CREATE(LoadConfigurationV6, m);
CREATE(LoadConfigurationV7, m);
}
}
}

123
api/python/PE/pyPE.hpp
View File

@ -16,7 +16,9 @@
#ifndef PY_LIEF_PE_H_
#define PY_LIEF_PE_H_
#include <pybind11/pybind11.h>
#include <pybind11/stl_bind.h>
#include <map>
#include <string>
@ -24,76 +26,81 @@
#include "pyLIEF.hpp"
using namespace LIEF::PE;
#define SPECIALIZE_CREATE(X) \
template<> \
void create<X>(py::module&)
// utils
void init_PE_utils(py::module&);
#define CREATE(X,Y) create<X>(Y)
void init_PE_Parser_class(py::module&);
void init_PE_Binary_class(py::module&);
void init_PE_DataDirectory_class(py::module&);
void init_PE_Header_class(py::module&);
void init_PE_DosHeader_class(py::module&);
void init_PE_RichHeader_class(py::module&);
void init_PE_RichEntry_class(py::module&);
void init_PE_Section_class(py::module&);
void init_PE_OptionalHeader_class(py::module&);
void init_PE_Import_class(py::module&);
void init_PE_ImportEntry_class(py::module&);
void init_PE_TLS_class(py::module&);
void init_PE_Symbol_class(py::module&);
void init_PE_Relocation_class(py::module&);
void init_PE_RelocationEntry_class(py::module&);
void init_PE_Export_class(py::module&);
void init_PE_ExportEntry_class(py::module&);
void init_PE_Builder_class(py::module&);
void init_PE_Debug_class(py::module&);
void init_PE_CodeView_class(py::module&);
void init_PE_CodeViewPDB_class(py::module&);
void init_PE_CodeIntegrity_class(py::module&);
void init_PE_load_configurations(py::module&);
namespace LIEF {
namespace PE {
void init_PE_Signature_class(py::module&);
void init_PE_ContentInfo_class(py::module&);
void init_PE_x509_class(py::module&);
void init_PE_SignerInfo_class(py::module&);
void init_PE_AuthenticatedAttributes_class(py::module&);
template<class T>
void create(py::module&);
void init_PE_ResourceNode_class(py::module&);
void init_PE_ResourceData_class(py::module&);
void init_PE_ResourceDirectory_class(py::module&);
void init_python_module(py::module& m);
void init_objects(py::module&);
void init_enums(py::module&);
void init_utils(py::module&);
void init_PE_ResourcesIcon_class(py::module&);
SPECIALIZE_CREATE(Parser);
void init_PE_ResourceVersion_class(py::module&);
void init_PE_ResourceFixedFileInfo_class(py::module&);
void init_PE_ResourceVarFileInfo_class(py::module&);
void init_PE_ResourceStringFileInfo_class(py::module&);
void init_PE_LangCodeItem_class(py::module&);
SPECIALIZE_CREATE(Binary);
SPECIALIZE_CREATE(DosHeader);
SPECIALIZE_CREATE(Header);
SPECIALIZE_CREATE(OptionalHeader);
SPECIALIZE_CREATE(RichHeader);
SPECIALIZE_CREATE(RichEntry);
SPECIALIZE_CREATE(DataDirectory);
SPECIALIZE_CREATE(Section);
SPECIALIZE_CREATE(Relocation);
SPECIALIZE_CREATE(RelocationEntry);
SPECIALIZE_CREATE(Export);
SPECIALIZE_CREATE(ExportEntry);
SPECIALIZE_CREATE(TLS);
SPECIALIZE_CREATE(Symbol);
SPECIALIZE_CREATE(Debug);
SPECIALIZE_CREATE(CodeView);
SPECIALIZE_CREATE(CodeViewPDB);
SPECIALIZE_CREATE(Import);
SPECIALIZE_CREATE(ImportEntry);
SPECIALIZE_CREATE(ResourceNode);
SPECIALIZE_CREATE(ResourceData);
SPECIALIZE_CREATE(ResourceDirectory);
SPECIALIZE_CREATE(ResourcesManager);
SPECIALIZE_CREATE(ResourceVersion);
SPECIALIZE_CREATE(ResourceStringFileInfo);
SPECIALIZE_CREATE(ResourceFixedFileInfo);
SPECIALIZE_CREATE(ResourceVarFileInfo);
SPECIALIZE_CREATE(LangCodeItem);
SPECIALIZE_CREATE(ResourceIcon);
SPECIALIZE_CREATE(ResourceDialog);
SPECIALIZE_CREATE(ResourceDialogItem);
SPECIALIZE_CREATE(Signature);
SPECIALIZE_CREATE(x509);
SPECIALIZE_CREATE(SignerInfo);
SPECIALIZE_CREATE(ContentInfo);
SPECIALIZE_CREATE(AuthenticatedAttributes);
SPECIALIZE_CREATE(CodeIntegrity);
void init_PE_ResourcesDialog_class(py::module&);
void init_PE_ResourcesDialogItem_class(py::module&);
SPECIALIZE_CREATE(LoadConfiguration);
SPECIALIZE_CREATE(LoadConfigurationV0);
SPECIALIZE_CREATE(LoadConfigurationV1);
SPECIALIZE_CREATE(LoadConfigurationV2);
SPECIALIZE_CREATE(LoadConfigurationV3);
SPECIALIZE_CREATE(LoadConfigurationV4);
SPECIALIZE_CREATE(LoadConfigurationV5);
SPECIALIZE_CREATE(LoadConfigurationV6);
SPECIALIZE_CREATE(LoadConfigurationV7);
void init_PE_ResourcesManager_class(py::module&);
SPECIALIZE_CREATE(ResourcesManager);
// Enums
void init_PE_Structures_enum(py::module&);
// Load Configurations
void init_PE_LoadConfiguration_class(py::module&);
void init_PE_LoadConfigurationV0_class(py::module&);
void init_PE_LoadConfigurationV1_class(py::module&);
void init_PE_LoadConfigurationV2_class(py::module&);
void init_PE_LoadConfigurationV3_class(py::module&);
void init_PE_LoadConfigurationV4_class(py::module&);
void init_PE_LoadConfigurationV5_class(py::module&);
void init_PE_LoadConfigurationV6_class(py::module&);
void init_PE_LoadConfigurationV7_class(py::module&);
}
}
// Opaque containers
PYBIND11_MAKE_OPAQUE(std::vector<LangCodeItem>)
PYBIND11_MAKE_OPAQUE(std::vector<LIEF::PE::LangCodeItem>)
using dict_langcode_item = std::map<std::u16string, std::u16string>;
PYBIND11_MAKE_OPAQUE(dict_langcode_item)

9
api/python/PE/pyUtils.cpp
View File

@ -17,7 +17,11 @@
#include "LIEF/PE/utils.hpp"
void init_PE_utils(py::module& m) {
namespace LIEF {
namespace PE {
void init_utils(py::module& m) {
m.def("is_pe",
@ -63,3 +67,6 @@ void init_PE_utils(py::module& m) {
"import"_a, "strict"_a = false,
py::return_value_policy::copy);
}
}
}

13
api/python/pyLIEF.cpp
View File

@ -21,6 +21,14 @@
#include "ELF/pyELF.hpp"
#endif
#if defined(LIEF_PE_SUPPORT)
#include "PE/pyPE.hpp"
#endif
#if defined(LIEF_MACHO_SUPPORT)
#include "MachO/pyMachO.hpp"
#endif
#if defined(LIEF_OAT_SUPPORT)
#include "OAT/pyOAT.hpp"
#endif
@ -68,15 +76,14 @@ PYBIND11_MODULE(_pylief, LIEF_module) {
// Init the PE module
#if defined(LIEF_PE_SUPPORT)
init_PE_module(LIEF_module);
LIEF::PE::init_python_module(LIEF_module);
#endif
// Init the MachO module
#if defined(LIEF_MACHO_SUPPORT)
init_MachO_module(LIEF_module);
LIEF::MachO::init_python_module(LIEF_module);
#endif
// Init the OAT module
#if defined(LIEF_OAT_SUPPORT)
LIEF::OAT::init_python_module(LIEF_module);

6
api/python/pyLIEF.hpp
View File

@ -43,12 +43,6 @@ void init_LIEF_exceptions(py::module&);
void init_LIEF_module(py::module&);
void init_hash_functions(py::module&);
#if defined(LIEF_PE_SUPPORT)
void init_PE_module(py::module&);
#endif
#if defined(LIEF_MACHO_SUPPORT)
void init_MachO_module(py::module&);
#endif
void init_utils_functions(py::module&);