aboutsummaryrefslogtreecommitdiff
path: root/elf/tests
diff options
context:
space:
mode:
authorSunil Nimmagadda <sunil@nimmagadda.net>2026-11-10 17:47:44 +0530
committerSunil Nimmagadda <sunil@nimmagadda.net>2026-11-10 18:40:29 +0530
commit54c78686ac1bd8121ec87e74bb613cbab1186e0e (patch)
tree067746ef52fb45cb50f2c6e94e1f437ec2b58bdd /elf/tests
parentd41f116c1d384e844e3b6a135d06c34ba5b1bad1 (diff)
section.normalize() tests.
While here, move into tests/ sub-directory.
Diffstat (limited to 'elf/tests')
-rw-r--r--elf/tests/test_elf.lua542
1 files changed, 542 insertions, 0 deletions
diff --git a/elf/tests/test_elf.lua b/elf/tests/test_elf.lua
new file mode 100644
index 0000000..a8c5cf2
--- /dev/null
+++ b/elf/tests/test_elf.lua
@@ -0,0 +1,542 @@
+local fmt = require("elf.fmt")
+local elf_header = require("elf.header")
+local elf_segment = require("elf.segment")
+local elf_section = require("elf.section")
+local ec = require("elf.constants")
+
+local nfail = 0
+local function test(name, fn)
+ local ok, err = pcall(fn)
+ if not ok then
+ nfail = nfail + 1
+ print("fail: " .. name .. ": " .. err)
+ end
+end
+
+-- Test fmt.lua
+test("fmt.endian big", function ()
+ assert(fmt.endian(ec.Endian.big) == ">", "invalid format string")
+end)
+
+test("fmt.endian little", function ()
+ assert(fmt.endian(ec.Endian.little) == "<", "invalid format string")
+end)
+
+test("fmt.endian", function ()
+ ---@diagnostic disable-next-line: param-type-mismatch
+ local ok = pcall(function () fmt.endian(42) end)
+ assert(not ok, "invalid input accepted")
+end)
+
+test("fmt.word 64", function ()
+ assert(fmt.word(ec.Class.bit64) == "I8", "invalid format string")
+end)
+
+test("fmt.word 32", function ()
+ assert(fmt.word(ec.Class.bit32) == "I4", "invalid format string")
+end)
+
+test("fmt.word", function ()
+ ---@diagnostic disable-next-line: param-type-mismatch
+ local ok = pcall(function () fmt.word(42) end)
+ assert(not ok, "invalid input accepted")
+end)
+
+-- Test header.lua
+test("header.normalize ELF64 defaults", function ()
+ local h = elf_header.normalize({
+ class = ec.Class.bit64,
+ data = ec.Endian.little,
+ type = ec.Type.exec,
+ machine = ec.Machine.x86_64,
+ })
+
+ assert(h.magic[1] == 0x7f, "magic[1] mismatch")
+ assert(h.magic[2] == 0x45, "magic[2] mismatch")
+ assert(h.magic[3] == 0x4c, "magic[3] mismatch")
+ assert(h.magic[4] == 0x46, "magic[4] mismatch")
+ assert(h.class == ec.Class.bit64, "class mismatch")
+ assert(h.data == ec.Endian.little, "data mismatch")
+ assert(h.type == ec.Type.exec, "type mismatch")
+ assert(h.machine == ec.Machine.x86_64, "machine mismatch")
+ assert(h.ident_version == ec.VERSION, "ident_version mismatch")
+ assert(h.osabi == ec.Osabi.sysv, "osabi mismatch")
+ assert(h.abiversion == 0, "abiversion mismatch")
+ assert(h.version == ec.VERSION, "version mismatch")
+ assert(h.entry == 0, "entry mismatch")
+ assert(h.phoff == 0x40, "phoff mismatch")
+ assert(h.shoff == 0, "shoff mismatch")
+ assert(h.flags == 0, "flags mismatch")
+ assert(h.ehsize == 0x40, "ehsize mismatch")
+ assert(h.phentsize == 0x38, "phentsize mismatch")
+ assert(h.phnum == 0, "phnum mismatch")
+ assert(h.shentsize == 0x40, "shentsize mismatch")
+ assert(h.shnum == 0, "shnum mismatch")
+ assert(h.shstrndx == 0, "shstrndx mismatch")
+end)
+
+test("header.normalize preserve specified values", function ()
+ local h = elf_header.normalize({
+ class = ec.Class.bit64,
+ data = ec.Endian.little,
+ type = ec.Type.exec,
+ machine = ec.Machine.x86_64,
+ entry = 0x401000,
+ flags = 3,
+ phnum = 2,
+ shnum = 4,
+ shstrndx = 3,
+ })
+ assert(h.entry == 0x401000, "entry mismatch")
+ assert(h.flags == 3, "flags mismatch")
+ assert(h.phnum == 2, "phnum mismatch")
+ assert(h.shnum == 4, "shnum mismatch")
+ assert(h.shstrndx == 3, "shstrndx mismatch")
+ -- Layout defaults remain ELF64 values.
+ assert(h.phoff == 0x40, "phoff mismatch")
+ assert(h.ehsize == 0x40, "ehsize mismatch")
+ assert(h.phentsize == 0x38, "phentsize mismatch")
+ assert(h.shentsize == 0x40, "shentsize mismatch")
+end)
+
+test("header.normalize ELF32 layout", function ()
+ local h = elf_header.normalize({
+ class = ec.Class.bit32,
+ data = ec.Endian.little,
+ type = ec.Type.exec,
+ machine = ec.Machine.i386,
+ })
+ assert(h.phoff == 0x34, "phoff mismatch")
+ assert(h.ehsize == 0x34, "ehsize mismatch")
+ assert(h.phentsize == 0x20, "phentsize mismatch")
+ assert(h.shentsize == 0x28, "shentsize mismatch")
+end)
+
+local function hex_to_bytes(hex)
+ return (hex:gsub("..", function (pair)
+ local byte = assert(tonumber(pair, 16), "Invalid hex")
+ return string.char(byte)
+ end))
+end
+
+test("header.pack 64_le_x86-64", function ()
+ local h = {
+ class = ec.Class.bit64,
+ data = ec.Endian.little,
+ type = ec.Type.exec,
+ machine = ec.Machine.x86_64,
+ }
+ local expected = hex_to_bytes(table.concat({
+ -- "BBBBBBBBBxxxxxxx"
+ "7f454c46020101000000000000000000",
+ -- "I2I2I4"
+ "02003e0001000000",
+ -- string.rep(fmt.word(hdr.class), 3), where I8 is selected
+ "0000000000000000", -- entry
+ "4000000000000000", -- phoff
+ "0000000000000000", -- shoff
+ -- "I4I2I2I2I2I2I2"
+ "00000000", -- flags
+ "4000", -- ehsize
+ "3800", -- phentsize
+ "0000", -- phnum
+ "4000", -- shentsize
+ "0000", -- shnum
+ "0000", -- shstrndx
+ }))
+ local actual = elf_header.pack(elf_header.normalize(h))
+ assert(#actual == 64, "invalid ELF64 header size")
+ assert(actual == expected, "mismatch")
+end)
+
+test("header.pack 32_le_i386", function ()
+ local h = {
+ class = ec.Class.bit32,
+ data = ec.Endian.little,
+ type = ec.Type.exec,
+ machine = ec.Machine.i386,
+ entry = 0x01020304,
+ phoff = 0x11121314,
+ shoff = 0x21222324,
+ flags = 0x31323334,
+ ehsize = 0x3435,
+ phentsize = 0x3637,
+ phnum = 0x3839,
+ shentsize = 0x3a3b,
+ shnum = 0x3c3d,
+ shstrndx = 0x3e3f,
+ }
+ local expected = hex_to_bytes(table.concat({
+ -- "BBBBBBBBBxxxxxxx"
+ "7f454c46010101000000000000000000",
+ -- "I2I2I4"
+ "0200030001000000",
+ -- string.rep(fmt.word(hdr.class), 3), where I4 is selected
+ "04030201", -- entry
+ "14131211", -- phoff
+ "24232221", -- shoff
+ -- "I4I2I2I2I2I2I2"
+ "34333231", -- flags
+ "3534", -- ehsize
+ "3736", -- phentsize
+ "3938", -- phnum
+ "3b3a", -- shentsize
+ "3d3c", -- shnum
+ "3f3e", -- shstrndx
+ }))
+ local actual = elf_header.pack(elf_header.normalize(h))
+ assert(#actual == 52, "invalid ELF32 header size")
+ assert(actual == expected, "mismatch")
+end)
+
+test("header.pack 32_be_i386", function ()
+ local h = {
+ class = ec.Class.bit32,
+ data = ec.Endian.big,
+ type = ec.Type.exec,
+ machine = ec.Machine.i386,
+ entry = 0x01020304,
+ phoff = 0x11121314,
+ shoff = 0x21222324,
+ flags = 0x31323334,
+ ehsize = 0x3435,
+ phentsize = 0x3637,
+ phnum = 0x3839,
+ shentsize = 0x3a3b,
+ shnum = 0x3c3d,
+ shstrndx = 0x3e3f,
+ }
+ local expected = hex_to_bytes(table.concat({
+ -- "BBBBBBBBBxxxxxxx"
+ "7f454c46010201000000000000000000",
+ -- "I2I2I4"
+ "0002000300000001",
+ -- string.rep(fmt.word(hdr.class), 3), where I4 is selected
+ "01020304", -- entry
+ "11121314", -- phoff
+ "21222324", -- shoff
+ -- "I4I2I2I2I2I2I2"
+ "31323334", -- flags
+ "3435", -- ehsize
+ "3637", -- phentsize
+ "3839", -- phnum
+ "3a3b", -- shentsize
+ "3c3d", -- shnum
+ "3e3f", -- shstrndx
+ }))
+ local actual = elf_header.pack(elf_header.normalize(h))
+ assert(#actual == 52, "invalid ELF32 header size")
+ assert(actual == expected, "mismatch")
+end)
+
+test("header.pack 64_be_x86-64", function ()
+ local h = {
+ class = ec.Class.bit64,
+ data = ec.Endian.big,
+ type = ec.Type.exec,
+ machine = ec.Machine.x86_64,
+ entry = 0x0102030405060708,
+ phoff = 0x1112131415161718,
+ shoff = 0x2122232425262728,
+ flags = 0x31323334,
+ ehsize = 0x3435,
+ phentsize = 0x3637,
+ phnum = 0x3839,
+ shentsize = 0x3a3b,
+ shnum = 0x3c3d,
+ shstrndx = 0x3e3f,
+ }
+ local expected = hex_to_bytes(table.concat({
+ -- "BBBBBBBBBxxxxxxx"
+ "7f454c46020201000000000000000000",
+ -- "I2I2I4"
+ "0002003e00000001",
+ -- string.rep(fmt.word(hdr.class), 3), where I8 is selected
+ "0102030405060708", -- entry
+ "1112131415161718", -- phoff
+ "2122232425262728", -- shoff
+ -- "I4I2I2I2I2I2I2"
+ "31323334", -- flags
+ "3435", -- ehsize
+ "3637", -- phentsize
+ "3839", -- phnum
+ "3a3b", -- shentsize
+ "3c3d", -- shnum
+ "3e3f", -- shstrndx
+ }))
+ local actual = elf_header.pack(elf_header.normalize(h))
+ assert(#actual == 64, "invalid ELF64 header size")
+ assert(actual == expected, "mismatch")
+end)
+
+-- Test segment.lua
+test("segment.normalize defaults", function ()
+ local s = elf_segment.normalize({
+ type = ec.SegmentType.load,
+ })
+ assert(s.type == ec.SegmentType.load, "type mismatch")
+ assert(s.flags == 0, "flags mismatch")
+ assert(s.offset == 0, "offset mismatch")
+ assert(s.vaddr == 0, "vaddr mismatch")
+ assert(s.paddr == 0, "paddr mismatch")
+ assert(s.filesz == 0, "filesz mismatch")
+ assert(s.memsz == 0, "memsz mismatch")
+ assert(s.align == 1, "align mismatch")
+ assert(s.first_section == "", "first_section mismatch")
+ assert(s.last_section == "", "last_section mismatch")
+end)
+
+test("segment.normalize does not validate missing type", function ()
+ local ok, segment = pcall(elf_segment.normalize, {})
+ assert(ok, "missing type rejected")
+ assert(segment.type == nil, "type mismatch")
+end)
+
+test("segment.normalize preserve specified values", function ()
+ local s = elf_segment.normalize({
+ type = ec.SegmentType.load,
+ flags = ec.SegmentFlags.r + ec.SegmentFlags.x,
+ offset = 0x1000,
+ vaddr = 0x401000,
+ paddr = 0x401000,
+ filesz = 0x200,
+ memsz = 0x300,
+ align = 0x1000,
+ first_section = ".text",
+ last_section = ".rodata",
+ })
+ assert(s.type == ec.SegmentType.load, "type mismatch")
+ assert(s.flags == ec.SegmentFlags.r + ec.SegmentFlags.x, "flags mismatch")
+ assert(s.offset == 0x1000, "offset mismatch")
+ assert(s.vaddr == 0x401000, "vaddr mismatch")
+ assert(s.paddr == 0x401000, "paddr mismatch")
+ assert(s.filesz == 0x200, "filesz mismatch")
+ assert(s.memsz == 0x300, "memsz mismatch")
+ assert(s.align == 0x1000, "align mismatch")
+ assert(s.first_section == ".text", "first_section mismatch")
+ assert(s.last_section == ".rodata", "last_section mismatch")
+end)
+
+test("segment.normalize preserve zero values", function ()
+ local s = elf_segment.normalize({
+ type = ec.SegmentType.null,
+ flags = 0,
+ offset = 0,
+ vaddr = 0,
+ paddr = 0,
+ filesz = 0,
+ memsz = 0,
+ align = 0,
+ })
+ assert(s.type == ec.SegmentType.null, "type mismatch")
+ assert(s.flags == 0, "flags mismatch")
+ assert(s.offset == 0, "offset mismatch")
+ assert(s.vaddr == 0, "vaddr mismatch")
+ assert(s.paddr == 0, "paddr mismatch")
+ assert(s.filesz == 0, "filesz mismatch")
+ assert(s.memsz == 0, "memsz mismatch")
+ assert(s.align == 0, "align mismatch")
+end)
+
+test("segment.pack 32_le", function ()
+ local s = {
+ type = ec.SegmentType.dynamic,
+ flags = 0x11121314,
+ offset = 0x21222324,
+ vaddr = 0x31323334,
+ paddr = 0x41424344,
+ filesz = 0x51525354,
+ memsz = 0x61626364,
+ align = 0x71727374,
+ }
+ local expected = hex_to_bytes(table.concat({
+ -- string.rep(fmt.word(ec.Class.bit32), 8)
+ "02000000", -- type
+ "24232221", -- offset
+ "34333231", -- vaddr
+ "44434241", -- paddr
+ "54535251", -- filesz
+ "64636261", -- memsz
+ "14131211", -- flags
+ "74737271", -- align
+ }))
+ local ns = elf_segment.normalize(s)
+ local actual = elf_segment.pack(ns, ec.Endian.little, ec.Class.bit32)
+ assert(#actual == 32, "invalid ELF32 segment header size")
+ assert(actual == expected, "mismatch")
+end)
+
+test("segment.pack 32_be", function ()
+ local s = {
+ type = 0x01020304,
+ flags = 0x11121314,
+ offset = 0x21222324,
+ vaddr = 0x31323334,
+ paddr = 0x41424344,
+ filesz = 0x51525354,
+ memsz = 0x61626364,
+ align = 0x71727374,
+ }
+ local expected = hex_to_bytes(table.concat({
+ -- string.rep(fmt.word(ec.Class.bit32), 8) where I4 is selected
+ "01020304", -- type
+ "21222324", -- offset
+ "31323334", -- vaddr
+ "41424344", -- paddr
+ "51525354", -- filesz
+ "61626364", -- memsz
+ "11121314", -- flags
+ "71727374", -- align
+ }))
+ local ns = elf_segment.normalize(s)
+ local actual = elf_segment.pack(ns, ec.Endian.big, ec.Class.bit32)
+ assert(#actual == 32, "invalid ELF32 segment header size")
+ assert(actual == expected, "mismatch")
+end)
+
+test("segment.pack 64_le", function ()
+ local s = {
+ type = 0x01020304,
+ flags = 0x11121314,
+ offset = 0x2122232425262728,
+ vaddr = 0x3132333435363738,
+ paddr = 0x4142434445464748,
+ filesz = 0x5152535455565758,
+ memsz = 0x6162636465666768,
+ align = 0x7172737475767778,
+ }
+ local expected = hex_to_bytes(table.concat({
+ -- "I4I4"
+ "04030201", -- type
+ "14131211", -- flags
+ -- string.rep(fmt.word(ec.Class.bit64), 6) where I8 is selected
+ "2827262524232221", -- offset
+ "3837363534333231", -- vaddr
+ "4847464544434241", -- paddr
+ "5857565554535251", -- filesz
+ "6867666564636261", -- memsz
+ "7877767574737271", -- align
+ }))
+ local ns = elf_segment.normalize(s)
+ local actual = elf_segment.pack(ns, ec.Endian.little, ec.Class.bit64)
+ assert(#actual == 56, "invalid ELF64 segment header size")
+ assert(actual == expected, "mismatch")
+end)
+
+test("segment.pack 64_be", function ()
+ local s = {
+ type = 0x01020304,
+ flags = 0x11121314,
+ offset = 0x2122232425262728,
+ vaddr = 0x3132333435363738,
+ paddr = 0x4142434445464748,
+ filesz = 0x5152535455565758,
+ memsz = 0x6162636465666768,
+ align = 0x7172737475767778,
+ }
+ local expected = hex_to_bytes(table.concat({
+ -- "I4I4"
+ "01020304", -- type
+ "11121314", -- flags
+ -- string.rep(fmt.word(ec.Class.bit64), 6) where I8 is selected
+ "2122232425262728", -- offset
+ "3132333435363738", -- vaddr
+ "4142434445464748", -- paddr
+ "5152535455565758", -- filesz
+ "6162636465666768", -- memsz
+ "7172737475767778", -- align
+ }))
+ local ns = elf_segment.normalize(s)
+ local actual = elf_segment.pack(ns, ec.Endian.big, ec.Class.bit64)
+ assert(#actual == 56, "invalid ELF64 segment header size")
+ assert(actual == expected, "mismatch")
+end)
+
+-- Test section.lua
+test("section.normalize defaults", function ()
+ local s = elf_section.normalize({
+ name = ".text",
+ type = ec.SectionType.progbits,
+ flags = ec.SectionFlags.alloc,
+ })
+ assert(s.name == ".text", "name mismatch")
+ assert(s.type == ec.SectionType.progbits, "type mismatch")
+ assert(s.flags == ec.SectionFlags.alloc, "flags mismatch")
+ assert(s.addr == 0, "addr mismatch")
+ assert(s.offset == 0, "offset mismatch")
+ assert(s.size == 0, "size mismatch")
+ assert(s.link == 0, "link mismatch")
+ assert(s.info == 0, "info mismatch")
+ assert(s.addralign == 0, "addralign mismatch")
+ assert(s.entsize == 0, "entsize mismatch")
+ assert(s.content == "", "content mismatch")
+end)
+
+test("section.normalize does not validate missing fields", function ()
+ local ok, section = pcall(elf_section.normalize, {})
+ assert(ok, "missing fields rejected")
+ assert(section.name == nil, "name mismatch")
+ assert(section.type == nil, "type mismatch")
+ assert(section.flags == nil, "flags mismatch")
+end)
+
+test("section.normalize preserve specified values", function ()
+ local s = elf_section.normalize({
+ name = ".data",
+ type = ec.SectionType.progbits,
+ flags = ec.SectionFlags.alloc & ec.SectionFlags.write,
+ addr = 0x401000,
+ offset = 0x1000,
+ size = 0x200,
+ link = 1,
+ info = 2,
+ addralign = 0x1000,
+ entsize = 8,
+ content = "contents",
+ })
+ assert(s.name == ".data", "name mismatch")
+ assert(s.type == ec.SectionType.progbits, "type mismatch")
+ assert(s.flags == 0x2 & 0x1,"flags mismatch")
+ assert(s.addr == 0x401000, "addr mismatch")
+ assert(s.offset == 0x1000, "offset mismatch")
+ assert(s.size == 0x200, "size mismatch")
+ assert(s.link == 1, "link mismatch")
+ assert(s.info == 2, "info mismatch")
+ assert(s.addralign == 0x1000, "addralign mismatch")
+ assert(s.entsize == 8, "entsize mismatch")
+ assert(s.content == "contents", "content mismatch")
+end)
+
+test("section.normalize preserve zero values", function ()
+ local s = elf_section.normalize({
+ name = ".null",
+ type = ec.SectionType.null,
+ flags = 0,
+ addr = 0,
+ offset = 0,
+ size = 0,
+ link = 0,
+ info = 0,
+ addralign = 0,
+ entsize = 0,
+ content = "",
+ })
+ assert(s.name == ".null", "name mismatch")
+ assert(s.type == ec.SectionType.null, "type mismatch")
+ assert(s.flags == 0, "flags mismatch")
+ assert(s.addr == 0, "addr mismatch")
+ assert(s.offset == 0, "offset mismatch")
+ assert(s.size == 0, "size mismatch")
+ assert(s.link == 0, "link mismatch")
+ assert(s.info == 0, "info mismatch")
+ assert(s.addralign == 0, "addralign mismatch")
+ assert(s.entsize == 0, "entsize mismatch")
+ assert(s.content == "", "content mismatch")
+end)
+
+-- Test layout.lua
+
+if nfail > 0 then
+ print(("%d %s failed"):format(nfail, (nfail == 1) and "test" or "tests"))
+ os.exit(1)
+end