← 返回蜂巢洞察

如何使用JavaScript构建基于浏览器的PDF密码保护工具

合同、发票、医疗报告以及扫描后的身份证件通常都会被转换为PDF文件。而如果这些文件被放到了错误的收件箱或共享文件夹中,那么任何人都可以打开它们。 为PDF文件设置密码就可以解决这个问题。经过加密的PDF文件在有人输入正确的密码之前是无法被读取的。 大多数提供这种功能的在线工具都会要求用户先上传文档。但对于那些希望保护隐私的文件来说,这样的操作实在有些不合常理。 在本教程中,你将使用JavaScript制作一个基于浏览器的PDF加密工具。你可以打开一个PDF文件,设置密码,决定他人是否可以打印、复制或编辑该文件,然后使用AES-256算法对文件进行加密,检查加密结果后将其下载。整个过程中,文件从

合同、发票、医疗报告以及扫描后的身份证件通常都会被转换为PDF文件。而如果这些文件被放到了错误的收件箱或共享文件夹中,那么任何人都可以打开它们。

为PDF文件设置密码就可以解决这个问题。经过加密的PDF文件在有人输入正确的密码之前是无法被读取的。

大多数提供这种功能的在线工具都会要求用户先上传文档。但对于那些希望保护隐私的文件来说,这样的操作实在有些不合常理。

在本教程中,你将使用JavaScript制作一个基于浏览器的PDF加密工具。你可以打开一个PDF文件,设置密码,决定他人是否可以打印、复制或编辑该文件,然后使用AES-256算法对文件进行加密,检查加密结果后将其下载。整个过程中,文件从未离开过浏览器。

有趣的是,目前最流行的JavaScript PDF处理库PDF-lib实际上并不支持PDF文件的加密功能。因此,你将需要自行利用Web Crypto API,并按照PDF 2.0的标准来实现加密功能。其实所需的代码量并没有你想象中的那么多——大约只有150行而已。

我为All In One Tools开发了这个工具,在那里它被作为“Protect PDF”工具来使用。本文介绍的是一个简化版本,你只需要用三个文件就可以制作出这个工具。

All In One Tools中的Protect PDF工具,显示用于添加PDF文件的区域

我们将会介绍的内容

这个PDF保护工具的功能

使用这个工具后,你只需点击按钮或将文件拖放到指定位置,就能打开PDF文件。你可以设置一个密码来解锁文件(还可以选择设置第二个密码以控制文件的访问权限)。此外,你还可以决定他人是否可以打印文件、复制其中的文本和图片,或者编辑文件内容。

该工具还会使用AES-256算法对PDF文件进行加密,并会确保新生成的加密文件确实需要输入密码才能被打开;同时,你也可以重新命名或下载这些经过保护的文件副本。

通过以上所有这些功能,原始文件本身并不会被修改,也不会有任何数据被发送到服务器上。

PDF加密的原理

在编写相关代码之前,了解受保护的PDF文件内部的结构是很有帮助的。虽然你不需要详细阅读相关技术规范,但以下这些基本概念会让你更容易理解后续的内容。

1. 内容被加密,而结构保持不变

PDF文件实际上是由一系列编号对象组成的:字典、数组、数字、文本字符串以及数据流。当PDF文件被设置为受保护状态时,所有的文本字符串和数据流都会被加密;不过数字、名称以及这些对象之间的引用关系仍然保持可读性,因此PDF阅读器依然能够正常读取文件内容。

2. 一个随机密钥用于加密所有数据

该工具会生成一个随机的256位密钥,然后使用AES算法对所有的文本字符串和数据流进行加密。需要注意的是,密码本身并不是用来加密文件的密钥。

3. 密码用于解密密钥

PDF文件会将这个密钥保存两次,每次都会用相应的密码哈希值对其进行加密;同时,文件中还包含一个验证机制,用来确认用户输入的密码是否正确。这些信息存储在加密字典中,而文件的尾部会通过/Encrypt标签指向这个加密字典。

4. 需要设置两个密码

  • 用户密码用于解锁文件本身。
  • 所有者密码不仅用于解锁文件,还能让文件所有者更改其他访问权限设置。

5. 访问权限并不等于真正的保护机制

允许用户执行的操作(如打印、复制、编辑等)会被存储在一个名为/P的数值中,这些信息以二进制形式存在。正规的PDF阅读器会遵守这些规则,但即使忽略这些规则的程序,在文件被打开后仍然可以执行相应的操作。因此,真正保护文件内容的是用户密码。

多年来,PDF文件采用了多种加密技术:

加密方法 版本 当前使用状态
RC4 40位和128位加密 R2至R4版本 已经过时且安全性较低,不建议用于新文件
AES-128 R4版本 Acrobat 7及更高版本可以打开这种格式的文件
AES-256 R6版本 PDF 2.0标准所采用的加密方式,所有现代PDF阅读器都能支持

这个工具使用的是AES-256(第6版)加密算法。这是最强大的加密选项,同时也是实现起来最简单的方案,因为所有数据都会使用相同的密钥进行加密。

让我们来详细看看整个加密流程。

从PDF文件开始:

  • PDF-lib会加载文件中的各个数据对象
  • 生成一个随机的32字节密钥文件
  • 从用户输入的密码中提取U、UE、O、OE以及权限信息,然后使用SHA-2和AES算法进行加密处理
  • 所有字符串和数据流都会使用AES-256进行加密
  • 最后会在PDF文件的末尾添加/Encrypt字典和/ID信息
  • 完成加密后,会用PDF.js工具检查文件格式是否正确,然后再下载保存好的PDF文件

项目设置

这个项目只需要三个文件,且不需要任何构建步骤:

pdf-protector/
├── index.html
├── style.css
└── script.js

