Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/modules/signature/services/padesSeal.server.test.ts
T

101 lines
4.3 KiB
TypeScript

import { createHash } from "node:crypto";
import { createRequire } from "node:module";
import { serializeExportTableToPdf } from "@hivegrid/exports";
import { describe, expect, it } from "vitest";
import { buildRfc3161TimestampRequest, readTimestampResponseBytes, sealPdfWithPades } from "./padesSeal.server";
const requireNode = createRequire(import.meta.url);
function createTestPkcs12(passphrase: string): Buffer {
const forge = requireNode("node-forge");
const keys = forge.pki.rsa.generateKeyPair(1024);
const certificate = forge.pki.createCertificate();
certificate.publicKey = keys.publicKey;
certificate.serialNumber = "01";
certificate.validity.notBefore = new Date("2025-01-01T00:00:00.000Z");
certificate.validity.notAfter = new Date("2030-01-01T00:00:00.000Z");
const attributes = [{ name: "commonName", value: "HiveGrid test signer" }];
certificate.setSubject(attributes);
certificate.setIssuer(attributes);
certificate.sign(keys.privateKey, forge.md.sha256.create());
const p12 = forge.pkcs12.toPkcs12Asn1(keys.privateKey, [certificate], passphrase, {
algorithm: "3des",
});
return Buffer.from(forge.asn1.toDer(p12).getBytes(), "binary");
}
describe("buildRfc3161TimestampRequest", () => {
it("builds a DER encoded RFC3161 request for a SHA-256 message imprint", () => {
const digest = createHash("sha256").update("pdf bytes").digest();
const request = buildRfc3161TimestampRequest(digest, Buffer.from("0102030405060708", "hex"));
expect(request.byteLength).toBeGreaterThan(40);
expect(request[0]).toBe(0x30);
expect(request.includes(Buffer.from("608648016503040201", "hex"))).toBe(true);
expect(request.includes(digest)).toBe(true);
});
});
describe("readTimestampResponseBytes", () => {
it("bounds both declared and actual response bytes", async () => {
const valid = new Response(new Uint8Array([1, 2, 3]), { headers: { "content-length": "3" } });
await expect(readTimestampResponseBytes(valid, 3)).resolves.toEqual(new Uint8Array([1, 2, 3]));
const declaredTooLarge = new Response(new Uint8Array([1]), { headers: { "content-length": "4" } });
await expect(readTimestampResponseBytes(declaredTooLarge, 3)).rejects.toThrow("size limit");
const understated = new Response(new Uint8Array([1, 2, 3, 4]), { headers: { "content-length": "2" } });
await expect(readTimestampResponseBytes(understated, 3)).rejects.toThrow("size limit");
});
});
describe("sealPdfWithPades", () => {
it("signs a generated PDF with the supported PKCS#12 and PDF dependency graph", async () => {
const passphrase = "test-passphrase";
const original = {
p12: process.env.SIGNATURE_P12_BASE64,
passphrase: process.env.SIGNATURE_P12_PASSPHRASE,
requirePades: process.env.SIGNATURE_REQUIRE_PADES,
tsaUrl: process.env.SIGNATURE_TSA_URL,
};
process.env.SIGNATURE_P12_BASE64 = createTestPkcs12(passphrase).toString("base64");
process.env.SIGNATURE_P12_PASSPHRASE = passphrase;
process.env.SIGNATURE_REQUIRE_PADES = "true";
delete process.env.SIGNATURE_TSA_URL;
try {
const pdfBytes = await serializeExportTableToPdf(
{ columns: [{ key: "value", label: "Value" }], rows: [{ value: "signed" }] },
{ title: "Dependency compatibility" },
);
const result = await sealPdfWithPades({
pdfBytes,
title: "Dependency compatibility",
signerName: "HiveGrid test signer",
contactInfo: "security@example.invalid",
location: "Test",
reason: "Dependency compatibility",
signingTime: new Date("2026-01-01T00:00:00.000Z"),
});
const signedPdf = Buffer.from(result.bytes).toString("latin1");
expect(result.mode).toBe("pades_cades_detached");
expect(result.certificateConfigured).toBe(true);
expect(result.bytes.byteLength).toBeGreaterThan(pdfBytes.byteLength);
expect(signedPdf).toContain("/ByteRange");
expect(signedPdf).toContain("/SubFilter /ETSI.CAdES.detached");
} finally {
for (const [key, value] of Object.entries({
SIGNATURE_P12_BASE64: original.p12,
SIGNATURE_P12_PASSPHRASE: original.passphrase,
SIGNATURE_REQUIRE_PADES: original.requirePades,
SIGNATURE_TSA_URL: original.tsaUrl,
})) {
if (value === undefined) delete process.env[key];
else process.env[key] = value;
}
}
});
});