Files
reverse-engineering-anything/src/firmware/FirmwareFiles.ts
T
morluto b87b318ae7 refactor(wasm): leave WABT cancellation to the shared owners (#10796)
* fix(pcap): report a refused tool launch as an unavailable tool

When a capture read's tool launch was refused with EPERM, pcap reported it
as unreadable tool output (AnalysisProtocolError) instead of an unavailable
tool. Pcap also never told "not executable" apart from "missing".

Add classifyLaunchFailure in src/process as the one owner of which spawn
errnos mean missing (ENOENT, ENOTDIR) and which mean present but not
executable (EACCES, EPERM, ENOEXEC, EISDIR). Pcap, apktool and gdb used three
different errno lists; all three now use it.

* refactor(process): classify owned command outcomes through one owner

Add ProviderOutcome, read once from the supervisor's facts, and classifyProviderOutcome, the one mapping from an outcome to a typed error. Migrate pcap and the shared artifact producer command failure (TShark, sigrok). Add the rea/provider-failure-classifier lint rule with a shrink-only baseline of per-site (cause: unknown) => AnalysisError functions.

* refactor(process): classify Java and adb launch refusals with the shared owner (#10598)

The Ghidra and JADX Java probes and adb's version probe now take
missing-versus-not-executable from classifyLaunchFailure instead of their
own errno checks. ELOOP and ENAMETOOLONG join the owner's missing set, so
adb keeps its existing classification and both Java probes now treat a
non-directory path component as a missing runtime.

* fix(pcap): preserve command launch attribution

* test(pcap): expect an unknown failing stage when a limited capture tool exits unsuccessfully

* refactor(process): classify owned command outcomes through one owner

Add ProviderOutcome, read once from the supervisor's facts, and classifyProviderOutcome, the one mapping from an outcome to a typed error. Migrate pcap and the shared artifact producer command failure (TShark, sigrok). Add the rea/provider-failure-classifier lint rule with a shrink-only baseline of per-site (cause: unknown) => AnalysisError functions.

* test(lint): cover baselined files in the provider-failure classifier rule

* fix(apktool): report the decoder JVM's heap exhaustion as memory, not a target refusal

The supervisor now watches for a managed runtime's out-of-memory report while output streams (JVM java.lang.OutOfMemoryError, V8 'JavaScript heap out of memory'), so a retention budget cannot hide it. ProviderOutcome gains a runtime-exhausted kind and classifyProviderOutcome maps it once. Apktool decode opts in and moves to the shared classifier; Ghidra's single-purpose output token becomes the JVM runtime option and its area matching reuses the shared table.

* fix(process): keep the runtime's out-of-memory report on the memory error it supports

* fix(pcap): attribute a limited capture's exit through the prlimit wrapper

* fix(process): keep a shortened out-of-memory line marked as shortened

* fix(process): identify the refused executable for every launcher shape

Name the executable on errnos Node throws synchronously from spawn
(ENOEXEC, ENOTDIR, ...) and read the Windows native launcher's
executable-launch constraint, so pcap attributes those refusals to the
selected tool or limiter instead of an unknown stage.

* test(pcap): prove synchronous launch naming with ENOTDIR on every POSIX host

* fix(apktool): advise the JVM limit that governs the reported memory area

* fix(ghidra): read the supervisor's parsed OOM area instead of reparsing lines

* fix(sqlite,capture): read V8 heap exhaustion from streamed output, not retained stderr (#10724)

The SQLite worker and the Node capture decoders now declare runtime: "v8", so the supervisor observes V8's heap report as output streams. Both classifiers read the runtime-exhausted outcome instead of matching retained stderr, so a report beyond the retention budget, or one whose process then overflowed its output budget, is still reported as memory exhaustion.

* refactor(evm): classify EVMole worker outcomes through the shared provider classifier (#10716)

* refactor(evm): classify EVMole worker outcomes through the shared provider classifier

The EVMole worker's cancellation, deadline, output budget and CPU/file-size signals now go through classifyProviderOutcome; only the prlimit launch refusal and the reserved EFBIG exit remain in its dialect. The worker is opted into V8 exhaustion scanning so a heap report names its fixed 256 MiB heap. providerOutcomeOf now reads a launch refusal only from a spawn errno, so a private-storage or carrier read errno is no longer reported as a limiter launch failure.

* fix(evm): keep a stream failure's exit status and update Linux worker expectations

* refactor(process): read launch refusals through the launcher identity owner

* refactor(wasm): classify WABT command outcomes through the shared provider classifier (#10727)

* refactor(wasm): classify WABT command outcomes through the shared provider classifier

WABT's cancellation, command deadline, output budget, and inherited-limit signals now go through classifyProviderOutcome; its dialect keeps only the configuration-probe and launch-refusal unavailability and the unclassified-exit output error. A tool ended by SIGXCPU/SIGXFSZ or the memory limit is now a resource constraint instead of an output error, and a refused launch in the producer phase is reported as unavailable. The shared timeout context gains the analysis setting that selected the deadline, and the output-limit context may name its exceeded budget.

* fix(wasm): keep setup guidance when a WABT version probe's output cannot be collected

* refactor(providers): classify raw provider failures through one owner

* refactor(process): build classified cancellations with cancelledBy and the carried caller reason

* chore(lint): count runOwned's close-failure mapper from main in the classifier baseline

* fix(process): carry the runtime's exhaustion report on every memory error that claims it

SQLite and historical-capture memory errors recognised a streamed V8 heap report but dropped it, so a report outside retained output reached callers without its source line or omission flags. One projection, runtimeExhaustionReport, now owns that shape for the shared classifier and both consumers. Also lowers the EVMole and WABT cancellation-constructor baselines.

* fix(process): keep the provider's recovery for a native-thread exhaustion report

The shared classifier replaced the provider-supplied recovery with generic capacity advice whenever the JVM reported it could not create a native thread, dropping Apktool's launcher guidance and flipping retryable to true. The provider's recovery now wins; the capacity advice remains the fallback for providers that supply none.

* refactor(pwntools): classify pwntools failures through the shared provider classifier (#10782)

* refactor(pwntools): classify pwntools failures through the shared provider classifier

pwntools' per-site classifier is replaced by pwntoolsFailureDialect for classifyProviderFailure. Command outcomes go through classifyProviderOutcome, launch refusals through launcherRefusalOf instead of a 'spawn ' syscall prefix check, the input limit through the file dialect's fileSize, and the cleanup report through commandCleanup. The shared read cancellation now carries the reader's partial observation, and resource-signal reports accept provider detail.

* fix(pwntools): report a failed command's output once and expect resource_constraint for overflow

The shared outcome owner already attaches the command's output as capturedOutput, so the pwntools adapter fallback no longer copies the same text into diagnostics.stdout, diagnostics.stderr and diagnostics.captured_output; diagnostics keep the exit facts. Update the overflow expectations the dialect migration missed (layout provider cleanup and over-budget rows, pwntools cleanup) to resource_constraint.

* refactor(wasm): leave WABT cancellation to the shared owners

WabtFailures matched any Error named AbortError as a cancellation. No WABT path produces one: reads, path checks and owned commands report cancellation as ArtifactReaderFailure or OwnedCommandFailure, which classifyProviderFailure and classifyProviderOutcome already classify with the caller's reason. The provider's two signal checks now build the cancellation with cancelledBy. Lowers the AnalysisCancelledError constructor baseline for both WABT files to zero.

* fix(wasm): report a cancelled snapshot write as the caller's cancellation

The private snapshot write passed the caller's signal to Node's writeFile, whose abort envelope reached the dialect's unclassified output failure once the name-based AbortError guess was removed. The write now turns the envelope carrying its own signal's reason into cancelledBy at the producer.

* refactor(firmware): classify firmware failures through the shared provider classifier (#10810)

Firmware producers now report their own deadline expiry: the start check, the output inventory and launcher admission throw the phase timeout where they observe the abort, and a read the phase signal cancelled reports it through the dialect's interruption. The classifier no longer rereads a cancellation's reason as a timeout. A new readCleanup hook keeps firmware's cleanup report shape.
2026-11-15 17:42:49 +08:00

546 lines
19 KiB
TypeScript

import { safeParseUtf8Json } from "../domain/safeJson.js";
import { createHash } from "node:crypto";
import { createWriteStream } from "node:fs";
import { chmod, lstat, opendir, readlink } from "node:fs/promises";
import { isAbsolute, join, relative, sep } from "node:path";
import { Readable, Transform } from "node:stream";
import { pipeline } from "node:stream/promises";
import {
isAborted,
AnalysisAccessDeniedError,
AnalysisResourceConstraintError,
AnalysisInputError,
AnalysisOutputError,
} from "../domain/analysisErrorCore.js";
import type { FirmwareRequest } from "../domain/firmware/firmwareAnalysis.js";
import {
MAX_FIRMWARE_STAGING_BYTES,
MAX_FIRMWARE_STAGING_ENTRIES,
} from "../domain/firmware/firmwareAnalysis.js";
import { absoluteCallerPath } from "../filesystem/callerPath.js";
import { readLinuxResourceLimits } from "../process/LinuxResourceLimits.js";
import { readBoundedFileBytes } from "../process/BoundedFileBytes.js";
import { FIRMWARE_LIMITS } from "./FirmwareRelease.js";
import {
firmwareLimitRecovery,
firmwareSignalInterruption,
} from "./FirmwareFailures.js";
import type { FirmwareDeadline } from "./FirmwareDeadline.js";
import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
import type { SafeOutputTree } from "../artifacts/SafeOutputTree.js";
import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
import {
withArtifactRegularFile,
assertArtifactReadActive,
mapArtifactFileFailure,
artifactSelectedPathErrno,
} from "../artifacts/ArtifactFileOperation.js";
import { readArtifactFileChunks } from "../artifacts/readArtifactFileChunks.js";
import { decodeDirectoryEntryName } from "../filesystem/decodeDirectoryEntryName.js";
import { NonRegularFileReadError } from "../filesystem/RegularFile.js";
import { observedSymlinkTarget } from "../domain/symlinkTarget.js";
/** One regular file or unpublished filesystem entry in a private extraction. */
export interface FirmwareEntry {
readonly relativePath: string;
readonly path: string;
readonly size: number;
readonly kind: "file" | "symlink" | "special";
readonly linkTarget: string | null;
readonly linkTargetHex?: string;
}
/** An aborted inventory reports its phase deadline's timeout or its caller's cancellation. */
const throwIfFirmwareInventoryCancelled = (
signal: AbortSignal | undefined,
operation: string,
deadline: FirmwareDeadline | undefined,
): void => {
if (isAborted(signal))
throw firmwareSignalInterruption(operation, signal, deadline);
};
/** Own all firmware reads, including rejected admission and final descriptor cleanup. */
export class FirmwareFileAccess {
readonly resources = new ArtifactResourceScope();
/** Retry retained descriptors without closing admission for future operations. */
retryCleanup(): Promise<void> {
return this.resources.retryCleanup();
}
/** Wait for admitted operations and retry every retained descriptor. */
close(): Promise<void> {
return this.resources.close();
}
/** Read inherited file policy through this same retryable descriptor owner. */
async fileSizeCeiling(signal?: AbortSignal): Promise<number> {
return this.resources.run(async () => {
assertArtifactReadActive(signal);
const limits = await readLinuxResourceLimits(
{
address_space_bytes: FIRMWARE_LIMITS.addressSpaceBytes,
cpu_seconds: FIRMWARE_LIMITS.cpuSeconds,
file_bytes: Number.MAX_SAFE_INTEGER,
},
this.resources,
);
assertArtifactReadActive(signal);
return limits.file_bytes;
});
}
/** Hash one admitted regular file without retaining its bytes in memory. */
hash(path: string, signal?: AbortSignal): Promise<string> {
return this.resources.run(() => this.#hash(path, signal));
}
async #hash(path: string, signal?: AbortSignal): Promise<string> {
return withArtifactRegularFile(
path,
this.resources,
signal,
async ({ handle }) => {
const hash = createHash("sha256");
for await (const chunk of readArtifactFileChunks(handle, { signal })) {
assertArtifactReadActive(signal);
hash.update(chunk);
}
assertArtifactReadActive(signal);
return hash.digest("hex");
},
);
}
/** Copy and identify the exact bytes consumed by firmware providers. */
snapshot(request: FirmwareRequest, root: string, signal: AbortSignal) {
return this.resources.run(() => this.#snapshot(request, root, signal));
}
async #snapshot(request: FirmwareRequest, root: string, signal: AbortSignal) {
const sourcePath = absoluteCallerPath(request.input.path);
let sourceAdmitted = false;
const fullPath = join(root, "firmware.bin");
const copied = await withArtifactRegularFile(
sourcePath,
this.resources,
signal,
async ({ handle, initial: stat }) => {
sourceAdmitted = true;
if (stat.size === 0 || stat.size > FIRMWARE_LIMITS.inputBytes)
throw firmwareInputFailure(request.operation);
const hash = createHash("sha256");
let size = 0;
const meter = new Transform({
transform(chunk: Buffer, _encoding, callback) {
size += chunk.length;
if (size > FIRMWARE_LIMITS.inputBytes) {
callback(firmwareInputFailure(request.operation));
return;
}
hash.update(chunk);
callback(null, chunk);
},
});
await pipeline(
readArtifactFileChunks(handle, { signal }),
meter,
createWriteStream(fullPath, { flags: "wx", mode: 0o600 }),
);
return { size, sha256: hash.digest("hex") };
},
"follow",
).catch((cause: unknown) => {
// Destination writes and reads after admission retain their own failure.
throw sourceAdmitted
? cause
: firmwareSourceAdmissionFailure(request.operation, sourcePath, cause);
});
const { size, sha256 } = copied;
await chmod(fullPath, 0o400);
const selected =
request.operation === "extract_firmware"
? request.input.range
: undefined;
const offset = selected?.offset ?? 0;
const length = selected?.length ?? size;
if (length === 0 || offset > size || length > size - offset)
throw new AnalysisInputError(request.operation, undefined, [
{
path: ["range"],
reason: "out_of_range",
message: `Selected range must be within the ${size}-byte firmware file`,
},
]);
let inputPath = fullPath;
if (selected !== undefined) {
inputPath = join(root, "selected.bin");
await withArtifactRegularFile(
fullPath,
this.resources,
signal,
async ({ handle }) => {
await pipeline(
readArtifactFileChunks(handle, {
start: offset,
end: offset + length - 1,
signal,
}),
createWriteStream(inputPath, { flags: "wx", mode: 0o600 }),
);
},
);
await chmod(inputPath, 0o400);
}
return {
subject: { path: sourcePath, sha256, format: "file" as const },
size,
inputPath,
selection: {
offset,
length,
sha256:
selected === undefined ? sha256 : await this.#hash(inputPath, signal),
},
};
}
/** Own the exact source descriptor consumed by publication through its final close. */
publish(
entry: FirmwareEntry,
sha256: string,
tree: SafeOutputTree,
signal: AbortSignal,
) {
return this.resources.run(() =>
withArtifactRegularFile(
entry.path,
this.resources,
signal,
({ handle }) =>
tree.write(
entry.relativePath,
// SafeOutputTree awaits destination setup before consuming. Defer
// the abort-bound descriptor stream until it has a consumer.
Readable.from(
(async function* () {
assertArtifactReadActive(signal);
yield* readArtifactFileChunks(handle, { signal });
})(),
),
{ sha256, bytes: entry.size },
signal,
),
),
);
}
/**
* Read a complete bounded report; oversized data is never reported as complete.
* Each refusal records its observed report state, so an absent or empty report
* is never conflated with an empty scan or a malformed one.
*/
async report(
path: string,
operation: string,
signal?: AbortSignal,
): Promise<unknown> {
return this.resources.run(() =>
withArtifactRegularFile(
path,
this.resources,
signal,
async ({ handle }) => {
const bytes = await readBoundedFileBytes(
handle,
FIRMWARE_LIMITS.reportBytes,
);
if (bytes === undefined)
throw firmwareReportFailure(
operation,
"oversized",
`Report exceeded ${FIRMWARE_LIMITS.reportBytes} bytes`,
);
assertArtifactReadActive(signal);
if (bytes.length === 0)
throw firmwareReportFailure(operation, "empty", "Report is empty");
try {
const decoded = safeParseUtf8Json(bytes);
if (!decoded.ok) throw decoded.cause;
return decoded.value;
} catch (cause: unknown) {
throw firmwareReportFailure(
operation,
"invalid_json",
"Tool report is not valid complete JSON",
cause,
);
}
},
).catch((cause: unknown) => {
throw mapArtifactFileFailure(cause, (primary) =>
primary instanceof NonRegularFileReadError
? firmwareReportFailure(
operation,
"not_regular_file",
"Report is not a regular file",
primary,
)
: primary instanceof Error &&
"code" in primary &&
primary.code === "ENOENT"
? firmwareReportFailure(
operation,
"missing",
"Report was not created",
primary,
)
: primary,
);
}),
);
}
}
/** Observed state of a producer report that cannot supply analysis Evidence. */
type FirmwareReportState =
| "missing"
| "empty"
| "oversized"
| "invalid_json"
| "not_regular_file";
const firmwareReportFailure = (
operation: string,
state: FirmwareReportState,
reason: string,
cause?: unknown,
) =>
new AnalysisOutputError(operation, reason, {
cause,
diagnostics: { report_state: state },
});
/** Attribute only failures observed while admitting the caller-selected source. */
const firmwareSourceAdmissionFailure = (
operation: string,
path: string,
cause: unknown,
): unknown =>
mapArtifactFileFailure(cause, (primary) => {
if (primary instanceof NonRegularFileReadError)
return firmwareInputFailure(operation, primary);
if (
primary instanceof Error &&
"code" in primary &&
(primary.code === "EACCES" || primary.code === "EPERM")
)
return new AnalysisAccessDeniedError(operation, path, primary.code, {
cause: primary,
});
if (artifactSelectedPathErrno(primary) !== undefined)
return new AnalysisInputError(operation, { cause: primary }, [
{
path: ["path"],
reason: "invalid_value",
message: "Firmware source must resolve to an accessible regular file",
},
]);
return primary;
});
const firmwareInputFailure = (operation: string, cause?: unknown) => {
const message = `Firmware must be a nonempty regular file no larger than ${String(FIRMWARE_LIMITS.inputBytes)} bytes. Select a stable copy within this allowance. ${firmwareLimitRecovery(`The firmware input allowance is ${String(FIRMWARE_LIMITS.inputBytes)} bytes`)}`;
return new AnalysisInputError(operation, { cause, userMessage: message }, [
{
path: ["path"],
reason: "out_of_range",
message,
},
]);
};
/**
* Inventory private output without following links, enforcing aggregate staging
* budgets and the producer's per-file limit.
*/
export const inventoryFirmwareOutput = async (
root: string,
maxBytes: number,
maxEntries: number,
fileSizeBytes: number,
operation: string,
signal?: AbortSignal,
/** The phase deadline that owns an expiry of `signal`. */
deadline?: FirmwareDeadline,
): Promise<FirmwareEntry[]> => {
const entries: FirmwareEntry[] = [];
const pending = [root];
let bytes = 0;
let count = 0;
while (pending.length > 0) {
throwIfFirmwareInventoryCancelled(signal, operation, deadline);
const directory = pending.pop();
if (directory === undefined) break;
const directoryStat = await lstat(directory).catch((cause: unknown) => {
if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
return undefined;
throw cause;
});
if (
directoryStat === undefined ||
!directoryStat.isDirectory() ||
directoryStat.isSymbolicLink()
)
continue;
const handle = await opendir(directory, {
encoding: "buffer" as BufferEncoding,
}).catch((cause: unknown) => {
if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
return undefined;
throw cause;
});
if (handle === undefined) continue;
const names: string[] = [];
for await (const entry of handle) {
throwIfFirmwareInventoryCancelled(signal, operation, deadline);
count++;
if (count > maxEntries)
throw firmwareStagingLimit(operation, "max_output_files", maxEntries);
const decoded = decodeDirectoryEntryName(entry.name);
if (decoded.kind === "unrepresentable")
throw new AnalysisOutputError(
operation,
"Extracted filename cannot be represented losslessly as UTF-8",
{
diagnostics: {
directory: relative(root, directory),
raw_name_hex: decoded.rawHex,
},
},
);
names.push(decoded.name);
}
for (const name of names.sort()) {
const path = join(directory, name);
const stat = await lstat(path).catch((cause: unknown) => {
if (
cause instanceof Error &&
"code" in cause &&
cause.code === "ENOENT"
)
return undefined;
throw cause;
});
if (stat === undefined) continue;
if (stat.isDirectory()) {
pending.push(path);
continue;
}
if (stat.isFile()) bytes += stat.size;
if (bytes > maxBytes)
throw firmwareStagingLimit(operation, "max_output_bytes", maxBytes);
if (stat.isFile() && stat.size >= fileSizeBytes)
throw firmwareFileSizeLimitReached(operation, fileSizeBytes);
const linkTarget = stat.isSymbolicLink()
? observedSymlinkTarget(await readlink(path, { encoding: "buffer" }))
: undefined;
entries.push({
path,
relativePath: relative(root, path).split(sep).join("/"),
size: stat.size,
kind: stat.isSymbolicLink()
? "symlink"
: stat.isFile()
? "file"
: "special",
linkTarget: linkTarget?.text ?? null,
...(linkTarget === undefined ? {} : { linkTargetHex: linkTarget.hex }),
});
}
}
return entries.sort((a, b) =>
compareUnicodeCodePoints(a.relativePath, b.relativePath),
);
};
/**
* Recovery for one staging budget refusal. At the schema ceiling a larger
* selection is impossible, so that case must not recommend raising the value.
*/
export const firmwareStagingBudgetRemediation = (
budget: "max_output_files" | "max_output_bytes",
selectedLimit: number,
): string => {
const maximum =
budget === "max_output_files"
? MAX_FIRMWARE_STAGING_ENTRIES
: MAX_FIRMWARE_STAGING_BYTES;
const description =
budget === "max_output_files"
? "staging entry budget, which counts extracted directories and links"
: "staging file-byte budget, checked during extraction";
if (selectedLimit < maximum)
return `The ${description} was exceeded (${budget}=${String(selectedLimit)}; supported maximum ${String(maximum)}). Increase ${budget} up to ${String(maximum)} if the larger extraction is required, or select a materially narrower firmware byte range. analysis_timeout_ms does not raise this staging allowance.`;
return `The ${description} reached its supported maximum (${budget}=${String(selectedLimit)}; maximum ${String(maximum)}). Raising ${budget} further is not supported. Select a smaller firmware byte range or analyze a smaller image. analysis_timeout_ms does not raise this staging allowance.`;
};
/** The same selected aggregate budget is enforced during and after extraction. */
const firmwareStagingLimit = (
operation: string,
field: "max_output_files" | "max_output_bytes",
maximum: number,
) =>
new AnalysisResourceConstraintError(
operation,
"capacity",
`Firmware staging exceeded ${field} (${maximum})`,
{ [field]: maximum },
{
retryable: false,
remediationAction: firmwareStagingBudgetRemediation(field, maximum),
},
);
/**
* The kernel stops a write at RLIMIT_FSIZE without extending the file, so a
* staged file that reaches the producer's limit may be truncated. That limit
* sits one byte above every budget unless an inherited ceiling removed the byte.
*/
const firmwareFileSizeLimitReached = (
operation: string,
fileSizeBytes: number,
) =>
new AnalysisResourceConstraintError(
operation,
"file-size",
`A staged firmware file reached the ${String(fileSizeBytes)}-byte per-file limit and may be truncated`,
{ file_size_bytes: fileSizeBytes },
{
retryable: false,
remediationAction: `REA inherited a ${String(fileSizeBytes)}-byte file-size limit (RLIMIT_FSIZE), so it could not keep one byte of headroom above max_output_bytes and the report and diagnostic allowances. A staged file that reaches the limit cannot be told apart from one the kernel cut short. Raise the file-size limit REA inherits (for example ulimit -f in the launching shell or service) above the largest file the extraction needs. analysis_timeout_ms does not raise it, and repeating the unchanged request fails the same way.`,
},
);
/** Bind producer paths to the selected input or private extraction tree. */
export const firmwareLogicalPath = (
path: string,
inputPath: string,
outputRoot: string,
): string => {
if (path === inputPath) return "$input";
const rel = relative(outputRoot, path);
if (
!isAbsolute(path) ||
rel === ".." ||
rel.startsWith(`..${sep}`) ||
isAbsolute(rel)
)
throw new AnalysisOutputError(
"extract_firmware",
`Provider reported a path outside its owned output: ${path}`,
);
return rel === "" ? "$output" : `$output/${rel.split(sep).join("/")}`;
};