由于Web Crypto API只能在安全的环境中正常使用,因此请通过https://或http://localhost地址来打开这个页面。如果使用file://路径或普通的http://地址来打开index.html文件,那么crypto.subtle对象将会变成undefined,从而导致加密功能无法正常使用。

搭建本地服务器最简单的方法是:

npx serve .

之后就可以访问系统显示的地址了,例如http://localhost:3000。

使用的库和浏览器API

PDF-lib 1.17.1版本可以读取PDF文件并将其内容转换为可修改的数据对象,然后再将这些数据写回PDF文件中。不过它不支持加密功能,因此这部分加密逻辑需要由你自己来实现。

PDF.js 3.11.174版本是Mozilla提供的PDF阅读器。你可以用它来打开被保护的PDF文件,验证其功能是否正常。

Web Crypto API已经被内置在所有现代浏览器中。它提供了AES加密功能、SHA-256/384/512哈希算法以及安全的随机数生成功能。千万不要使用Math.random()来生成密钥。

这两个库都会在index.html文件的末尾通过CDN进行加载:

<script src="https://unpkg.com/pdf-lib@1.17.1/dist/pdf-lib.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174/pdf.min.js"></script>
<script src="script.js"></script>

创建HTML页面布局

这个页面分为三个部分:上传区域、设置面板以及结果展示区。其中,设置面板和结果展示区在初始状态下是隐藏的。

<!-- 1. 上传文件 -->
<section id="uploadArea" class="upload-area">
  <p>将PDF文件拖放到这里或
  

这里有几点细节值得注意:

  • 密码输入框使用了 `autocomplete="new-password"` 属性,因此浏览器不会自动填充用户之前保存的登录密码。
  • 状态提示信息使用了 `aria-live="polite"` 属性,因此屏幕阅读器会读取这些信息,并将其读出来,例如“两个密码不相同”。
  • 文件输入框是隐藏的,需要通过一个普通的按钮来显示它,这样更便于进行样式设置。

相关的 CSS 代码只是用于实现常规的布局和颜色效果,因此这里不再赘述。您可以直接从演示文件中复制这些代码。

PDF密码保护工具的上传区域,其中包含一个“选择PDF文件”按钮

打开PDF文件

首先,`script.js` 从这两个库中获取所需的类,将 PDF.js 指向其对应的worker线程,并将应用程序的状态存储在一个对象中:

// ---------- 设置过程 ----------
const { PDFDocument, PDFName, PDFNumber, PDFBool, PDFHexString, PDFString,
  PDFDict, PDFArray, PDFRawStream } = PDFLib;

pdfjsLib.GlobalWorkerOptions.workerSrc =
  'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174/pdf.worker.min.js';

const state = {
  file: null,     // 用户选择的文件
  bytes: null,    // 文件的内容,以 Uint8Array 的形式存储
  pages: 0,
  result: null    // 加密后的PDF文件内容,以 Uint8Array 的形式存储
};

const $ = (id) => document.getElementById(id);
const uploadArea = $('uploadArea');
const fileInput = $('fileInput');
const fileInfo = $('fileInfo');
const settings = $('settings');
const openPw = $('openPw');
const openPw2 = $('openPw2');
const ownerPw = $('ownerPw');
const strength = $('strength');
const protectBtn = $('protectBtn');
const statusText = $('status');
const result = $('result');
const checks = $('checks');
const fileName = $('fileName');
const downloadBtn = $('downloadBtn');

用户可以通过按钮选择文件,或者将文件拖放到上传区域:

// ---------- 打开PDF文件 ----------
$('selectBtn').addEventListener('click', () => fileInput.click());
fileInput.addEventListener('change', () => {
  if (fileInput.files[0]) loadFile(fileInput.files[0]);
  fileInput.value = '';
});

