pdf-codec 4.0.12 → 4.1.0

package/dist/encrypt-write.js

@@ -0,0 +1,231 @@
+import { pdfArray, pdfBool, pdfDict, pdfHexString, pdfName, pdfNum } from "./objects.js";
+import { concatBytes } from "./bytes/writer.js";
+import { aesCbcEncrypt } from "./crypto/aes.js";
+import { md5 } from "./crypto/md5.js";
+import { rc4 } from "./crypto/rc4.js";
+import { PASSWORD_PADDING, ZERO_IV, computeLegacyFileKeyFromPaddedPassword, hardenedHash, legacyUserValueCore, objectKey, padOrTruncatePassword, permissionsBytes } from "./encrypt.js";
+import { randomBytes } from "./crypto/random.js";
+//#region src/encrypt-write.ts
+var PdfEncryptionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PdfEncryptionError";
+	}
+};
+const RC4_128_KEY_BYTES = 16;
+const R6_PASSWORD_MAX_BYTES = 127;
+const RESERVED_BIT_7_AND_8 = 192;
+const DEPRECATED_ALWAYS_ONE_BIT_10 = 512;
+const SCHEME_SPECS = {
+	"rc4-40": {
+		v: 1,
+		r: 2,
+		keyBytes: 5,
+		method: "rc4"
+	},
+	"rc4-128": {
+		v: 2,
+		r: 3,
+		keyBytes: RC4_128_KEY_BYTES,
+		method: "rc4"
+	},
+	"aes-128": {
+		v: 4,
+		r: 4,
+		keyBytes: 16,
+		method: "aes"
+	},
+	"aes-256": {
+		v: 5,
+		r: 6,
+		keyBytes: 32,
+		method: "aes"
+	}
+};
+function legacyPasswordBytes(password) {
+	const bytes = new Uint8Array(password.length);
+	for (let i = 0; i < password.length; i++) {
+		const code = password.charCodeAt(i);
+		if (code > 127) throw new PdfEncryptionError(`password contains character code ${String(code)}, outside the printable-ASCII range this writer supports for the rc4-40/rc4-128/aes-128 schemes; use a plain-ASCII password, or the aes-256 scheme, whose revision-6 passwords are Unicode`);
+		bytes[i] = code;
+	}
+	return bytes;
+}
+function r6PasswordBytes(password) {
+	return new TextEncoder().encode(password.normalize("NFKC")).subarray(0, R6_PASSWORD_MAX_BYTES);
+}
+function permissionsToP(permissions) {
+	let p = 0;
+	if (permissions?.print ?? true) p |= 4;
+	if (permissions?.modifyContents ?? true) p |= 8;
+	if (permissions?.copy ?? true) p |= 16;
+	if (permissions?.annotate ?? true) p |= 32;
+	p |= RESERVED_BIT_7_AND_8;
+	if (permissions?.fillForms ?? true) p |= 256;
+	p |= DEPRECATED_ALWAYS_ONE_BIT_10;
+	if (permissions?.assemble ?? true) p |= 1024;
+	if (permissions?.printHighRes ?? true) p |= 2048;
+	for (let bit = 13; bit <= 32; bit++) p |= 1 << bit - 1;
+	return p;
+}
+function computeLegacyOwnerValue(ownerPassword, userPassword, revision, keyBytes) {
+	let digest = md5(padOrTruncatePassword(ownerPassword));
+	if (revision >= 3) for (let i = 0; i < 50; i++) digest = md5(digest);
+	const ownerKey = digest.subarray(0, keyBytes);
+	let value = rc4(ownerKey, padOrTruncatePassword(userPassword));
+	if (revision >= 3) for (let i = 1; i <= 19; i++) {
+		const roundKey = Uint8Array.from(ownerKey, (byte) => byte ^ i);
+		value = rc4(roundKey, value);
+	}
+	return value;
+}
+function computeLegacyUserValue(fileKey, fileId, revision) {
+	const core = legacyUserValueCore(fileKey, fileId, revision);
+	if (revision === 2) return core;
+	return concatBytes([core, randomBytes(PASSWORD_PADDING.length - core.length)]);
+}
+function encryptAes(key, data) {
+	const iv = randomBytes(16);
+	const padLength = 16 - data.length % 16;
+	const padded = new Uint8Array(data.length + padLength);
+	padded.set(data);
+	padded.fill(padLength, data.length);
+	return concatBytes([iv, aesCbcEncrypt(key, iv, padded)]);
+}
+function applyEncryptMethod(method, fileKey, perObjectKeys, bytes, num, gen) {
+	if (method === "identity") return bytes;
+	const key = perObjectKeys ? objectKey(fileKey, num, gen, method) : fileKey;
+	return method === "rc4" ? rc4(key, bytes) : encryptAes(key, bytes);
+}
+function buildEncryptor(encryptDict, fileKey, method, perObjectKeys, encryptMetadata) {
+	return {
+		encryptDict,
+		encryptString(bytes, num, gen) {
+			return applyEncryptMethod(method, fileKey, perObjectKeys, bytes, num, gen);
+		},
+		encryptStream(bytes, dict, num, gen) {
+			const type = dict.entries.get("Type");
+			if (!encryptMetadata && type?.kind === "name" && type.name === "Metadata") return bytes;
+			return applyEncryptMethod(method, fileKey, perObjectKeys, bytes, num, gen);
+		}
+	};
+}
+function buildLegacyEncryptor(spec, options, fileId) {
+	const userPassword = legacyPasswordBytes(options.userPassword ?? "");
+	const ownerPassword = legacyPasswordBytes(options.ownerPassword ?? options.userPassword ?? "");
+	const encryptMetadata = options.encryptMetadata ?? true;
+	const p = permissionsToP(options.permissions);
+	const owner = computeLegacyOwnerValue(ownerPassword, userPassword, spec.r, spec.keyBytes);
+	const fileKey = computeLegacyFileKeyFromPaddedPassword(padOrTruncatePassword(userPassword), owner, p, fileId, spec.r, spec.keyBytes, encryptMetadata);
+	const user = computeLegacyUserValue(fileKey, fileId, spec.r);
+	const entries = /* @__PURE__ */ new Map([
+		["Filter", pdfName("Standard")],
+		["V", pdfNum(spec.v)],
+		["R", pdfNum(spec.r)],
+		["O", pdfHexString(owner)],
+		["U", pdfHexString(user)],
+		["P", pdfNum(p)],
+		["Length", pdfNum(spec.keyBytes * 8)]
+	]);
+	if (spec.v === 4) {
+		entries.set("CF", pdfDict({ StdCF: pdfDict({
+			AuthEvent: pdfName("DocOpen"),
+			CFM: pdfName("AESV2"),
+			Length: pdfNum(spec.keyBytes)
+		}) }));
+		entries.set("StmF", pdfName("StdCF"));
+		entries.set("StrF", pdfName("StdCF"));
+		entries.set("EncryptMetadata", pdfBool(encryptMetadata));
+	}
+	return buildEncryptor(pdfDict(entries), fileKey, spec.method, true, encryptMetadata);
+}
+function buildAes256Encryptor(spec, options) {
+	const userPassword = r6PasswordBytes(options.userPassword ?? "");
+	const ownerPassword = r6PasswordBytes(options.ownerPassword ?? options.userPassword ?? "");
+	const encryptMetadata = options.encryptMetadata ?? true;
+	const p = permissionsToP(options.permissions);
+	const fileKey = randomBytes(32);
+	const userValidationSalt = randomBytes(8);
+	const userKeySalt = randomBytes(8);
+	const empty = /* @__PURE__ */ new Uint8Array(0);
+	const userHash = hardenedHash(userPassword, userValidationSalt, empty, spec.r);
+	const u = concatBytes([
+		userHash,
+		userValidationSalt,
+		userKeySalt
+	]);
+	const userIntermediateKey = hardenedHash(userPassword, userKeySalt, empty, spec.r);
+	const ue = aesCbcEncrypt(userIntermediateKey, ZERO_IV, fileKey);
+	const ownerValidationSalt = randomBytes(8);
+	const ownerKeySalt = randomBytes(8);
+	const ownerHash = hardenedHash(ownerPassword, ownerValidationSalt, u, spec.r);
+	const o = concatBytes([
+		ownerHash,
+		ownerValidationSalt,
+		ownerKeySalt
+	]);
+	const ownerIntermediateKey = hardenedHash(ownerPassword, ownerKeySalt, u, spec.r);
+	const oe = aesCbcEncrypt(ownerIntermediateKey, ZERO_IV, fileKey);
+	const permsBlock = /* @__PURE__ */ new Uint8Array(16);
+	permsBlock.set(permissionsBytes(p), 0);
+	permsBlock.set([
+		255,
+		255,
+		255,
+		255
+	], 4);
+	permsBlock[8] = encryptMetadata ? 84 : 70;
+	permsBlock.set([
+		97,
+		100,
+		98
+	], 9);
+	permsBlock.set(randomBytes(4), 12);
+	const perms = aesCbcEncrypt(fileKey, ZERO_IV, permsBlock);
+	const entries = /* @__PURE__ */ new Map([
+		["Filter", pdfName("Standard")],
+		["V", pdfNum(spec.v)],
+		["R", pdfNum(spec.r)],
+		["O", pdfHexString(o)],
+		["U", pdfHexString(u)],
+		["OE", pdfHexString(oe)],
+		["UE", pdfHexString(ue)],
+		["P", pdfNum(p)],
+		["Perms", pdfHexString(perms)],
+		["Length", pdfNum(spec.keyBytes * 8)],
+		["CF", pdfDict({ StdCF: pdfDict({
+			AuthEvent: pdfName("DocOpen"),
+			CFM: pdfName("AESV3"),
+			Length: pdfNum(spec.keyBytes)
+		}) })],
+		["StmF", pdfName("StdCF")],
+		["StrF", pdfName("StdCF")],
+		["EncryptMetadata", pdfBool(encryptMetadata)]
+	]);
+	return buildEncryptor(pdfDict(entries), fileKey, spec.method, false, encryptMetadata);
+}
+function createStandardEncryptor(options, fileId) {
+	const scheme = options.scheme ?? "aes-256";
+	const spec = SCHEME_SPECS[scheme];
+	return spec.v === 5 ? buildAes256Encryptor(spec, options) : buildLegacyEncryptor(spec, options, fileId);
+}
+function encryptIndirectObject(value, num, gen, encryptor) {
+	if (value.kind === "string") return {
+		kind: "string",
+		bytes: encryptor.encryptString(value.bytes, num, gen),
+		hex: value.hex
+	};
+	if (value.kind === "array") return pdfArray(value.items.map((item) => encryptIndirectObject(item, num, gen, encryptor)));
+	if (value.kind === "dict") return encryptDictEntries(value, num, gen, encryptor);
+	if (value.kind === "stream") return {
+		kind: "stream",
+		dict: encryptDictEntries(value.dict, num, gen, encryptor),
+		raw: encryptor.encryptStream(value.raw, value.dict, num, gen)
+	};
+	return value;
+}
+function encryptDictEntries(dict, num, gen, encryptor) {
+	return pdfDict(new Map(Array.from(dict.entries, ([key, entry]) => [key, encryptIndirectObject(entry, num, gen, encryptor)])));
+}
+//#endregion
+export { PdfEncryptionError, createStandardEncryptor, encryptIndirectObject };

