489 lines
22 KiB
JavaScript
Executable File
489 lines
22 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
||
'use strict';
|
||
|
||
const fs = require('fs');
|
||
const path = require('path');
|
||
|
||
function parseArgs(argv) {
|
||
const args = {
|
||
types: 'canvas,webgl,dom-geometry',
|
||
out: '',
|
||
apiPattern: '',
|
||
chunkSize: 3000,
|
||
deprecatedMaxDataUrlLength: null,
|
||
};
|
||
for (let i = 2; i < argv.length; i++) {
|
||
const a = argv[i];
|
||
if (a === '--types') args.types = argv[++i] || args.types;
|
||
else if (a === '--out') args.out = argv[++i] || '';
|
||
else if (a === '--api-pattern') args.apiPattern = argv[++i] || '';
|
||
else if (a === '--chunk-size') args.chunkSize = Number(argv[++i] || args.chunkSize);
|
||
else if (a === '--max-data-url-length') {
|
||
// 兼容旧参数名：历史版本用它裁剪 dataURL；当前版本严禁裁剪，只把它当作“分片大小”。
|
||
args.deprecatedMaxDataUrlLength = Number(argv[++i] || args.chunkSize);
|
||
args.chunkSize = args.deprecatedMaxDataUrlLength;
|
||
}
|
||
else if (a === '--help' || a === '-h') args.help = true;
|
||
else throw new Error(`未知参数：${a}`);
|
||
}
|
||
if (!Number.isFinite(args.chunkSize) || args.chunkSize < 512) args.chunkSize = 3000;
|
||
return args;
|
||
}
|
||
|
||
function usage() {
|
||
return `用法：
|
||
node scripts/generate_fingerprint_hook.js --types canvas,webgl,dom-geometry --out case/hooks/fingerprint-hook.js
|
||
node scripts/generate_fingerprint_hook.js --types canvas,webgl,webgpu,audio,dom-geometry --chunk-size 3000
|
||
|
||
说明：
|
||
生成浏览器侧指纹终端 API 采样 Hook。该脚本只用于前置取证，不得进入最终 result/ 交付目录。
|
||
长指纹值不会被裁剪为 4000 / 4096 字符；Canvas / WebGL / WebGPU / Audio 等大结果会完整保存或按 chunks 分片保存。
|
||
旧参数 --max-data-url-length 已废弃裁剪语义，仅兼容为分片大小，不能用于截断最终值。`;
|
||
}
|
||
|
||
function q(v) { return JSON.stringify(String(v)); }
|
||
|
||
function header(args) {
|
||
return `// 指纹终端 API 采样 Hook，仅用于授权前置取证。
|
||
// 使用方式：在用户已确认的取证工具中注入，触发最少量业务动作后执行：
|
||
// copy(JSON.stringify(await window.__WEB_JS_ENV_PATCHER_FINALIZE_FINGERPRINT__(), null, 2))
|
||
// 如果控制台不支持 await，可先执行：
|
||
// window.__WEB_JS_ENV_PATCHER_FINALIZE_FINGERPRINT__().then(v => copy(JSON.stringify(v, null, 2)))
|
||
// 注意：长指纹值必须完整保存或分片保存，不得裁剪为 4000 / 4096 字符，也不得把 Trace 可见片段当最终值。
|
||
// 不要把本 Hook 放入最终 result/ 交付目录。
|
||
(function installFingerprintSampler() {
|
||
if (window.__WEB_JS_ENV_PATCHER_FINGERPRINT_HOOKED__) return;
|
||
Object.defineProperty(window, "__WEB_JS_ENV_PATCHER_FINGERPRINT_HOOKED__", { value: true, configurable: true });
|
||
const chunkSize = ${Number(args.chunkSize) || 3000};
|
||
const apiPattern = ${q(args.apiPattern)};
|
||
const store = window.__WEB_JS_ENV_PATCHER_FINGERPRINT__ = window.__WEB_JS_ENV_PATCHER_FINGERPRINT__ || {
|
||
version: 2,
|
||
source: {
|
||
pageUrl: location.href,
|
||
userAgent: navigator.userAgent,
|
||
language: navigator.language,
|
||
languages: Array.from(navigator.languages || []),
|
||
timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "",
|
||
capturedAt: new Date().toISOString(),
|
||
capturedBy: "真实浏览器指纹采样 Hook",
|
||
traceStatus: "browser-complete-sampled",
|
||
apiPattern
|
||
},
|
||
canvas: { toDataURL: [], toBlob: [], measureText: [], getImageData: [] },
|
||
webgl: { getParameter: [], getSupportedExtensions: null, getExtension: [], getShaderPrecisionFormat: [], readPixels: [] },
|
||
webgpu: { requestAdapter: [] },
|
||
audio: { startRendering: [], getChannelData: [] },
|
||
domGeometry: { getBoundingClientRect: [], getClientRects: [], offset: [] }
|
||
};
|
||
function stack() { try { return new Error().stack || ""; } catch(e) { return ""; } }
|
||
function chunkString(value, encoding) {
|
||
const text = String(value == null ? "" : value);
|
||
const chunks = [];
|
||
for (let i = 0; i < text.length; i += chunkSize) chunks.push(text.slice(i, i + chunkSize));
|
||
return {
|
||
encoding,
|
||
valueLength: text.length,
|
||
chunkSize,
|
||
chunks,
|
||
truncated: false,
|
||
sha256: "",
|
||
sha256Of: encoding === "base64-chunks" ? "base64-string" : "string",
|
||
hashStatus: "pending-finalize"
|
||
};
|
||
}
|
||
function b64FromArrayLike(arr) {
|
||
try {
|
||
const bytes = new Uint8Array(arr.buffer || arr, arr.byteOffset || 0, arr.byteLength || arr.length || 0);
|
||
let s = "";
|
||
const step = 0x8000;
|
||
for (let i = 0; i < bytes.length; i += step) {
|
||
const sub = bytes.subarray(i, Math.min(i + step, bytes.length));
|
||
s += String.fromCharCode.apply(null, sub);
|
||
}
|
||
return btoa(s);
|
||
} catch(e) { return ""; }
|
||
}
|
||
function chunkArrayLikeAsBase64(arr) {
|
||
const encoded = b64FromArrayLike(arr);
|
||
const out = chunkString(encoded, "base64-chunks");
|
||
try {
|
||
const bytes = new Uint8Array(arr.buffer || arr, arr.byteOffset || 0, arr.byteLength || arr.length || 0);
|
||
out.rawByteLength = bytes.byteLength;
|
||
} catch(e) {}
|
||
return out;
|
||
}
|
||
function clonePlain(value, depth) {
|
||
if (depth <= 0) return String(value);
|
||
if (value == null) return value;
|
||
if (typeof value === "string") return value.length >= 3900 ? chunkString(value, "string-chunks") : value;
|
||
if (typeof value === "number" || typeof value === "boolean") return value;
|
||
if (Array.isArray(value)) return value.map(v => clonePlain(v, depth - 1));
|
||
if (value instanceof Set) return Array.from(value).map(v => clonePlain(v, depth - 1));
|
||
if (value instanceof Map) return Array.from(value.entries()).map(([k, v]) => [clonePlain(k, depth - 1), clonePlain(v, depth - 1)]);
|
||
if (typeof value === "object") {
|
||
const out = {};
|
||
for (const key of Object.keys(value)) {
|
||
try { out[key] = clonePlain(value[key], depth - 1); } catch(e) { out[key] = "<read-error>"; }
|
||
}
|
||
return out;
|
||
}
|
||
return String(value);
|
||
}
|
||
function selectorOf(el) {
|
||
try {
|
||
if (!el) return "";
|
||
if (el.id) return "#" + el.id;
|
||
if (el.className && typeof el.className === "string") return "." + el.className.trim().split(/\\s+/)[0];
|
||
return String(el.tagName || "").toLowerCase();
|
||
} catch(e) { return ""; }
|
||
}
|
||
async function sha256Text(text) {
|
||
const input = new TextEncoder().encode(String(text));
|
||
const digest = await crypto.subtle.digest("SHA-256", input);
|
||
return Array.from(new Uint8Array(digest)).map(b => b.toString(16).padStart(2, "0")).join("");
|
||
}
|
||
async function fillChunkHashes(node) {
|
||
if (!node || typeof node !== "object") return;
|
||
if ((node.encoding === "string-chunks" || node.encoding === "base64-chunks") && Array.isArray(node.chunks)) {
|
||
const text = node.chunks.join("");
|
||
node.valueLength = text.length;
|
||
node.truncated = false;
|
||
try {
|
||
node.sha256 = await sha256Text(text);
|
||
node.hashStatus = "ok";
|
||
} catch(e) {
|
||
node.hashStatus = "failed:" + (e && e.message || String(e));
|
||
}
|
||
}
|
||
if (Array.isArray(node)) {
|
||
for (const item of node) await fillChunkHashes(item);
|
||
} else {
|
||
for (const key of Object.keys(node)) await fillChunkHashes(node[key]);
|
||
}
|
||
}
|
||
window.__WEB_JS_ENV_PATCHER_FINALIZE_FINGERPRINT__ = async function finalizeFingerprint() {
|
||
await fillChunkHashes(store);
|
||
store.source.finalizedAt = new Date().toISOString();
|
||
store.source.finalizeNote = "长指纹值已完整保存或分片保存，sha256 针对完整字符串或完整 base64 字符串计算，truncated 必须为 false。";
|
||
return store;
|
||
};
|
||
`;
|
||
}
|
||
|
||
function footer() {
|
||
return ` console.info("[web-js-env-patcher] 指纹采样 Hook 已安装。触发目标动作后执行：copy(JSON.stringify(await window.__WEB_JS_ENV_PATCHER_FINALIZE_FINGERPRINT__(), null, 2))");
|
||
})();`;
|
||
}
|
||
|
||
function canvasSnippet() {
|
||
return `
|
||
// ===== Canvas 终端 API 采样 =====
|
||
if (window.HTMLCanvasElement) {
|
||
const rawToDataURL = HTMLCanvasElement.prototype.toDataURL;
|
||
if (rawToDataURL && !rawToDataURL.__wjep_hooked__) {
|
||
HTMLCanvasElement.prototype.toDataURL = function patchedToDataURL(type, quality) {
|
||
const result = rawToDataURL.apply(this, arguments);
|
||
store.canvas.toDataURL.push({
|
||
match: { width: this.width, height: this.height, type: type || "image/png" },
|
||
result: chunkString(result, "string-chunks"),
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
return result;
|
||
};
|
||
HTMLCanvasElement.prototype.toDataURL.__wjep_hooked__ = true;
|
||
}
|
||
const rawToBlob = HTMLCanvasElement.prototype.toBlob;
|
||
if (rawToBlob && !rawToBlob.__wjep_hooked__) {
|
||
HTMLCanvasElement.prototype.toBlob = function patchedToBlob(callback, type, quality) {
|
||
const width = this.width, height = this.height, callStack = stack();
|
||
return rawToBlob.call(this, function(blob) {
|
||
store.canvas.toBlob.push({
|
||
match: { width, height, type: type || (blob && blob.type) || "image/png" },
|
||
result: { type: blob && blob.type || type || "", size: blob && blob.size || 0 },
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: callStack
|
||
});
|
||
return callback && callback.apply(this, arguments);
|
||
}, type, quality);
|
||
};
|
||
HTMLCanvasElement.prototype.toBlob.__wjep_hooked__ = true;
|
||
}
|
||
}
|
||
if (window.CanvasRenderingContext2D) {
|
||
const p = CanvasRenderingContext2D.prototype;
|
||
const rawMeasureText = p.measureText;
|
||
if (rawMeasureText && !rawMeasureText.__wjep_hooked__) {
|
||
p.measureText = function patchedMeasureText(text) {
|
||
const ret = rawMeasureText.apply(this, arguments);
|
||
store.canvas.measureText.push({
|
||
match: { text: String(text), font: this.font },
|
||
result: {
|
||
width: ret.width,
|
||
actualBoundingBoxLeft: ret.actualBoundingBoxLeft,
|
||
actualBoundingBoxRight: ret.actualBoundingBoxRight,
|
||
actualBoundingBoxAscent: ret.actualBoundingBoxAscent,
|
||
actualBoundingBoxDescent: ret.actualBoundingBoxDescent,
|
||
fontBoundingBoxAscent: ret.fontBoundingBoxAscent,
|
||
fontBoundingBoxDescent: ret.fontBoundingBoxDescent
|
||
},
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
return ret;
|
||
};
|
||
p.measureText.__wjep_hooked__ = true;
|
||
}
|
||
const rawGetImageData = p.getImageData;
|
||
if (rawGetImageData && !rawGetImageData.__wjep_hooked__) {
|
||
p.getImageData = function patchedGetImageData(sx, sy, sw, sh) {
|
||
const ret = rawGetImageData.apply(this, arguments);
|
||
store.canvas.getImageData.push({
|
||
match: { sx, sy, sw, sh },
|
||
result: { width: ret.width, height: ret.height, dataBase64: chunkArrayLikeAsBase64(ret.data) },
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
return ret;
|
||
};
|
||
p.getImageData.__wjep_hooked__ = true;
|
||
}
|
||
}
|
||
`;
|
||
}
|
||
|
||
function webglSnippet() {
|
||
return `
|
||
// ===== WebGL 终端 API 采样 =====
|
||
for (const Ctor of [window.WebGLRenderingContext, window.WebGL2RenderingContext].filter(Boolean)) {
|
||
const p = Ctor.prototype;
|
||
if (p.getParameter && !p.getParameter.__wjep_hooked__) {
|
||
const raw = p.getParameter;
|
||
p.getParameter = function patchedGetParameter(pname) {
|
||
const ret = raw.apply(this, arguments);
|
||
store.webgl.getParameter.push({
|
||
match: { pname },
|
||
result: clonePlain(ret, 3),
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
return ret;
|
||
};
|
||
p.getParameter.__wjep_hooked__ = true;
|
||
}
|
||
if (p.getSupportedExtensions && !p.getSupportedExtensions.__wjep_hooked__) {
|
||
const raw = p.getSupportedExtensions;
|
||
p.getSupportedExtensions = function patchedGetSupportedExtensions() {
|
||
const ret = raw.apply(this, arguments);
|
||
store.webgl.getSupportedExtensions = {
|
||
result: Array.from(ret || []),
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
};
|
||
return ret;
|
||
};
|
||
p.getSupportedExtensions.__wjep_hooked__ = true;
|
||
}
|
||
if (p.getExtension && !p.getExtension.__wjep_hooked__) {
|
||
const raw = p.getExtension;
|
||
p.getExtension = function patchedGetExtension(name) {
|
||
const ret = raw.apply(this, arguments);
|
||
store.webgl.getExtension.push({
|
||
match: { name: String(name) },
|
||
result: ret ? { exists: true, keys: Object.keys(ret).slice(0, 50) } : null,
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
return ret;
|
||
};
|
||
p.getExtension.__wjep_hooked__ = true;
|
||
}
|
||
if (p.getShaderPrecisionFormat && !p.getShaderPrecisionFormat.__wjep_hooked__) {
|
||
const raw = p.getShaderPrecisionFormat;
|
||
p.getShaderPrecisionFormat = function patchedGetShaderPrecisionFormat(shaderType, precisionType) {
|
||
const ret = raw.apply(this, arguments);
|
||
store.webgl.getShaderPrecisionFormat.push({
|
||
match: { shaderType, precisionType },
|
||
result: ret ? { rangeMin: ret.rangeMin, rangeMax: ret.rangeMax, precision: ret.precision } : null,
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
return ret;
|
||
};
|
||
p.getShaderPrecisionFormat.__wjep_hooked__ = true;
|
||
}
|
||
if (p.readPixels && !p.readPixels.__wjep_hooked__) {
|
||
const raw = p.readPixels;
|
||
p.readPixels = function patchedReadPixels(x, y, width, height, format, type, pixels) {
|
||
const ret = raw.apply(this, arguments);
|
||
store.webgl.readPixels.push({
|
||
match: { x, y, width, height, format, type },
|
||
result: { dataBase64: pixels ? chunkArrayLikeAsBase64(pixels) : chunkString("", "base64-chunks") },
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
return ret;
|
||
};
|
||
p.readPixels.__wjep_hooked__ = true;
|
||
}
|
||
}
|
||
`;
|
||
}
|
||
|
||
function webgpuSnippet() {
|
||
return `
|
||
// ===== WebGPU 终端 API 采样 =====
|
||
if (navigator.gpu && navigator.gpu.requestAdapter && !navigator.gpu.requestAdapter.__wjep_hooked__) {
|
||
const rawRequestAdapter = navigator.gpu.requestAdapter.bind(navigator.gpu);
|
||
navigator.gpu.requestAdapter = async function patchedRequestAdapter(options) {
|
||
const adapter = await rawRequestAdapter(options);
|
||
const info = adapter && adapter.info ? clonePlain(adapter.info, 4) : null;
|
||
store.webgpu.requestAdapter.push({
|
||
match: { options: clonePlain(options || {}, 4) },
|
||
result: {
|
||
info,
|
||
features: adapter && adapter.features ? Array.from(adapter.features) : [],
|
||
limits: adapter && adapter.limits ? clonePlain(adapter.limits, 3) : {}
|
||
},
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
return adapter;
|
||
};
|
||
navigator.gpu.requestAdapter.__wjep_hooked__ = true;
|
||
}
|
||
`;
|
||
}
|
||
|
||
function audioSnippet() {
|
||
return `
|
||
// ===== Audio 指纹终端 API 采样 =====
|
||
if (window.AudioBuffer && AudioBuffer.prototype.getChannelData && !AudioBuffer.prototype.getChannelData.__wjep_hooked__) {
|
||
const rawGetChannelData = AudioBuffer.prototype.getChannelData;
|
||
AudioBuffer.prototype.getChannelData = function patchedGetChannelData(channel) {
|
||
const ret = rawGetChannelData.apply(this, arguments);
|
||
try {
|
||
store.audio.getChannelData.push({
|
||
match: { channel, length: this.length, sampleRate: this.sampleRate, numberOfChannels: this.numberOfChannels },
|
||
result: { channelBase64: chunkArrayLikeAsBase64(ret) },
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
} catch(e) {}
|
||
return ret;
|
||
};
|
||
AudioBuffer.prototype.getChannelData.__wjep_hooked__ = true;
|
||
}
|
||
if (window.OfflineAudioContext && OfflineAudioContext.prototype.startRendering && !OfflineAudioContext.prototype.startRendering.__wjep_hooked__) {
|
||
const rawStartRendering = OfflineAudioContext.prototype.startRendering;
|
||
OfflineAudioContext.prototype.startRendering = function patchedStartRendering() {
|
||
const callStack = stack();
|
||
const ret = rawStartRendering.apply(this, arguments);
|
||
if (ret && typeof ret.then === "function") {
|
||
return ret.then(buffer => {
|
||
try {
|
||
const data = buffer.getChannelData(0);
|
||
store.audio.startRendering.push({
|
||
match: { length: buffer.length, sampleRate: buffer.sampleRate, numberOfChannels: buffer.numberOfChannels },
|
||
result: { channel0Base64: chunkArrayLikeAsBase64(data) },
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: callStack
|
||
});
|
||
} catch(e) {}
|
||
return buffer;
|
||
});
|
||
}
|
||
return ret;
|
||
};
|
||
OfflineAudioContext.prototype.startRendering.__wjep_hooked__ = true;
|
||
}
|
||
`;
|
||
}
|
||
|
||
function domSnippet() {
|
||
return `
|
||
// ===== DOM 几何 / 字体探测终端 API 采样 =====
|
||
if (window.Element) {
|
||
const p = Element.prototype;
|
||
const rawRect = p.getBoundingClientRect;
|
||
if (rawRect && !rawRect.__wjep_hooked__) {
|
||
p.getBoundingClientRect = function patchedGetBoundingClientRect() {
|
||
const ret = rawRect.apply(this, arguments);
|
||
store.domGeometry.getBoundingClientRect.push({
|
||
match: { selector: selectorOf(this) },
|
||
result: { x: ret.x, y: ret.y, width: ret.width, height: ret.height, top: ret.top, left: ret.left, right: ret.right, bottom: ret.bottom },
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
return ret;
|
||
};
|
||
p.getBoundingClientRect.__wjep_hooked__ = true;
|
||
}
|
||
const rawRects = p.getClientRects;
|
||
if (rawRects && !rawRects.__wjep_hooked__) {
|
||
p.getClientRects = function patchedGetClientRects() {
|
||
const ret = rawRects.apply(this, arguments);
|
||
store.domGeometry.getClientRects.push({
|
||
match: { selector: selectorOf(this) },
|
||
result: Array.from(ret || []).map(r => ({ x: r.x, y: r.y, width: r.width, height: r.height, top: r.top, left: r.left, right: r.right, bottom: r.bottom })),
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
return ret;
|
||
};
|
||
p.getClientRects.__wjep_hooked__ = true;
|
||
}
|
||
for (const key of ["offsetWidth", "offsetHeight", "scrollWidth", "scrollHeight", "clientWidth", "clientHeight"]) {
|
||
const desc = Object.getOwnPropertyDescriptor(HTMLElement.prototype, key) || Object.getOwnPropertyDescriptor(Element.prototype, key);
|
||
if (!desc || !desc.get || desc.get.__wjep_hooked__) continue;
|
||
Object.defineProperty(HTMLElement.prototype, key, {
|
||
get: function patchedGeometryGetter() {
|
||
const value = desc.get.call(this);
|
||
store.domGeometry.offset.push({
|
||
match: { selector: selectorOf(this) },
|
||
result: { [key]: value },
|
||
source: { capturedBy: "真实浏览器 Hook", tool: "用户选择的取证浏览器", traceStatus: "browser-complete-sampled" },
|
||
stack: stack()
|
||
});
|
||
return value;
|
||
},
|
||
enumerable: desc.enumerable,
|
||
configurable: true
|
||
});
|
||
try { Object.getOwnPropertyDescriptor(HTMLElement.prototype, key).get.__wjep_hooked__ = true; } catch(e) {}
|
||
}
|
||
}
|
||
`;
|
||
}
|
||
|
||
function build(args) {
|
||
const types = new Set(String(args.types || '').split(',').map(s => s.trim().toLowerCase()).filter(Boolean));
|
||
const parts = [header(args)];
|
||
if (types.has('canvas')) parts.push(canvasSnippet());
|
||
if (types.has('webgl')) parts.push(webglSnippet());
|
||
if (types.has('webgpu')) parts.push(webgpuSnippet());
|
||
if (types.has('audio')) parts.push(audioSnippet());
|
||
if (types.has('dom') || types.has('dom-geometry') || types.has('font') || types.has('fonts')) parts.push(domSnippet());
|
||
parts.push(footer());
|
||
return parts.join('\n');
|
||
}
|
||
|
||
try {
|
||
const args = parseArgs(process.argv);
|
||
if (args.help) { console.log(usage()); process.exit(0); }
|
||
const code = build(args);
|
||
if (args.out) {
|
||
const out = path.resolve(args.out);
|
||
fs.mkdirSync(path.dirname(out), { recursive: true });
|
||
fs.writeFileSync(out, code, 'utf8');
|
||
const compatNote = args.deprecatedMaxDataUrlLength ? '\n- 兼容提醒：--max-data-url-length 已按分片大小处理，没有裁剪任何值。' : '';
|
||
console.log(`# 指纹采样 Hook 已生成\n- 输出文件：${out}\n- 类型：${args.types}\n- 分片大小：${args.chunkSize}\n- 提醒：该 Hook 只用于前置取证，不得放入最终 result/ 目录；长指纹值必须 finalize 后完整分片保存。${compatNote}`);
|
||
} else {
|
||
process.stdout.write(code + '\n');
|
||
}
|
||
} catch (err) {
|
||
console.error(err.message || String(err));
|
||
console.error(usage());
|
||
process.exit(1);
|
||
}
|