uploadArea.addEventListener('dragover', (e) => {
  e.preventDefault();
  uploadArea.classList.add('dragover');
});
uploadArea.addEventListener('dragleave', () => uploadArea.classList.remove('dragover');
uploadArea.addEventListener('drop', (e) => {
  e.preventDefault();
  uploadArea.classList.remove('dragover');
  if (e.dataTransfer.files[0]) loadFile(e.dataTransfer.files[0]);
});

在读取文件内容后,将 `fileInput.value` 设置为空值,这样用户就可以再次选择同一个文件进行上传。

`loadFile` 函数会检查文件是否为PDF格式,将其内容读入一个 `Uint8Array` 中,然后尝试使用 PDF-lib 库来加载这个文件。

async function loadFile(file) {
  const isPdf = file.type === 'application/pdf' || /\.pdf$/i.test(file.name);
  if (!isPdf) {
    fileInfo.textContent = `${file.name}不是PDF文件。`;
    return;
  }

  const bytes = new Uint8Array(await file.arrayBuffer());
  try {
    const doc = await PDFDocument.load(bytes, { updateMetadata: false });
    state.file = file;
    state.bytes = bytes;
    state.pages = doc.getPageCount();
  } catch (err) {
    fileInfo.textContent = /encrypted/i.test(err.message)
      ? `${file.name}已经设置了密码。请先解锁它。`
      : `${file.name}无法被读取。文件可能已损坏。`;
    return;
  }

  fileInfo.textContent = `${file.name}: 共${state.pages}页,文件大小为${formatSize(file.size)}`;
  settings.hidden = false;
  result-hidden = true;
  openPw.focus();
}

function formatSize(n) {
  if (n < 1024) return n + ' B';
  if (n < 1024 * 1024) return (n / 1024).toFixed(1) + ' KB';
  return (n / 1024 / 1024).toFixed(1) + ' MB';
}

在这里加载文件会完成两项工作:首先,它会统计文件的页数,这样你之后就可以用这些信息来查看处理结果;其次,它能够识别那些已经设置了密码的文件。当PDF-lib遇到这样的文件时,它会抛出一个错误,其错误信息中会包含“encrypted”这个词,因此这个工具可以提示用户先解锁文件。

在这里,“updateMetadata: false”这个选项非常重要。默认情况下,PDF-lib在加载文档时会更改文件的生成者信息和修改日期。你只需要为文件设置密码,而不需要重新编写文档的详细信息。

提示选中的PDF文件已经设置了密码,需要先解锁 显示PDF文件的页数、大小以及密码和权限设置

处理密码字段

每个“显示”按钮都会将其输入类型在“password”和“text”之间切换,这样用户就可以查看自己输入的内容了:

// ---------- 密码字段 ----------
document.querySelectorAll('.show-btn').forEach((btn) => {
  btn.addEventListener('click', () => {
    const input = $(btn.dataset.target);
    const show = input.type === 'password';
    input.type = show ? 'text' : 'password';
    btn.textContent = show ? '隐藏' : '显示';
  });
});

当用户输入密码时,系统会提供一个简短的提示,告诉用户他们的密码包含了多少种类型的字符(小写字母、大写字母、数字和符号):

openPw.addEventListener('input', () => {
  const pw = openPw.value;
  const kinds = [/[a-z]/, /[A-Z]/, /[0-9]/, /[^A-Za-z0-9]/]
    .filter((re) => re.test(pw)).length;

  if (pw.length < 8) {
    strength.textContent = '至少需要8个字符。';
    strength.className = '提示:密码太弱了。';
  } else if (pw.length >= 12 && kinds >= 3) {
    strength.textContent = '密码很强。';
    strength.className = '提示:密码很好。';
  } else {
    strength.textContent = '还可以。如果密码更长,并且包含数字和符号,会更安全。';
    strength.className = '提示:可以改进。';
  }
});

这其实并不是一个真正的密码强度检测工具,也不需要具备这样的功能。它的作用仅仅是让人们避免使用像1234这样的简单密码。

在加密之前,passwordProblem函数会检查输入是否正确:如果存在问题,它会返回一条提示信息;如果一切正常,它则会返回一个空字符串:

function passwordProblem() {
  if (openPw.value.length < 8) return '密码长度必须至少为8个字符。';
  if (openPw.value !== openPw2.value) return '这两个密码不相同。';
  if (ownerPw.value === openPw.value) {
    return '请使用不同的权限密码,或者将其留空。';
  }
  return '';
}

设置这条规则的原因在于:如果两个密码完全相同,那么设置权限就没有任何意义了——任何能够打开文件的人都可以更改这些密码。

带有红色边框的密码输入框,以及提示“两个密码不相同”的信息” height=

用于处理字节数据及Web加密的辅助函数

加密操作是针对字节数据进行的,因此需要一些辅助函数。concat用于连接字节数组,randomBytes用于生成安全的随机字节,而toHex则可以将字节转换为十六进制字符串,以便后续使用PDF-lib库:

// ---------- 字节处理辅助函数 ----------
function concat(...parts) {
  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
  let offset = 0;
  for (const p of parts) {
    out.set(p, offset);
    offset += p.length;
  }
  return out;
}

const randomBytes = (n) => crypto.getRandomValues(new Uint8Array(n));

function toHex(bytes) {
  return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
}

// PDF 2.0规定的密码必须是UTF-8格式,经过规范化处理,且长度最多为127个字节
function passwordBytes(text) {
  return new TextEncoder().encode(text.normalize('NFKC')).slice(0, 127);
}

passwordBytes函数会按照PDF 2.0的要求来生成密码:密码必须是UTF-8格式,长度最多为127个字节。调用normalize('NFKC')这个方法可以确保那些外观相同的字符能够以相同的方式被存储起来;例如,在不同的键盘上输入é,生成的字节序列会是相同的。虽然相关规范实际上使用了更为严格的SASLprep算法,但NFKC已经能够覆盖人们在实际使用中可能会遇到的各种情况。

接下来是用于Web加密的辅助函数:

// ---------- Web加密辅助函数 ----------
async function digest(algorithm, data) {
  return new Uint8Array(await crypto.subtle.digest(algorithm, data));
}

// AES-CBC加密算法,使用PKCS#7填充方式(PDF在处理字符串和数据流时就是采用这种格式)
async function aesEncrypt(keyBytes, iv, data) {
  const key = await crypto.subtle.importKey('raw', keyBytes, 'AES-CBC', false, ['encrypt']);
  return new Uint8Array(await crypto.subtle.encrypt({ name: 'AES-CBC', iv }, key, data));
}

// AES-CBC加密算法,不使用填充:输入的数据长度已经是16字节的整数倍,
// 因此我们直接使用前data.length个字节作为加密结果
async function aesEncryptNoPad(keyBytes, iv, data) {
  return (await aesEncrypt(keyBytes, iv, data)).slice(0, data.length);
}

Web Crypto中的AES-CBC加密方式总会添加PKCS#7填充字符。PDF格式也对字符串和数据流要求进行填充,因此aesEncrypt函数非常适合用于这些场景。不过,在加密字典中有一些数值在加密时必须不使用任何填充字符。这些数值的输入长度总是16字节的整数倍,因此输出结果中的前data.length个字节就是所需的内容,而aesEncryptNoPad函数则会直接去掉多余的填充部分。

PDF 2.0版本的密码哈希算法

AES-256格式的PDF文件并不会直接使用简单的SHA-256算法来对密码进行哈希处理。它们会采用一种速度较慢的哈希算法(ISO 32000-2标准中的2.B算法),这种算法能够有效增加猜测密码的难度:

// ---------- PDF 2.0版本的密码哈希过程 ----------
// ISO 32000-2标准中的2.B算法:首先使用SHA-256进行哈希处理,然后再进行至少64轮AES-128加密,
// 最后再次使用SHA-256/384/512进行哈希处理,从而大大增加猜测密码的难度
async function hashPassword(password, salt, userKey) {
  let k = await digest('SHA-256', concat(password, salt, userKey));
  let e = new Uint8Array([0]);
  let round = 0;

  while (round < 64 || e[e.length - 1] > round - 32) {
    const block = concat(password, k, userKey);
    const k1 = new Uint8Array(block.length * 64);
    for (let i = 0; i < 64; i++) k1.set(block, i * block.length);

    e = await aesEncryptNoPad(k.slice(0, 16), k.slice(16, 32), k1);

    let sum = 0;
    for (let i = 0; i < 16; i++) sum += e[i];
    const hash = ['SHA-256', 'SHA-384', 'SHA-512'][sum % 3];
    k = await digest(hash, e);
    round++;
  }
  return k.slice(0, 32);
}

具体的处理流程如下:

  1. 首先对密码、盐值以及(对于所有者密码而言)48字节的U值进行SHA-256哈希处理。
  2. 将密码、当前的哈希结果以及额外的数据重复64次,然后使用AES-128算法对这些数据块进行加密。加密过程中使用的密钥和初始向量都是从当前哈希结果中提取出来的。
  3. 将加密结果的前16个字节相加,然后将这个总和除以3,根据余数来决定接下来应该使用SHA-256、SHA-384还是SHA-512算法进行哈希处理。
  4. 重复这个过程至少64次,直到加密结果块的最后一个字节的长度不超过64减去32的值为止。
  5. 最终得到的哈希结果的前32个字节就是最终的结果。

由于加密所需的轮数和所使用的哈希函数都会根据输入数据的不同而发生变化,因此攻击者无法通过专用硬件来加速这一过程。即使使用浏览器进行加密,也只需要几毫秒的时间就能完成操作。

将权限信息转换为数字形式

PDF文件中的权限信息被存储在/P路径下,表现为一个32位的数字。其中每一位都代表一种具体的权限:

// ---------- 权限信息 ----------
// 根据PDF标准定义的位位置(最低位为第1位)
const PERM = {
  print: 1 << 2,          // 第3位
  modify: 1 << 3,         // 第4位
  copy: 1 << 4,           // 第5位
  annotate: 1 << 5,       // 第6位
  fillForms: 1 << 8,      // 第9位
  accessibility: 1 << 9,  // 第10位
  assemble: 1 << 10,      // 第11位
  printHigh: 1 << 11      // 第12位
};

function permissionFlags({ print, copy, edit }) {
  let p = 0xFFFFF0C0;                    // 必须设置为1的保留位
  p |= PERM.accessibility;               // 始终允许使用屏幕阅读器
  if (print) p |= PERM.print | PERM.printHigh;
  if (copy) p |= PERM.copy;
  if (edit) p |= PERM.modify | PERMannotate | PERM.fillForms | PERM.assemble;
  return p | 0;                          // 返回一个带符号的32位数字
}

初始值0xFFFFF0C0用于设置那些规范中明确要求必须始终设置为1的位。随后,该函数会启用第10位(用于实现无障碍功能中的文本提取功能),这样屏幕阅读器就能继续正常工作;同时,它还会为用户选中的每个选项对应的位添加相应的值:

工具中的选项 被启用的位
打印 3(普通打印)和12(高质量打印)
复制文本和图片 5
编辑、添加注释及填写表格 4、6、9和11

最后的操作p | 0会将这个数值转换为有符号的32位整数。由于高几位被设置了值,因此该整数为负数,这是正常的:大多数PDF文件中都会包含类似/P -1324这样的信息。

强密码已开启,允许打印,但禁止复制和编辑

构建加密密钥

现在,你可以生成那些将被放入加密字典中的数值了:

// ---------- 构建加密字典所需的数值 ----------
async function makeKeys(userText, ownerText, p) {
  const fileKey = randomBytes(32);       // 用于加密整个文档的密钥
  const user = passwordBytes(userText);
  const owner = passwordBytes(ownerText);
  const none = new Uint8Array(0);
  const zeroIv = new Uint8Array(16);

  // U和UE:使用开启密码来验证用户身份并解密文件密钥
  const uValidation = randomBytes(8);
  const uKeySalt = randomBytes(8);
  const U = concat(await hashPassword(user, uValidation, none), uValidation, uKeySalt);
  const UE = await aesEncryptNoPad(await hashPassword(user, uKeySalt, none), zeroIv, fileKey);

  // O和OE:权限密码的处理方式与U相同
  const oValidation = randomBytes(8);
  const oKeySalt = randomBytes(8);
  const O = concat(await hashPassword(owner, oValidation, U), oValidation, oKeySalt);
  const OE = await aesEncryptNoPad.await hashPassword(owner, oKeySalt, U), zeroIv, fileKey);

  // Perms:权限设置值,使用文件密钥进行加密,因此他人无法修改这些值
  const perms = new Uint8Array(16);
  new DataView(perms.buffer).setInt32(0, p, true);   // 小端字节序
  perms.set([0xFF, 0xFF, 0xFF, 0xFF], 4);
  perms.set([0x54, 0x61, 0x64, 0x62], 8);            // 'T'表示加密元数据,'a', 'd', 'b'分别代表不同的权限设置
  perms.set(randomBytes(4), 12);
  const Perms = await aesEncryptNoPad(fileKey, zeroIv, perms);

  return { fileKey, U, UE, O, OE, Perms };
}