package/dist/encrypt.cjs

@@ -50,11 +50,12 @@ const AES_OBJECT_KEY_SALT = new Uint8Array([
 const MD5_DIGEST_BYTES = 16;
 const OBJECT_KEY_EXTRA_BYTES = 5;
 const LEGACY_KEY_ITERATIONS = 50;
-const ALGORITHM_5_ITERATIONS = 19;
+const RC4_OBFUSCATION_ROUNDS = 19;
 const R6_MINIMUM_ROUNDS = 64;
 const R6_ROUND_REPEATS = 64;
 const R6_TERMINATION_MARGIN = 32;
 const AESV3_KEY_BYTES = 32;
+const AESV3_SALT_BYTES = 8;
 const RC4_40_KEY_BYTES = 5;
 const AESV2_KEY_BYTES = 16;
 const DEFAULT_KEY_BITS = 40;
@@ -80,11 +81,16 @@ function permissionsBytes(p) {
 		unsigned >>> 24 & 255
 	]);
 }
-function computeLegacyFileKey(encryptDict, fileId, revision, keyBytes, encryptMetadata) {
-	const owner = requireStringBytes(encryptDict, "O");
-	const permissions = require_objects.asNumber(require_objects.dictGet(encryptDict, "P")) ?? 0;
+function padOrTruncatePassword(password) {
+	if (password.length >= PASSWORD_PADDING.length) return password.subarray(0, PASSWORD_PADDING.length);
+	const padded = new Uint8Array(PASSWORD_PADDING.length);
+	padded.set(password);
+	padded.set(PASSWORD_PADDING.subarray(0, PASSWORD_PADDING.length - password.length), password.length);
+	return padded;
+}
+function computeLegacyFileKeyFromPaddedPassword(paddedPassword, owner, permissions, fileId, revision, keyBytes, encryptMetadata) {
 	const parts = [
-		PASSWORD_PADDING,
+		paddedPassword,
 		owner.subarray(0, PASSWORD_PADDING.length),
 		permissionsBytes(permissions),
 		fileId
@@ -96,18 +102,26 @@ function computeLegacyFileKey(encryptDict, fileId, revision, keyBytes, encryptMe
 		255
 	]));
 	let digest = require_crypto_md5.md5(require_bytes_writer.concatBytes(parts));
-	if (revision >= 3) for (let i = 0; i < LEGACY_KEY_ITERATIONS; i++) digest = require_crypto_md5.md5(digest.subarray(0, keyBytes));
+	if (revision >= 3) for (let i = 0; i < 50; i++) digest = require_crypto_md5.md5(digest.subarray(0, keyBytes));
 	return digest.subarray(0, keyBytes);
 }
