rn-pdf-decrypt 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 PDFSmaller.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# rn-pdf-decrypt
+
+React Native compatible PDF decryption with **AES-256** and **RC4** support. Fork of [@pdfsmaller/pdf-decrypt](https://www.npmjs.com/package/@pdfsmaller/pdf-decrypt) that replaces Web Crypto API with [@noble/hashes](https://www.npmjs.com/package/@noble/hashes) + [@noble/ciphers](https://www.npmjs.com/package/@noble/ciphers) for Hermes compatibility.
+
+## Why this fork?
+
+The original `@pdfsmaller/pdf-decrypt` uses `crypto.subtle` (Web Crypto API), which is not available in React Native's Hermes engine. This fork swaps in pure JS crypto from the audited `@noble` libraries, making it work in React Native, Hermes, browsers, Node.js 18+, and Deno.
+
+Additionally, this fork adds support for **AES-256 V=5/R=5** (Adobe's pre-ISO extension used by Acrobat X/XI), which the upstream package does not support.
+
+## Features
+
+- **AES-256 decryption** (V=5, R=5/6) — PDF 2.0 standard + Adobe extension
+- **RC4 40/128-bit decryption** (V=1-2, R=2-3) — legacy support
+- **User + Owner passwords** — accepts either password to decrypt
+- **React Native / Hermes compatible** — no Web Crypto API dependency
+- **Pure JS crypto** — `@noble/hashes` + `@noble/ciphers` (audited, zero-dep)
+- **Lightweight** — ~18KB total (crypto + decryption logic)
+- **TypeScript types** included
+
+## Installation
+
+```bash
+npm install rn-pdf-decrypt pdf-lib
+```
+
+## Quick Start
+
+```javascript
+import { decryptPDF } from 'rn-pdf-decrypt';
+import fs from 'fs';
+
+const pdfBytes = fs.readFileSync('encrypted.pdf');
+const decrypted = await decryptPDF(new Uint8Array(pdfBytes), 'my-password');
+fs.writeFileSync('decrypted.pdf', decrypted);
+```
+
+## API
+
+### `decryptPDF(pdfBytes, password)`
+
+Decrypt a password-protected PDF. Supports both AES-256 and RC4 encryption — the algorithm is detected automatically.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pdfBytes` | `Uint8Array` | The encrypted PDF file as bytes |
+| `password` | `string` | The user or owner password |
+
+**Returns:** `Promise<Uint8Array>` — The decrypted PDF bytes
+
+**Throws:**
+- `"This PDF is not encrypted"` — if the PDF has no encryption dictionary
+- `"Incorrect password"` — if neither user nor owner password matches
+- `"Unsupported encryption"` — if the encryption version is not supported
+
+### `isEncrypted(pdfBytes)`
+
+Check if a PDF is encrypted without attempting to decrypt it.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pdfBytes` | `Uint8Array` | The PDF file as bytes |
+
+**Returns:** `Promise<{ encrypted: boolean, algorithm?: 'AES-256' | 'RC4', version?: number, revision?: number, keyLength?: number }>`
+
+## Examples
+
+### Decrypt with Auto-Detection
+
+```javascript
+import { decryptPDF, isEncrypted } from 'rn-pdf-decrypt';
+
+// Check encryption type first
+const info = await isEncrypted(pdfBytes);
+if (info.encrypted) {
+  console.log(`Encrypted with ${info.algorithm}`);
+  const decrypted = await decryptPDF(pdfBytes, password);
+}
+```
+
+### React Native Usage
+
+```javascript
+import { decryptPDF } from 'rn-pdf-decrypt';
+import RNFS from 'react-native-fs';
+
+const base64 = await RNFS.readFile(filePath, 'base64');
+const pdfBytes = Uint8Array.from(atob(base64), c => c.charCodeAt(0));
+
+const decrypted = await decryptPDF(pdfBytes, 'my-password');
+```
+
+## Supported Encryption
+
+| Algorithm | PDF Version | Key Length | Status |
+|-----------|-------------|-----------|--------|
+| AES-256 (V=5, R=6) | 2.0 (ISO 32000-2) | 256-bit | Supported |
+| AES-256 (V=5, R=5) | Adobe Extension Level 3 | 256-bit | Supported |
+| RC4 (V=2, R=3) | 1.4+ (ISO 32000-1) | 128-bit | Supported |
+| RC4 (V=1, R=2) | 1.1+ | 40-bit | Supported |
+| AES-128 (V=4, R=4) | 1.6+ | 128-bit | Not yet supported |
+
+## Differences from upstream
+
+| | `@pdfsmaller/pdf-decrypt` | `rn-pdf-decrypt` |
+|---|---|---|
+| Crypto backend | Web Crypto API (`crypto.subtle`) | `@noble/hashes` + `@noble/ciphers` |
+| React Native | No (Hermes lacks Web Crypto) | Yes |
+| AES-256 V=5/R=5 | No | Yes |
+| Dependencies | Zero (peer: pdf-lib) | `@noble/hashes`, `@noble/ciphers` (peer: pdf-lib) |
+
+## License
+
+MIT
+
+Based on [@pdfsmaller/pdf-decrypt](https://www.npmjs.com/package/@pdfsmaller/pdf-decrypt) by [PDFSmaller.com](https://pdfsmaller.com).

package/dist/crypto-aes.js

@@ -0,0 +1,192 @@
+/**
+ * AES-256 cryptographic utilities for PDF decryption (R=5/6)
+ * Uses @noble/hashes and @noble/ciphers — works in React Native (Hermes), browsers, Node.js, etc.
+ *
+ * @author imdewan (https://github.com/imdewan/rn-pdf-decrypt)
+ * @license MIT
+ *
+ * Includes encrypt-side functions (needed for Algorithm 2.B's AES-128-CBC encrypt step)
+ * plus decrypt functions for AES-256-CBC/ECB used in PDF object decryption.
+ *
+ * Implements Algorithm 2.B from ISO 32000-2:2020
+ * Verified against mozilla/pdf.js (the reference implementation)
+ */
+
+const { sha256: _sha256, sha384: _sha384, sha512: _sha512 } = require('@noble/hashes/sha2.js');
+const { cbc, ecb } = require('@noble/ciphers/aes.js');
+
+/**
+ * Concatenate multiple Uint8Arrays
+ */
+function concat(...arrays) {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+
+// ========== SHA Hash Functions (@noble/hashes) ==========
+
+async function sha256(data) {
+  return _sha256(data);
+}
+
+async function sha384(data) {
+  return _sha384(data);
+}
+
+async function sha512(data) {
+  return _sha512(data);
+}
+
+// ========== AES Encryption (@noble/ciphers) ==========
+// These encrypt functions are needed because Algorithm 2.B uses aes128CbcEncrypt
+// even during the decryption password validation flow.
+
+/**
+ * AES-128-CBC encrypt (for Algorithm 2.B intermediate step)
+ * Strips PKCS#7 padding since input is always block-aligned
+ */
+async function aes128CbcEncrypt(data, key, iv) {
+  const cipher = cbc(key, iv, { disablePadding: true });
+  return cipher.encrypt(data);
+}
+
+// ========== AES Decryption (@noble/ciphers) ==========
+
+/**
+ * AES-256-CBC decrypt with PKCS#7 padding removal (for per-object decryption)
+ *
+ * @param {Uint8Array} data - Ciphertext (must be multiple of 16 bytes)
+ * @param {Uint8Array} key - 32-byte AES-256 key
+ * @param {Uint8Array} iv - 16-byte initialization vector
+ * @returns {Promise<Uint8Array>} - Decrypted plaintext
+ */
+async function aes256CbcDecrypt(data, key, iv) {
+  const cipher = cbc(key, iv);
+  return cipher.decrypt(data);
+}
+
+/**
+ * AES-256-CBC decrypt without padding (for UE/OE — exactly 32 bytes, no PKCS#7)
+ *
+ * @param {Uint8Array} ciphertext - Ciphertext (32 bytes for UE/OE)
+ * @param {Uint8Array} key - 32-byte AES-256 key
+ * @param {Uint8Array} iv - 16-byte initialization vector
+ * @returns {Promise<Uint8Array>} - Decrypted plaintext (same length as ciphertext)
+ */
+async function aes256CbcDecryptNoPad(ciphertext, key, iv) {
+  const cipher = cbc(key, iv, { disablePadding: true });
+  return cipher.decrypt(ciphertext);
+}
+
+/**
+ * AES-256-ECB decrypt a single 16-byte block (for Perms verification)
+ *
+ * @param {Uint8Array} block - 16-byte ciphertext block
+ * @param {Uint8Array} key - 32-byte AES-256 key
+ * @returns {Promise<Uint8Array>} - 16-byte decrypted block
+ */
+async function aes256EcbDecryptBlock(block, key) {
+  const cipher = ecb(key, { disablePadding: true });
+  return cipher.decrypt(block);
+}
+
+/**
+ * Import an AES-256 key for reuse across multiple decrypt operations.
+ * With @noble/ciphers there's no CryptoKey concept — just return the raw key bytes.
+ *
+ * @param {Uint8Array} key - 32-byte AES-256 key
+ * @returns {Promise<Uint8Array>} - The same key bytes (for API compatibility)
+ */
+async function importAES256DecryptKey(key) {
+  return key;
+}
+
+/**
+ * AES-256-CBC decrypt using a pre-imported key (for per-object bulk decryption)
+ * Handles PKCS#7 padding removal automatically.
+ *
+ * @param {Uint8Array} data - Ciphertext (must be multiple of 16 bytes)
+ * @param {Uint8Array} key - Raw 32-byte AES-256 key
+ * @param {Uint8Array} iv - 16-byte initialization vector
+ * @returns {Promise<Uint8Array>} - Decrypted plaintext
+ */
+async function aes256CbcDecryptWithKey(data, key, iv) {
+  const cipher = cbc(key, iv);
+  return cipher.decrypt(data);
+}
+
+// ========== Algorithm 2.B (ISO 32000-2:2020) ==========
+
+/**
+ * Algorithm 2.B — Computing a hash for R=6
+ *
+ * This is the hardened key derivation function used by PDF 2.0 (AES-256).
+ * Iterates SHA-256/384/512 + AES-128-CBC for at least 64 rounds.
+ *
+ * Note: Algorithm 2.B uses AES-128-CBC *encrypt* (not decrypt) even during
+ * the decryption/validation flow. This is by design per the PDF spec.
+ *
+ * Verified against mozilla/pdf.js (PDF20._hash)
+ *
+ * @param {Uint8Array} password - UTF-8 password bytes (max 127)
+ * @param {Uint8Array} salt - 8-byte salt
+ * @param {Uint8Array} userKey - 48-byte U value (for owner ops) or empty
+ * @returns {Promise<Uint8Array>} - 32-byte hash
+ */
+async function computeHash2B(password, salt, userKey) {
+  // Step 1: Initial SHA-256 hash
+  const input = concat(password, salt, userKey);
+  let K = await sha256(input);
+
+  // Step 2: Iterative loop (minimum 64 rounds)
+  let i = 0;
+  let E;
+
+  while (true) {
+    // Step 2a: K1 = (password + K + userKey) repeated 64 times
+    const block = concat(password, K, userKey);
+    const K1 = new Uint8Array(block.length * 64);
+    for (let j = 0; j < 64; j++) {
+      K1.set(block, j * block.length);
+    }
+
+    // Step 2b: AES-128-CBC encrypt K1
+    // Key = K[0..15], IV = K[16..31]
+    const aesKey = K.slice(0, 16);
+    const aesIV = K.slice(16, 32);
+    E = await aes128CbcEncrypt(K1, aesKey, aesIV);
+
+    // Step 2c: Hash function selection
+    // Sum first 16 bytes of E mod 3 (equivalent to 128-bit big-endian mod 3)
+    let byteSum = 0;
+    for (let j = 0; j < 16; j++) {
+      byteSum += E[j];
+    }
+    const hashSelect = byteSum % 3;
+
+    // Step 2d: Hash E with selected function
+    if (hashSelect === 0) {
+      K = await sha256(E);
+    } else if (hashSelect === 1) {
+      K = await sha384(E);
+    } else {
+      K = await sha512(E);
+    }
+
+    // Step 2e: Termination (per pdf.js: while i < 64 || E[-1] > i - 32)
+    i++;
+    if (i >= 64 && E[E.length - 1] <= i - 32) {
+      break;
+    }
+  }
+
+  return K.slice(0, 32);
+}
+
+module.exports = { sha256, sha384, sha512, aes128CbcEncrypt, aes256CbcDecrypt, aes256CbcDecryptNoPad, aes256EcbDecryptBlock, importAES256DecryptKey, aes256CbcDecryptWithKey, computeHash2B, concat };

package/dist/crypto-aes.mjs

@@ -0,0 +1,190 @@
+/**
+ * AES-256 cryptographic utilities for PDF decryption (R=5/6)
+ * Uses @noble/hashes and @noble/ciphers — works in React Native (Hermes), browsers, Node.js, etc.
+ *
+ * @author imdewan (https://github.com/imdewan/rn-pdf-decrypt)
+ * @license MIT
+ *
+ * Includes encrypt-side functions (needed for Algorithm 2.B's AES-128-CBC encrypt step)
+ * plus decrypt functions for AES-256-CBC/ECB used in PDF object decryption.
+ *
+ * Implements Algorithm 2.B from ISO 32000-2:2020
+ * Verified against mozilla/pdf.js (the reference implementation)
+ */
+
+import { sha256 as _sha256, sha384 as _sha384, sha512 as _sha512 } from '@noble/hashes/sha2.js';
+import { cbc, ecb } from '@noble/ciphers/aes.js';
+
+/**
+ * Concatenate multiple Uint8Arrays
+ */
+export function concat(...arrays) {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+
+// ========== SHA Hash Functions (@noble/hashes) ==========
+
+export async function sha256(data) {
+  return _sha256(data);
+}
+
+export async function sha384(data) {
+  return _sha384(data);
+}
+
+export async function sha512(data) {
+  return _sha512(data);
+}
+
+// ========== AES Encryption (@noble/ciphers) ==========
+// These encrypt functions are needed because Algorithm 2.B uses aes128CbcEncrypt
+// even during the decryption password validation flow.
+
+/**
+ * AES-128-CBC encrypt (for Algorithm 2.B intermediate step)
+ * Strips PKCS#7 padding since input is always block-aligned
+ */
+export async function aes128CbcEncrypt(data, key, iv) {
+  const cipher = cbc(key, iv, { disablePadding: true });
+  return cipher.encrypt(data);
+}
+
+// ========== AES Decryption (@noble/ciphers) ==========
+
+/**
+ * AES-256-CBC decrypt with PKCS#7 padding removal (for per-object decryption)
+ *
+ * @param {Uint8Array} data - Ciphertext (must be multiple of 16 bytes)
+ * @param {Uint8Array} key - 32-byte AES-256 key
+ * @param {Uint8Array} iv - 16-byte initialization vector
+ * @returns {Promise<Uint8Array>} - Decrypted plaintext
+ */
+export async function aes256CbcDecrypt(data, key, iv) {
+  const cipher = cbc(key, iv);
+  return cipher.decrypt(data);
+}
+
+/**
+ * AES-256-CBC decrypt without padding (for UE/OE — exactly 32 bytes, no PKCS#7)
+ *
+ * @param {Uint8Array} ciphertext - Ciphertext (32 bytes for UE/OE)
+ * @param {Uint8Array} key - 32-byte AES-256 key
+ * @param {Uint8Array} iv - 16-byte initialization vector
+ * @returns {Promise<Uint8Array>} - Decrypted plaintext (same length as ciphertext)
+ */
+export async function aes256CbcDecryptNoPad(ciphertext, key, iv) {
+  const cipher = cbc(key, iv, { disablePadding: true });
+  return cipher.decrypt(ciphertext);
+}
+
+/**
+ * AES-256-ECB decrypt a single 16-byte block (for Perms verification)
+ *
+ * @param {Uint8Array} block - 16-byte ciphertext block
+ * @param {Uint8Array} key - 32-byte AES-256 key
+ * @returns {Promise<Uint8Array>} - 16-byte decrypted block
+ */
+export async function aes256EcbDecryptBlock(block, key) {
+  const cipher = ecb(key, { disablePadding: true });
+  return cipher.decrypt(block);
+}
+
+/**
+ * Import an AES-256 key for reuse across multiple decrypt operations.
+ * With @noble/ciphers there's no CryptoKey concept — just return the raw key bytes.
+ *
+ * @param {Uint8Array} key - 32-byte AES-256 key
+ * @returns {Promise<Uint8Array>} - The same key bytes (for API compatibility)
+ */
+export async function importAES256DecryptKey(key) {
+  return key;
+}
+
+/**
+ * AES-256-CBC decrypt using a pre-imported key (for per-object bulk decryption)
+ * Handles PKCS#7 padding removal automatically.
+ *
+ * @param {Uint8Array} data - Ciphertext (must be multiple of 16 bytes)
+ * @param {Uint8Array} key - Raw 32-byte AES-256 key
+ * @param {Uint8Array} iv - 16-byte initialization vector
+ * @returns {Promise<Uint8Array>} - Decrypted plaintext
+ */
+export async function aes256CbcDecryptWithKey(data, key, iv) {
+  const cipher = cbc(key, iv);
+  return cipher.decrypt(data);
+}
+
+// ========== Algorithm 2.B (ISO 32000-2:2020) ==========
+
+/**
+ * Algorithm 2.B — Computing a hash for R=6
+ *
+ * This is the hardened key derivation function used by PDF 2.0 (AES-256).
+ * Iterates SHA-256/384/512 + AES-128-CBC for at least 64 rounds.
+ *
+ * Note: Algorithm 2.B uses AES-128-CBC *encrypt* (not decrypt) even during
+ * the decryption/validation flow. This is by design per the PDF spec.
+ *
+ * Verified against mozilla/pdf.js (PDF20._hash)
+ *
+ * @param {Uint8Array} password - UTF-8 password bytes (max 127)
+ * @param {Uint8Array} salt - 8-byte salt
+ * @param {Uint8Array} userKey - 48-byte U value (for owner ops) or empty
+ * @returns {Promise<Uint8Array>} - 32-byte hash
+ */
+export async function computeHash2B(password, salt, userKey) {
+  // Step 1: Initial SHA-256 hash
+  const input = concat(password, salt, userKey);
+  let K = await sha256(input);
+
+  // Step 2: Iterative loop (minimum 64 rounds)
+  let i = 0;
+  let E;
+
+  while (true) {
+    // Step 2a: K1 = (password + K + userKey) repeated 64 times
+    const block = concat(password, K, userKey);
+    const K1 = new Uint8Array(block.length * 64);
+    for (let j = 0; j < 64; j++) {
+      K1.set(block, j * block.length);
+    }
+
+    // Step 2b: AES-128-CBC encrypt K1
+    // Key = K[0..15], IV = K[16..31]
+    const aesKey = K.slice(0, 16);
+    const aesIV = K.slice(16, 32);
+    E = await aes128CbcEncrypt(K1, aesKey, aesIV);
+
+    // Step 2c: Hash function selection
+    // Sum first 16 bytes of E mod 3 (equivalent to 128-bit big-endian mod 3)
+    let byteSum = 0;
+    for (let j = 0; j < 16; j++) {
+      byteSum += E[j];
+    }
+    const hashSelect = byteSum % 3;
+
+    // Step 2d: Hash E with selected function
+    if (hashSelect === 0) {
+      K = await sha256(E);
+    } else if (hashSelect === 1) {
+      K = await sha384(E);
+    } else {
+      K = await sha512(E);
+    }
+
+    // Step 2e: Termination (per pdf.js: while i < 64 || E[-1] > i - 32)
+    i++;
+    if (i >= 64 && E[E.length - 1] <= i - 32) {
+      break;
+    }
+  }
+
+  return K.slice(0, 32);
+}

package/dist/crypto-rc4.js

@@ -0,0 +1,185 @@
+/**
+ * rn-pdf-decrypt - RC4 cryptographic utilities
+ * React Native compatible fork of @pdfsmaller/pdf-decrypt
+ *
+ * @author imdewan (https://github.com/imdewan/rn-pdf-decrypt)
+ * @license MIT
+ * @see https://github.com/imdewan/rn-pdf-decrypt
+ *
+ * This minimal cryptographic implementation was built to solve the "impossible"
+ * problem of real PDF encryption within Cloudflare Workers' 1MB limit.
+ * Total size: ~7KB for complete PDF encryption!
+ */
+
+// Minimal cryptographic functions for PDF encryption
+// Implements only what's needed for PDF Standard Security Handler
+
+/**
+ * Minimal MD5 implementation
+ * Based on the MD5 algorithm - only what's needed for PDF encryption
+ * Part of rn-pdf-decrypt
+ */
+function md5(data) {
+  const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
+
+  // Initialize MD5 constants
+  const 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
+  ];
+
+  const K = new Uint32Array([
+    0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
+    0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
+    0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
+    0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
+    0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
+    0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
+    0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
+    0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
+    0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
+    0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
+    0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
+    0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
+    0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
+    0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
+    0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
+    0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
+  ]);
+
+  // Initialize hash values
+  let a0 = 0x67452301;
+  let b0 = 0xefcdab89;
+  let c0 = 0x98badcfe;
+  let d0 = 0x10325476;
+
+  // Pre-processing
+  const msgLen = bytes.length;
+  const msgBitLen = msgLen * 8;
+  const msgLenPadded = ((msgLen + 9 + 63) & ~63);
+  const msg = new Uint8Array(msgLenPadded);
+  msg.set(bytes);
+  msg[msgLen] = 0x80;
+
+  // Append length in bits
+  const dataView = new DataView(msg.buffer);
+  dataView.setUint32(msgLenPadded - 8, msgBitLen, true);
+  dataView.setUint32(msgLenPadded - 4, 0, true);
+
+  // Process message in 512-bit chunks
+  for (let offset = 0; offset < msgLenPadded; offset += 64) {
+    const chunk = new Uint32Array(msg.buffer, offset, 16);
+
+    let a = a0, b = b0, c = c0, d = d0;
+
+    for (let i = 0; i < 64; i++) {
+      let f, 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 + K[i] + chunk[g]) >>> 0;
+      a = d;
+      d = c;
+      c = b;
+      b = (b + ((f << S[i]) | (f >>> (32 - S[i])))) >>> 0;
+    }
+
+    a0 = (a0 + a) >>> 0;
+    b0 = (b0 + b) >>> 0;
+    c0 = (c0 + c) >>> 0;
+    d0 = (d0 + d) >>> 0;
+  }
+
+  // Produce the final hash value
+  const result = new Uint8Array(16);
+  const view = new DataView(result.buffer);
+  view.setUint32(0, a0, true);
+  view.setUint32(4, b0, true);
+  view.setUint32(8, c0, true);
+  view.setUint32(12, d0, true);
+
+  return result;
+}
+
+/**
+ * RC4 encryption/decryption
+ * RC4 is symmetric, so encryption and decryption are the same operation
+ * Part of rn-pdf-decrypt
+ */
+class RC4 {
+  constructor(key) {
+    this.s = new Uint8Array(256);
+    this.i = 0;
+    this.j = 0;
+
+    // Key scheduling algorithm (KSA)
+    for (let i = 0; i < 256; i++) {
+      this.s[i] = i;
+    }
+
+    let j = 0;
+    for (let i = 0; i < 256; i++) {
+      j = (j + this.s[i] + key[i % key.length]) & 0xFF;
+      // Swap
+      [this.s[i], this.s[j]] = [this.s[j], this.s[i]];
+    }
+  }
+
+  /**
+   * Encrypt/decrypt data
+   * @param {Uint8Array} data - Data to encrypt or decrypt
+   * @returns {Uint8Array} - Encrypted/decrypted data
+   */
+  process(data) {
+    const result = new Uint8Array(data.length);
+
+    for (let k = 0; k < data.length; k++) {
+      this.i = (this.i + 1) & 0xFF;
+      this.j = (this.j + this.s[this.i]) & 0xFF;
+
+      // Swap
+      [this.s[this.i], this.s[this.j]] = [this.s[this.j], this.s[this.i]];
+
+      const t = (this.s[this.i] + this.s[this.j]) & 0xFF;
+      result[k] = data[k] ^ this.s[t];
+    }
+
+    return result;
+  }
+}
+
+/**
+ * Convert hex string to Uint8Array
+ */
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+
+/**
+ * Convert Uint8Array to hex string
+ */
+function bytesToHex(bytes) {
+  return Array.from(bytes)
+    .map(b => b.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+module.exports = { md5, RC4, hexToBytes, bytesToHex };