让我们来详细了解一下这些内容:

  • fileKey是由32个随机字节组成的密钥,它用于加密整个文档。
  • U(长度为48字节)允许读取器验证用户的密码。这个值实际上是密码的哈希值加上两个8字节的随机盐值:其中一个盐值用于验证密码,另一个盐值则用于解密文件密钥。
  • UE是与U处理方式相同的密钥,只不过它是使用用户的密码哈希值和密钥盐值进行加密的。当用户输入正确的密码时,读取器会重新计算这个哈希值并解密出文件密钥。
  • O和OE的作用与U和UE相同,只是它们是用于验证所有者密码的。它们的哈希值中也包含了U,这样就能确保这两个密码都是用来加密同一个文件的。
  • Perms是由权限设置值加上一些校验字节组成的字符串,这些数据也是使用文件密钥进行加密的。读取器在解密这些数据后,会将其与文件中的/P字段进行比较;因此,如果有人试图通过文本编辑器修改/P字段,就会被发现。

规范中提到了两条规则:

  • UE、OE和Perms这些数据在加密时会不添加填充字符,并使用长度为0的IV进行加密。(由于Perms是一个16字节的整体,因此使用长度为0的IV进行AES-CBC加密时,其结果与规范中描述的AES-ECB模式相同。)
  • Perms中的字节T表示“元数据也被加密了”,这一信息必须与字典中设置的/EncryptMetadata true相匹配。

