Crate orecc_elf

Easy read/write ELF 32/64 relocatibles/executables/dynamics

To read an elf file:

let mut file = std::fs::File::open("test.o").unwrap();
dbg!(orecc_elf::ELF::<u64>::read(&mut file));

To write an elf file (source: https://www.youtube.com/watch?v=XH6jDiKxod8):

let mut file = std::fs::File::create("test.o").unwrap();
// An x86 program that just exits
let data = [
    0xB8, 0x01, 0x00, 0x00, 0x00,
    0xBB, 0x00, 0x00, 0x00, 0x00,
    0xCD, 0x80,
];
orecc_elf::ELF::<u32>::new(
    orecc_elf::Ident::new(
        orecc_elf::Class::ELF32,
        orecc_elf::ByteOrder::LSB,
        orecc_elf::ABI::None,
        0,
    ),
    orecc_elf::Type::Exec,
    orecc_elf::Machine::X86,
    true,
    vec![
        orecc_elf::SegmentTemplate::new(
            orecc_elf::SegmentType::Load,
            data.to_vec(),
            data.len() as _,
            orecc_elf::SegmentFlags::Readable as u32 | orecc_elf::SegmentFlags::Executable as u32,
        )
    ],
    Vec::new(),
)
.unwrap()
.write(&mut file)
.unwrap();

x86_64 version:

let mut file = std::fs::File::create("test.o").unwrap();
// An x86_64 program that just exits
let data = [
    0x48, 0xC7, 0xC0, 0x3C, 0x00, 0x00, 0x00,
    0x48, 0xC7, 0xC7, 0x2A, 0x00, 0x00, 0x00,
    0x0F, 0x05,
];
orecc_elf::ELF::<u64>::new(
    orecc_elf::Ident::default(),
    orecc_elf::Type::Exec,
    orecc_elf::Machine::X86_64,
    true,
    vec![
        orecc_elf::SegmentTemplate::new(
            orecc_elf::SegmentType::Load,
            data.to_vec(),
            data.len() as _,
            orecc_elf::SegmentFlags::Readable as u32 | orecc_elf::SegmentFlags::Executable as u32,
        )
    ],
    Vec::new(),
)
.unwrap()
.write(&mut file)
.unwrap();

Structs

• ELF
  The ELF file itself. This what you will be using. Use Self::read() to read if from a file, Self::new() to construct it from scratch and Self::write() to write it to a file T generic can be u32 for ELF32 and u64 for ELF64
• Ident
  e_ident. Specifies class, byte order and ABI of the ELF
• Section
  Section, when linking turned into segment
• Segment
  A segment, this gets loaded into memory when elf file gets executed
• SegmentTemplate
  A segment template, Segment will be generated from it

Enums

• ABI
  ABI. There is planety to chose from, but you probably should just use ABI::None
• ByteOrder
  Byte order, stored in e_ident.
• Class
  Class, stored in e_ident. ELF32/ELF64
• Error
  A custom error type
• Machine
  Machine. There is A LOT of them. Most common are Machine::X86, Machine::X86_64, Machine::ARM and Machine::ARM64
• SegmentFlags
  p_flags. Essentially permissions. See [Segment::flags] for details
• SegmentType
  p_type. A segment type (type of a program header). Most segments will probably have type SegmentType::Load
• Type
  Type of the ELF.

Traits

• SizeT
  ELF is supposed to be 32/64. This is a trait to specify this. It’s implemented for u32 and u64.

Type Aliases

• Result
  A custom result type