-function legacyUserPasswordVerifies(encryptDict, fileId, revision, fileKey) {
-	const storedUser = requireStringBytes(encryptDict, "U");
-	if (revision === 2) return bytesEqual(require_crypto_rc4.rc4(fileKey, PASSWORD_PADDING), storedUser, PASSWORD_PADDING.length);
+function computeLegacyFileKey(encryptDict, fileId, revision, keyBytes, encryptMetadata) {
+	const owner = requireStringBytes(encryptDict, "O");
+	const permissions = require_objects.asNumber(require_objects.dictGet(encryptDict, "P")) ?? 0;
+	return computeLegacyFileKeyFromPaddedPassword(PASSWORD_PADDING, owner, permissions, fileId, revision, keyBytes, encryptMetadata);
+}
+function legacyUserValueCore(fileKey, fileId, revision) {
+	if (revision === 2) return require_crypto_rc4.rc4(fileKey, PASSWORD_PADDING);
 	let value = require_crypto_rc4.rc4(fileKey, require_crypto_md5.md5(require_bytes_writer.concatBytes([PASSWORD_PADDING, fileId])));
-	for (let i = 1; i <= ALGORITHM_5_ITERATIONS; i++) {
+	for (let i = 1; i <= 19; i++) {
 		const roundKey = Uint8Array.from(fileKey, (byte) => byte ^ i);
 		value = require_crypto_rc4.rc4(roundKey, value);
 	}
-	return bytesEqual(value, storedUser, MD5_DIGEST_BYTES);
+	return value;
+}
+function legacyUserPasswordVerifies(encryptDict, fileId, revision, fileKey) {
+	const storedUser = requireStringBytes(encryptDict, "U");
+	return bytesEqual(legacyUserValueCore(fileKey, fileId, revision), storedUser, revision === 2 ? PASSWORD_PADDING.length : 16);
 }
 function hardenedHash(password, salt, userData, revision) {
 	let k = require_crypto_sha2.sha256(require_bytes_writer.concatBytes([
@@ -133,20 +147,20 @@ function hardenedHash(password, salt, userData, revision) {
 		k = selector === 0 ? require_crypto_sha2.sha256(e) : selector === 1 ? require_crypto_sha2.sha384(e) : require_crypto_sha2.sha512(e);
 		round++;
 	}
-	return k.subarray(0, AESV3_KEY_BYTES);
+	return k.subarray(0, 32);
 }
 function computeAesV3FileKey(encryptDict, revision) {
 	const storedUser = requireStringBytes(encryptDict, "U");
 	const expectedLength = 48;
 	if (storedUser.length < expectedLength) throw new require_diagnostics.PdfEncryptedError(`the /Encrypt dictionary's /U entry is ${String(storedUser.length)} bytes; revision ${String(revision)} requires ${String(expectedLength)}`);
 	const empty = /* @__PURE__ */ new Uint8Array(0);
-	const validationSalt = storedUser.subarray(AESV3_KEY_BYTES, 40);
+	const validationSalt = storedUser.subarray(32, 40);
 	const keySalt = storedUser.subarray(40, expectedLength);
-	if (!bytesEqual(hardenedHash(empty, validationSalt, empty, revision), storedUser, AESV3_KEY_BYTES)) throw new require_diagnostics.PdfPasswordRequiredError();
+	if (!bytesEqual(hardenedHash(empty, validationSalt, empty, revision), storedUser, 32)) throw new require_diagnostics.PdfPasswordRequiredError();
 	const intermediateKey = hardenedHash(empty, keySalt, empty, revision);
 	const wrappedKey = requireStringBytes(encryptDict, "UE");
-	if (wrappedKey.length < AESV3_KEY_BYTES) throw new require_diagnostics.PdfEncryptedError(`the /Encrypt dictionary's /UE entry is ${String(wrappedKey.length)} bytes; revision ${String(revision)} requires ${String(AESV3_KEY_BYTES)}`);
-	return require_crypto_aes.aesCbcDecrypt(intermediateKey, ZERO_IV, wrappedKey.subarray(0, AESV3_KEY_BYTES));
+	if (wrappedKey.length < 32) throw new require_diagnostics.PdfEncryptedError(`the /Encrypt dictionary's /UE entry is ${String(wrappedKey.length)} bytes; revision ${String(revision)} requires ${String(32)}`);
+	return require_crypto_aes.aesCbcDecrypt(intermediateKey, ZERO_IV, wrappedKey.subarray(0, 32));
 }
 function methodFromCryptFilterName(encryptDict, entryKey) {
 	const name = require_objects.asName(require_objects.dictGet(encryptDict, entryKey)) ?? "Identity";
@@ -164,7 +178,7 @@ function cryptFilterKeyBytes(encryptDict, declaredBits) {
 	const streamFilterName = require_objects.asName(require_objects.dictGet(encryptDict, "StmF")) ?? "Identity";
 	const filters = require_objects.asDict(require_objects.dictGet(encryptDict, "CF"));
 	const filter = filters !== void 0 ? require_objects.asDict(require_objects.dictGet(filters, streamFilterName)) : void 0;
-	if ((filter !== void 0 ? require_objects.asName(require_objects.dictGet(filter, "CFM")) : void 0) === "AESV2") return AESV2_KEY_BYTES;
+	if ((filter !== void 0 ? require_objects.asName(require_objects.dictGet(filter, "CFM")) : void 0) === "AESV2") return 16;
 	const declared = filter !== void 0 ? require_objects.asNumber(require_objects.dictGet(filter, "Length")) : void 0;
 	if (declared === void 0) return Math.floor(declaredBits / BITS_PER_BYTE);
 	return declared >= DEFAULT_KEY_BITS ? Math.floor(declared / BITS_PER_BYTE) : declared;
@@ -189,8 +203,8 @@ function setUpHandler(encryptDict, fileId) {
 	if (revision < 2 || revision > 4) throw new require_diagnostics.PdfEncryptedError(`unsupported standard security handler revision /R ${String(revision)}`);
 	const streamMethod = version === 4 ? methodFromCryptFilterName(encryptDict, "StmF") : "rc4";
 	const stringMethod = version === 4 ? methodFromCryptFilterName(encryptDict, "StrF") : "rc4";
-	const keyBytes = version === 1 ? RC4_40_KEY_BYTES : version === 2 ? Math.floor(declaredBits / BITS_PER_BYTE) : cryptFilterKeyBytes(encryptDict, declaredBits);
-	if (keyBytes < RC4_40_KEY_BYTES || keyBytes > MAX_RC4_KEY_BYTES) throw new require_diagnostics.PdfEncryptedError(`the /Encrypt dictionary declares a ${String(keyBytes * BITS_PER_BYTE)}-bit file key, outside the 40-128 bit range /V ${String(version)} permits`);
+	const keyBytes = version === 1 ? 5 : version === 2 ? Math.floor(declaredBits / BITS_PER_BYTE) : cryptFilterKeyBytes(encryptDict, declaredBits);
+	if (keyBytes < 5 || keyBytes > MAX_RC4_KEY_BYTES) throw new require_diagnostics.PdfEncryptedError(`the /Encrypt dictionary declares a ${String(keyBytes * BITS_PER_BYTE)}-bit file key, outside the 40-128 bit range /V ${String(version)} permits`);
 	const fileKey = computeLegacyFileKey(encryptDict, fileId, revision, keyBytes, encryptMetadata);
 	if (!legacyUserPasswordVerifies(encryptDict, fileId, revision, fileKey)) throw new require_diagnostics.PdfPasswordRequiredError();
 	return {
@@ -212,7 +226,7 @@ function objectKey(fileKey, num, gen, method) {
 		fileKey,
 		extra,
 		AES_OBJECT_KEY_SALT
-	] : [fileKey, extra])).subarray(0, Math.min(fileKey.length + OBJECT_KEY_EXTRA_BYTES, MD5_DIGEST_BYTES));
+	] : [fileKey, extra])).subarray(0, Math.min(fileKey.length + OBJECT_KEY_EXTRA_BYTES, 16));
 }
 function decryptAes(key, data, sink) {
 	if (data.length <= 16) {
@@ -261,4 +275,20 @@ function createStandardDecryptor(encryptDict, fileId, sink) {
 	};
 }
 //#endregion
+exports.AESV2_KEY_BYTES = AESV2_KEY_BYTES;
+exports.AESV3_KEY_BYTES = AESV3_KEY_BYTES;
+exports.AESV3_SALT_BYTES = AESV3_SALT_BYTES;
+exports.AES_OBJECT_KEY_SALT = AES_OBJECT_KEY_SALT;
+exports.LEGACY_KEY_ITERATIONS = LEGACY_KEY_ITERATIONS;
+exports.MD5_DIGEST_BYTES = MD5_DIGEST_BYTES;
+exports.PASSWORD_PADDING = PASSWORD_PADDING;
+exports.RC4_40_KEY_BYTES = RC4_40_KEY_BYTES;
+exports.RC4_OBFUSCATION_ROUNDS = RC4_OBFUSCATION_ROUNDS;
+exports.ZERO_IV = ZERO_IV;
+exports.computeLegacyFileKeyFromPaddedPassword = computeLegacyFileKeyFromPaddedPassword;
 exports.createStandardDecryptor = createStandardDecryptor;
+exports.hardenedHash = hardenedHash;
+exports.legacyUserValueCore = legacyUserValueCore;
+exports.objectKey = objectKey;
+exports.padOrTruncatePassword = padOrTruncatePassword;
+exports.permissionsBytes = permissionsBytes;

package/dist/encrypt.d.cts

@@ -1,11 +1,27 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { PdfDict } from "./objects.cjs";
+import { n as PdfDict } from "./objects-B7HdMeWS.cjs";
 //#region src/encrypt.d.ts
 type CipherMethod = "identity" | "rc4" | "aes";
 interface PdfDecryptor {
   decryptString(bytes: Uint8Array<ArrayBuffer>, num: number, gen: number): Uint8Array<ArrayBuffer>;
   decryptStream(bytes: Uint8Array<ArrayBuffer>, dict: PdfDict, num: number, gen: number): Uint8Array<ArrayBuffer>;
 }
+declare const PASSWORD_PADDING: Uint8Array<ArrayBuffer>;
+declare const AES_OBJECT_KEY_SALT: Uint8Array<ArrayBuffer>;
+declare const MD5_DIGEST_BYTES = 16;
+declare const LEGACY_KEY_ITERATIONS = 50;
+declare const RC4_OBFUSCATION_ROUNDS = 19;
+declare const AESV3_KEY_BYTES = 32;
+declare const AESV3_SALT_BYTES = 8;
+declare const RC4_40_KEY_BYTES = 5;
+declare const AESV2_KEY_BYTES = 16;
+declare const ZERO_IV: Uint8Array<ArrayBuffer>;
+declare function permissionsBytes(p: number): Uint8Array<ArrayBuffer>;
+declare function padOrTruncatePassword(password: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function computeLegacyFileKeyFromPaddedPassword(paddedPassword: Uint8Array<ArrayBuffer>, owner: Uint8Array<ArrayBuffer>, permissions: number, fileId: Uint8Array<ArrayBuffer>, revision: number, keyBytes: number, encryptMetadata: boolean): Uint8Array<ArrayBuffer>;
+declare function legacyUserValueCore(fileKey: Uint8Array<ArrayBuffer>, fileId: Uint8Array<ArrayBuffer>, revision: number): Uint8Array<ArrayBuffer>;
+declare function hardenedHash(password: Uint8Array<ArrayBuffer>, salt: Uint8Array<ArrayBuffer>, userData: Uint8Array<ArrayBuffer>, revision: number): Uint8Array<ArrayBuffer>;
+declare function objectKey(fileKey: Uint8Array<ArrayBuffer>, num: number, gen: number, method: CipherMethod): Uint8Array<ArrayBuffer>;
 declare function createStandardDecryptor(encryptDict: PdfDict, fileId: Uint8Array<ArrayBuffer>, sink: PdfDiagnosticSink): PdfDecryptor;
 //#endregion
-export { CipherMethod, PdfDecryptor, createStandardDecryptor };
+export { AESV2_KEY_BYTES, AESV3_KEY_BYTES, AESV3_SALT_BYTES, AES_OBJECT_KEY_SALT, CipherMethod, LEGACY_KEY_ITERATIONS, MD5_DIGEST_BYTES, PASSWORD_PADDING, PdfDecryptor, RC4_40_KEY_BYTES, RC4_OBFUSCATION_ROUNDS, ZERO_IV, computeLegacyFileKeyFromPaddedPassword, createStandardDecryptor, hardenedHash, legacyUserValueCore, objectKey, padOrTruncatePassword, permissionsBytes };

package/dist/encrypt.d.ts

@@ -1,11 +1,27 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { PdfDict } from "./objects.js";
+import { n as PdfDict } from "./objects-B7HdMeWS.js";
 //#region src/encrypt.d.ts
 type CipherMethod = "identity" | "rc4" | "aes";
 interface PdfDecryptor {
   decryptString(bytes: Uint8Array<ArrayBuffer>, num: number, gen: number): Uint8Array<ArrayBuffer>;
   decryptStream(bytes: Uint8Array<ArrayBuffer>, dict: PdfDict, num: number, gen: number): Uint8Array<ArrayBuffer>;
 }
+declare const PASSWORD_PADDING: Uint8Array<ArrayBuffer>;
+declare const AES_OBJECT_KEY_SALT: Uint8Array<ArrayBuffer>;
+declare const MD5_DIGEST_BYTES = 16;
+declare const LEGACY_KEY_ITERATIONS = 50;
+declare const RC4_OBFUSCATION_ROUNDS = 19;
+declare const AESV3_KEY_BYTES = 32;
+declare const AESV3_SALT_BYTES = 8;
+declare const RC4_40_KEY_BYTES = 5;
+declare const AESV2_KEY_BYTES = 16;
+declare const ZERO_IV: Uint8Array<ArrayBuffer>;
+declare function permissionsBytes(p: number): Uint8Array<ArrayBuffer>;
+declare function padOrTruncatePassword(password: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function computeLegacyFileKeyFromPaddedPassword(paddedPassword: Uint8Array<ArrayBuffer>, owner: Uint8Array<ArrayBuffer>, permissions: number, fileId: Uint8Array<ArrayBuffer>, revision: number, keyBytes: number, encryptMetadata: boolean): Uint8Array<ArrayBuffer>;
+declare function legacyUserValueCore(fileKey: Uint8Array<ArrayBuffer>, fileId: Uint8Array<ArrayBuffer>, revision: number): Uint8Array<ArrayBuffer>;
+declare function hardenedHash(password: Uint8Array<ArrayBuffer>, salt: Uint8Array<ArrayBuffer>, userData: Uint8Array<ArrayBuffer>, revision: number): Uint8Array<ArrayBuffer>;
+declare function objectKey(fileKey: Uint8Array<ArrayBuffer>, num: number, gen: number, method: CipherMethod): Uint8Array<ArrayBuffer>;
 declare function createStandardDecryptor(encryptDict: PdfDict, fileId: Uint8Array<ArrayBuffer>, sink: PdfDiagnosticSink): PdfDecryptor;
 //#endregion
-export { CipherMethod, PdfDecryptor, createStandardDecryptor };
+export { AESV2_KEY_BYTES, AESV3_KEY_BYTES, AESV3_SALT_BYTES, AES_OBJECT_KEY_SALT, CipherMethod, LEGACY_KEY_ITERATIONS, MD5_DIGEST_BYTES, PASSWORD_PADDING, PdfDecryptor, RC4_40_KEY_BYTES, RC4_OBFUSCATION_ROUNDS, ZERO_IV, computeLegacyFileKeyFromPaddedPassword, createStandardDecryptor, hardenedHash, legacyUserValueCore, objectKey, padOrTruncatePassword, permissionsBytes };

package/dist/encrypt.js

@@ -49,11 +49,12 @@ const AES_OBJECT_KEY_SALT = new Uint8Array([
 const MD5_DIGEST_BYTES = 16;
 const OBJECT_KEY_EXTRA_BYTES = 5;
 const LEGACY_KEY_ITERATIONS = 50;
-const ALGORITHM_5_ITERATIONS = 19;
+const RC4_OBFUSCATION_ROUNDS = 19;
 const R6_MINIMUM_ROUNDS = 64;
 const R6_ROUND_REPEATS = 64;
 const R6_TERMINATION_MARGIN = 32;
 const AESV3_KEY_BYTES = 32;
+const AESV3_SALT_BYTES = 8;
 const RC4_40_KEY_BYTES = 5;
 const AESV2_KEY_BYTES = 16;
 const DEFAULT_KEY_BITS = 40;
@@ -79,11 +80,16 @@ function permissionsBytes(p) {
 		unsigned >>> 24 & 255
 	]);
 }
-function computeLegacyFileKey(encryptDict, fileId, revision, keyBytes, encryptMetadata) {
-	const owner = requireStringBytes(encryptDict, "O");
-	const permissions = asNumber(dictGet(encryptDict, "P")) ?? 0;
+function padOrTruncatePassword(password) {
+	if (password.length >= PASSWORD_PADDING.length) return password.subarray(0, PASSWORD_PADDING.length);
+	const padded = new Uint8Array(PASSWORD_PADDING.length);
+	padded.set(password);
+	padded.set(PASSWORD_PADDING.subarray(0, PASSWORD_PADDING.length - password.length), password.length);
+	return padded;
+}
+function computeLegacyFileKeyFromPaddedPassword(paddedPassword, owner, permissions, fileId, revision, keyBytes, encryptMetadata) {
 	const parts = [
-		PASSWORD_PADDING,
+		paddedPassword,
 		owner.subarray(0, PASSWORD_PADDING.length),
 		permissionsBytes(permissions),
 		fileId
@@ -95,18 +101,26 @@ function computeLegacyFileKey(encryptDict, fileId, revision, keyBytes, encryptMe
 		255
 	]));
 	let digest = md5(concatBytes(parts));
-	if (revision >= 3) for (let i = 0; i < LEGACY_KEY_ITERATIONS; i++) digest = md5(digest.subarray(0, keyBytes));
+	if (revision >= 3) for (let i = 0; i < 50; i++) digest = md5(digest.subarray(0, keyBytes));
 	return digest.subarray(0, keyBytes);
 }
-function legacyUserPasswordVerifies(encryptDict, fileId, revision, fileKey) {
-	const storedUser = requireStringBytes(encryptDict, "U");
-	if (revision === 2) return bytesEqual(rc4(fileKey, PASSWORD_PADDING), storedUser, PASSWORD_PADDING.length);
+function computeLegacyFileKey(encryptDict, fileId, revision, keyBytes, encryptMetadata) {
+	const owner = requireStringBytes(encryptDict, "O");
+	const permissions = asNumber(dictGet(encryptDict, "P")) ?? 0;
+	return computeLegacyFileKeyFromPaddedPassword(PASSWORD_PADDING, owner, permissions, fileId, revision, keyBytes, encryptMetadata);
+}
+function legacyUserValueCore(fileKey, fileId, revision) {
+	if (revision === 2) return rc4(fileKey, PASSWORD_PADDING);
 	let value = rc4(fileKey, md5(concatBytes([PASSWORD_PADDING, fileId])));
-	for (let i = 1; i <= ALGORITHM_5_ITERATIONS; i++) {
+	for (let i = 1; i <= 19; i++) {
 		const roundKey = Uint8Array.from(fileKey, (byte) => byte ^ i);
 		value = rc4(roundKey, value);
 	}
-	return bytesEqual(value, storedUser, MD5_DIGEST_BYTES);
+	return value;
+}
+function legacyUserPasswordVerifies(encryptDict, fileId, revision, fileKey) {
+	const storedUser = requireStringBytes(encryptDict, "U");
+	return bytesEqual(legacyUserValueCore(fileKey, fileId, revision), storedUser, revision === 2 ? PASSWORD_PADDING.length : 16);
 }
 function hardenedHash(password, salt, userData, revision) {
 	let k = sha256(concatBytes([
@@ -132,20 +146,20 @@ function hardenedHash(password, salt, userData, revision) {
 		k = selector === 0 ? sha256(e) : selector === 1 ? sha384(e) : sha512(e);
 		round++;
 	}
-	return k.subarray(0, AESV3_KEY_BYTES);
+	return k.subarray(0, 32);
 }
 function computeAesV3FileKey(encryptDict, revision) {
 	const storedUser = requireStringBytes(encryptDict, "U");
 	const expectedLength = 48;
 	if (storedUser.length < expectedLength) throw new PdfEncryptedError(`the /Encrypt dictionary's /U entry is ${String(storedUser.length)} bytes; revision ${String(revision)} requires ${String(expectedLength)}`);
 	const empty = /* @__PURE__ */ new Uint8Array(0);
-	const validationSalt = storedUser.subarray(AESV3_KEY_BYTES, 40);
+	const validationSalt = storedUser.subarray(32, 40);
 	const keySalt = storedUser.subarray(40, expectedLength);
-	if (!bytesEqual(hardenedHash(empty, validationSalt, empty, revision), storedUser, AESV3_KEY_BYTES)) throw new PdfPasswordRequiredError();
+	if (!bytesEqual(hardenedHash(empty, validationSalt, empty, revision), storedUser, 32)) throw new PdfPasswordRequiredError();
 	const intermediateKey = hardenedHash(empty, keySalt, empty, revision);
 	const wrappedKey = requireStringBytes(encryptDict, "UE");
-	if (wrappedKey.length < AESV3_KEY_BYTES) throw new PdfEncryptedError(`the /Encrypt dictionary's /UE entry is ${String(wrappedKey.length)} bytes; revision ${String(revision)} requires ${String(AESV3_KEY_BYTES)}`);
-	return aesCbcDecrypt(intermediateKey, ZERO_IV, wrappedKey.subarray(0, AESV3_KEY_BYTES));
+	if (wrappedKey.length < 32) throw new PdfEncryptedError(`the /Encrypt dictionary's /UE entry is ${String(wrappedKey.length)} bytes; revision ${String(revision)} requires ${String(32)}`);
+	return aesCbcDecrypt(intermediateKey, ZERO_IV, wrappedKey.subarray(0, 32));
 }
 function methodFromCryptFilterName(encryptDict, entryKey) {
 	const name = asName(dictGet(encryptDict, entryKey)) ?? "Identity";
@@ -163,7 +177,7 @@ function cryptFilterKeyBytes(encryptDict, declaredBits) {
 	const streamFilterName = asName(dictGet(encryptDict, "StmF")) ?? "Identity";
 	const filters = asDict(dictGet(encryptDict, "CF"));
 	const filter = filters !== void 0 ? asDict(dictGet(filters, streamFilterName)) : void 0;
-	if ((filter !== void 0 ? asName(dictGet(filter, "CFM")) : void 0) === "AESV2") return AESV2_KEY_BYTES;
+	if ((filter !== void 0 ? asName(dictGet(filter, "CFM")) : void 0) === "AESV2") return 16;
 	const declared = filter !== void 0 ? asNumber(dictGet(filter, "Length")) : void 0;
 	if (declared === void 0) return Math.floor(declaredBits / BITS_PER_BYTE);
 	return declared >= DEFAULT_KEY_BITS ? Math.floor(declared / BITS_PER_BYTE) : declared;
@@ -188,8 +202,8 @@ function setUpHandler(encryptDict, fileId) {
 	if (revision < 2 || revision > 4) throw new PdfEncryptedError(`unsupported standard security handler revision /R ${String(revision)}`);
 	const streamMethod = version === 4 ? methodFromCryptFilterName(encryptDict, "StmF") : "rc4";
 	const stringMethod = version === 4 ? methodFromCryptFilterName(encryptDict, "StrF") : "rc4";
-	const keyBytes = version === 1 ? RC4_40_KEY_BYTES : version === 2 ? Math.floor(declaredBits / BITS_PER_BYTE) : cryptFilterKeyBytes(encryptDict, declaredBits);
-	if (keyBytes < RC4_40_KEY_BYTES || keyBytes > MAX_RC4_KEY_BYTES) throw new PdfEncryptedError(`the /Encrypt dictionary declares a ${String(keyBytes * BITS_PER_BYTE)}-bit file key, outside the 40-128 bit range /V ${String(version)} permits`);
+	const keyBytes = version === 1 ? 5 : version === 2 ? Math.floor(declaredBits / BITS_PER_BYTE) : cryptFilterKeyBytes(encryptDict, declaredBits);
+	if (keyBytes < 5 || keyBytes > MAX_RC4_KEY_BYTES) throw new PdfEncryptedError(`the /Encrypt dictionary declares a ${String(keyBytes * BITS_PER_BYTE)}-bit file key, outside the 40-128 bit range /V ${String(version)} permits`);
 	const fileKey = computeLegacyFileKey(encryptDict, fileId, revision, keyBytes, encryptMetadata);
 	if (!legacyUserPasswordVerifies(encryptDict, fileId, revision, fileKey)) throw new PdfPasswordRequiredError();
 	return {
@@ -211,7 +225,7 @@ function objectKey(fileKey, num, gen, method) {
 		fileKey,
 		extra,
 		AES_OBJECT_KEY_SALT
-	] : [fileKey, extra])).subarray(0, Math.min(fileKey.length + OBJECT_KEY_EXTRA_BYTES, MD5_DIGEST_BYTES));
+	] : [fileKey, extra])).subarray(0, Math.min(fileKey.length + OBJECT_KEY_EXTRA_BYTES, 16));
 }
 function decryptAes(key, data, sink) {
 	if (data.length <= 16) {
@@ -260,4 +274,4 @@ function createStandardDecryptor(encryptDict, fileId, sink) {
 	};
 }
 //#endregion
-export { createStandardDecryptor };
+export { AESV2_KEY_BYTES, AESV3_KEY_BYTES, AESV3_SALT_BYTES, AES_OBJECT_KEY_SALT, LEGACY_KEY_ITERATIONS, MD5_DIGEST_BYTES, PASSWORD_PADDING, RC4_40_KEY_BYTES, RC4_OBFUSCATION_ROUNDS, ZERO_IV, computeLegacyFileKeyFromPaddedPassword, createStandardDecryptor, hardenedHash, legacyUserValueCore, objectKey, padOrTruncatePassword, permissionsBytes };

package/dist/filters.d.cts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { PdfDict, PdfObject } from "./objects.cjs";
+import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.cjs";
 //#region src/filters.d.ts
 interface DecodedStream {
   readonly bytes: Uint8Array<ArrayBuffer>;

package/dist/filters.d.ts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { PdfDict, PdfObject } from "./objects.js";
+import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.js";
 //#region src/filters.d.ts
 interface DecodedStream {
   readonly bytes: Uint8Array<ArrayBuffer>;

package/dist/font-read.d.cts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { PdfDict } from "./objects.cjs";
+import { n as PdfDict } from "./objects-B7HdMeWS.cjs";
 import { FontMetricsPort, PdfObjectResolver } from "./interpret.cjs";
 //#region src/font-read.d.ts
 interface PdfFont {

package/dist/font-read.d.ts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { PdfDict } from "./objects.js";
+import { n as PdfDict } from "./objects-B7HdMeWS.js";
 import { FontMetricsPort, PdfObjectResolver } from "./interpret.js";
 //#region src/font-read.d.ts
 interface PdfFont {

package/dist/form.d.cts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { PdfDict } from "./objects.cjs";
+import { n as PdfDict } from "./objects-B7HdMeWS.cjs";
 import { PdfObjectResolver } from "./interpret.cjs";
 import { LayoutFormField } from "./layout.cjs";
 import { PageIndexLookup } from "./navigation.cjs";

package/dist/form.d.ts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { PdfDict } from "./objects.js";
+import { n as PdfDict } from "./objects-B7HdMeWS.js";
 import { PdfObjectResolver } from "./interpret.js";
 import { LayoutFormField } from "./layout.js";
 import { PageIndexLookup } from "./navigation.js";

package/dist/images-read.d.cts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { PdfDict } from "./objects.cjs";
+import { n as PdfDict } from "./objects-B7HdMeWS.cjs";
 import { PdfObjectResolver } from "./interpret.cjs";
 //#region src/images-read.d.ts
 interface ExtractedPdfImage {

package/dist/images-read.d.ts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { PdfDict } from "./objects.js";
+import { n as PdfDict } from "./objects-B7HdMeWS.js";
 import { PdfObjectResolver } from "./interpret.js";
 //#region src/images-read.d.ts
 interface ExtractedPdfImage {

package/dist/index.cjs

@@ -11,6 +11,7 @@ const require_image_jpeg2000_errors = require("./image/jpeg2000-errors.cjs");
 const require_image_jp2_boxes = require("./image/jp2-boxes.cjs");
 const require_image_jpeg2000 = require("./image/jpeg2000.cjs");
 const require_read = require("./read.cjs");
+const require_encrypt_write = require("./encrypt-write.cjs");
 const require_font_registry = require("./font-registry.cjs");
 const require_math_stretch = require("./math-stretch.cjs");
 const require_math_font = require("./math-font.cjs");
@@ -52,6 +53,7 @@ exports.LayoutTextSchema = require_layout.LayoutTextSchema;
 exports.NOOP_DIAGNOSTIC_SINK = require_diagnostics.NOOP_DIAGNOSTIC_SINK;
 exports.PdfBytesSchema = require_codec.PdfBytesSchema;
 exports.PdfEncryptedError = require_diagnostics.PdfEncryptedError;
+exports.PdfEncryptionError = require_encrypt_write.PdfEncryptionError;
 exports.PdfParseError = require_diagnostics.PdfParseError;
 exports.PdfPasswordRequiredError = require_diagnostics.PdfPasswordRequiredError;
 exports.STANDARD_METRICS = require_afm_widths.STANDARD_METRICS;