加密每一个字符串和数据流

当文件密钥准备就绪后,就可以开始对文档进行加密了。对于AES-256算法而言,每个字符串或数据流都会使用文件密钥以及一个随机生成的16字节IV来进行加密,而这个IV会被存储在加密后的数据之前:

// ---------- 加密各个对象 ----------
// 使用AES-256算法,每个字符串和数据流都会用文件密钥
// 以及一个随机生成的IV进行加密,该IV会放在加密数据的前面
async function encryptData(fileKey, data) {
  const iv = randomBytes(16);
  return concat(iv, await aesEncrypt(fileKey, iv, data));
}

async function encryptStrings(value, fileKey) {
  if (value instanceof PDFDict) {
    for (const [key, item] of value.entries()) {
      const replacement = await encryptValue(item, fileKey);
      if (replacement) value.set(key, replacement);
    }
  } else if (value instanceof PDFArray) {
    for (let i = 0; i < value.size(); i++) {
      const replacement = await encryptValue(value.get(i), fileKey);
      if (replacement) value.set(i, replacement);
    }
  }
}

async function encryptValue(item, fileKey) {
  if (item instanceof PDFString || item instanceof PDFHexString) {
    return PDF_hexString.of(toHex(await encryptData(fileKey, item.asBytes]));
  }
  await encryptStrings(item, fileKey);   // 处理嵌套的字典和数组
  return null;
}

async function encryptObjects(context, fileKey) {
  const objects = context.enumerateIndirectObjects();
  for (const [ref, object] of objects) {
    if (object instanceof PDFRawStream) {
      const type = object.dict.get(PDFName.of('Type'));
      if (type === PDFName.of('XRef')) {     // 旧式的交叉引用流
        context.delete(ref);
        continue;
      }
      await encryptStrings(object(dict, fileKey);
      const data = await encryptData(fileKey, objectcontents);
      context.assign(ref, PDFRawStream.of(object.dict, data));
    } else {
      await encryptStrings(object, fileKey);
    }
  }
}

encryptObjects会遍历文件中的每一个对象:

  • 数据流(PDFRawStream类型):它们的数据会被替换成加密后的版本。PDF-lib在保存数据时会自动更新/Length字段的值。
  • 字典和数组:函数encryptStrings会遍历这些结构,将其中的每个字符串都替换成加密后的十六进制字符串;对于嵌套的字典和数组,也会再次调用这个函数来进行处理。
  • 交叉引用流(/Type /XRef类型)会被删除。因为这些流仅用于指示对象在原始文件中的位置,而PDF-lib会重新生成新的交叉引用表,因此这些流绝对不能被加密。

PDF-lib提供了两种字符串类型:PDFString用于表示像(Hello)这样的普通字符串,而PDFHexString则用于表示像<48656C6C6F>这样的十六进制字符串。这两种类型都拥有asBytes()方法,该方法可以返回这些字符串对应的实际字节内容,而这些字节内容正是会被加密的对象。

流式数据在加密时会保持文件中的原始格式,而这些数据通常已经经过了压缩。因此,正确的处理顺序应该是:首先由解密工具对数据进行解密,然后再进行解压操作。

编写受保护的PDF文件

protectPdf函数将所有这些步骤整合到一起:

// ---------- 保护PDF文件 ----------
async function protectPdf(bytes, options) {
  const doc = await PDFDocument.load(bytes, { updateMetadata: false });
  const context = doc.context;

  const p = permissionFlags(options);
  const ownerText = options.ownerPw || toHex(randomBytes(16));
  const keys = await makeKeys'options.openPw, ownerText, p);

  // 1. 加密文件中已存在的所有字符串和流式数据
  await encryptObjects(context, keys.fileKey);

  // 2. 添加加密字典(注意:这个字典本身不能被加密)
  const hex = (b) => PDFHexString.of(toHex(b));
  const stdCF = context.obj({ AuthEvent: 'DocOpen', CFM: 'AESV3', Length: 32 });
  const encrypt = context.obj({
    Filter: 'Standard',
    V: 5,
    R: 6,
    Length: 256,
    CF: context.obj({ StdCF: stdCF }),
    StmF: 'StdCF',
    StrF: 'StdCF',
    P: PDFNumber.of(p),
    EncryptMetadata: PDFBool.True
  });
  encrypt.set(PDFName.of('U'), hex(keys.U));
  encrypt.set(PDFName.of('UE'), hex(keys.UE));
  encrypt.set(PDFName.of('O'), hex(keys.O));
  encrypt.set(PDFName.of('OE'), hexkeys.OE));
  encrypt.set(PDFName.of('Perms'), hex(keys.Perms));

  // 3. 为PDF文件添加加密标记并指定一个唯一标识符
  context.trailerInfo.Encrypt = context.register(encrypt);
  const id = hex(randomBytes(16));
  context.trailerInfo.ID = context.obj([id, id]);

  // 由于对象流可能会隐藏第一步中加密的对象,因此需要以普通形式存储这些对象
  return doc.save({ useObjectStreams: false });
}

