[LINUX] Entete des fichier ELF 32bits

Codes specifiques à Linux
Anonyme

[LINUX] Entete des fichier ELF 32bits

Message par Anonyme »

Voici un code permettant de faire joujou avec des fichier ELF 32 bits

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 

Vous pouvez vous baladez la dedans : :)

Image

Le Man Elf en français :

http://www.bash-linux.com/unix-man-elf-francais.html
Cls
Messages : 620
Inscription : mer. 22/juin/2005 8:51
Localisation : Nantes

Message par Cls »

Je vois que tu ne chômes pas ! :D

J'ai peu de temps à consacrer au format PE pour l'instant mais ça viendra ;)
Merci pour le code :D
Répondre