diff --git a/docs/elf-dependencies.md b/docs/elf-dependencies.md index 9a51fb0f65..ecfc80573d 100644 --- a/docs/elf-dependencies.md +++ b/docs/elf-dependencies.md @@ -59,6 +59,10 @@ out of the derived set. `version_definitions` summarizes the image's own each import keeps its version index, hidden bit, and a resolved `library@version` when a matching verneed record exists. Index 0 and 1 stay `unversioned`. A missing matching record is `unknown` and is an issue. +For `DT_VERSYM`, the reader keeps the contiguous prefix of complete slots +that share one unambiguous file translation. It stops at the first slot that +cannot be admitted, even if later slots map independently. Later import +versions remain unexamined and coverage is `partial`. A missing `PT_DYNAMIC` is an observed empty load-time dependency inventory. It is not proof another overlay or container carried dynamic linking metadata. diff --git a/src/native/elf/ElfDependencies.fixture.ts b/src/native/elf/ElfDependencies.fixture.ts index 9df2db82cf..6d80c07a65 100644 --- a/src/native/elf/ElfDependencies.fixture.ts +++ b/src/native/elf/ElfDependencies.fixture.ts @@ -120,8 +120,12 @@ export interface ElfDependencyFixtureOptions { readonly sectionEntrySizes?: Readonly>; /** Leaves DT_SYMENT out of the dynamic table. */ readonly omitSymentTag?: boolean; + /** Leaves DT_SYMTAB out of the dynamic table. */ + readonly omitSymtabTag?: boolean; /** Splits the identity PT_LOAD in two halfway through the .hash table. */ readonly splitLoadAtHash?: boolean; + /** Adds a one-byte zero-fill load alias at this offset into .gnu.version. */ + readonly versymZeroFillOffset?: number; } const defaultNeeded = (): string[] => [ @@ -325,6 +329,7 @@ const writeProgramHeader = ( size: number, align: number, vaddr = offset, + memorySize = size, ): void => { write32(bytes, at, type, little); if (bits === 64) { @@ -333,7 +338,7 @@ const writeProgramHeader = ( writeWord(bytes, at + 16, vaddr, bits, little); writeWord(bytes, at + 24, vaddr, bits, little); writeWord(bytes, at + 32, size, bits, little); - writeWord(bytes, at + 40, size, bits, little); + writeWord(bytes, at + 40, memorySize, bits, little); writeWord(bytes, at + 48, align, bits, little); return; } @@ -341,7 +346,7 @@ const writeProgramHeader = ( writeWord(bytes, at + 8, vaddr, bits, little); writeWord(bytes, at + 12, vaddr, bits, little); writeWord(bytes, at + 16, size, bits, little); - writeWord(bytes, at + 20, size, bits, little); + writeWord(bytes, at + 20, memorySize, bits, little); write32(bytes, at + 24, flags, little); writeWord(bytes, at + 28, align, bits, little); }; @@ -408,7 +413,9 @@ interface FixtureConfig { readonly sectionSizes: Readonly>; readonly sectionEntrySizes: Readonly>; readonly omitSymentTag: boolean; + readonly omitSymtabTag: boolean; readonly splitLoadAtHash: boolean; + readonly versymZeroFillOffset: number | undefined; } interface DependencyTables { @@ -505,7 +512,9 @@ const fixtureConfig = (options: ElfDependencyFixtureOptions): FixtureConfig => { sectionSizes: options.sectionSizes ?? {}, sectionEntrySizes: options.sectionEntrySizes ?? {}, omitSymentTag: options.omitSymentTag === true, + omitSymtabTag: options.omitSymtabTag === true, splitLoadAtHash: options.splitLoadAtHash === true, + versymZeroFillOffset: options.versymZeroFillOffset, }; }; @@ -643,7 +652,7 @@ const buildDynamicTags = ( addTag(4, offsets.hashOff); if (tables.gnuHashBytes.length !== 0) addTag(0x6ffffef5, offsets.gnuHashOff); addTag(5, offsets.dynstrOff); - addTag(6, offsets.dynsymOff); + if (!config.omitSymtabTag) addTag(6, offsets.dynsymOff); addTag(10, tables.dynstrBytes.length); if (!config.omitSymentTag) addTag(11, bits === 64 ? 24 : 16); addTag(0x6ffffff0, offsets.versymOff); @@ -680,7 +689,8 @@ const layoutDependencyImage = ( const programCount = (config.interpreter === null ? 0 : 1) + (config.splitLoadAtHash ? 2 : 1) + - (config.omitDynamic ? 0 : 1); + (config.omitDynamic ? 0 : 1) + + (config.versymZeroFillOffset === undefined ? 0 : 1); const phoff = headerSize; let cursor = phoff + programCount * phent; const place = (size: number): number => { @@ -830,6 +840,20 @@ const writeDependencyPrograms = ( } else add(1, 5, 0, layout.fileSize, 0x1000); if (!config.omitDynamic) add(2, 6, layout.dynamicOff, layout.dynamicBytes.length, 8); + if (config.versymZeroFillOffset !== undefined) + writeProgramHeader( + bytes, + layout.phoff + programIndex * layout.phent, + config.bits, + config.little, + 1, + 4, + 0, + 0, + 1, + layout.versymOff + config.versymZeroFillOffset, + 1, + ); }; const writeDependencySections = ( diff --git a/src/native/elf/ElfDependencyParser.ts b/src/native/elf/ElfDependencyParser.ts index 14bdb07c54..64a69b052c 100644 --- a/src/native/elf/ElfDependencyParser.ts +++ b/src/native/elf/ElfDependencyParser.ts @@ -523,6 +523,45 @@ const tableFromVirtual = ( }; }; +const GNU_VERSYM_SLOT_BYTES = 2; + +/** Keep complete leading slots in one proven file translation. */ +const tableFromMappedVersym = ( + mappings: ElfLoadMappings, + address: bigint | undefined, + count: number, +): LocatedTable | null => { + if (address === undefined) return null; + const complete = tableFromVirtual( + mappings, + address, + count * GNU_VERSYM_SLOT_BYTES, + ); + if (complete !== null || count <= 1) return complete; + + const mapping = createFileMappingIndex( + mappings.fileBacked, + mappings.zeroFills, + ); + let low = 0; + let high = count - 1; + let offset: number | null = null; + // A mapped prefix proves every shorter span at the same start. + while (low < high) { + const slots = Math.ceil((low + high) / 2); + try { + offset = mapping.offset(address, slots * GNU_VERSYM_SLOT_BYTES); + low = slots; + } catch (cause) { + if (!(cause instanceof BinaryMappingFailure)) throw cause; + high = slots - 1; + } + } + if (offset === null) return null; + const size = low * GNU_VERSYM_SLOT_BYTES; + return { offset, size, location: { offset, bytes: size } }; +}; + /** * Reads hash-table words from file bytes `[base, end)`. File mapping stays * here; `elfHashSymbolCount.ts` owns the DT_HASH and DT_GNU_HASH layouts. @@ -1058,7 +1097,7 @@ export const readElfDependenciesSteps = function* ( tableFromSection(versymSection, bytes.length, "GNU versym", issues) ?? (symbolCount === null ? null - : tableFromVirtual(mappings, addresses.get(DT_VERSYM), symbolCount * 2)); + : tableFromMappedVersym(mappings, addresses.get(DT_VERSYM), symbolCount)); if ( dynsymTable === null && symbolCount !== null && @@ -1081,12 +1120,29 @@ export const readElfDependenciesSteps = function* ( message: "GNU versym table could not be located from section headers or DT_VERSYM", }); + const versymSlots = + versymTable === null + ? null + : { + offset: versymTable.offset, + count: Math.floor(versymTable.size / GNU_VERSYM_SLOT_BYTES), + }; + if ( + versymSlots !== null && + symbolCount !== null && + versymSlots.count < symbolCount + ) + issues.push({ + code: "table_unavailable", + location: hex(versymSlots.offset), + message: `GNU versym table holds ${String(versymSlots.count)} of ${String(symbolCount)} dynamic symbol slots; later slots were not read`, + }); const imports = parseImports( reader, bytes, bits, dynsymTable, - versymTable, + versymSlots, dynstr, symbolCount, symbolEntrySize, @@ -1578,7 +1634,7 @@ const parseImports = ( bytes: Buffer, bits: 32 | 64, dynsym: LocatedTable | null, - versym: LocatedTable | null, + versym: { readonly offset: number; readonly count: number } | null, dynstr: DynamicStrings, declaredCount: number | null, entrySize: number, @@ -1623,17 +1679,13 @@ const parseImports = ( } let versymBytes: Buffer | null = null; if (versym !== null) { - // A short table still holds whole slots for its leading symbols; keep those - // and leave only the symbols past its end without a version. - const slotCount = Math.min(symbolCount, Math.floor(versym.size / 2)); - if (slotCount < symbolCount) - issues.push({ - code: "table_unavailable", - location: hex(versym.offset), - message: `GNU versym table holds ${String(slotCount)} of ${String(symbolCount)} dynamic symbol slots; later imports have no version`, - }); + const slotCount = Math.min(symbolCount, versym.count); try { - versymBytes = reader.range(versym.offset, slotCount * 2, "GNU versym"); + versymBytes = reader.range( + versym.offset, + slotCount * GNU_VERSYM_SLOT_BYTES, + "GNU versym", + ); } catch (cause) { if (!(cause instanceof BinaryFormatFailure)) throw cause; issues.push({ @@ -1673,9 +1725,12 @@ const parseImports = ( `dynsym[${String(index)}]`, ); let version: ElfDependencyImport["version"] = null; - if (versymBytes !== null && (index + 1) * 2 <= versymBytes.length) { + if ( + versymBytes !== null && + (index + 1) * GNU_VERSYM_SLOT_BYTES <= versymBytes.length + ) { const raw = new BinaryReader(versymBytes, reader.little, "elf").u16( - index * 2, + index * GNU_VERSYM_SLOT_BYTES, ); const versionIndex = raw & 0x7fff; const hidden = (raw & 0x8000) !== 0; @@ -1700,7 +1755,9 @@ const parseImports = ( if (resolved === undefined) issues.push({ code: "version_unresolved", - location: hex((versym?.offset ?? 0) + index * 2), + location: hex( + (versym?.offset ?? 0) + index * GNU_VERSYM_SLOT_BYTES, + ), message: `Import ${name ?? `#${String(index)}`} references version index ${String(versionIndex)} with no matching verneed record`, }); } diff --git a/tests/acceptance/elfDependenciesCli.test.ts b/tests/acceptance/elfDependenciesCli.test.ts index eb12d34daa..c5d89de635 100644 --- a/tests/acceptance/elfDependenciesCli.test.ts +++ b/tests/acceptance/elfDependenciesCli.test.ts @@ -275,3 +275,109 @@ for (const tableAvailable of [true, false]) { }, ); } + +cliTest( + "retains backed leading GNU version slots without section headers", + async ({ cli }) => { + const root = await createTestTempDirectory("rea-elf-dependencies-versym-"); + for (const { label, alias, versions, coverage } of [ + { + label: "complete", + alias: undefined, + versions: [ + "GLIBC_2.34", + "GLIBC_2.2.5", + "GLIBCXX_3.4.29", + null, + "GLIBC_2.2.5", + ], + coverage: "complete", + }, + { + label: "later-byte-ambiguous", + alias: 7, + versions: ["GLIBC_2.34", "GLIBC_2.2.5", null, null, null], + coverage: "partial", + }, + { + label: "first-slot-ambiguous", + alias: 1, + versions: [null, null, null, null, null], + coverage: "partial", + }, + ]) { + const path = join(root, label); + await writeFile( + path, + elfDependencyFixture({ + stripped: true, + ...(alias === undefined ? {} : { versymZeroFillOffset: alias }), + }), + ); + const result = await cli.run({ + arguments: ["inspect-elf-dependencies", path, "--json"], + }); + expect(result.exitCode, JSON.stringify(result.json)).toBe(0); + const report = dependenciesContract.outputSchema.parse( + result.json, + ).normalized_result; + if (!("imports" in report)) + throw new Error("Expected an inline ELF dependency inventory"); + expect(report.coverage.status, label).toBe(coverage); + expect( + report.imports.map(({ name }) => name), + label, + ).toEqual(["printf", "memcpy", "_ZSt4cout", "abort", "_exit"]); + expect( + report.imports.map(({ version }) => version?.name ?? null), + label, + ).toEqual(versions); + if (alias !== undefined) { + const blocked = report.imports.slice(alias === 7 ? 2 : 0); + expect( + blocked.map(({ version }) => version), + label, + ).toEqual(blocked.map(() => null)); + } + if (alias === 7) + expect(report.issues, label).toContainEqual( + expect.objectContaining({ code: "table_unavailable" }), + ); + } + }, +); + +cliTest( + "reports short GNU version tables when the symbol table is unavailable", + async ({ cli }) => { + const root = await createTestTempDirectory( + "rea-elf-dependencies-short-versym-", + ); + const path = join(root, "program"); + await writeFile( + path, + elfDependencyFixture({ + stripped: true, + omitSymtabTag: true, + versymZeroFillOffset: 7, + }), + ); + const result = await cli.run({ + arguments: ["inspect-elf-dependencies", path, "--json"], + }); + expect(result.exitCode, JSON.stringify(result.json)).toBe(0); + const report = dependenciesContract.outputSchema.parse( + result.json, + ).normalized_result; + if (!("imports" in report)) + throw new Error("Expected an inline ELF dependency inventory"); + expect(report.coverage).toMatchObject({ + status: "partial", + examined_imports: 0, + }); + expect(report.imports).toEqual([]); + expect(report.issues).toContainEqual( + expect.objectContaining({ code: "table_unavailable" }), + ); + }, +);