Code : Tout sélectionner
#EI_MAG0=0
#ELFMAG0=$7F
#EI_MAG1=1
#ELFMAG1='E'
#EI_MAG2=2
#ELFMAG2='L'
#EI_MAG3=3
#ELFMAG3='F'
; e_type
#ET_NONE=0
#ET_REL=1
#ET_EXEC=2
#ET_DYN=3
#ET_CORE=4
#ET_NUM=5
#ET_LOPROC=$FF
#ET_HIPROC=$FFFF
;e_machine
#EM_NONE=0
#EM_M32=1
#EM_SPARC=2
#EM_386=3
#EM_68K=4
#EM_88K=5
#EM_486=6
#EM_860=7
#EM_MIPS=8
;e_version
#EV_NONE=0
#EV_CURRENT=1
#EV_NUM=2
; Segment types - p_type
#PT_NULL=0
#PT_LOAD=1
#PT_DYNAMIC=2
#PT_INTERP=3
#PT_NOTE=4
#PT_SHLIB=5
#PT_PHDR=6
#PT_NUM=7
#PT_LOOS=$60000000
#PT_HIOS=$6fffffff
#PT_LOPROC=$70000000
#PT_HIPROC=$7fffffff
;Segment flags - p_flags
#PF_X=$1
#PF_W=$2
#PF_R=$4
#PF_MASKPROC=$f0000000
; Special Section Indexes
#SHN_UNDEF=0
#SHN_LORESERVE=$ff00
#SHN_LOPROC=$ff00
#SHN_HIPROC=$ff1f
#SHN_ABS=$fff1
#SHN_COMMON=$fff2
#SHN_HIRESERVE=$ffff
; sh_type
#SHT_NULL=0
#SHT_PROGBITS=1
#SHT_SYMTAB=2
#SHT_STRTAB=3
#SHT_RELA=4
#SHT_HASH=5
#SHT_DYNAMIC=6
#SHT_NOTE=7
#SHT_NOBITS=8
#SHT_REL=9
#SHT_SHLIB=10
#SHT_DYNSYM=11
#SHT_NUM=12
#SHT_LOPROC=$70000000
#SHT_HIPROC=$7fffffff
#SHT_LOUSER=$80000000
#SHT_HIUSER=$ffffffff
#EI_NIDENT = 16
Structure Elf32_Ehdr
e_ident.c[#EI_NIDENT]
e_type.w
e_machine.w
e_version.l
e_entry.l
e_phoff.l
e_shoff.l
e_flags.l
e_ehsize.w
e_phentsize.w
e_phnum.w
e_shentsize.w
e_shnum.w
e_shstrndx.w
EndStructure
Structure Elf32_Phdr
p_type.l
p_offset.l
p_vaddr.l
p_paddr.l
p_filesz.l
p_memsz.l
p_flags.l
p_align.l
EndStructure
Structure Elf32_Shdr
sh_name.l
sh_type.l
sh_flags.l
sh_addr.l
sh_offset.l
sh_size.l
sh_link.l
sh_info.l
sh_addralign.l
sh_entsize.l
EndStructure
Procedure.c Get_Elf32_Ehdr_e_ident(*Memory.Elf32_Ehdr,index)
ProcedureReturn *Memory\e_ident[index]
EndProcedure
Procedure.w Get_Elf32_Ehdr_e_type(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_type
EndProcedure
Procedure.w Get_Elf32_Ehdr_e_machine(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_machine
EndProcedure
Procedure Get_Elf32_Ehdr_e_version(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_version
EndProcedure
Procedure Get_Elf32_Ehdr_e_entry(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_entry & 255
EndProcedure
Procedure Get_Elf32_Ehdr_e_phoff(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_phoff
EndProcedure
Procedure Get_Elf32_Ehdr_e_shoff(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_shoff
EndProcedure
Procedure Get_Elf32_Ehdr_e_flags(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_flags & 255
EndProcedure
Procedure.w Get_Elf32_Ehdr_e_ehsize(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_ehsize
EndProcedure
Procedure.w Get_Elf32_Ehdr_e_phentsize(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_phentsize
EndProcedure
Procedure.w Get_Elf32_Ehdr_e_phnum(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_phnum
EndProcedure
Procedure.w Get_Elf32_Ehdr_e_shentsize(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_shentsize
EndProcedure
Procedure.w Get_Elf32_Ehdr_e_shnum(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_shnum
EndProcedure
Procedure.w Get_Elf32_Ehdr_e_shstrndx(*Memory.Elf32_Ehdr)
ProcedureReturn *Memory\e_shstrndx
EndProcedure
Procedure Set_Elf32_Ehdr_e_ident(*Memory.Elf32_Ehdr,index , value.c )
*Memory\e_ident[index] = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_type(*Memory.Elf32_Ehdr , value.w )
*Memory\e_type = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_machine(*Memory.Elf32_Ehdr , value.w )
*Memory\e_machine = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_version(*Memory.Elf32_Ehdr , value )
*Memory\e_version = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_entry(*Memory.Elf32_Ehdr , value )
*Memory\e_entry
EndProcedure
Procedure Set_Elf32_Ehdr_e_phoff(*Memory.Elf32_Ehdr , value )
*Memory\e_phoff = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_shoff(*Memory.Elf32_Ehdr , value )
*Memory\e_shoff = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_flags(*Memory.Elf32_Ehdr , value )
*Memory\e_flags = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_ehsize(*Memory.Elf32_Ehdr , value.w )
*Memory\e_ehsize = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_phentsize(*Memory.Elf32_Ehdr , value.w )
*Memory\e_phentsize = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_phnum(*Memory.Elf32_Ehdr , value.w )
*Memory\e_phnum = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_shentsize(*Memory.Elf32_Ehdr , value.w )
*Memory\e_shentsize = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_shnum(*Memory.Elf32_Ehdr , value.w )
*Memory\e_shnum = value
EndProcedure
Procedure Set_Elf32_Ehdr_e_shstrndx(*Memory.Elf32_Ehdr , value )
*Memory\e_shstrndx = value
EndProcedure
Procedure Get_Elf32_Phdr_p_type(*Memory.Elf32_Phdr)
ProcedureReturn *Memory\p_type
EndProcedure
Procedure Get_Elf32_Phdr_p_offset(*Memory.Elf32_Phdr)
ProcedureReturn *Memory\p_offset
EndProcedure
Procedure Get_Elf32_Phdr_p_vaddr(*Memory.Elf32_Phdr)
ProcedureReturn *Memory\p_vaddr & 255
EndProcedure
Procedure Get_Elf32_Phdr_p_paddr(*Memory.Elf32_Phdr)
ProcedureReturn *Memory\p_paddr & 255
EndProcedure
Procedure Get_Elf32_Phdr_p_filesz(*Memory.Elf32_Phdr)
ProcedureReturn *Memory\p_filesz
EndProcedure
Procedure Get_Elf32_Phdr_p_memsz(*Memory.Elf32_Phdr)
ProcedureReturn *Memory\p_memsz
EndProcedure
Procedure Get_Elf32_Phdr_p_flags(*Memory.Elf32_Phdr)
ProcedureReturn *Memory\p_flags
EndProcedure
Procedure Get_Elf32_Phdr_p_align(*Memory.Elf32_Phdr)
ProcedureReturn *Memory\p_align
EndProcedure
Procedure Set__Elf32_Phdr_p_type(*Memory.Elf32_Phdr , value )
*Memory\p_type = Value
EndProcedure
Procedure Set_Elf32_Phdr_p_offset(*Memory.Elf32_Phdr , value )
*Memory\p_offset = Value
EndProcedure
Procedure Set_Elf32_Phdr_p_vaddr(*Memory.Elf32_Phdr , value )
*Memory\p_vaddr = Value
EndProcedure
Procedure Set_Elf32_Phdr_p_paddr(*Memory.Elf32_Phdr , value )
*Memory\p_paddr = Value
EndProcedure
Procedure Set_Elf32_Phdr_p_filesz(*Memory.Elf32_Phdr , value )
*Memory\p_filesz = Value
EndProcedure
Procedure Set_Elf32_Phdr_p_memsz(*Memory.Elf32_Phdr , value )
*Memory\p_memsz = Value
EndProcedure
Procedure Set_Elf32_Phdr_p_flags(*Memory.Elf32_Phdr , value )
*Memory\p_flags = Value
EndProcedure
Procedure Set_Elf32_Phdr_p_align(*Memory.Elf32_Phdr , value )
*Memory\p_align = Value
EndProcedure
Procedure Get_Elf32_Shdr_sh_name(*Memory.Elf32_Shdr)
ProcedureReturn *Memory\sh_name & 255
EndProcedure
Procedure Get_Elf32_Shdr_sh_type(*Memory.Elf32_Shdr)
ProcedureReturn *Memory\sh_type & 255
EndProcedure
Procedure Get_Elf32_Shdr_sh_flags(*Memory.Elf32_Shdr)
ProcedureReturn *Memory\sh_flags & 255
EndProcedure
Procedure Get_Elf32_Shdr_sh_addr(*Memory.Elf32_Shdr)
ProcedureReturn *Memory\sh_addr & 255
EndProcedure
Procedure Get_Elf32_Shdr_sh_offset(*Memory.Elf32_Shdr)
ProcedureReturn *Memory\sh_offset
EndProcedure
Procedure Get_Elf32_Shdr_sh_size(*Memory.Elf32_Shdr)
ProcedureReturn *Memory\sh_size & 255
EndProcedure
Procedure Get_Elf32_Shdr_sh_link(*Memory.Elf32_Shdr)
ProcedureReturn *Memory\sh_link & 255
EndProcedure
Procedure Get_Elf32_Shdr_sh_info(*Memory.Elf32_Shdr)
ProcedureReturn *Memory\sh_info & 255
EndProcedure
Procedure Get_Elf32_Shdr_sh_addralign(*Memory.Elf32_Shdr)
ProcedureReturn *Memory\sh_addralign & 255
EndProcedure
Procedure Get_Elf32_Shdr_sh_entsize(*Memory.Elf32_Shdr)
ProcedureReturn *Memory\sh_entsize & 255
EndProcedure
Procedure Set_Elf32_Shdr_sh_name(*Memory.Elf32_Shdr , Value )
*Memory\sh_name = Value
EndProcedure
Procedure Set_Elf32_Shdr_sh_type(*Memory.Elf32_Shdr , Value )
*Memory\sh_type = Value
EndProcedure
Procedure Set_Elf32_Shdr_sh_flags(*Memory.Elf32_Shdr , Value )
*Memory\sh_flags = Value
EndProcedure
Procedure Set_Elf32_Shdr_sh_addr(*Memory.Elf32_Shdr , Value )
*Memory\sh_addr = Value
EndProcedure
Procedure Set_Elf32_Shdr_sh_offset(*Memory.Elf32_Shdr , Value )
*Memory\sh_offset = Value
EndProcedure
Procedure Set_Elf32_Shdr_sh_size(*Memory.Elf32_Shdr , Value )
*Memory\sh_size = Value
EndProcedure
Procedure Set_Elf32_Shdr_sh_link(*Memory.Elf32_Shdr , Value )
*Memory\sh_link = Value
EndProcedure
Procedure Set_Elf32_Shdr_sh_info(*Memory.Elf32_Shdr , Value )
*Memory\sh_info = Value
EndProcedure
Procedure Set_Elf32_Shdr_sh_addralign(*Memory.Elf32_Shdr , Value )
*Memory\sh_addralign = Value
EndProcedure
Procedure Set_Elf32_Shdr_sh_entsize(*Memory.Elf32_Shdr , Value )
*Memory\sh_entsize = Value
EndProcedure
avec un petit programme d'exemple :
Code : Tout sélectionner
IncludeFile "Header_Elf32.pbi"
#GADGET_OUT = 1
#FILE_OUT = 1
#OUT_STD=0
#OUT_FILE=1
#OUT_MEMORY=2
Global *MemoryString = AllocateMemory(4*10000)
Global OffSetString
; DeleteFile("./Out.txt")
; OpenFile(#OUT_FILE,"./Out.txt")
OpenWindow(0,0,0,1024,768,"")
EditorGadget(#GADGET_OUT,5,5,1024-10,768-10)
#STD_OUT = #OUT_MEMORY
Procedure PrintN_EX(Message$)
Select #STD_OUT
Case #OUT_STD
PrintN(Message$)
Case #OUT_FILE
WriteStringN(#FILE_OUT,Message$)
Case #OUT_MEMORY
PokeS(*MemoryString+OffSetString,Message$+#CRLF$)
OffSetString + Len(Message$+#CRLF$)
EndSelect
EndProcedure
Procedure Print_EX(Message$)
Select #STD_OUT
Case #OUT_STD
Print(Message$)
Case #OUT_FILE
WriteString(#FILE_OUT,Message$)
Case #OUT_MEMORY
PokeS(*MemoryString+OffSetString,Message$)
OffSetString + Len(Message$)
EndSelect
EndProcedure
Procedure Message(Title$,Context$)
Print_EX(LSet(Title$+" : ",50,"."))
PrintN_EX(" "+Context$)
EndProcedure
Procedure.s ExtractStringTable(*Memory,Offset,Size)
For i = *Memory + Offset To *Memory + Offset + Size
Ascii.c = PeekC(i)
If Ascii = #Null
Ascii = '#'
EndIf
String$ + Chr(Ascii)
Next
ProcedureReturn String$
EndProcedure
Procedure.s ExtractHexa(*Memory,Offset,Size)
For i = *Memory + Offset To *Memory + Offset + Size
Ascii.c = PeekC(i)
If Ascii = #Null
String$ + " 0x00 "
Else
String$ + " 0x"+Hex(Ascii)+" "
EndIf
Next
ProcedureReturn String$
EndProcedure
Procedure ReadELF(File$)
; Mise en mémoire du fichier ELF
OpenFile(0,File$)
If File$
*ElfFile = AllocateMemory(Lof(0))
ReadData(0,*ElfFile,Lof(0))
Else
ProcedureReturn -1
EndIf
; On fait une copie du Header ( 52 octets )
*Header.Elf32_Ehdr = AllocateMemory(SizeOf(Elf32_Ehdr))
CopyMemory(*ElfFile,*Header,SizeOf(Elf32_Ehdr))
; Lecture des 4 premier bytes
If Get_Elf32_Ehdr_e_ident(*Header,#EI_MAG0)<>#ELFMAG0 And Get_Elf32_Ehdr_e_ident(*Header,#EI_MAG1)<>#ELFMAG1 And Get_Elf32_Ehdr_e_ident(*Header,#EI_MAG2)<>#ELFMAG2 And Get_Elf32_Ehdr_e_ident(*Header,#EI_MAG3)<>#ELFMAG3
Message("Error","Invalid ELF format")
ProcedureReturn -1
Else
Message(File$,"Valid ELF format")
EndIf
PrintN_EX("")
PrintN_EX("==========================================================================")
PrintN_EX("=======================[ELF HEADER INFORMATIONS]==========================")
PrintN_EX("==========================================================================")
PrintN_EX("")
; Lecture du type d'ELF
Select Get_Elf32_Ehdr_e_type(*Header)
Case #ET_NONE : Message("Ehdr_e_type","ET_NONE")
Case #ET_REL : Message("Ehdr_e_type","ET_REL")
Case #ET_EXEC : Message("Ehdr_e_type","ET_EXEC")
Case #ET_DYN : Message("Ehdr_e_type","ET_DYN")
Case #ET_CORE : Message("Ehdr_e_type","ET_CORE")
Case #ET_NUM : Message("Ehdr_e_type","ET_NUM")
Case #ET_LOPROC : Message("Ehdr_e_type","ET_LOPROC")
Case #ET_HIPROC : Message("Ehdr_e_type","ET_HIPROC")
EndSelect
; Lecture de la machine CIBLE
Select Get_Elf32_Ehdr_e_machine(*Header)
Case #EM_NONE : Message("Ehdr_e_machine","Unknown")
Case #EM_M32 : Message("Ehdr_e_machine","AT&T WE 32100")
Case #EM_SPARC : Message("Ehdr_e_machine","SPARC")
Case #EM_386 : Message("Ehdr_e_machine","i386")
Case #EM_68K : Message("Ehdr_e_machine","Motorola 68000")
Case #EM_88K : Message("Ehdr_e_machine","Motorola 88000")
Case #EM_486 : Message("Ehdr_e_machine","i486")
Case #EM_860 : Message("Ehdr_e_machine","i860")
Case #EM_MIPS : Message("Ehdr_e_machine","MIPS R3000 Big-Endian only")
EndSelect
;Version
Select Get_Elf32_Ehdr_e_version(*Header)
Case #EV_NONE : Message("Ehdr_e_version","EV_NONE")
Case #EV_CURRENT : Message("Ehdr_e_version","1")
Case #EV_NUM : Message("Ehdr_e_version","2")
EndSelect
e_entry = Get_Elf32_Ehdr_e_entry(*Header)
Message("Ehdr_e_entry",Str(e_entry))
e_phoff = Get_Elf32_Ehdr_e_phoff(*Header)
Message("Ehdr_e_phoff",Str(e_phoff))
e_shoff = Get_Elf32_Ehdr_e_shoff(*Header)
Message("Ehdr_e_shoff",Str(e_shoff))
e_flags = Get_Elf32_Ehdr_e_flags(*Header)
Message("Ehdr_e_flags",Str(e_flags))
e_ehsize = Get_Elf32_Ehdr_e_ehsize(*Header)
Message("Ehdr_e_ehsize",Str(e_ehsize))
e_phentsize = Get_Elf32_Ehdr_e_phentsize(*Header)
Message("Ehdr_e_phentsize",Str(e_phentsize))
e_phnum = Get_Elf32_Ehdr_e_phnum(*Header)
Message("Ehdr_e_phnum",Str(e_phnum))
e_shentsize = Get_Elf32_Ehdr_e_shentsize(*Header)
Message("Ehdr_e_shentsize",Str(e_shentsize))
e_shnum = Get_Elf32_Ehdr_e_shnum(*Header)
Message("Ehdr_e_shnum",Str(e_shnum))
e_shstrndx = Get_Elf32_Ehdr_e_shstrndx(*Header)
Message("Ehdr_e_shstrndx",Str(e_shstrndx))
PrintN_EX("")
PrintN_EX("==========================================================================")
PrintN_EX("============================[PROGRAM HEADER]==============================")
PrintN_EX("==========================================================================")
PrintN_EX("")
For i = 0 To e_phnum-1
Message("PROGRAM HEADER",Str(i))
Message("OFFSET","0x"+Hex(OffSet))
PrintN_EX("")
OffSet = e_phoff + ( i * e_phentsize)
*ProgramHeader.Elf32_Phdr = AllocateMemory(SizeOf(Elf32_Phdr))
CopyMemory(*ElfFile+OffSet,*ProgramHeader,e_phentsize)
p_type = Get_Elf32_Phdr_p_type(*ProgramHeader)
p_offset = Get_Elf32_Phdr_p_offset(*ProgramHeader)
p_vaddr = Get_Elf32_Phdr_p_vaddr(*ProgramHeader)
p_paddr = Get_Elf32_Phdr_p_paddr(*ProgramHeader)
p_filesz = Get_Elf32_Phdr_p_filesz(*ProgramHeader)
p_memsz = Get_Elf32_Phdr_p_memsz(*ProgramHeader)
p_flags = Get_Elf32_Phdr_p_flags(*ProgramHeader)
p_align = Get_Elf32_Phdr_p_align(*ProgramHeader)
Select p_type
Case #PT_NULL : Message("p_type","PT_NULL")
Case #PT_LOAD : Message("p_type","PT_LOAD")
Case #PT_DYNAMIC : Message("p_type","PT_DYNAMIC")
Case #PT_INTERP : Message("p_type","PT_INTERP")
Case #PT_NOTE : Message("p_type","PT_NOTE")
Case #PT_SHLIB : Message("p_type","PT_SHLIB")
Case #PT_PHDR : Message("p_type","PT_PHDR")
Case #PT_NUM : Message("p_type","PT_NUM")
Case #PT_LOOS : Message("p_type","PT_LOOS")
Case #PT_HIOS : Message("p_type","PT_HIOS")
Case #PT_LOPROC : Message("p_type","PT_LOPROC")
Case #PT_HIPROC : Message("p_type","PT_HIPROC")
EndSelect
Message("p_offset",Str(p_offset))
Message("p_vaddr", Str(p_vaddr ))
Message("p_paddr", Str(p_paddr ))
Message("p_filesz",Str(p_filesz))
Message("p_memsz", Str(p_memsz ))
Message("p_flags", Str(p_flags ))
Message("p_align", Str(p_align ))
PrintN_EX("")
PrintN_EX("==========================================================================")
Next
If e_shnum > 0
PrintN_EX("")
PrintN_EX("==========================================================================")
PrintN_EX("============================[SECTION HEADER]==============================")
PrintN_EX("==========================================================================")
PrintN_EX("")
; On parcour les sections
For i = 0 To e_shnum-1
OffSet = e_shoff + ( i * e_shentsize)
*SectionHeader.Elf32_Shdr = AllocateMemory(SizeOf(Elf32_Shdr))
CopyMemory(*ElfFile+OffSet,*SectionHeader,e_shentsize)
Message("SECTION HEADER",Str(i))
Message("OFFSET","0x"+Hex(OffSet))
PrintN_EX("")
PrintN_EX("==========================================================================")
sh_name = Get_Elf32_Shdr_sh_name(*SectionHeader)
Message("sh_name",Str(sh_name))
sh_type = Get_Elf32_Shdr_sh_type(*SectionHeader)
Select sh_type
Case #SHT_NULL : Message("sh_type","Inactive")
Case #SHT_PROGBITS : Message("sh_type","Program defined information")
Case #SHT_SYMTAB : Message("sh_type","Symbol table")
Case #SHT_STRTAB : Message("sh_type","String table")
Case #SHT_RELA : Message("sh_type","Relocation with addends")
Case #SHT_HASH : Message("sh_type","Symbol hash table")
Case #SHT_DYNAMIC : Message("sh_type","Dynamic section")
Case #SHT_NOTE : Message("sh_type","Note section")
Case #SHT_NOBITS : Message("sh_type","No space section")
Case #SHT_REL : Message("sh_type","Relation whithout addends")
Case #SHT_SHLIB : Message("sh_type","Reserved")
Case #SHT_DYNSYM : Message("sh_type","Dynamic symbol table")
Case #SHT_NUM : Message("sh_type","Number of section types")
Case #SHT_LOPROC : Message("sh_type","Reserved range for processor")
Case #SHT_HIPROC : Message("sh_type","Specific section header types")
Case #SHT_LOUSER : Message("sh_type","Reserved range for application")
Case #SHT_HIUSER : Message("sh_type","Specific indexes")
Default : Message("sh_type","?> 0x"+Hex(sh_type))
EndSelect
sh_flags = Get_Elf32_Shdr_sh_flags(*SectionHeader)
Message("sh_flags",Str(sh_flags))
sh_addr = Get_Elf32_Shdr_sh_addr(*SectionHeader)
Message("sh_addr",Str(sh_addr))
sh_offset = Get_Elf32_Shdr_sh_offset(*SectionHeader)
Message("sh_offset",Str(sh_offset))
sh_size = Get_Elf32_Shdr_sh_size(*SectionHeader)
Message("sh_size",Str(sh_size))
sh_link = Get_Elf32_Shdr_sh_link(*SectionHeader)
Message("sh_link",Str(sh_link))
sh_info = Get_Elf32_Shdr_sh_info(*SectionHeader)
Message("sh_info",Str(sh_info))
sh_addralign = Get_Elf32_Shdr_sh_addralign(*SectionHeader)
Message("sh_addralign",Str(sh_addralign))
sh_entsize = Get_Elf32_Shdr_sh_entsize(*SectionHeader)
Message("sh_entsize",Str(sh_entsize))
If sh_type = #SHT_STRTAB Or sh_type = #SHT_SYMTAB
PrintN_EX(" ")
PrintN_EX("String table : ")
StrTab$ = ExtractStringTable(*ElfFile,sh_offset,sh_size)
PrintN_EX(StrTab$)
PrintN_EX(" ")
EndIf
If sh_type = #SHT_DYNAMIC Or sh_type = #SHT_PROGBITS Or sh_type = #SHT_DYNSYM
PrintN_EX(" ")
PrintN_EX("Dynamic section : ")
StrTab$ = ExtractHexa(*ElfFile,sh_offset,sh_size)
PrintN_EX(StrTab$)
PrintN_EX(" ")
EndIf
PrintN_EX("")
PrintN_EX("==========================================================================")
Next
EndIf
EndProcedure
PrintN_EX("")
PrintN_EX("==========================================================================")
PrintN_EX("ELF-DECOMPILER BY ORTALI JEROME")
PrintN_EX("CopyLeft 2009")
PrintN_EX("==========================================================================")
PrintN_EX("")
ReadELF("../../mydata")
For i = 0 To 4*10000
Char.c = PeekC(*MemoryString+i)
T$+Chr(Char)
Next
SetGadgetText(#GADGET_OUT,T$)
If LoadFont(0, "Monospace", 12)
SetGadgetFont(#GADGET_OUT,FontID(0))
EndIf
SetGadgetColor(#GADGET_OUT,#PB_Gadget_BackColor,$0)
SetGadgetColor(#GADGET_OUT,#PB_Gadget_FrontColor,$00CC00)
Repeat
event = WindowEvent()
Until event = #PB_Event_CloseWindow
End
Le Man Elf en français :
http://www.bash-linux.com/unix-man-elf-francais.html