test(dotnet): add managed conformance verifier
This commit is contained in:
@@ -0,0 +1,386 @@
|
||||
import { Buffer } from "node:buffer";
|
||||
|
||||
const textEncoder = new TextEncoder();
|
||||
|
||||
const DEFAULT_MVID = Buffer.from([
|
||||
0x33, 0x22, 0x11, 0x00, 0x55, 0x44, 0x77, 0x66, 0x88, 0x99, 0xaa, 0xbb, 0xcc,
|
||||
0xdd, 0xee, 0xff,
|
||||
]);
|
||||
|
||||
const align4 = (value) => (value + 3) & ~3;
|
||||
const cString = (value) => Buffer.from(`${value}\0`, "utf8");
|
||||
|
||||
class StringHeap {
|
||||
#chunks = [Buffer.from([0])];
|
||||
#size = 1;
|
||||
|
||||
add(value) {
|
||||
if (value.length === 0) return 0;
|
||||
const index = this.#size;
|
||||
const chunk = cString(value);
|
||||
this.#chunks.push(chunk);
|
||||
this.#size += chunk.length;
|
||||
return index;
|
||||
}
|
||||
|
||||
toBuffer() {
|
||||
return Buffer.concat(this.#chunks);
|
||||
}
|
||||
}
|
||||
|
||||
class BlobHeap {
|
||||
#chunks = [Buffer.from([0])];
|
||||
#size = 1;
|
||||
|
||||
add(value) {
|
||||
if (value.length === 0) return 0;
|
||||
if (value.length > 0x7f)
|
||||
throw new RangeError("Managed PE fixture blob is too large");
|
||||
const index = this.#size;
|
||||
this.#chunks.push(Buffer.from([value.length]), value);
|
||||
this.#size += value.length + 1;
|
||||
return index;
|
||||
}
|
||||
|
||||
toBuffer() {
|
||||
return Buffer.concat(this.#chunks);
|
||||
}
|
||||
}
|
||||
|
||||
const u16 = (value) => {
|
||||
const bytes = Buffer.alloc(2);
|
||||
bytes.writeUInt16LE(value, 0);
|
||||
return bytes;
|
||||
};
|
||||
|
||||
const u32 = (value) => {
|
||||
const bytes = Buffer.alloc(4);
|
||||
bytes.writeUInt32LE(value, 0);
|
||||
return bytes;
|
||||
};
|
||||
|
||||
const guidHeap = (mvid = DEFAULT_MVID) => {
|
||||
if (mvid.length !== 16)
|
||||
throw new RangeError("Managed PE fixture MVID must be 16 bytes");
|
||||
return Buffer.from(mvid);
|
||||
};
|
||||
|
||||
const moduleRow = (name) =>
|
||||
Buffer.concat([u16(0), u16(name), u16(1), u16(0), u16(0)]);
|
||||
|
||||
const typeRefRow = (name, namespace) =>
|
||||
Buffer.concat([u16(0), u16(name), u16(namespace)]);
|
||||
|
||||
const typeDefRow = (name, namespace, fieldList, methodList) =>
|
||||
Buffer.concat([
|
||||
u32(0x0010_0001),
|
||||
u16(name),
|
||||
u16(namespace),
|
||||
u16((1 << 2) | 1),
|
||||
u16(fieldList),
|
||||
u16(methodList),
|
||||
]);
|
||||
|
||||
const fieldRow = (name, signature) =>
|
||||
Buffer.concat([u16(0x0001), u16(name), u16(signature)]);
|
||||
|
||||
const methodDefRow = ({
|
||||
flags = 0x0016,
|
||||
implFlags = 0,
|
||||
name,
|
||||
rva,
|
||||
signature,
|
||||
}) =>
|
||||
Buffer.concat([
|
||||
u32(rva),
|
||||
u16(implFlags),
|
||||
u16(flags),
|
||||
u16(name),
|
||||
u16(signature),
|
||||
u16(0),
|
||||
]);
|
||||
|
||||
const memberRefRow = (name, signature) =>
|
||||
Buffer.concat([u16((1 << 3) | 1), u16(name), u16(signature)]);
|
||||
|
||||
const moduleRefRow = (name) => Buffer.concat([u16(name)]);
|
||||
|
||||
const implMapRow = (importName, importScope, mappingFlags, memberRow = 1) =>
|
||||
Buffer.concat([
|
||||
u16(mappingFlags),
|
||||
u16((memberRow << 1) | 1),
|
||||
u16(importName),
|
||||
u16(importScope),
|
||||
]);
|
||||
|
||||
const assemblyRow = (name) =>
|
||||
Buffer.concat([
|
||||
u32(0x0000_8004),
|
||||
u16(1),
|
||||
u16(2),
|
||||
u16(3),
|
||||
u16(4),
|
||||
u32(0),
|
||||
u16(0),
|
||||
u16(name),
|
||||
u16(0),
|
||||
]);
|
||||
|
||||
const assemblyRefRow = (name, keyOrToken) =>
|
||||
Buffer.concat([
|
||||
u16(8),
|
||||
u16(0),
|
||||
u16(0),
|
||||
u16(0),
|
||||
u32(0),
|
||||
u16(keyOrToken),
|
||||
u16(name),
|
||||
u16(0),
|
||||
u16(0),
|
||||
]);
|
||||
|
||||
const customAttributeRow = (value) =>
|
||||
Buffer.concat([u16((1 << 5) | 14), u16((1 << 3) | 3), u16(value)]);
|
||||
|
||||
const manifestResourceRow = (name) =>
|
||||
Buffer.concat([u32(0), u32(2), u16(name), u16(0)]);
|
||||
|
||||
const fixedStringAttributeBlob = (value) => {
|
||||
const bytes = Buffer.from(textEncoder.encode(value));
|
||||
if (bytes.length > 0x7f)
|
||||
throw new RangeError("Managed PE fixture target framework is too long");
|
||||
return Buffer.concat([Buffer.from([1, 0, bytes.length]), bytes, u16(0)]);
|
||||
};
|
||||
|
||||
const metadataStreamHeader = (relativeOffset, size, name) => {
|
||||
const named = cString(name);
|
||||
const paddedName = Buffer.alloc(align4(named.length));
|
||||
named.copy(paddedName);
|
||||
return Buffer.concat([u32(relativeOffset), u32(size), paddedName]);
|
||||
};
|
||||
|
||||
const metadataRoot = (tables, strings, guid, blob) => {
|
||||
const version = Buffer.from("v4.0.30319\0\0", "utf8");
|
||||
const header = Buffer.concat([
|
||||
u32(0x424a_5342),
|
||||
u16(1),
|
||||
u16(1),
|
||||
u32(0),
|
||||
u32(version.length),
|
||||
version,
|
||||
u16(0),
|
||||
u16(4),
|
||||
]);
|
||||
const streamHeaderSize =
|
||||
metadataStreamHeader(0, 0, "#~").length +
|
||||
metadataStreamHeader(0, 0, "#Strings").length +
|
||||
metadataStreamHeader(0, 0, "#GUID").length +
|
||||
metadataStreamHeader(0, 0, "#Blob").length;
|
||||
let offset = align4(header.length + streamHeaderSize);
|
||||
const tablesOffset = offset;
|
||||
offset = align4(offset + tables.length);
|
||||
const stringsOffset = offset;
|
||||
offset = align4(offset + strings.length);
|
||||
const guidOffset = offset;
|
||||
offset = align4(offset + guid.length);
|
||||
const blobOffset = offset;
|
||||
const headers = Buffer.concat([
|
||||
metadataStreamHeader(tablesOffset, tables.length, "#~"),
|
||||
metadataStreamHeader(stringsOffset, strings.length, "#Strings"),
|
||||
metadataStreamHeader(guidOffset, guid.length, "#GUID"),
|
||||
metadataStreamHeader(blobOffset, blob.length, "#Blob"),
|
||||
]);
|
||||
const root = Buffer.alloc(align4(blobOffset + blob.length));
|
||||
header.copy(root, 0);
|
||||
headers.copy(root, header.length);
|
||||
tables.copy(root, tablesOffset);
|
||||
strings.copy(root, stringsOffset);
|
||||
guid.copy(root, guidOffset);
|
||||
blob.copy(root, blobOffset);
|
||||
return root;
|
||||
};
|
||||
|
||||
const tablesStream = (rows, extraValidMask = 0n) => {
|
||||
let valid = extraValidMask;
|
||||
for (const table of rows.keys()) valid |= 1n << BigInt(table);
|
||||
const header = Buffer.alloc(24);
|
||||
header.writeUInt8(2, 4);
|
||||
header.writeUInt8(1, 7);
|
||||
header.writeBigUInt64LE(valid, 8);
|
||||
const counts = [];
|
||||
for (let index = 0; index <= 44; index += 1) {
|
||||
const tableRows = rows.get(index);
|
||||
if (tableRows !== undefined) counts.push(u32(tableRows.length));
|
||||
}
|
||||
const data = [];
|
||||
for (let index = 0; index <= 44; index += 1) {
|
||||
const tableRows = rows.get(index);
|
||||
if (tableRows !== undefined) data.push(...tableRows);
|
||||
}
|
||||
return Buffer.concat([header, ...counts, ...data]);
|
||||
};
|
||||
|
||||
const defaultIlBody = Buffer.from([
|
||||
0x32, 0x02, 0x7b, 0x01, 0x00, 0x00, 0x04, 0x28, 0x01, 0x00, 0x00, 0x0a, 0x2a,
|
||||
]);
|
||||
|
||||
const retOnlyIlBody = Buffer.from([0x2a]);
|
||||
|
||||
export const alternateMvid = Buffer.from([
|
||||
0xde, 0xad, 0xbe, 0xef, 0x44, 0x33, 0x66, 0x55, 0xaa, 0xbb, 0xcc, 0xdd, 0xee,
|
||||
0xff, 0x11, 0x22,
|
||||
]);
|
||||
|
||||
/** Build a source-owned PE/CLI fixture without committing compiled binaries. */
|
||||
export const buildManagedPeFixture = (options = {}) => {
|
||||
const strings = new StringHeap();
|
||||
const blobs = new BlobHeap();
|
||||
const methods = options.methods ?? [
|
||||
{
|
||||
name: options.methodName ?? "Main",
|
||||
body: options.ilBody ?? defaultIlBody,
|
||||
flags: options.pinvoke === undefined ? 0x0016 : 0x2016,
|
||||
implFlags: options.methodImplFlags ?? 0,
|
||||
},
|
||||
];
|
||||
const stringsForMethods = methods.map((method) => strings.add(method.name));
|
||||
const moduleName = strings.add("Fixture.dll");
|
||||
const assemblyName = strings.add("Fixture.Managed");
|
||||
const attributeName = strings.add("TargetFrameworkAttribute");
|
||||
const attributeNamespace = strings.add("System.Runtime.Versioning");
|
||||
const constructorName = strings.add(".ctor");
|
||||
const typeName = strings.add(options.typeName ?? "Program");
|
||||
const typeNamespace = strings.add(options.typeNamespace ?? "Fixture");
|
||||
const fieldName = strings.add(options.fieldName ?? "counter");
|
||||
const pinvokeModuleName =
|
||||
options.pinvoke === undefined
|
||||
? null
|
||||
: strings.add(options.pinvoke.moduleName ?? "user32.dll");
|
||||
const pinvokeImportName =
|
||||
options.pinvoke === undefined
|
||||
? null
|
||||
: strings.add(options.pinvoke.importName ?? "MessageBoxW");
|
||||
const resourceName = strings.add("Fixture.resources");
|
||||
const referenceNames = options.references ?? ["System.Runtime"];
|
||||
const referenceStringIndexes = referenceNames.map((name) =>
|
||||
strings.add(name),
|
||||
);
|
||||
const tokenBlob = blobs.add(Buffer.from("b77a5c561934e089", "hex"));
|
||||
const fieldSignature = blobs.add(Buffer.from([0x06, 0x08]));
|
||||
const methodSignature = blobs.add(Buffer.from([0x00, 0x00, 0x01]));
|
||||
const constructorSignature = blobs.add(Buffer.from([0x20, 0x01, 0x01, 0x0e]));
|
||||
const attributeBlob = blobs.add(
|
||||
fixedStringAttributeBlob(
|
||||
options.targetFramework ?? ".NETCoreApp,Version=v8.0",
|
||||
),
|
||||
);
|
||||
const methodRows = methods.map((method, index) =>
|
||||
methodDefRow({
|
||||
name: stringsForMethods[index],
|
||||
signature: methodSignature,
|
||||
rva: method.rva ?? 0x2800 + index * 0x20,
|
||||
flags: method.flags ?? 0x0016,
|
||||
implFlags: method.implFlags ?? 0,
|
||||
}),
|
||||
);
|
||||
const rows = new Map([
|
||||
[0, [moduleRow(moduleName)]],
|
||||
[1, [typeRefRow(attributeName, attributeNamespace)]],
|
||||
[2, [typeDefRow(typeName, typeNamespace, 1, 1)]],
|
||||
[4, [fieldRow(fieldName, fieldSignature)]],
|
||||
[6, methodRows],
|
||||
[10, [memberRefRow(constructorName, constructorSignature)]],
|
||||
[12, [customAttributeRow(attributeBlob)]],
|
||||
...(pinvokeModuleName === null
|
||||
? []
|
||||
: [[26, [moduleRefRow(pinvokeModuleName)]]]),
|
||||
...(pinvokeImportName === null
|
||||
? []
|
||||
: [
|
||||
[
|
||||
28,
|
||||
[
|
||||
implMapRow(
|
||||
pinvokeImportName,
|
||||
1,
|
||||
options.pinvoke?.mappingFlags ?? 0x0344,
|
||||
options.pinvoke?.memberRow ?? 1,
|
||||
),
|
||||
],
|
||||
],
|
||||
]),
|
||||
[32, [assemblyRow(assemblyName)]],
|
||||
[35, referenceStringIndexes.map((name) => assemblyRefRow(name, tokenBlob))],
|
||||
[40, [manifestResourceRow(resourceName)]],
|
||||
]);
|
||||
const metadata = metadataRoot(
|
||||
tablesStream(rows, options.metadataValidMaskExtra ?? 0n),
|
||||
strings.toBuffer(),
|
||||
guidHeap(options.mvid),
|
||||
blobs.toBuffer(),
|
||||
);
|
||||
if (options.corruptMetadataSignature === true) metadata.writeUInt32LE(0, 0);
|
||||
const resourceData = options.resourceData ?? Buffer.from("resource-data");
|
||||
const resourceDirectory = Buffer.concat([
|
||||
u32(resourceData.length),
|
||||
resourceData,
|
||||
]);
|
||||
const image = Buffer.alloc(0x1000);
|
||||
image.write("MZ", 0, "ascii");
|
||||
image.writeUInt32LE(0x80, 0x3c);
|
||||
image.writeUInt32LE(0x0000_4550, 0x80);
|
||||
const coff = 0x84;
|
||||
image.writeUInt16LE(options.machine ?? 0x014c, coff);
|
||||
image.writeUInt16LE(1, coff + 2);
|
||||
image.writeUInt16LE(0x00e0, coff + 16);
|
||||
image.writeUInt16LE(0x0102, coff + 18);
|
||||
const optional = coff + 20;
|
||||
image.writeUInt16LE(0x010b, optional);
|
||||
image.writeUInt32LE(0x2000, optional + 20);
|
||||
image.writeUInt32LE(0x0040_0000, optional + 28);
|
||||
image.writeUInt32LE(0x1000, optional + 32);
|
||||
image.writeUInt32LE(0x200, optional + 36);
|
||||
image.writeUInt32LE(0x3000, optional + 56);
|
||||
image.writeUInt32LE(0x200, optional + 60);
|
||||
image.writeUInt32LE(16, optional + 92);
|
||||
image.writeUInt32LE(0x2000, optional + 96 + 14 * 8);
|
||||
image.writeUInt32LE(72, optional + 96 + 14 * 8 + 4);
|
||||
const section = optional + 0x00e0;
|
||||
image.write(".text\0\0\0", section, "ascii");
|
||||
image.writeUInt32LE(0x1000, section + 8);
|
||||
image.writeUInt32LE(0x2000, section + 12);
|
||||
image.writeUInt32LE(0x0e00, section + 16);
|
||||
image.writeUInt32LE(0x0200, section + 20);
|
||||
image.writeUInt32LE(0x6000_0020, section + 36);
|
||||
const cli = 0x0200;
|
||||
image.writeUInt32LE(72, cli);
|
||||
image.writeUInt16LE(2, cli + 4);
|
||||
image.writeUInt16LE(5, cli + 6);
|
||||
image.writeUInt32LE(0x2100, cli + 8);
|
||||
image.writeUInt32LE(metadata.length, cli + 12);
|
||||
image.writeUInt32LE(options.cliFlags ?? 1, cli + 16);
|
||||
image.writeUInt32LE(0x0600_0001, cli + 20);
|
||||
image.writeUInt32LE(0x2600, cli + 24);
|
||||
image.writeUInt32LE(resourceDirectory.length, cli + 28);
|
||||
if (options.readyToRun === true) {
|
||||
image.writeUInt32LE(0x2700, cli + 64);
|
||||
image.writeUInt32LE(4, cli + 68);
|
||||
image.write("RTR\0", 0x0900, "ascii");
|
||||
}
|
||||
methods.forEach((method, index) => {
|
||||
const offset = 0x0a00 + index * 0x20;
|
||||
(method.body ?? retOnlyIlBody).copy(image, offset);
|
||||
});
|
||||
metadata.copy(image, 0x0300);
|
||||
resourceDirectory.copy(image, 0x0800);
|
||||
return image;
|
||||
};
|
||||
|
||||
/** Build a syntactically valid PE32 fixture with no CLI directory. */
|
||||
export const buildNativePeFixture = () => {
|
||||
const image = buildManagedPeFixture();
|
||||
const cliDirectory = 0x84 + 20 + 96 + 14 * 8;
|
||||
image.writeUInt32LE(0, cliDirectory);
|
||||
image.writeUInt32LE(0, cliDirectory + 4);
|
||||
return image;
|
||||
};
|
||||
@@ -0,0 +1,274 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { mkdtemp, rm, writeFile } from "node:fs/promises";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import assert from "node:assert/strict";
|
||||
|
||||
import { parseBinaryTarget } from "../dist/domain/binaryTarget.js";
|
||||
import { inspectManagedArtifactBytes } from "../dist/dotnet/ManagedArtifactInspector.js";
|
||||
import { inspectManagedMembersBytes } from "../dist/dotnet/ManagedMemberInspector.js";
|
||||
import { inspectManagedNativeBoundariesBytes } from "../dist/dotnet/ManagedNativeBoundaryInspector.js";
|
||||
import { compareManagedMemberPaths } from "../dist/application/ManagedMemberComparisonService.js";
|
||||
import {
|
||||
alternateMvid,
|
||||
buildManagedPeFixture,
|
||||
buildNativePeFixture,
|
||||
} from "./lib/managed-pe-fixture.mjs";
|
||||
|
||||
const inspectionLimits = {
|
||||
referenceOffset: 0,
|
||||
referenceLimit: 100,
|
||||
resourceOffset: 0,
|
||||
resourceLimit: 100,
|
||||
attributeOffset: 0,
|
||||
attributeLimit: 100,
|
||||
maxMetadataBytes: 1024 * 1024,
|
||||
maxTableRows: 1_000,
|
||||
maxHeapItemBytes: 1024 * 1024,
|
||||
};
|
||||
|
||||
const memberLimits = {
|
||||
typeOffset: 0,
|
||||
typeLimit: 100,
|
||||
methodOffset: 0,
|
||||
methodLimit: 100,
|
||||
fieldOffset: 0,
|
||||
fieldLimit: 100,
|
||||
memberRefOffset: 0,
|
||||
memberRefLimit: 100,
|
||||
edgeOffset: 0,
|
||||
edgeLimit: 100,
|
||||
instructionAnchorLimit: 100,
|
||||
maxMetadataBytes: 1024 * 1024,
|
||||
maxTableRows: 1_000,
|
||||
maxHeapItemBytes: 1024 * 1024,
|
||||
maxMethodBodyBytes: 1024 * 1024,
|
||||
maxMethodInstructions: 1_000,
|
||||
};
|
||||
|
||||
const nativeBoundaryLimits = {
|
||||
moduleRefOffset: 0,
|
||||
moduleRefLimit: 100,
|
||||
importOffset: 0,
|
||||
importLimit: 100,
|
||||
implementationOffset: 0,
|
||||
implementationLimit: 100,
|
||||
maxMetadataBytes: 1024 * 1024,
|
||||
maxTableRows: 1_000,
|
||||
maxHeapItemBytes: 1024 * 1024,
|
||||
};
|
||||
|
||||
const comparisonLimits = {
|
||||
max_method_matches: 100,
|
||||
max_field_matches: 100,
|
||||
max_candidates: 20,
|
||||
};
|
||||
|
||||
const defaultIlBody = Buffer.from([
|
||||
0x32, 0x02, 0x7b, 0x01, 0x00, 0x00, 0x04, 0x28, 0x01, 0x00, 0x00, 0x0a, 0x2a,
|
||||
]);
|
||||
|
||||
const workspace = await mkdtemp(join(tmpdir(), "rea-managed-conformance-"));
|
||||
|
||||
try {
|
||||
const modern = await fixture("modern-anycpu.exe", {
|
||||
references: ["System.Runtime"],
|
||||
resourceData: Buffer.from("source-owned managed resource"),
|
||||
});
|
||||
const modernArtifact = inspectManagedArtifactBytes(
|
||||
modern.bytes,
|
||||
modern.target,
|
||||
inspectionLimits,
|
||||
);
|
||||
assert.equal(modernArtifact.classification.status, "managed");
|
||||
assert.equal(modernArtifact.classification.runtime_family, "modern-dotnet");
|
||||
assert.equal(modernArtifact.classification.managed_architecture, "anycpu");
|
||||
assert.deepEqual(modernArtifact.target_frameworks, [
|
||||
".NETCoreApp,Version=v8.0",
|
||||
]);
|
||||
assert.equal(
|
||||
modernArtifact.resources.items[0]?.data_sha256,
|
||||
sha256(Buffer.from("source-owned managed resource")),
|
||||
);
|
||||
|
||||
const framework = await fixture("framework-x86-pinvoke.exe", {
|
||||
cliFlags: 0x0000_0003,
|
||||
targetFramework: ".NETFramework,Version=v4.8",
|
||||
pinvoke: {
|
||||
moduleName: "user32.dll",
|
||||
importName: "MessageBoxW",
|
||||
mappingFlags: 0x0345,
|
||||
},
|
||||
});
|
||||
const frameworkArtifact = inspectManagedArtifactBytes(
|
||||
framework.bytes,
|
||||
framework.target,
|
||||
inspectionLimits,
|
||||
);
|
||||
assert.equal(
|
||||
frameworkArtifact.classification.runtime_family,
|
||||
"dotnet-framework",
|
||||
);
|
||||
assert.equal(frameworkArtifact.classification.managed_architecture, "x86");
|
||||
const frameworkBoundaries = inspectManagedNativeBoundariesBytes(
|
||||
framework.bytes,
|
||||
framework.target,
|
||||
nativeBoundaryLimits,
|
||||
);
|
||||
assert.equal(frameworkBoundaries.pinvoke_imports.total, 1);
|
||||
assert.equal(
|
||||
frameworkBoundaries.pinvoke_imports.items[0]?.verification,
|
||||
"managed-declaration-only",
|
||||
);
|
||||
assert.equal(
|
||||
frameworkBoundaries.pinvoke_imports.items[0]?.char_set,
|
||||
"unicode",
|
||||
);
|
||||
assert.equal(
|
||||
frameworkBoundaries.pinvoke_imports.items[0]?.call_convention,
|
||||
"stdcall",
|
||||
);
|
||||
|
||||
const readyToRun = await fixture("r2r-x64.exe", {
|
||||
machine: 0x8664,
|
||||
readyToRun: true,
|
||||
methods: [
|
||||
{
|
||||
name: "NativeBody",
|
||||
implFlags: 0x0001,
|
||||
body: Buffer.from([0x2a]),
|
||||
},
|
||||
],
|
||||
});
|
||||
const r2rArtifact = inspectManagedArtifactBytes(
|
||||
readyToRun.bytes,
|
||||
readyToRun.target,
|
||||
inspectionLimits,
|
||||
);
|
||||
assert.equal(r2rArtifact.pe.architecture, "x86_64");
|
||||
assert.equal(
|
||||
r2rArtifact.classification.implementation,
|
||||
"cil-and-ready-to-run",
|
||||
);
|
||||
const r2rBoundaries = inspectManagedNativeBoundariesBytes(
|
||||
readyToRun.bytes,
|
||||
readyToRun.target,
|
||||
nativeBoundaryLimits,
|
||||
);
|
||||
assert.equal(r2rBoundaries.summary.ready_to_run, true);
|
||||
assert.equal(
|
||||
r2rBoundaries.native_implementations.items[0]?.code_type,
|
||||
"native",
|
||||
);
|
||||
assert.equal(
|
||||
r2rBoundaries.native_implementations.items[0]?.boundary_kind,
|
||||
"native-body",
|
||||
);
|
||||
|
||||
const obfuscated = await fixture("obfuscated.exe", {
|
||||
typeName: "ꙮType",
|
||||
methodName: "λ⛧",
|
||||
fieldName: "字段",
|
||||
});
|
||||
const obfuscatedMembers = inspectManagedMembersBytes(
|
||||
obfuscated.bytes,
|
||||
obfuscated.target,
|
||||
memberLimits,
|
||||
);
|
||||
assert.equal(obfuscatedMembers.types.items[0]?.full_name, "Fixture.ꙮType");
|
||||
assert.equal(obfuscatedMembers.methods.items[0]?.name, "λ⛧");
|
||||
assert.equal(obfuscatedMembers.fields.items[0]?.name, "字段");
|
||||
|
||||
const left = await fixture("token-drift-left.exe", {
|
||||
methodName: "StableSemanticSlice",
|
||||
});
|
||||
const right = await fixture("token-drift-right.exe", {
|
||||
mvid: alternateMvid,
|
||||
methods: [
|
||||
{ name: "InsertedHelper", body: Buffer.from([0x2a]) },
|
||||
{ name: "RenamedSemanticSlice", body: defaultIlBody },
|
||||
],
|
||||
});
|
||||
const comparison = await compareManagedMemberPaths({
|
||||
leftPath: left.path,
|
||||
rightPath: right.path,
|
||||
memberLimits: {
|
||||
maxFileBytes: 1024 * 1024,
|
||||
...memberLimits,
|
||||
},
|
||||
comparisonLimits,
|
||||
});
|
||||
assert.equal(comparison.ok, true);
|
||||
const comparisonResult = comparison.value.normalized_result;
|
||||
assert.equal(comparisonResult.algorithm.name_matching, "not-used");
|
||||
assert.equal(comparisonResult.matching.exact_il_signature, 1);
|
||||
assert.equal(
|
||||
comparisonResult.methods.some(
|
||||
({ left, right, match }) =>
|
||||
left.token === "0x06000001" &&
|
||||
right?.token === "0x06000002" &&
|
||||
match.basis === "exact-il-signature",
|
||||
),
|
||||
true,
|
||||
);
|
||||
|
||||
const nativeOnly = await fixtureBytes(
|
||||
"native-only.exe",
|
||||
buildNativePeFixture(),
|
||||
);
|
||||
const nativeResult = inspectManagedArtifactBytes(
|
||||
nativeOnly.bytes,
|
||||
nativeOnly.target,
|
||||
inspectionLimits,
|
||||
);
|
||||
assert.equal(nativeResult.classification.status, "not-managed");
|
||||
|
||||
const malformed = await fixture("malformed-metadata.exe", {
|
||||
corruptMetadataSignature: true,
|
||||
});
|
||||
const malformedResult = inspectManagedArtifactBytes(
|
||||
malformed.bytes,
|
||||
malformed.target,
|
||||
inspectionLimits,
|
||||
);
|
||||
assert.equal(malformedResult.classification.status, "malformed");
|
||||
|
||||
process.stdout.write(
|
||||
`${JSON.stringify({
|
||||
verified: 7,
|
||||
managedSurfaces: [
|
||||
"inspect_managed_artifact",
|
||||
"inspect_managed_members",
|
||||
"inspect_managed_native_boundaries",
|
||||
"compare_managed_members",
|
||||
],
|
||||
coverage: [
|
||||
"modern-dotnet-anycpu",
|
||||
"dotnet-framework-x86-pinvoke",
|
||||
"x64-ready-to-run-native-body",
|
||||
"unicode-obfuscated-identifiers",
|
||||
"mvid-and-token-drift",
|
||||
"not-managed",
|
||||
"malformed-metadata",
|
||||
],
|
||||
})}\n`,
|
||||
);
|
||||
} finally {
|
||||
await rm(workspace, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
async function fixture(name, options) {
|
||||
return fixtureBytes(name, buildManagedPeFixture(options));
|
||||
}
|
||||
|
||||
async function fixtureBytes(name, bytes) {
|
||||
const path = join(workspace, name);
|
||||
await writeFile(path, bytes);
|
||||
const parsed = await parseBinaryTarget(path);
|
||||
if (!parsed.ok) throw parsed.error;
|
||||
return { bytes, path, target: parsed.value };
|
||||
}
|
||||
|
||||
function sha256(bytes) {
|
||||
return createHash("sha256").update(bytes).digest("hex");
|
||||
}
|
||||
@@ -20,6 +20,7 @@ import { TOOL_CONTRACTS } from "../dist/contracts/toolContracts.js";
|
||||
import * as prompts from "./verify-package-prompts.mjs";
|
||||
import { verifyPackagedInvestigation } from "./verify-package-investigation.mjs";
|
||||
import { verifyPackedBridge } from "./verify-packed-bridge.mjs";
|
||||
import { buildManagedPeFixture } from "./lib/managed-pe-fixture.mjs";
|
||||
|
||||
const exec = promisify(execFile);
|
||||
const root = process.cwd();
|
||||
@@ -215,6 +216,83 @@ try {
|
||||
?.paired_renderer_transmissions !== 1
|
||||
)
|
||||
throw new Error("packaged JavaScript application analysis CLI failed");
|
||||
|
||||
const managedPath = join(workspace, "managed-fixture.exe");
|
||||
const managedRightPath = join(workspace, "managed-fixture-right.exe");
|
||||
await Promise.all([
|
||||
writeFile(
|
||||
managedPath,
|
||||
buildManagedPeFixture({
|
||||
pinvoke: {
|
||||
moduleName: "user32.dll",
|
||||
importName: "MessageBoxW",
|
||||
mappingFlags: 0x0345,
|
||||
},
|
||||
}),
|
||||
),
|
||||
writeFile(
|
||||
managedRightPath,
|
||||
buildManagedPeFixture({
|
||||
mvid: Buffer.from([
|
||||
0xde, 0xad, 0xbe, 0xef, 0x44, 0x33, 0x66, 0x55, 0xaa, 0xbb, 0xcc,
|
||||
0xdd, 0xee, 0xff, 0x11, 0x22,
|
||||
]),
|
||||
}),
|
||||
),
|
||||
]);
|
||||
const managedArtifact = json(
|
||||
await run(
|
||||
cli,
|
||||
["inspect-managed-artifact", managedPath, "--json"],
|
||||
environment,
|
||||
),
|
||||
);
|
||||
if (
|
||||
managedArtifact.operation !== "inspect_managed_artifact" ||
|
||||
managedArtifact.provider?.id !== "rea-dotnet-static" ||
|
||||
managedArtifact.normalized_result?.classification?.status !== "managed"
|
||||
)
|
||||
throw new Error("packaged managed artifact CLI failed");
|
||||
const managedMembers = json(
|
||||
await run(
|
||||
cli,
|
||||
["inspect-managed-members", managedPath, "--json"],
|
||||
environment,
|
||||
),
|
||||
);
|
||||
if (
|
||||
managedMembers.operation !== "inspect_managed_members" ||
|
||||
managedMembers.normalized_result?.methods?.total !== 1
|
||||
)
|
||||
throw new Error("packaged managed member CLI failed");
|
||||
const managedBoundaries = json(
|
||||
await run(
|
||||
cli,
|
||||
["inspect-managed-native-boundaries", managedPath, "--json"],
|
||||
environment,
|
||||
),
|
||||
);
|
||||
if (
|
||||
managedBoundaries.operation !== "inspect_managed_native_boundaries" ||
|
||||
managedBoundaries.normalized_result?.pinvoke_imports?.total !== 1 ||
|
||||
managedBoundaries.normalized_result?.pinvoke_imports?.items?.[0]
|
||||
?.verification !== "managed-declaration-only"
|
||||
)
|
||||
throw new Error("packaged managed native-boundary CLI failed");
|
||||
const managedComparison = json(
|
||||
await run(
|
||||
cli,
|
||||
["compare-managed-members", managedPath, managedRightPath, "--json"],
|
||||
environment,
|
||||
),
|
||||
);
|
||||
if (
|
||||
managedComparison.operation !== "compare_managed_members" ||
|
||||
managedComparison.provider?.id !== "rea-dotnet-workflows" ||
|
||||
managedComparison.normalized_result?.algorithm?.name_matching !== "not-used"
|
||||
)
|
||||
throw new Error("packaged managed comparison CLI failed");
|
||||
|
||||
// prettier-ignore
|
||||
const investigationReplay = await verifyPackagedInvestigation({ cli, workspace, evidenceRoot, artifactArchive, environment });
|
||||
const unknownProviderExecution = await runWithStatus(
|
||||
@@ -766,7 +844,7 @@ try {
|
||||
}
|
||||
|
||||
process.stdout.write(
|
||||
`${JSON.stringify({ cli: true, analysisCli: true, artifactCli: true, evidenceCli: true, incurMcpCommand: "npx -y rea-agents mcp", doctor: "platform-appropriate", setup: supportedSetupHost ? "planned-then-idempotent" : "unsupported-host-rejected", setupPlanReadOnly: supportedSetupHost, existingHopperPreserved: supportedSetupHost, clients: supportedSetupHost ? 3 : 0, backupReadback: supportedSetupHost, failureRecovery: supportedSetupHost, configSymlinkLifecycle: supportedSetupHost, skill: supportedSetupHost, mcpTools: TOOL_CONTRACTS.length, mcpPrompts: prompts.names.length, promptCompletion: true, promptCompletionLifecycle: true, evidenceMcp: true, targetFree: true, targetLifecycle: true, boundedRegexBridge: true })}\n`,
|
||||
`${JSON.stringify({ cli: true, analysisCli: true, artifactCli: true, managedCli: true, evidenceCli: true, incurMcpCommand: "npx -y rea-agents mcp", doctor: "platform-appropriate", setup: supportedSetupHost ? "planned-then-idempotent" : "unsupported-host-rejected", setupPlanReadOnly: supportedSetupHost, existingHopperPreserved: supportedSetupHost, clients: supportedSetupHost ? 3 : 0, backupReadback: supportedSetupHost, failureRecovery: supportedSetupHost, configSymlinkLifecycle: supportedSetupHost, skill: supportedSetupHost, mcpTools: TOOL_CONTRACTS.length, mcpPrompts: prompts.names.length, promptCompletion: true, promptCompletionLifecycle: true, evidenceMcp: true, targetFree: true, targetLifecycle: true, boundedRegexBridge: true })}\n`,
|
||||
);
|
||||
} finally {
|
||||
if (tarball) await rm(join(root, tarball), { force: true });
|
||||
|
||||
Reference in New Issue
Block a user