Copyright	(c) Aleksey Makarov 2021
License	BSD 3-Clause License
Maintainer	aleksey.makarov@gmail.com
Stability	experimental
Portability	portable
Safe Haskell	None
Language	Haskell2010

Data.Elf.Headers

Contents

Data definition
Singletons
Types of ELF header
Types of ELF tables
Parse header and section and segment tables
Parse/serialize array of data
Misc helpers

Description

Parse headers and table entries of ELF files

Synopsis

elfMagic :: Be Word32
data ElfClass
- = ELFCLASS32
- | ELFCLASS64
data ElfData
- = ELFDATA2LSB
- | ELFDATA2MSB
data SingElfClass (a :: ElfClass) where
- SELFCLASS32 :: SingElfClass 'ELFCLASS32
- SELFCLASS64 :: SingElfClass 'ELFCLASS64
class (Typeable c, Typeable (WordXX c), Data (WordXX c), Show (WordXX c), Read (WordXX c), Eq (WordXX c), Ord (WordXX c), Bounded (WordXX c), Enum (WordXX c), Num (WordXX c), Integral (WordXX c), Real (WordXX c), Bits (WordXX c), FiniteBits (WordXX c), Binary (Be (WordXX c)), Binary (Le (WordXX c))) => SingElfClassI (c :: ElfClass) where
- type WordXX (c :: ElfClass) = (r :: Type) | r -> c
- singElfClass :: SingElfClass c
withSingElfClass :: forall (c :: ElfClass) r. SingElfClassI c => (SingElfClass c -> r) -> r
withSingElfClassI :: forall (c :: ElfClass) r. SingElfClass c -> (SingElfClassI c => r) -> r
fromSingElfClass :: forall (c :: ElfClass). SingElfClass c -> ElfClass
withElfClass :: ElfClass -> (forall (c :: ElfClass). SingElfClassI c => SingElfClass c -> r) -> r
data HeaderXX (c :: ElfClass) = HeaderXX {
- hData :: ElfData
- hOSABI :: ElfOSABI
- hABIVersion :: Word8
- hType :: ElfType
- hMachine :: ElfMachine
- hEntry :: WordXX c
- hPhOff :: WordXX c
- hShOff :: WordXX c
- hFlags :: Word32
- hPhEntSize :: Word16
- hPhNum :: Word16
- hShEntSize :: Word16
- hShNum :: Word16
- hShStrNdx :: ElfSectionIndex
}
headerSize :: Num a => ElfClass -> a
data Header = Header (SingElfClass a) (HeaderXX a)
data SectionXX (c :: ElfClass) = SectionXX {
- sName :: Word32
- sType :: ElfSectionType
- sFlags :: WordXX c
- sAddr :: WordXX c
- sOffset :: WordXX c
- sSize :: WordXX c
- sLink :: Word32
- sInfo :: Word32
- sAddrAlign :: WordXX c
- sEntSize :: WordXX c
}
sectionTableEntrySize :: Num a => ElfClass -> a
data SegmentXX (c :: ElfClass) = SegmentXX {
- pType :: ElfSegmentType
- pFlags :: ElfSegmentFlag
- pOffset :: WordXX c
- pVirtAddr :: WordXX c
- pPhysAddr :: WordXX c
- pFileSize :: WordXX c
- pMemSize :: WordXX c
- pAlign :: WordXX c
}
segmentTableEntrySize :: Num a => ElfClass -> a
data SymbolXX (c :: ElfClass) = SymbolXX {
- stName :: Word32
- stInfo :: Word8
- stOther :: Word8
- stShNdx :: ElfSectionIndex
- stValue :: WordXX c
- stSize :: WordXX c
}
symbolTableEntrySize :: Num a => ElfClass -> a
data RelaXX (c :: ElfClass) = RelaXX {
- relaOffset :: WordXX c
- relaSym :: Word32
- relaType :: Word32
- relaAddend :: WordXX c
}
relocationTableAEntrySize :: forall (a :: ElfClass). SingElfClassI a => WordXX a
data Headers = Headers (SingElfClass a) (HeaderXX a) [SectionXX a] [SegmentXX a]
parseHeaders :: MonadThrow m => ByteString -> m Headers
parseBList :: (MonadThrow m, Binary (Le a), Binary (Be a)) => ElfData -> ByteString -> m [a]
serializeBList :: (Binary (Le a), Binary (Be a)) => ElfData -> [a] -> ByteString
sectionIsSymbolTable :: ElfSectionType -> Bool
getSectionData :: forall (a :: ElfClass). SingElfClassI a => ByteString -> SectionXX a -> ByteString
getString :: ByteString -> Int64 -> String
wordSize :: Num a => ElfClass -> a