具体的操作步骤如下:

  1. 首先加密文件中已存在的所有对象。这个步骤必须在添加加密字典之前完成,因为加密字典本身必须是可读的。
  2. 接着创建加密字典。context.obj()方法会将普通字符串转换为PDF特有的名称格式,因此Filter: 'Standard'会变成/Filter /Standard。参数V 5和R 6表示使用PDF 2.0标准中的AES-256加密算法,而StdCF这个加密过滤器则指示解密工具对所有流式数据(StmF)和字符串(StrF)都使用AES-256进行加密。
  3. 最后更新PDF文件的尾部信息。需要为文件添加/Encrypt标记,并指定一个唯一的/ID。PDF-lib会自动将这个id写入文件尾部,但这个id本身不会被加密。

如果用户没有设置权限密码,该工具会使用16个随机生成的字节作为所有者密码。由于没有人知道这个密码,因此也就无法解除对这些文件的加密限制。(不过,如果你直接使用空字符串作为所有者密码,那么任何PDF处理软件都可以轻松解除这些加密措施。)

最后,文件会使用useObjectStreams: false选项进行保存。对象流会将多个对象压缩成一个流文件。在对象流中,其中的字符串本身不能被加密,因为整个流文件都是经过加密处理的。由于你已经对每个字符串分别进行了加密处理,因此直接写入未加密的对象即可保证文件的正确性。

在保存后的文件中,加密字典的具体内容如下:

<<
/Filter /Standard /V 5 /R 6 /Length 256
/CF << /StdCF << /AuthEvent /DocOpen /CFM /AESV3 /Length 32 >>> >>
/StmF /StdCF /StrF /StdCF
/P -1324 /EncryptMetadata true
/U <...48 bytes...>> /UE <...32 bytes...>>
/O <...48 bytes...>> /OE <...32 bytes...>>
/Perms <...16 bytes...>>
>>

使用PDF.js检查加密结果

加密相关的问题很容易出现,但也很难被及时发现。有时候,某个文件在某个阅读器中可以正常打开,但在另一个阅读器中却无法打开;有时文件可能根本就没有被加密。因此,在提供下载选项之前,我们会使用PDF.js来验证文件的加密状态:

// ---------- 使用PDF.js检查加密结果 ----------
async function verify(bytes, password) {
  const results = [];

  // 1. 如果没有输入密码,PDF.js会要求用户输入密码
  try {
    const doc = await pdfjsLib.getDocument({ data: bytes.slice() }).promise;
    await doc.destroy();
    results.push([false, '文件在未输入密码的情况下成功打开']);
  } catch (err) {
    results.push([err.name === 'PasswordException', '需要输入密码才能打开文件']);
  }

  // 2. 如果输入了正确的密码,文件应该能够正常打开,并且页面数量也应该与原始文件相同
  try {
    const doc = await pdfjsLib.getDocument({ data: bytes.slice(), password }).promise;
    results.push([doc.numPages === state.pages, `使用您的密码成功打开了文件,共有${doc.numPages}页`]);
    await doc.destroy();
  } catch (err) {
    results.push([false, '使用密码无法打开文件']);
  }
  return results;
}

共有两项检查内容:

  1. 如果未输入密码尝试打开文件,应该会遇到PasswordException错误。如果文件能够正常打开,那就说明该文件没有经过加密保护。
  2. 如果输入了正确的密码成功打开了文件,那么文件的页面数量必须与原始文件相同。

bytes.slice()这个方法会创建一个副本,因为PDF.js会将原始数据缓冲区传递给它的后台处理线程,否则原始数组就会变为空。

连接按钮功能

点击按钮后,相关逻辑会检查用户输入的密码,然后调用protectPdf函数进行加密处理,接着执行各种检查步骤,并最终显示检查结果:

// ---------- 执行所有操作 ----------
protectBtn.addEventListener('click', async () => {
  const problem = passwordProblem();
  openPw.setAttribute('aria-invalid', String(openPw.value.length < 8));
  openPw2.setAttribute('aria-invalid', String(openPw.value !== openPw2.value));
  if (problem) {
    statusText.textContent = problem;
    statusText.className = 'status error';
    return;
  }

  protectBtn.disabled = true;
  statusText.className = 'status';
  statusText.textContent = '正在加密文件…';
  try {
    const options = {
      openPw: openPw.value,
      ownerPw: ownerPw.value,
      print: $('allowPrint').checked,
      copy: $('allowCopy').checked,
      edit: $('allowEdit').checked
    };
    state.result = await protectPdf(state.bytes, options);

    statusText.textContent = '正在检查加密后的文件…';
    const results = await verify(state.result, options.openPw);
    checks.innerHTML = '';
    for (const [ok, text] of results) {
      const li = document.createElement('li');
      li.textContent = (ok ? '✅ ' : '❌ ') + text;
      checks.appendChild(li);
    }
    const sizeLi = document.createElement('li');
    sizeLi.textContent = '文件大小:' + formatSize(state.result.length);
    checks.appendChild(sizeLi);

    fileName.value = state.file.name.replace(/\.pdf$/i, '') + '-protected.pdf';
    statusText.textContent = '';
    result.hidden = false;
    result.scrollIntoView({ behavior: 'smooth' });
  } catch (err) {
    console.error(err);
    statusText.textContent = '出现错误:' + err.message;
    statusText.className = 'status error';
  } finally {
    protectBtn.disabled = false;
  }
});

