reamkit 1.6.0 → 1.9.0

package/dist/esm/pdf-reader/crypto.js

@@ -0,0 +1,609 @@
+//#region src/pdf-reader/crypto.ts
+function rc4(key, data) {
+	const s = new Uint8Array(256);
+	for (let i = 0; i < 256; i++) s[i] = i;
+	let j = 0;
+	for (let i = 0; i < 256; i++) {
+		j = j + s[i] + key[i % key.length] & 255;
+		[s[i], s[j]] = [s[j], s[i]];
+	}
+	const out = new Uint8Array(data.length);
+	let a = 0;
+	let b = 0;
+	for (let k = 0; k < data.length; k++) {
+		a = a + 1 & 255;
+		b = b + s[a] & 255;
+		[s[a], s[b]] = [s[b], s[a]];
+		out[k] = data[k] ^ s[s[a] + s[b] & 255];
+	}
+	return out;
+}
+var MD5_S = [
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21
+];
+var MD5_K = Array.from({ length: 64 }, (_, i) => Math.floor(Math.abs(Math.sin(i + 1)) * 4294967296));
+function md5(input) {
+	const len = input.length;
+	const withOne = (len + 8 >> 6) + 1;
+	const msg = new Uint8Array(withOne * 64);
+	msg.set(input);
+	msg[len] = 128;
+	const bitLen = len * 8;
+	for (let i = 0; i < 4; i++) msg[msg.length - 8 + i] = bitLen >>> 8 * i & 255;
+	let a0 = 1732584193;
+	let b0 = 4023233417;
+	let c0 = 2562383102;
+	let d0 = 271733878;
+	const rol = (x, c) => x << c | x >>> 32 - c;
+	for (let off = 0; off < msg.length; off += 64) {
+		const m = new Array(16);
+		for (let i = 0; i < 16; i++) m[i] = msg[off + i * 4] | msg[off + i * 4 + 1] << 8 | msg[off + i * 4 + 2] << 16 | msg[off + i * 4 + 3] << 24;
+		let a = a0;
+		let b = b0;
+		let c = c0;
+		let d = d0;
+		for (let i = 0; i < 64; i++) {
+			let f;
+			let g;
+			if (i < 16) {
+				f = b & c | ~b & d;
+				g = i;
+			} else if (i < 32) {
+				f = d & b | ~d & c;
+				g = (5 * i + 1) % 16;
+			} else if (i < 48) {
+				f = b ^ c ^ d;
+				g = (3 * i + 5) % 16;
+			} else {
+				f = c ^ (b | ~d);
+				g = 7 * i % 16;
+			}
+			f = f + a + MD5_K[i] + m[g] | 0;
+			a = d;
+			d = c;
+			c = b;
+			b = b + rol(f, MD5_S[i]) | 0;
+		}
+		a0 = a0 + a | 0;
+		b0 = b0 + b | 0;
+		c0 = c0 + c | 0;
+		d0 = d0 + d | 0;
+	}
+	const out = new Uint8Array(16);
+	[
+		a0,
+		b0,
+		c0,
+		d0
+	].forEach((v, i) => {
+		out[i * 4] = v & 255;
+		out[i * 4 + 1] = v >>> 8 & 255;
+		out[i * 4 + 2] = v >>> 16 & 255;
+		out[i * 4 + 3] = v >>> 24 & 255;
+	});
+	return out;
+}
+var SHA256_K = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+];
+function sha256(input) {
+	const h = [
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	];
+	const len = input.length;
+	const blocks = (len + 8 >> 6) + 1;
+	const msg = new Uint8Array(blocks * 64);
+	msg.set(input);
+	msg[len] = 128;
+	const bitLen = len * 8;
+	const dv = new DataView(msg.buffer);
+	dv.setUint32(msg.length - 4, bitLen >>> 0);
+	dv.setUint32(msg.length - 8, Math.floor(bitLen / 4294967296));
+	const rotr = (x, n) => x >>> n | x << 32 - n;
+	const w = new Array(64);
+	for (let off = 0; off < msg.length; off += 64) {
+		for (let i = 0; i < 16; i++) w[i] = dv.getUint32(off + i * 4);
+		for (let i = 16; i < 64; i++) {
+			const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+			const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+			w[i] = w[i - 16] + s0 + w[i - 7] + s1 | 0;
+		}
+		let [a, b, c, d, e, f, g, hh] = h;
+		for (let i = 0; i < 64; i++) {
+			const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = hh + S1 + ch + SHA256_K[i] + w[i] | 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+			hh = g;
+			g = f;
+			f = e;
+			e = d + t1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 | 0;
+		}
+		h[0] = h[0] + a | 0;
+		h[1] = h[1] + b | 0;
+		h[2] = h[2] + c | 0;
+		h[3] = h[3] + d | 0;
+		h[4] = h[4] + e | 0;
+		h[5] = h[5] + f | 0;
+		h[6] = h[6] + g | 0;
+		h[7] = h[7] + hh | 0;
+	}
+	const out = new Uint8Array(32);
+	new DataView(out.buffer).setUint32(0, h[0] >>> 0);
+	for (let i = 0; i < 8; i++) new DataView(out.buffer).setUint32(i * 4, h[i] >>> 0);
+	return out;
+}
+var MASK64 = (1n << 64n) - 1n;
+var SHA512_K = [
+	4794697086780616226n,
+	8158064640168781261n,
+	13096744586834688815n,
+	16840607885511220156n,
+	4131703408338449720n,
+	6480981068601479193n,
+	10538285296894168987n,
+	12329834152419229976n,
+	15566598209576043074n,
+	1334009975649890238n,
+	2608012711638119052n,
+	6128411473006802146n,
+	8268148722764581231n,
+	9286055187155687089n,
+	11230858885718282805n,
+	13951009754708518548n,
+	16472876342353939154n,
+	17275323862435702243n,
+	1135362057144423861n,
+	2597628984639134821n,
+	3308224258029322869n,
+	5365058923640841347n,
+	6679025012923562964n,
+	8573033837759648693n,
+	10970295158949994411n,
+	12119686244451234320n,
+	12683024718118986047n,
+	13788192230050041572n,
+	14330467153632333762n,
+	15395433587784984357n,
+	489312712824947311n,
+	1452737877330783856n,
+	2861767655752347644n,
+	3322285676063803686n,
+	5560940570517711597n,
+	5996557281743188959n,
+	7280758554555802590n,
+	8532644243296465576n,
+	9350256976987008742n,
+	10552545826968843579n,
+	11727347734174303076n,
+	12113106623233404929n,
+	14000437183269869457n,
+	14369950271660146224n,
+	15101387698204529176n,
+	15463397548674623760n,
+	17586052441742319658n,
+	1182934255886127544n,
+	1847814050463011016n,
+	2177327727835720531n,
+	2830643537854262169n,
+	3796741975233480872n,
+	4115178125766777443n,
+	5681478168544905931n,
+	6601373596472566643n,
+	7507060721942968483n,
+	8399075790359081724n,
+	8693463985226723168n,
+	9568029438360202098n,
+	10144078919501101548n,
+	10430055236837252648n,
+	11840083180663258601n,
+	13761210420658862357n,
+	14299343276471374635n,
+	14566680578165727644n,
+	15097957966210449927n,
+	16922976911328602910n,
+	17689382322260857208n,
+	500013540394364858n,
+	748580250866718886n,
+	1242879168328830382n,
+	1977374033974150939n,
+	2944078676154940804n,
+	3659926193048069267n,
+	4368137639120453308n,
+	4836135668995329356n,
+	5532061633213252278n,
+	6448918945643986474n,
+	6902733635092675308n,
+	7801388544844847127n
+];
+function sha512Core(iv, input, outLen) {
+	const rotr = (x, n) => (x >> n | x << 64n - n) & MASK64;
+	const h = [...iv];
+	const len = input.length;
+	const blocks = (len + 16 >> 7) + 1;
+	const msg = new Uint8Array(blocks * 128);
+	msg.set(input);
+	msg[len] = 128;
+	let bitLen = BigInt(len) * 8n;
+	for (let i = 0; i < 16; i++) {
+		msg[msg.length - 1 - i] = Number(bitLen & 255n);
+		bitLen >>= 8n;
+	}
+	const w = new Array(80);
+	for (let off = 0; off < msg.length; off += 128) {
+		for (let i = 0; i < 16; i++) {
+			let v = 0n;
+			for (let b = 0; b < 8; b++) v = v << 8n | BigInt(msg[off + i * 8 + b]);
+			w[i] = v;
+		}
+		for (let i = 16; i < 80; i++) {
+			const s0 = rotr(w[i - 15], 1n) ^ rotr(w[i - 15], 8n) ^ w[i - 15] >> 7n;
+			const s1 = rotr(w[i - 2], 19n) ^ rotr(w[i - 2], 61n) ^ w[i - 2] >> 6n;
+			w[i] = w[i - 16] + s0 + w[i - 7] + s1 & MASK64;
+		}
+		let [a, b, c, d, e, f, g, hh] = h;
+		for (let i = 0; i < 80; i++) {
+			const S1 = rotr(e, 14n) ^ rotr(e, 18n) ^ rotr(e, 41n);
+			const ch = e & f ^ ~e & MASK64 & g;
+			const t1 = hh + S1 + ch + SHA512_K[i] + w[i] & MASK64;
+			const t2 = (rotr(a, 28n) ^ rotr(a, 34n) ^ rotr(a, 39n)) + (a & b ^ a & c ^ b & c) & MASK64;
+			hh = g;
+			g = f;
+			f = e;
+			e = d + t1 & MASK64;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 & MASK64;
+		}
+		h[0] = h[0] + a & MASK64;
+		h[1] = h[1] + b & MASK64;
+		h[2] = h[2] + c & MASK64;
+		h[3] = h[3] + d & MASK64;
+		h[4] = h[4] + e & MASK64;
+		h[5] = h[5] + f & MASK64;
+		h[6] = h[6] + g & MASK64;
+		h[7] = h[7] + hh & MASK64;
+	}
+	const out = new Uint8Array(h.length * 8);
+	h.forEach((v, i) => {
+		for (let b = 7; b >= 0; b--) {
+			out[i * 8 + b] = Number(v & 255n);
+			v >>= 8n;
+		}
+	});
+	return out.slice(0, outLen);
+}
+function sha512(input) {
+	return sha512Core([
+		7640891576956012808n,
+		13503953896175478587n,
+		4354685564936845355n,
+		11912009170470909681n,
+		5840696475078001361n,
+		11170449401992604703n,
+		2270897969802886507n,
+		6620516959819538809n
+	], input, 64);
+}
+function sha384(input) {
+	return sha512Core([
+		14680500436340154072n,
+		7105036623409894663n,
+		10473403895298186519n,
+		1526699215303891257n,
+		7436329637833083697n,
+		10282925794625328401n,
+		15784041429090275239n,
+		5167115440072839076n
+	], input, 48);
+}
+var AES = buildAesTables();
+function buildAesTables() {
+	const exp = new Uint8Array(256);
+	const log = new Uint8Array(256);
+	let x = 1;
+	for (let i = 0; i < 255; i++) {
+		exp[i] = x;
+		log[x] = i;
+		x ^= x << 1 ^ (x & 128 ? 283 : 0);
+		x &= 255;
+	}
+	const sbox = new Uint8Array(256);
+	const inv = new Uint8Array(256);
+	for (let i = 0; i < 256; i++) {
+		const invByte = i === 0 ? 0 : exp[(255 - log[i]) % 255];
+		let s = invByte;
+		let acc = invByte;
+		for (let r = 0; r < 4; r++) {
+			acc = (acc << 1 | acc >> 7) & 255;
+			s ^= acc;
+		}
+		s ^= 99;
+		sbox[i] = s;
+		inv[s] = i;
+	}
+	return {
+		sbox,
+		inv
+	};
+}
+function gmul(a, b) {
+	let p = 0;
+	for (let i = 0; i < 8; i++) {
+		if (b & 1) p ^= a;
+		const hi = a & 128;
+		a = a << 1 & 255;
+		if (hi) a ^= 27;
+		b >>= 1;
+	}
+	return p;
+}
+function expandKey(key) {
+	const nk = key.length / 4;
+	const total = 4 * (nk + 6 + 1);
+	const w = new Uint8Array(total * 4);
+	w.set(key);
+	let rcon = 1;
+	for (let i = nk; i < total; i++) {
+		const t = [
+			w[(i - 1) * 4],
+			w[(i - 1) * 4 + 1],
+			w[(i - 1) * 4 + 2],
+			w[(i - 1) * 4 + 3]
+		];
+		if (i % nk === 0) {
+			const tmp = t[0];
+			t[0] = AES.sbox[t[1]] ^ rcon;
+			t[1] = AES.sbox[t[2]];
+			t[2] = AES.sbox[t[3]];
+			t[3] = AES.sbox[tmp];
+			rcon = gmul(rcon, 2);
+		} else if (nk > 6 && i % nk === 4) for (let j = 0; j < 4; j++) t[j] = AES.sbox[t[j]];
+		for (let j = 0; j < 4; j++) w[i * 4 + j] = w[(i - nk) * 4 + j] ^ t[j];
+	}
+	return w;
+}
+function decryptBlock(input, w, nr, out, outOff) {
+	const s = input.slice(0, 16);
+	const addRoundKey = (round) => {
+		for (let i = 0; i < 16; i++) s[i] = s[i] ^ w[round * 16 + i];
+	};
+	addRoundKey(nr);
+	for (let round = nr - 1; round >= 1; round--) {
+		invShiftRows(s);
+		invSubBytes(s);
+		addRoundKey(round);
+		invMixColumns(s);
+	}
+	invShiftRows(s);
+	invSubBytes(s);
+	addRoundKey(0);
+	out.set(s, outOff);
+}
+function invSubBytes(s) {
+	for (let i = 0; i < 16; i++) s[i] = AES.inv[s[i]];
+}
+function invShiftRows(s) {
+	const t = s.slice();
+	for (let r = 1; r < 4; r++) for (let c = 0; c < 4; c++) s[c * 4 + r] = t[(c - r + 4) % 4 * 4 + r];
+}
+function invMixColumns(s) {
+	for (let c = 0; c < 4; c++) {
+		const o = c * 4;
+		const a0 = s[o];
+		const a1 = s[o + 1];
+		const a2 = s[o + 2];
+		const a3 = s[o + 3];
+		s[o] = gmul(a0, 14) ^ gmul(a1, 11) ^ gmul(a2, 13) ^ gmul(a3, 9);
+		s[o + 1] = gmul(a0, 9) ^ gmul(a1, 14) ^ gmul(a2, 11) ^ gmul(a3, 13);
+		s[o + 2] = gmul(a0, 13) ^ gmul(a1, 9) ^ gmul(a2, 14) ^ gmul(a3, 11);
+		s[o + 3] = gmul(a0, 11) ^ gmul(a1, 13) ^ gmul(a2, 9) ^ gmul(a3, 14);
+	}
+}
+function aesCbcDecrypt(key, iv, data, stripPad) {
+	const w = expandKey(key);
+	const nr = key.length / 4 + 6;
+	const blocks = Math.floor(data.length / 16);
+	const out = new Uint8Array(blocks * 16);
+	let prev = iv;
+	for (let i = 0; i < blocks; i++) {
+		const cipher = data.subarray(i * 16, i * 16 + 16);
+		decryptBlock(cipher, w, nr, out, i * 16);
+		for (let j = 0; j < 16; j++) out[i * 16 + j] = out[i * 16 + j] ^ prev[j];
+		prev = cipher;
+	}
+	if (!stripPad || out.length === 0) return out;
+	const pad = out[out.length - 1];
+	return pad >= 1 && pad <= 16 && pad <= out.length ? out.subarray(0, out.length - pad) : out;
+}
+function aesCbcEncrypt(key, iv, data) {
+	const w = expandKey(key);
+	const nr = key.length / 4 + 6;
+	const blocks = Math.floor(data.length / 16);
+	const out = new Uint8Array(blocks * 16);
+	let prev = iv;
+	for (let i = 0; i < blocks; i++) {
+		const block = data.slice(i * 16, i * 16 + 16);
+		for (let j = 0; j < 16; j++) block[j] = block[j] ^ prev[j];
+		encryptBlock(block, w, nr, out, i * 16);
+		prev = out.subarray(i * 16, i * 16 + 16);
+	}
+	return out;
+}
+function encryptBlock(input, w, nr, out, off) {
+	const s = input.slice(0, 16);
+	const addRoundKey = (round) => {
+		for (let i = 0; i < 16; i++) s[i] = s[i] ^ w[round * 16 + i];
+	};
+	addRoundKey(0);
+	for (let round = 1; round < nr; round++) {
+		subBytes(s);
+		shiftRows(s);
+		mixColumns(s);
+		addRoundKey(round);
+	}
+	subBytes(s);
+	shiftRows(s);
+	addRoundKey(nr);
+	out.set(s, off);
+}
+function subBytes(s) {
+	for (let i = 0; i < 16; i++) s[i] = AES.sbox[s[i]];
+}
+function shiftRows(s) {
+	const t = s.slice();
+	for (let r = 1; r < 4; r++) for (let c = 0; c < 4; c++) s[c * 4 + r] = t[(c + r) % 4 * 4 + r];
+}
+function mixColumns(s) {
+	for (let c = 0; c < 4; c++) {
+		const o = c * 4;
+		const a0 = s[o];
+		const a1 = s[o + 1];
+		const a2 = s[o + 2];
+		const a3 = s[o + 3];
+		s[o] = gmul(a0, 2) ^ gmul(a1, 3) ^ a2 ^ a3;
+		s[o + 1] = a0 ^ gmul(a1, 2) ^ gmul(a2, 3) ^ a3;
+		s[o + 2] = a0 ^ a1 ^ gmul(a2, 2) ^ gmul(a3, 3);
+		s[o + 3] = gmul(a0, 3) ^ a1 ^ a2 ^ gmul(a3, 2);
+	}
+}
+//#endregion
+export { aesCbcDecrypt, aesCbcEncrypt, md5, rc4, sha256, sha384, sha512 };

package/dist/esm/pdf-reader/decrypt.d.ts

@@ -0,0 +1,5 @@
+import { PdfDict, PdfValue } from '../pdf/objects.js';
+export interface Decryptor {
+    decrypt: (value: PdfValue, objNum: number, gen: number) => PdfValue;
+}
+export declare function buildDecryptor(encrypt: PdfDict, idArray: PdfValue | undefined, password?: string): Decryptor | undefined;