Data definition

elfMagic :: Be Word32 Source #

The first 4 bytes of the ELF file

data ElfClass Source #

ELF class. Tells if ELF defines 32- or 64-bit objects

Constructors

ELFCLASS32	32-bit ELF format
ELFCLASS64	64-bit ELF format

Instances

Instances details

Show ElfClass Source #
Instance details Defined in Data.Elf.Headers Methods showsPrec :: Int -> ElfClass -> ShowS # show :: ElfClass -> String # showList :: [ElfClass] -> ShowS #
Binary ElfClass Source #
Instance details Defined in Data.Elf.Headers Methods put :: ElfClass -> Put # get :: Get ElfClass # putList :: [ElfClass] -> Put #
Eq ElfClass Source #
Instance details Defined in Data.Elf.Headers Methods (==) :: ElfClass -> ElfClass -> Bool # (/=) :: ElfClass -> ElfClass -> Bool #

data ElfData Source #

ELF data. Specifies the endianness of the ELF data

Constructors

ELFDATA2LSB	Little-endian ELF format
ELFDATA2MSB	Big-endian ELF format

Instances

Instances details

Show ElfData Source #
Instance details Defined in Data.Elf.Headers Methods showsPrec :: Int -> ElfData -> ShowS # show :: ElfData -> String # showList :: [ElfData] -> ShowS #
Binary ElfData Source #
Instance details Defined in Data.Elf.Headers Methods put :: ElfData -> Put # get :: Get ElfData # putList :: [ElfData] -> Put #
Eq ElfData Source #
Instance details Defined in Data.Elf.Headers Methods (==) :: ElfData -> ElfData -> Bool # (/=) :: ElfData -> ElfData -> Bool #

Singletons

data SingElfClass (a :: ElfClass) where Source #

Singletons for ElfClass

Constructors

SELFCLASS32
Fields :: SingElfClass 'ELFCLASS32 Singleton for `ELFCLASS32`
SELFCLASS64
Fields :: SingElfClass 'ELFCLASS64 Singleton for `ELFCLASS64`

class (Typeable c, Typeable (WordXX c), Data (WordXX c), Show (WordXX c), Read (WordXX c), Eq (WordXX c), Ord (WordXX c), Bounded (WordXX c), Enum (WordXX c), Num (WordXX c), Integral (WordXX c), Real (WordXX c), Bits (WordXX c), FiniteBits (WordXX c), Binary (Be (WordXX c)), Binary (Le (WordXX c))) => SingElfClassI (c :: ElfClass) where Source #

SingElfClassI a is defined for each constructor of ElfClass. It defines WordXX a, which is Word32 for ELFCLASS32 and Word64 for ELFCLASS64. Also it defines singletons for each of the ElfClass type.

Associated Types

type WordXX (c :: ElfClass) = (r :: Type) | r -> c Source #

Methods

singElfClass :: SingElfClass c Source #

Instances

Instances details

SingElfClassI 'ELFCLASS32 Source #

Instance details

Defined in Data.Elf.Headers

Associated Types

type WordXX 'ELFCLASS32
Instance details Defined in Data.Elf.Headers type WordXX 'ELFCLASS32 = Word32

Methods

singElfClass :: SingElfClass 'ELFCLASS32 Source #

SingElfClassI 'ELFCLASS64 Source #

Instance details

Defined in Data.Elf.Headers

Associated Types

type WordXX 'ELFCLASS64
Instance details Defined in Data.Elf.Headers type WordXX 'ELFCLASS64 = Word64