在文件加密过程进行时,该按钮会被禁用,因此双击该按钮并不会启动两次加密操作。即使某些步骤出现错误,finally代码块也会重新启用该按钮。

重命名与下载

结果面板会建议使用诸如report-protected.pdf这样的文件名。当用户点击“下载PDF”按钮时,系统会清除文件名中的多余字符,然后保存文件:


// ---------- 下载过程 ----------
downloadBtn.addEventListener('click', () => {
  let name = fileName.value.trim().replace(/[\\/:*?"<>>|]+/g, '-') || 'protected.pdf';
  if (!/\.pdf$/i.test(name)) name += '.pdf';

  const blob = new Blob([state.result], { type: 'application/pdf' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = name;
  a.click();
  setTimeout(() => URL.revokeObjectURL(url), 60000);
});

这个正则表达式用于替换那些Windows系统不允许出现在文件名中的字符。对象URL会在一分钟后被释放,这样浏览器就有足够的时间开始下载文件。

结果面板显示:PDF文件需要输入密码才能打开,同时会显示文件名和下载按钮

在浏览器外测试文件

如果一个PDF文件只能在特定的工具中打开,那么它就没什么实际用途了。因此,你还需要在其他软件中测试该文件的格式是否正确。

qpdf是一款免费的命令行工具,它可以用来严格检测加密后的PDF文件。使用以下命令可以查看文件的加密信息:


# 应该显示:“无效密码”
qpdf --check report-protected.pdf

# 应该显示:“未发现语法或流编码错误”
qpdf --check --password='your password' report-protected.pdf

# 会显示加密参数:R = 6, AESv3,以及各种权限设置
qpdf --show-encryption --password='your password' report-protected.pdf

对于本文中提到的版本来说,执行qpdf --show-encryption命令后,会输出以下信息:


R = 6
P = -1324
用户密码:Correct-Horse-42
输入的密码与用户设置的密码一致
允许用于无障碍访问:是
允许用于任何目的:是
允许以低分辨率打印:是
允许以高分辨率打印:是
不允许修改文档结构:否
不允许修改表格:否
不允许修改注释:否
不允许进行其他任何修改:否
使用的流加密算法:AESv3
字符串加密算法:AESv3
文件整体加密算法:AESv3

你还可以在浏览器的PDF阅读器以及Adobe Acrobat Reader中打开这个文件。这两种工具都会要求输入密码,而Acrobat的“文档属性”>“安全”选项卡也会显示你之前设置的各种限制条件。

演示:Protect PDF工具的工作原理

以下是“All In One Tools”中该工具的具体使用流程。

步骤1:添加PDF文件

只需将PDF文件拖放到页面上,或点击“选择PDF文件”。系统会显示文件的预览页,这样你就可以在保护文件之前确认文件是否正确。

上传的PDF文件,包含文件名、大小以及页面的放大预览图

步骤2:设置密码与限制选项

请将开放密码输入两次。如果你想限制文件的打印、复制或编辑功能,可以启用相关限制,并设置一个专门的权限密码。默认情况下,系统会使用AES-256加密算法。

密码设置界面,显示了选定的AES-256加密算法、开放密码、权限密码以及打印/复制限制选项

步骤3:检查文件并下载

该工具会在浏览器中打开已加密的文件,确认用户输入的密码是否正确,如果密码错误,系统会拒绝访问;成功验证后,会显示文件的预览页。你可以根据需要重新命名文件,然后点击“下载PDF”按钮进行下载。

已加密PDF文件的预览页面,包含浏览器中的验证结果及“下载PDF”按钮” height=

性能优化建议

有一些方法可以帮助你确保该工具能够高效运行。

首先,应一次处理一个文件对象。代码会依次执行每个文件的加密操作,这样就能有效降低内存占用,因为每次只会有一个数据流被复制到新的文件中。对于包含大量小对象的文件,可以使用`Promise.all`方法将文件分成50个部分进行批量加密,从而提高加密速度。

其次,需要了解文件大小可能会略有增加。每个字符串或数据流在加密过程中都会添加16字节的初始向量(IV)以及最多16字节的填充字符,而且如果不使用对象流来保存文件内容,生成的交叉引用表也会变得更大。因此,一个4KB的文件在加密后可能会变成8KB,而5MB的文件增加的大小通常只有几KB而已。

另外,在进行文件验证时,不需要再次对文件进行加密。该工具会直接检查即将下载的文件数据是否正确,如果重新运行`protectPdf`函数,文件将会使用新的随机密钥进行加密,从而导致之前的验证结果失效。

最后,在处理完大型文件后,请及时释放内存。当完成对PDF文件的加密操作后,应调用`doc.destroy()`方法来释放相关内存资源,就像`verify`函数所做的那样。否则,浏览器的工作进程会继续保留已解析的文件数据,从而导致内存浪费。

常见错误与注意事项

在使用该工具时,也有一些需要注意的地方。

首先,不要通过普通的`http://`地址来访问该工具页面。`crypto.subtle`这个API只有在安全的环境中才能正常使用。如果在`http://example.com`或`file://`路径下尝试使用该接口,系统会报错“无法读取未定义对象的属性”。请务必使用`https://`或`localhost`地址。

不要使用 `Math.random()` 来生成密钥或盐值。这种函数并非为安全用途而设计,其生成的随机数其实是可以被预测的。请始终使用 `crypto getRandomValues()`。

你也应该避免对用于加密的配置信息进行加密。如果 `/U`、`/O` 或 `/Perms` 这些字符串被加密了,那么任何试图解密的人都无法验证密码的正确性。正确的做法应该是先加密文档本身,然后再添加这些配置信息。

请避免使用对象流来保存文件。PDF-lib 默认会使用对象流进行存储,在使用加密功能时,文件中的字符串会被重复加密两次。因此,请设置 `useObjectStreams: false` 以避免这种问题。

另外,在将字节数据传递给 PDF.js 时,别忘了使用 `slice()` 方法。PDF.js 会将这些字节数据传输到其后台工作线程中,之后你的原始 `Uint8Array` 对象就会变为空,而下载得到的文件也会是大小为 0 字节的空文件。

不要将权限设置视为一种安全措施。限制用户打印或复制文件确实对诚实的读者有一定作用,但这并不能真正起到保护作用。如果内容必须保持保密性,那么真正的关键还是密码本身。

请注意,不要对已经经过数字签名的 PDF 文件进行加密。因为加密操作会改变签名所覆盖的每一个字节,从而导致签名失效。正确的做法应该是先设置密码,然后再对文件进行签名处理。

最后,请确保你自己和你的用户都不会忘记这个密码。由于 AES-256 算法的特性,这种加密方式不存在任何后门机制,也没有“忘记密码”这样的功能。请告诉你的用户将密码保存在安全的地方。

总结

通过本教程,你成功开发了一个基于浏览器的工具,该工具能够使用 AES-256 加密技术为 PDF 文件添加密码保护。

你学习了 PDF 加密机制的原理,了解了如何使用 PDF 2.0 算法对密码进行哈希处理,学会了如何利用 Web Crypto API 来生成 `/U`、`UE`、`O`、`OE` 和 `Perms` 这些配置信息,也知道了如何使用 PDF-lib 对各种字符串和数据流进行加密,同时还掌握了如何使用 PDF.js 和 qpdf 来验证加密结果。

所有这些操作都是在浏览器中完成的,因此文件会一直保存在用户的设备上。

你可以在 “保护 PDF” 链接处尝试这个工具的完整版本。该版本提供了页面预览功能、针对旧版浏览器的 AES-128 和 RC4 加密选项、仅支持低分辨率打印的功能,以及更详细的权限设置选项。

如果你想对自己的版本进行进一步扩展,以下是一些可行的想法:

  • 添加一个“解锁”功能,让用户在知道密码后能够删除加密保护
  • 允许用户选择“仅支持低分辨率打印”这一选项
  • 可以一次性使用同一个密码来保护多个 PDF 文件
  • 当 PDF 文件包含数字签名时,系统应显示警告提示

相关文章

技术实践

如何使用JavaScript开发一款可将基于浏览器的图像故事板转换为PDF格式的工具

在任何人开始拍摄视频、制作广告或绘制漫画的最终画面之前,通常会先画出一份故事板草图:按照拍摄顺序为每一镜头绘制一幅图片,并附上简短的说明,说明该镜头中发生了什么以及持续时间有多长。 大多数人已经拥有这些图片了——它们可能是手机照片、截图、粗略的草图,或者是通过人工智能生成的图像文件,这些文件都保存在某个文件夹里。但他们所缺乏的是一种能够将这些文件快速整理成格式规范、编号整齐的文档,并将其打印出来或发送给客户的工具。 在这个教程中,你将学习如何制作这样一个基于浏览器的工具。你需要添加一组图片,为每张图片指定标题、描述和持续时间,选择合适的布局方式,预览生成的文档,然后下载可供打印的PDF文件。

阅读全文
技术实践

如何使用Shell命令自动化生成用于Postgres的Docker镜像

如果在项目中某些代码行需要反复被执行,那么有一个相当标准的解决方法:使用函数。 但当同一个项目文件的结构需要被多次重复使用时,该如何解决这个问题呢? 这时就可以使用bash脚本了。Bash脚本的作用是自动在你的机器上执行一系列命令,而你无需亲自操作。这就是所谓的“工作流程自动化”,而在本文中,我将会教你如何实现这一点。 目录 先决条件 这个项目的起源是什么? 引言 Bash中的条件语句 交互式Shell 如何创建文件及向其中写入内容 Bash参数与标志 如何使你的脚本可执行,并使其出现在PC的路径中 结论 先决条件 要顺利阅读本文,你需要满足以下条件: 你的机器上已经安装了Git-bash 具

阅读全文
技术实践

如何使用 WebAuthn、Next.js 以及 NestJS 来构建基于通行密钥的认证系统

密码对用户和服务提供商来说都是一件麻烦事。用户往往难以记住密码,而且在多个网站上重复使用密码或遭遇网络钓鱼攻击的风险也很大。 开发人员不得不对密码进行加密处理、添加盐值、限制登录尝试的频率,还要设计“忘记密码”的功能流程,而这些过程往往令用户感到不便。 幸运的是,passkey技术解决了其中的许多问题。用户无需使用传统密码,而是可以通过其他设备上已有的认证方式(如指纹识别、面部识别或PIN码)来验证自己的身份。这些认证方式会使用存储在设备上的加密密钥来生成相应的验证码,而这些密钥永远不会被分享给他人。 本教程将向您展示如何构建一个不使用传统密码的应用程序。后端采用NestJS API,用户信息

阅读全文
技术实践

如何使用TypeScript从零开始构建一个AI代理程序

许多关于AI代理的教程都是从语言模型开始讲起,为它提供一些工具,然后让它运行循环直到产生答案。这样的做法确实足以展示这些工具的使用方法,但却没有回答那些有趣的工程学问题。 当某个工具出现故障时会发生什么?谁来验证这些操作的结果?是什么机制能防止代理无限期地运行、执行不安全的命令,或者耗尽其上下文信息?又如何在不依赖模型不可预测的响应的情况下测试这些功能呢? 这些职责都属于 代理框架 ——也就是位于语言模型与其所运行的环境之间的那层软件。 在本次教程中,我们将使用TypeScript来构建一个小型且与具体工具提供商无关的代理框架,并以编码代理作为示例进行讲解。我们会从基本的执行循环开始,逐步添加

阅读全文