mirror of
https://github.com/morluto/rea.git
synced 2026-11-20 13:45:30 +00:00
Admit exact string heap aliases and retain independent Module row facts for distinct declarations. Bind the optional partial row to the same scope checks as named Module Evidence.
265 lines
8.1 KiB
TypeScript
265 lines
8.1 KiB
TypeScript
import type {
|
|
ManagedArtifactInspection,
|
|
ManagedParseIssue,
|
|
NamedManagedModule,
|
|
UnresolvedManagedModuleName,
|
|
} from "./managedArtifact.js";
|
|
import {
|
|
METADATA_TABLE_NAMES,
|
|
type ManagedMetadataLayout,
|
|
type MetadataTableLayout,
|
|
} from "./managedMetadataLayout.js";
|
|
import {
|
|
readAssembly,
|
|
readAssemblyReference,
|
|
readCustomAttribute,
|
|
readModule,
|
|
readResource,
|
|
managedMetadataTypeNames,
|
|
type ManagedMetadataTypeNameLookup,
|
|
} from "./managedMetadataInventoryRows.js";
|
|
import { metadataToken } from "./managedMetadataHeaps.js";
|
|
import type { TypeMemberListFacts } from "./managedTypeMemberLists.js";
|
|
import {
|
|
appendManagedParseIssues,
|
|
readManagedValue,
|
|
uniqueManagedParseIssues,
|
|
} from "./managedReaderFailure.js";
|
|
import type { ManagedPeLayout } from "./managedPeReader.js";
|
|
|
|
type AssemblyIdentity = NonNullable<ManagedArtifactInspection["assembly"]>;
|
|
type AssemblyReference = ManagedArtifactInspection["references"][number];
|
|
type ManagedResource = ManagedArtifactInspection["resources"][number];
|
|
type CustomAttribute = ManagedArtifactInspection["attributes"][number];
|
|
export interface ManagedResourceDirectory {
|
|
readonly offset: number;
|
|
readonly size: number;
|
|
}
|
|
|
|
/** Map optional embedded resources without discarding admitted CLI metadata. */
|
|
export const readManagedResourceDirectory = (
|
|
pe: ManagedPeLayout,
|
|
issues: ManagedParseIssue[],
|
|
): ManagedResourceDirectory | null => {
|
|
const resources = pe.cli?.resources;
|
|
if (resources === undefined || (resources.rva === 0 && resources.size === 0))
|
|
return null;
|
|
return (
|
|
readManagedValue(
|
|
() => ({
|
|
offset: pe.rvaToOffset(resources.rva, resources.size, "cli.resources"),
|
|
size: resources.size,
|
|
}),
|
|
issues,
|
|
) ?? null
|
|
);
|
|
};
|
|
|
|
export interface ManagedMetadataInventory {
|
|
readonly module: NamedManagedModule | null;
|
|
readonly unresolvedModuleName: UnresolvedManagedModuleName | null;
|
|
readonly assembly: AssemblyIdentity | null;
|
|
readonly targetFrameworks: readonly string[];
|
|
readonly referenceNames: readonly string[];
|
|
readonly references: readonly AssemblyReference[];
|
|
readonly resources: readonly ManagedResource[];
|
|
readonly attributes: readonly CustomAttribute[];
|
|
readonly issues: readonly ManagedParseIssue[];
|
|
}
|
|
|
|
const readRows = <Item>(
|
|
descriptor: MetadataTableLayout | undefined,
|
|
read: (row: number) => Item | undefined,
|
|
): readonly Item[] => {
|
|
const total = descriptor?.rowCount ?? 0;
|
|
const items: Item[] = [];
|
|
for (let index = 0; index < total; index += 1) {
|
|
const item = read(index + 1);
|
|
if (item !== undefined) items.push(item);
|
|
}
|
|
return items;
|
|
};
|
|
|
|
const validateIdentityTableCounts = (
|
|
layout: ManagedMetadataLayout,
|
|
issues: ManagedParseIssue[],
|
|
): void => {
|
|
const moduleRows = layout.table(0)?.rowCount ?? 0;
|
|
if (moduleRows !== 1)
|
|
issues.push({
|
|
code: "invalid-row",
|
|
scope: "metadata.Module",
|
|
offset: layout.table(0)?.offset ?? null,
|
|
detail: `Module table must contain exactly one row; found ${String(moduleRows)}`,
|
|
});
|
|
|
|
const assemblyRows = layout.table(32)?.rowCount ?? 0;
|
|
if (assemblyRows > 1)
|
|
issues.push({
|
|
code: "invalid-row",
|
|
scope: "metadata.Assembly",
|
|
offset: layout.table(32)?.offset ?? null,
|
|
detail: `Assembly table can contain at most one row; found ${String(assemblyRows)}`,
|
|
});
|
|
};
|
|
|
|
/** Module identity is independent of assembly references, attributes and resources. */
|
|
export const readManagedModuleIdentity = (
|
|
bytes: Buffer,
|
|
layout: ManagedMetadataLayout,
|
|
): Pick<
|
|
ManagedMetadataInventory,
|
|
"module" | "unresolvedModuleName" | "issues"
|
|
> => {
|
|
const issues: ManagedParseIssue[] =
|
|
layout.guid.issue === null ? [] : [layout.guid.issue];
|
|
if (layout.blob?.issue) issues.push(layout.blob.issue);
|
|
if (layout.strings.issue !== null) issues.push(layout.strings.issue);
|
|
validateIdentityTableCounts(layout, issues);
|
|
const row = readManagedValue(() => readModule(bytes, layout, issues), issues);
|
|
return {
|
|
module: row?.name === null ? null : (row ?? null),
|
|
unresolvedModuleName: row?.name === null ? row : null,
|
|
issues,
|
|
};
|
|
};
|
|
|
|
const readReferences = (
|
|
bytes: Buffer,
|
|
layout: ManagedMetadataLayout,
|
|
issues: ManagedParseIssue[],
|
|
): {
|
|
readonly references: readonly AssemblyReference[];
|
|
readonly referenceNames: readonly string[];
|
|
} => {
|
|
const referenceNames = new Set<string>();
|
|
const references = readRows(layout.table(35), (row) => {
|
|
const observed = readManagedValue(
|
|
() => readAssemblyReference(bytes, layout, row),
|
|
issues,
|
|
);
|
|
if (observed === undefined) return undefined;
|
|
referenceNames.add(observed.name);
|
|
return observed.reference ?? undefined;
|
|
});
|
|
return { references, referenceNames: [...referenceNames].sort() };
|
|
};
|
|
|
|
const readResources = ({
|
|
bytes,
|
|
layout,
|
|
resourceDirectory,
|
|
issues,
|
|
}: {
|
|
readonly bytes: Buffer;
|
|
readonly layout: ManagedMetadataLayout;
|
|
readonly resourceDirectory: ManagedResourceDirectory | null;
|
|
readonly issues: ManagedParseIssue[];
|
|
}): readonly ManagedResource[] =>
|
|
readRows(layout.table(40), (row) =>
|
|
readManagedValue(
|
|
() =>
|
|
readResource({
|
|
bytes,
|
|
layout,
|
|
row,
|
|
directory: resourceDirectory,
|
|
issues,
|
|
}),
|
|
issues,
|
|
),
|
|
);
|
|
|
|
const readAttributes = (
|
|
bytes: Buffer,
|
|
layout: ManagedMetadataLayout,
|
|
issues: ManagedParseIssue[],
|
|
memberLists: TypeMemberListFacts,
|
|
typeNames: ManagedMetadataTypeNameLookup,
|
|
): {
|
|
readonly attributes: readonly CustomAttribute[];
|
|
readonly targetFrameworks: readonly string[];
|
|
} => {
|
|
const attributes = readRows(layout.table(12), (row) =>
|
|
readManagedValue(
|
|
() =>
|
|
readCustomAttribute(bytes, layout, row, issues, memberLists, typeNames),
|
|
issues,
|
|
),
|
|
);
|
|
const targetFrameworks = new Set<string>();
|
|
for (const attribute of attributes) {
|
|
if (
|
|
attribute.parent_token === metadataToken(32, 1) &&
|
|
attribute.type_name ===
|
|
"System.Runtime.Versioning.TargetFrameworkAttribute" &&
|
|
attribute.decoded_fixed_string !== null
|
|
)
|
|
targetFrameworks.add(attribute.decoded_fixed_string);
|
|
}
|
|
return { attributes, targetFrameworks: [...targetFrameworks].sort() };
|
|
};
|
|
|
|
/** Inventory identity tables without CLR reflection or execution. */
|
|
export const readManagedMetadataInventory = (
|
|
bytes: Buffer,
|
|
layout: ManagedMetadataLayout,
|
|
resourceDirectory: ManagedResourceDirectory | null,
|
|
memberLists: TypeMemberListFacts,
|
|
identity: Pick<
|
|
ManagedMetadataInventory,
|
|
"module" | "unresolvedModuleName" | "issues"
|
|
> = readManagedModuleIdentity(bytes, layout),
|
|
typeNames?: ManagedMetadataTypeNameLookup,
|
|
): ManagedMetadataInventory => {
|
|
const issues: ManagedParseIssue[] = [...memberLists.issues];
|
|
appendManagedParseIssues(issues, identity.issues);
|
|
const { module, unresolvedModuleName } = identity;
|
|
const assembly =
|
|
readManagedValue(() => readAssembly(bytes, layout), issues) ?? null;
|
|
const { references, referenceNames } = readReferences(bytes, layout, issues);
|
|
const resources = readResources({
|
|
bytes,
|
|
layout,
|
|
resourceDirectory,
|
|
issues,
|
|
});
|
|
const { attributes, targetFrameworks } = readAttributes(
|
|
bytes,
|
|
layout,
|
|
issues,
|
|
memberLists,
|
|
typeNames ?? managedMetadataTypeNames(bytes, layout, issues),
|
|
);
|
|
return {
|
|
module,
|
|
unresolvedModuleName,
|
|
assembly,
|
|
targetFrameworks,
|
|
referenceNames,
|
|
references,
|
|
resources,
|
|
attributes,
|
|
issues: uniqueManagedParseIssues(issues),
|
|
};
|
|
};
|
|
|
|
/** Add row-local identity only when the checked Module row has an unresolved name. */
|
|
export const unresolvedModuleMetadata = (
|
|
identity: Pick<ManagedMetadataInventory, "unresolvedModuleName">,
|
|
): { readonly unresolved_module_name?: UnresolvedManagedModuleName } =>
|
|
identity.unresolvedModuleName === null
|
|
? {}
|
|
: { unresolved_module_name: identity.unresolvedModuleName };
|
|
|
|
/** Stable table-name/count projection for caller-visible coverage. */
|
|
export const managedTableRowCounts = (
|
|
layout: ManagedMetadataLayout,
|
|
): Readonly<Record<string, number>> =>
|
|
Object.fromEntries(
|
|
[...layout.tables.values()].map(({ index, rowCount }) => [
|
|
METADATA_TABLE_NAMES[index] ?? `Table${String(index)}`,
|
|
rowCount,
|
|
]),
|
|
);
|