Methods

singElfClass :: SingElfClass 'ELFCLASS64 Source #

withSingElfClass :: forall (c :: ElfClass) r. SingElfClassI c => (SingElfClass c -> r) -> r Source #

A convenience function useful when we need to name a singleton value multiple times. Without this function, each use of sing could potentially refer to a different singleton, and one has to use type signatures (often with ScopedTypeVariables) to ensure that they are the same. See also withSingI

withSingElfClassI :: forall (c :: ElfClass) r. SingElfClass c -> (SingElfClassI c => r) -> r Source #

Convenience function for creating a context with an implicit singleton available. See also withSing

fromSingElfClass :: forall (c :: ElfClass). SingElfClass c -> ElfClass Source #

Convert a singleton to its unrefined version. See also fromSing

withElfClass :: ElfClass -> (forall (c :: ElfClass). SingElfClassI c => SingElfClass c -> r) -> r Source #

Use this instead of toSing

Types of ELF header

data HeaderXX (c :: ElfClass) Source #

Parsed ELF header

Constructors

HeaderXX

Fields

hData :: ElfData
Data encoding (big- or little-endian)
hOSABI :: ElfOSABI
OS/ABI identification
hABIVersion :: Word8
ABI version
hType :: ElfType
Object file type
hMachine :: ElfMachine
Machine type
hEntry :: WordXX c
Entry point address
hPhOff :: WordXX c
Program header offset
hShOff :: WordXX c
Section header offset
hFlags :: Word32
Processor-specific flags
hPhEntSize :: Word16
Size of program header entry
hPhNum :: Word16
Number of program header entries
hShEntSize :: Word16
Size of section header entry
hShNum :: Word16
Number of section header entries
hShStrNdx :: ElfSectionIndex
Section name string table index

headerSize :: Num a => ElfClass -> a Source #

Size of ELF header.

data Header Source #

Header is a sigma type where the first entry defines the type of the second one

Constructors

(SingElfClass a) (HeaderXX a)

Instances

Types of ELF tables

Section table

data SectionXX (c :: ElfClass) Source #

Parsed ELF section table entry

Constructors

SectionXX

Fields

sName :: Word32
Section name
sType :: ElfSectionType
Section type
sFlags :: WordXX c
Section attributes
sAddr :: WordXX c
Virtual address in memory
sOffset :: WordXX c
Offset in file
sSize :: WordXX c
Size of section
sLink :: Word32
Link to other section
sInfo :: Word32
Miscellaneous information
sAddrAlign :: WordXX c
Address alignment boundary
sEntSize :: WordXX c
Size of entries, if section has table

Instances

Instances details

SingElfClassI a => Binary (Be (SectionXX a)) Source #
Instance details Defined in Data.Elf.Headers Methods put :: Be (SectionXX a) -> Put # get :: Get (Be (SectionXX a)) # putList :: [Be (SectionXX a)] -> Put #
SingElfClassI a => Binary (Le (SectionXX a)) Source #
Instance details Defined in Data.Elf.Headers Methods put :: Le (SectionXX a) -> Put # get :: Get (Le (SectionXX a)) # putList :: [Le (SectionXX a)] -> Put #

sectionTableEntrySize :: Num a => ElfClass -> a Source #

Size of section table entry.

Segment table

data SegmentXX (c :: ElfClass) Source #

Parsed ELF segment table entry

Constructors

SegmentXX
Fields pType :: ElfSegmentType Type of segment pFlags :: ElfSegmentFlag Segment attributes pOffset :: WordXX c Offset in file pVirtAddr :: WordXX c Virtual address in memory pPhysAddr :: WordXX c Physical address pFileSize :: WordXX c Size of segment in file pMemSize :: WordXX c Size of segment in memory pAlign :: WordXX c Alignment of segment

Instances

Instances details

SingElfClassI a => Binary (Be (SegmentXX a)) Source #
Instance details Defined in Data.Elf.Headers Methods put :: Be (SegmentXX a) -> Put # get :: Get (Be (SegmentXX a)) # putList :: [Be (SegmentXX a)] -> Put #
SingElfClassI a => Binary (Le (SegmentXX a)) Source #
Instance details Defined in Data.Elf.Headers Methods put :: Le (SegmentXX a) -> Put # get :: Get (Le (SegmentXX a)) # putList :: [Le (SegmentXX a)] -> Put #

segmentTableEntrySize :: Num a => ElfClass -> a Source #

Size of segment table entry.

Sybmol table

data SymbolXX (c :: ElfClass) Source #

Parsed ELF symbol table entry

Constructors

SymbolXX
Fields stName :: Word32 Symbol name stInfo :: Word8 Type and Binding attributes stOther :: Word8 Reserved stShNdx :: ElfSectionIndex Section table index stValue :: WordXX c Symbol value stSize :: WordXX c Size of object

Instances

Instances details

SingElfClassI a => Binary (Be (SymbolXX a)) Source #
Instance details Defined in Data.Elf.Headers Methods put :: Be (SymbolXX a) -> Put # get :: Get (Be (SymbolXX a)) # putList :: [Be (SymbolXX a)] -> Put #
SingElfClassI a => Binary (Le (SymbolXX a)) Source #
Instance details Defined in Data.Elf.Headers Methods put :: Le (SymbolXX a) -> Put # get :: Get (Le (SymbolXX a)) # putList :: [Le (SymbolXX a)] -> Put #

symbolTableEntrySize :: Num a => ElfClass -> a Source #

Size of symbol table entry.

Relocation table

data RelaXX (c :: ElfClass) Source #

Parsed relocation table entry (ElfXX_Rela)

Constructors

RelaXX
Fields relaOffset :: WordXX c Address of reference relaSym :: Word32 Symbol table index relaType :: Word32 Relocation type relaAddend :: WordXX c Constant part of expression

Instances

Instances details

SingElfClassI a => Binary (Be (RelaXX a)) Source #
Instance details Defined in Data.Elf.Headers Methods put :: Be (RelaXX a) -> Put # get :: Get (Be (RelaXX a)) # putList :: [Be (RelaXX a)] -> Put #
SingElfClassI a => Binary (Le (RelaXX a)) Source #
Instance details Defined in Data.Elf.Headers Methods put :: Le (RelaXX a) -> Put # get :: Get (Le (RelaXX a)) # putList :: [Le (RelaXX a)] -> Put #

relocationTableAEntrySize :: forall (a :: ElfClass). SingElfClassI a => WordXX a Source #

Size of RelaXX a in bytes.

Parse header and section and segment tables

data Headers Source #

Sigma type to hold the ELF header and section and segment tables for a given ElfClass.

Constructors

Headers (SingElfClass a) (HeaderXX a) [SectionXX a] [SegmentXX a]

parseHeaders :: MonadThrow m => ByteString -> m Headers Source #

Parse ELF file and produce header and section and segment tables

Parse/serialize array of data

BList is an internal newtype for [a] that is an instance of Binary. When serializing, the Binary instance for BList does not write the length of the array to the stream. Instead, parser just reads all the stream till the end.

parseBList Source #

Arguments

:: (MonadThrow m, Binary (Le a), Binary (Be a))
=> ElfData	Tells if parser should expect big or little endian data
-> ByteString	Data for parsing
-> m [a]

Parse an array

serializeBList Source #

Arguments

:: (Binary (Le a), Binary (Be a))
=> ElfData	Tells if serializer should tread the data as bit or little endian
-> [a]	The array to serialize
-> ByteString

Serialize an array

Misc helpers

sectionIsSymbolTable :: ElfSectionType -> Bool Source #

Test if the section with such integer value of section type field (sType) contains symbol table

getSectionData Source #

Arguments

:: forall (a :: ElfClass). SingElfClassI a
=> ByteString	ELF file
-> SectionXX a	Parsed section entry
-> ByteString	Section Data

Get section data

getString Source #

Arguments

:: ByteString	Section data of a string table section
-> Int64	Offset to the start of the string in that data
-> String

Get string from string table

wordSize :: Num a => ElfClass -> a Source #

Size of WordXX a in bytes.