PDF.js 源码解读: crypto

trailer /Encrypt
  → XRef.parse
  → new CipherTransformFactory(dict, fileId, password)
  → #prepareKeyData / #createEncryptionKey20        （口令校验，得到 encryptionKey）
  → XRef.fetchUncompressed(ref)
  → createCipherTransform(num, gen)                 （按对象号派生对象密钥）
  → Parser(cipherTransform)
      → decryptString                               （字符串，整段解密）
      → createStream → DecryptStream → decryptBlock （流，分块解密）
  → Dict / BaseStream

Writer.writeObject
  → encrypt.createCipherTransform(ref.num, ref.gen)
  → transform.encryptString(string)
  → 写出加密后的字符串 / 流

if (encrypt instanceof Dict) {
  const ids = trailerDict.get('ID');
  const fileId = ids?.length ? ids[0] : '';
  // The 'Encrypt' dictionary itself should not be encrypted, and by
  // setting `suppressEncryption` we can prevent an infinite loop inside
  // of `XRef_fetchUncompressed` if the dictionary contains indirect
  // objects (fixes issue7665.pdf).
  encrypt.suppressEncryption = true;
  this.encrypt = new CipherTransformFactory(encrypt, fileId, this.pdfManager.password);
}

// 加密字典的结构示意，不是可直接运行的 PDF 解析结果
const encryptDict = {
  Filter: 'Standard',
  V: 4,
  R: 4,
  Length: 128,
  CF: {
    StdCF: {
      CFM: 'AESV2',
      AuthEvent: 'DocOpen',
      Length: 16,
    },
  },
  StmF: 'StdCF',
  StrF: 'StdCF',
  EFF: 'StdCF',
  O: '32 字节校验值 + 8 字节校验盐 + 8 字节密钥盐',
  U: '32 字节校验值 + 8 字节校验盐 + 8 字节密钥盐',
  P: -3904,
  EncryptMetadata: true,
};

class ARCFourCipher {
  a = 0;
 
  b = 0;
 
  constructor(key) {
    const s = new Uint8Array(256);
    const keyLength = key.length;
 
    for (let i = 0; i < 256; ++i) {
      s[i] = i;
    }
    for (let i = 0, j = 0; i < 256; ++i, ++j) {
      const tmp = s[i];
      j = (j + tmp + key[i % keyLength]) & 0xff;
      s[i] = s[j];
      s[j] = tmp;
    }
    this.s = s;
  }

  encryptBlock(data) {
    let a = this.a,
      b = this.b;
    const s = this.s;
    const n = data.length;
    const output = new Uint8Array(n);
    for (let i = 0; i < n; ++i) {
      a = (a + 1) & 0xff;
      const tmp = s[a];
      b = (b + tmp) & 0xff;
      const tmp2 = s[b];
      s[a] = tmp2;
      s[b] = tmp;
      output[i] = data[i] ^ s[(tmp + tmp2) & 0xff];
    }
    this.a = a;
    this.b = b;
    return output;
  }

  decryptBlock(data) {
    return this.encryptBlock(data);
  }
 
  encrypt(data) {
    return this.encryptBlock(data);
  }

class NullCipher {
  decryptBlock(data) {
    return data;
  }
 
  encrypt(data) {
    return data;
  }
}

_s = new Uint8Array([
  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
  // 其余 240 项省略
]);

_mix = new Uint32Array([
  0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927,
  // 其余 250 项省略
]);

_mixCol = Uint8Array.from({ length: 256 }, (_, i) => (i < 128 ? i << 1 : (i << 1) ^ 0x1b));

  constructor() {
    if (
      (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) &&
      this.constructor === AESBaseCipher
    ) {
      unreachable("Cannot initialize AESBaseCipher.");
    }
    this.buffer = new Uint8Array(16);
    this.bufferPosition = 0;
  }
 
  _expandKey(cipherKey) {
    unreachable("Cannot call `_expandKey` on the base class");
  }

  _decrypt(input, key) {
    let t, u, v;
    const state = new Uint8Array(16);
    state.set(input);
 
    // AddRoundKey
    for (let j = 0, k = this._keySize; j < 16; ++j, ++k) {
      state[j] ^= key[k];
    }
    for (let i = this._cyclesOfRepetition - 1; i >= 1; --i) {
      // InvShiftRows
      t = state[13];
      state[13] = state[9];
      state[9] = state[5];
      state[5] = state[1];
      state[1] = t;
      t = state[14];
      u = state[10];
      state[14] = state[6];
      state[10] = state[2];
      state[6] = t;
      state[2] = u;
      t = state[15];
      u = state[11];
      v = state[7];
      state[15] = state[3];
      state[11] = t;
      state[7] = u;
      state[3] = v;
      // InvSubBytes
      for (let j = 0; j < 16; ++j) {
        state[j] = this._inv_s[state[j]];
      }
      // AddRoundKey
      for (let j = 0, k = i * 16; j < 16; ++j, ++k) {
        state[j] ^= key[k];
      }
      // InvMixColumns
      for (let j = 0; j < 16; j += 4) {
        const s0 = this._mix[state[j]];
        const s1 = this._mix[state[j + 1]];
        const s2 = this._mix[state[j + 2]];
        const s3 = this._mix[state[j + 3]];
        t =
          s0 ^
          (s1 >>> 8) ^
          (s1 << 24) ^
          (s2 >>> 16) ^
          (s2 << 16) ^
          (s3 >>> 24) ^
          (s3 << 8);
        state[j] = (t >>> 24) & 0xff;
        state[j + 1] = (t >> 16) & 0xff;
        state[j + 2] = (t >> 8) & 0xff;
        state[j + 3] = t & 0xff;
      }
    }
    // InvShiftRows
    t = state[13];
    state[13] = state[9];
    state[9] = state[5];
    state[5] = state[1];
    state[1] = t;
    t = state[14];
    u = state[10];
    state[14] = state[6];
    state[10] = state[2];
    state[6] = t;
    state[2] = u;
    t = state[15];
    u = state[11];
    v = state[7];
    state[15] = state[3];
    state[11] = t;
    state[7] = u;
    state[3] = v;
    for (let j = 0; j < 16; ++j) {
      // InvSubBytes
      state[j] = this._inv_s[state[j]];
      // AddRoundKey
      state[j] ^= key[j];
    }
    return state;
  }

t = state[13];
state[13] = state[9];
state[9] = state[5];
state[5] = state[1];
state[1] = t;

t = s0 ^ (s1 >>> 8) ^ (s1 << 24) ^ (s2 >>> 16) ^ (s2 << 16) ^ (s3 >>> 24) ^ (s3 << 8);

  _encrypt(input, key) {
    const s = this._s;
 
    let t, u, v;
    const state = new Uint8Array(16);
    state.set(input);
 
    for (let j = 0; j < 16; ++j) {
      // AddRoundKey
      state[j] ^= key[j];
    }
 
    for (let i = 1; i < this._cyclesOfRepetition; i++) {
      // SubBytes
      for (let j = 0; j < 16; ++j) {
        state[j] = s[state[j]];
      }
      // ShiftRows
      v = state[1];
      state[1] = state[5];
      state[5] = state[9];
      state[9] = state[13];
      state[13] = v;
      v = state[2];
      u = state[6];
      state[2] = state[10];
      state[6] = state[14];
      state[10] = v;
      state[14] = u;
      v = state[3];
      u = state[7];
      t = state[11];
      state[3] = state[15];
      state[7] = v;
      state[11] = u;
      state[15] = t;
      // MixColumns
      for (let j = 0; j < 16; j += 4) {
        const s0 = state[j];
        const s1 = state[j + 1];
        const s2 = state[j + 2];
        const s3 = state[j + 3];
        t = s0 ^ s1 ^ s2 ^ s3;
        state[j] ^= t ^ this._mixCol[s0 ^ s1];
        state[j + 1] ^= t ^ this._mixCol[s1 ^ s2];
        state[j + 2] ^= t ^ this._mixCol[s2 ^ s3];
        state[j + 3] ^= t ^ this._mixCol[s3 ^ s0];
      }
      // AddRoundKey
      for (let j = 0, k = i * 16; j < 16; ++j, ++k) {
        state[j] ^= key[k];
      }
    }
 
    // SubBytes
    for (let j = 0; j < 16; ++j) {
      state[j] = s[state[j]];
    }
    // ShiftRows
    v = state[1];
    state[1] = state[5];
    state[5] = state[9];
    state[9] = state[13];
    state[13] = v;
    v = state[2];
    u = state[6];
    state[2] = state[10];
    state[6] = state[14];
    state[10] = v;
    state[14] = u;
    v = state[3];
    u = state[7];
    t = state[11];
    state[3] = state[15];
    state[7] = v;
    state[11] = u;
    state[15] = t;
    // AddRoundKey
    for (let j = 0, k = this._keySize; j < 16; ++j, ++k) {
      state[j] ^= key[k];
    }
    return state;
  }

v = state[1];
state[1] = state[5];
state[5] = state[9];
state[9] = state[13];
state[13] = v;

t = s0 ^ s1 ^ s2 ^ s3;
state[j] ^= t ^ this._mixCol[s0 ^ s1];
state[j + 1] ^= t ^ this._mixCol[s1 ^ s2];
state[j + 2] ^= t ^ this._mixCol[s2 ^ s3];
state[j + 3] ^= t ^ this._mixCol[s3 ^ s0];

  _decryptBlock2(data, finalize) {
    const sourceLength = data.length;
    let buffer = this.buffer,
      bufferLength = this.bufferPosition;
    const result = [];
    let iv = this.iv;
 
    for (let i = 0; i < sourceLength; ++i) {
      buffer[bufferLength] = data[i];
      ++bufferLength;
      if (bufferLength < 16) {
        continue;
      }
      // buffer is full, decrypting
      const plain = this._decrypt(buffer, this._key);
      // xor-ing the IV vector to get plain text
      for (let j = 0; j < 16; ++j) {
        plain[j] ^= iv[j];
      }
      iv = buffer;
      result.push(plain);
      buffer = new Uint8Array(16);
      bufferLength = 0;
    }
    // saving incomplete buffer
    this.buffer = buffer;
    this.bufferLength = bufferLength;
    this.iv = iv;
    if (result.length === 0) {
      return new Uint8Array(0);
    }
    // combining plain text blocks into one
    let outputLength = 16 * result.length;
    if (finalize) {
      // undo a padding that is described in RFC 2898
      const lastBlock = result.at(-1);
      let psLen = lastBlock[15];
      if (psLen <= 16) {
        for (let i = 15, ii = 16 - psLen; i >= ii; --i) {
          if (lastBlock[i] !== psLen) {
            // Invalid padding, assume that the block has no padding.
            psLen = 0;
            break;
          }
        }
        outputLength -= psLen;
        result[result.length - 1] = lastBlock.subarray(0, 16 - psLen);
      }
    }
    const output = new Uint8Array(outputLength);
    for (let i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
      output.set(result[i], j);
    }
    return output;
  }

  decryptBlock(data, finalize, iv = null) {
    const sourceLength = data.length;
    const buffer = this.buffer;
    let bufferLength = this.bufferPosition;
    // If an IV is not supplied, wait for IV values. They are at the start
    // of the stream.
    if (iv) {
      this.iv = iv;
    } else {
      for (
        let i = 0;
        bufferLength < 16 && i < sourceLength;
        ++i, ++bufferLength
      ) {
        buffer[bufferLength] = data[i];
      }
      if (bufferLength < 16) {
        // Need more data.
        this.bufferLength = bufferLength;
        return new Uint8Array(0);
      }
      this.iv = buffer;
      data = data.subarray(16);
    }
    this.buffer = new Uint8Array(16);
    this.bufferLength = 0;
    // starting decryption
    this.decryptBlock = this._decryptBlock2;
    return this.decryptBlock(data, finalize);
  }

this.decryptBlock = this._decryptBlock2;

  encrypt(data, iv) {
    const sourceLength = data.length;
    let buffer = this.buffer,
      bufferLength = this.bufferPosition;
    const result = [];
 
    iv ||= new Uint8Array(16);
    for (let i = 0; i < sourceLength; ++i) {
      buffer[bufferLength] = data[i];
      ++bufferLength;
      if (bufferLength < 16) {
        continue;
      }
 
      for (let j = 0; j < 16; ++j) {
        buffer[j] ^= iv[j];
      }
 
      // buffer is full, encrypting
      const cipher = this._encrypt(buffer, this._key);
      iv = cipher;
      result.push(cipher);
      buffer = new Uint8Array(16);
      bufferLength = 0;
    }
    // saving incomplete buffer
    this.buffer = buffer;
    this.bufferLength = bufferLength;
    this.iv = iv;
    if (result.length === 0) {
      return new Uint8Array(0);
    }
    // combining plain text blocks into one
    const outputLength = 16 * result.length;
    const output = new Uint8Array(outputLength);
    for (let i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
      output.set(result[i], j);
    }
    return output;
  }

class AES128Cipher extends AESBaseCipher {
  constructor(key) {
    super();
 
    this._cyclesOfRepetition = 10;
    this._keySize = 160; // bits
 
    this._key = this._expandKey(key);
  }

class AES256Cipher extends AESBaseCipher {
  constructor(key) {
    super();
 
    this._cyclesOfRepetition = 14;
    this._keySize = 224; // bits
 
    this._key = this._expandKey(key);
  }

_rcon = new Uint8Array([
  0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
  0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a,
  // 后续项按 AES 的 xtime 序列继续
]);

  _expandKey(cipherKey) {
    const b = 176;
    const s = this._s;
    const rcon = this._rcon;
 
    const result = new Uint8Array(b);
    result.set(cipherKey);
 
    for (let j = 16, i = 1; j < b; ++i) {
      // RotWord
      let t1 = result[j - 3];
      let t2 = result[j - 2];
      let t3 = result[j - 1];
      let t4 = result[j - 4];
      // SubWord
      t1 = s[t1];
      t2 = s[t2];
      t3 = s[t3];
      t4 = s[t4];
      // Rcon
      t1 ^= rcon[i];
      for (let n = 0; n < 4; ++n) {
        result[j] = t1 ^= result[j - 16];
        j++;
        result[j] = t2 ^= result[j - 16];
        j++;
        result[j] = t3 ^= result[j - 16];
        j++;
        result[j] = t4 ^= result[j - 16];
        j++;
      }
    }
    return result;
  }

  _expandKey(cipherKey) {
    const b = 240;
    const s = this._s;
 
    const result = new Uint8Array(b);
    result.set(cipherKey);
 
    let r = 1;
    let t1, t2, t3, t4;
    for (let j = 32, i = 1; j < b; ++i) {
      if (j % 32 === 16) {
        t1 = s[t1];
        t2 = s[t2];
        t3 = s[t3];
        t4 = s[t4];
      } else if (j % 32 === 0) {
        // RotWord
        t1 = result[j - 3];
        t2 = result[j - 2];
        t3 = result[j - 1];
        t4 = result[j - 4];
        // SubWord
        t1 = s[t1];
        t2 = s[t2];
        t3 = s[t3];
        t4 = s[t4];
        // Rcon
        t1 ^= r;
        if ((r <<= 1) >= 256) {
          r = (r ^ 0x1b) & 0xff;
        }
      }
 
      for (let n = 0; n < 4; ++n) {
        result[j] = t1 ^= result[j - 32];
        j++;
        result[j] = t2 ^= result[j - 32];
        j++;
        result[j] = t3 ^= result[j - 32];
        j++;
        result[j] = t4 ^= result[j - 32];
        j++;
      }
    }
    return result;
  }

class PDFBase {
  constructor() {
    if (
      (typeof PDFJSDev === 'undefined' || PDFJSDev.test('TESTING')) &&
      this.constructor === PDFBase
    ) {
      unreachable('Cannot initialize PDFBase.');
    }
  }
 
  _hash(password, input, userBytes) {
    unreachable('Abstract method `_hash` called');
  }
 
  checkOwnerPassword(password, ownerValidationSalt, userBytes, ownerPassword) {
    const hashData = new Uint8Array(password.length + 56);
    hashData.set(password, 0);
    hashData.set(ownerValidationSalt, password.length);
    hashData.set(userBytes, password.length + ownerValidationSalt.length);
    const result = this._hash(password, hashData, userBytes);
    return isArrayEqual(result, ownerPassword);
  }
 
  checkUserPassword(password, userValidationSalt, userPassword) {
    const hashData = new Uint8Array(password.length + 8);
    hashData.set(password, 0);
    hashData.set(userValidationSalt, password.length);
    const result = this._hash(password, hashData, []);
    return isArrayEqual(result, userPassword);
  }
 
  getOwnerKey(password, ownerKeySalt, userBytes, ownerEncryption) {
    const hashData = new Uint8Array(password.length + 56);
    hashData.set(password, 0);
    hashData.set(ownerKeySalt, password.length);
    hashData.set(userBytes, password.length + ownerKeySalt.length);
    const key = this._hash(password, hashData, userBytes);
    const cipher = new AES256Cipher(key);
    return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));
  }
 
  getUserKey(password, userKeySalt, userEncryption) {
    const hashData = new Uint8Array(password.length + 8);
    hashData.set(password, 0);
    hashData.set(userKeySalt, password.length);
    // `key` is the decryption key for the UE string.
    const key = this._hash(password, hashData, []);
    const cipher = new AES256Cipher(key);
    return cipher.decryptBlock(userEncryption, false, new Uint8Array(16));
  }
}

const cipher = new AES256Cipher(key);
return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));

class PDF17 extends PDFBase {
  _hash(password, input, userBytes) {
    return calculateSHA256(input, 0, input.length);
  }
}

class PDF20 extends PDFBase {
  _hash(password, input, userBytes) {
    // This refers to Algorithm 2.B as defined in ISO 32000-2.
    let k = calculateSHA256(input, 0, input.length).subarray(0, 32);
    let e = [0];
    let i = 0;
    while (i < 64 || e.at(-1) > i - 32) {
      const combinedLength = password.length + k.length + userBytes.length,
        combinedArray = new Uint8Array(combinedLength);
      let writeOffset = 0;
      combinedArray.set(password, writeOffset);
      writeOffset += password.length;
      combinedArray.set(k, writeOffset);
      writeOffset += k.length;
      combinedArray.set(userBytes, writeOffset);
 
      const k1 = new Uint8Array(combinedLength * 64);
      for (let j = 0, pos = 0; j < 64; j++, pos += combinedLength) {
        k1.set(combinedArray, pos);
      }
      // AES128 CBC NO PADDING with first 16 bytes of k as the key
      // and the second 16 as the iv.
      const cipher = new AES128Cipher(k.subarray(0, 16));
      e = cipher.encrypt(k1, k.subarray(16, 32));
      // Now we have to take the first 16 bytes of an unsigned big endian
      // integer and compute the remainder modulo 3. That is a fairly large
      // number and JavaScript isn't going to handle that well.
      // The number is e0 + 256 * e1 + 256^2 * e2... and 256 % 3 === 1, hence
      // the powers of 256 are === 1 modulo 3 and finally the number modulo 3
      // is equal to the remainder modulo 3 of the sum of the e_n.
      const remainder = Math.sumPrecise(e.slice(0, 16)) % 3;
      if (remainder === 0) {
        k = calculateSHA256(e, 0, e.length);
      } else if (remainder === 1) {
        k = calculateSHA384(e, 0, e.length);
      } else if (remainder === 2) {
        k = calculateSHA512(e, 0, e.length);
      }
      i++;
    }
    return k.subarray(0, 32);
  }
}

function utf8PasswordToBytes(password) {
  try {
    password = utf8StringToString(password);
  } catch {
    warn('CipherTransformFactory: Unable to convert UTF8 encoded password.');
  }
  return stringToBytes(password);
}

function utf8StringToString(str) {
  return unescape(encodeURIComponent(str));
}

if (revision === 6) {
  const preppedPassword = saslPrep(password);
  passwordBytes = utf8PasswordToBytes(preppedPassword);
  if (preppedPassword !== password) {
    rawPasswordBytes = utf8PasswordToBytes(password);
  }
}

class CipherTransform {
  /** @type {Map<string, CipherConstructors>} */
  #cipherCache = new Map();
 
  /** @type {Name | null} */
  embeddedFilterName = null;
 
  constructor(resolveCipher, stringFilterName = null, streamFilterName = null) {
    this.resolveCipher = resolveCipher;
    this.streamFilterName = streamFilterName;
    this.stringFilterName = stringFilterName;
  }
 
  #getCipher(filterName = null) {
    const key = filterName instanceof Name ? filterName.name : "__default__";
 
    return this.#cipherCache.getOrInsertComputed(key, () =>
      this.resolveCipher(filterName)
    );
  }

  createStream(stream, length, cryptFilterName = null) {
    const defaultFilterName =
      this.embeddedFilterName && isDict(stream.dict, "EmbeddedFile")
        ? this.embeddedFilterName
        : this.streamFilterName;
    const Cipher = this.#getCipher(cryptFilterName || defaultFilterName);
    const cipher = new Cipher();
    return new DecryptStream(
      stream,
      length,
      function cipherTransformDecryptStream(data, finalize) {
        return cipher.decryptBlock(data, finalize);
      }
    );
  }

  decryptString(s) {
    const Cipher = this.#getCipher(this.stringFilterName);
    const cipher = new Cipher();
    let data = stringToBytes(s);
    data = cipher.decryptBlock(data, true);
    return bytesToString(data);
  }

  encryptString(s) {
    const Cipher = this.#getCipher(this.stringFilterName);
    const cipher = new Cipher();
    if (cipher instanceof AESBaseCipher) {
      // Append some chars equal to "16 - (M mod 16)"
      // where M is the string length (see section 7.6.2 in PDF specification)
      // to have a final string where the length is a multiple of 16.
      // Special note:
      //   "Note that the pad is present when M is evenly divisible by 16;
      //   it contains 16 bytes of 0x10."
      const strLen = s.length;
      const pad = 16 - (strLen % 16);
      s += String.fromCharCode(pad).repeat(pad);
 
      // Generate an initialization vector
      const iv = new Uint8Array(16);
      crypto.getRandomValues(iv);
 
      let data = stringToBytes(s);
      data = cipher.encrypt(data, iv);
 
      const buf = new Uint8Array(16 + data.length);
      buf.set(iv);
      buf.set(data, 16);
 
      return bytesToString(buf);
    }
 
    let data = stringToBytes(s);
    data = cipher.encrypt(data);
    return bytesToString(data);
  }

  constructor(dict, fileId, password) {
    const filter = dict.get("Filter");
    if (!isName(filter, "Standard")) {
      throw new FormatError("unknown encryption method");
    }
    this.filterName = filter.name;
    this.dict = dict;
    this.#fileId = fileId;
    const algorithm = dict.get("V");
    if (
      !Number.isInteger(algorithm) ||
      (algorithm !== 1 && algorithm !== 2 && algorithm !== 4 && algorithm !== 5)
    ) {
      throw new FormatError("unsupported encryption algorithm");
    }
    this.algorithm = algorithm;

let keyLength = dict.get('Length');
if (!keyLength) {
  // Spec asks to rely on encryption dictionary's Length entry, however
  // some PDFs don't have it. Trying to recover.
  if (algorithm <= 3) {
    // For 1 and 2 it's fixed to 40-bit, for 3 40-bit is a minimal value.
    keyLength = 40;
  } else {
    // Trying to find default handler -- it usually has Length.
    const cfDict = dict.get('CF');
    const streamCryptoName = dict.get('StmF');
    if (cfDict instanceof Dict && streamCryptoName instanceof Name) {
      cfDict.suppressEncryption = true; // See comment below.
      const handlerDict = cfDict.get(streamCryptoName.name);
      keyLength = handlerDict?.get('Length') || 128;
      if (keyLength < 40) {
        // Sometimes it's incorrect value of bits, generators specify
        // bytes.
        keyLength <<= 3;
      }
    }
  }
}
if (!Number.isInteger(keyLength) || keyLength < 40 || keyLength % 8 !== 0) {
  throw new FormatError('invalid key length');
}

let cf = null;
let stmf = Name.get('Identity');
let strf = Name.get('Identity');
let eff = stmf;
 
if (algorithm >= 4) {
  cf = dict.get('CF');
  if (cf instanceof Dict) {
    // The 'CF' dictionary itself should not be encrypted, and by setting
    // `suppressEncryption` we can prevent an infinite loop inside of
    // `XRef_fetchUncompressed` if the dictionary contains indirect
    // objects (fixes issue7665.pdf).
    cf.suppressEncryption = true;
  }
  stmf = dict.get('StmF') || Name.get('Identity');
  strf = dict.get('StrF') || Name.get('Identity');
  eff = dict.get('EFF') || stmf;
}
this.cf = cf;
this.stmf = stmf;
this.strf = strf;
this.eff = eff;

const ownerBytes = stringToBytes(dict.get('O')),
  userBytes = stringToBytes(dict.get('U'));
// prepare keys
const ownerPassword = ownerBytes.subarray(0, 32);
const userPassword = userBytes.subarray(0, 32);
const flags = dict.get('P');
const revision = dict.get('R');
// meaningful when V is 4 or 5
const encryptMetadata =
  (algorithm === 4 || algorithm === 5) && dict.get('EncryptMetadata') !== false;
this.encryptMetadata = encryptMetadata;
 
const fileIdBytes = stringToBytes(fileId);

let passwordBytes, rawPasswordBytes;
if (password) {
  if (revision === 6) {
    const preppedPassword = saslPrep(password);
    passwordBytes = utf8PasswordToBytes(preppedPassword);
    if (preppedPassword !== password) {
      rawPasswordBytes = utf8PasswordToBytes(password);
    }
  } else if (algorithm === 5) {
    passwordBytes = utf8PasswordToBytes(password);
  } else {
    passwordBytes = stringToBytes(password);
  }
}

let encryptionKey;
if (algorithm !== 5) {
  encryptionKey = this.#prepareKeyData(
    fileIdBytes,
    passwordBytes,
    ownerPassword,
    userPassword,
    flags,
    revision,
    keyLength,
    encryptMetadata,
  );
} else {
  const ownerValidationSalt = ownerBytes.subarray(32, 40);
  const ownerKeySalt = ownerBytes.subarray(40, 48);
  const uBytes = userBytes.subarray(0, 48);
  const userValidationSalt = userBytes.subarray(32, 40);
  const userKeySalt = userBytes.subarray(40, 48);
  const ownerEncryption = stringToBytes(dict.get('OE'));
  const userEncryption = stringToBytes(dict.get('UE'));
  const perms = stringToBytes(dict.get('Perms'));
  for (const candidate of rawPasswordBytes ? [passwordBytes, rawPasswordBytes] : [passwordBytes]) {
    encryptionKey = this.#createEncryptionKey20(
      revision,
      candidate,
      ownerPassword,
      ownerValidationSalt,
      ownerKeySalt,
      uBytes,
      userPassword,
      userValidationSalt,
      userKeySalt,
      ownerEncryption,
      userEncryption,
      perms,
    );
    if (encryptionKey) {
      break;
    }
  }
}

const hashDataSize = 40 + ownerPassword.length + fileId.length;
const hashData = new Uint8Array(hashDataSize);
let i = 0,
  j,
  n;
if (password) {
  n = Math.min(32, password.length);
  for (; i < n; ++i) {
    hashData[i] = password[i];
  }
}
j = 0;
while (i < 32) {
  hashData[i++] = CipherTransformFactory._defaultPasswordBytes[j++];
}
// as now the padded password in the hashData[0..i]
hashData.set(ownerPassword, i);
i += ownerPassword.length;
hashData[i++] = flags & 0xff;
hashData[i++] = (flags >> 8) & 0xff;
hashData[i++] = (flags >> 16) & 0xff;
hashData[i++] = (flags >>> 24) & 0xff;
hashData.set(fileId, i);
i += fileId.length;
if (revision >= 4 && !encryptMetadata) {
  hashData.fill(0xff, i, i + 4);
  i += 4;
}
let hash = calculateMD5(hashData, 0, i);
const keyLengthInBytes = keyLength >> 3;
if (revision >= 3) {
  for (j = 0; j < 50; ++j) {
    hash = calculateMD5(hash, 0, keyLengthInBytes);
  }
}
const encryptionKey = hash.subarray(0, keyLengthInBytes);

let cipher, userPassword;
if (revision >= 3) {
  userPassword = ownerPassword;
  const derivedKey = new Uint8Array(keyLengthInBytes);
  for (j = 19; j >= 0; j--) {
    for (let k = 0; k < keyLengthInBytes; ++k) {
      derivedKey[k] = hash[k] ^ j;
    }
    cipher = new ARCFourCipher(derivedKey);
    userPassword = cipher.encryptBlock(userPassword);
  }
} else {
  cipher = new ARCFourCipher(hash.subarray(0, keyLengthInBytes));
  userPassword = cipher.encryptBlock(ownerPassword);
}
return userPassword;

const pdfAlgorithm = revision === 6 ? new PDF20() : new PDF17();
 
if (pdfAlgorithm.checkUserPassword(password, userValidationSalt, userPassword)) {
  return pdfAlgorithm.getUserKey(password, userKeySalt, userEncryption);
} else if (
  password.length &&
  pdfAlgorithm.checkOwnerPassword(password, ownerValidationSalt, uBytes, ownerPassword)
) {
  return pdfAlgorithm.getOwnerKey(password, ownerKeySalt, uBytes, ownerEncryption);
}
 
return null;

    if (!encryptionKey) {
      if (!password) {
        if (
          this.algorithm >= 4 &&
          isName(this.stmf, "Identity") &&
          isName(this.strf, "Identity")
        ) {
          const effCF = this.cf?.get(this.eff.name);
          const authEvent = effCF?.get("AuthEvent");
 
          if (isName(authEvent, "EFOpen")) {
            // For EFOpen with Identity as default stream/string filters, defer
            // password prompting until an EmbeddedFile stream is actually read.
            this.encryptionKey = null;
            return;
          }
        }
        throw new PasswordException(
          "No password given",
          PasswordResponses.NEED_PASSWORD
        );
      }

  #buildObjectKey(num, gen, encryptionKey, isAes = false) {
    const n = encryptionKey.length;
    const key = new Uint8Array(n + 9);
    key.set(encryptionKey);
    let i = n;
    key[i++] = num & 0xff;
    key[i++] = (num >> 8) & 0xff;
    key[i++] = (num >> 16) & 0xff;
    key[i++] = gen & 0xff;
    key[i++] = (gen >> 8) & 0xff;
    if (isAes) {
      key[i++] = 0x73;
      key[i++] = 0x41;
      key[i++] = 0x6c;
      key[i++] = 0x54;
    }
    const hash = calculateMD5(key, 0, i);
    return hash.subarray(0, Math.min(n + 5, 16));
  }

  createCipherTransform(num, gen) {
    if (this.algorithm === 4 || this.algorithm === 5) {
      /** @type {ResolveCipher} */
      const resolveCipher = filterName => {
        if (!(filterName instanceof Name)) {
          throw new FormatError("Invalid crypt filter name.");
        }
        const cryptFilter = this.cf.get(filterName.name);
        const cfm = cryptFilter?.get("CFM");
 
        if (!cfm || cfm.name === "None") {
          return NullCipher;
        }
        if (!this.encryptionKey) {
          throw new PasswordException(
            "No password given",
            PasswordResponses.NEED_PASSWORD
          );
        }
        if (this.algorithm === 5 || cfm.name === "AESV3") {
          // V=5 always uses 256-bit AES with the file encryption key, even
          // when a producer wrongly sets the crypt filter's CFM to AESV2
          // (bug 2046659).
          return AES256Cipher.bind(null, this.encryptionKey);
        }
        if (cfm.name === "V2") {
          return ARCFourCipher.bind(
            null,
            this.#buildObjectKey(
              num,
              gen,
              this.encryptionKey,
              /* isAes = */ false
            )
          );
        }
        if (cfm.name === "AESV2") {
          return AES128Cipher.bind(
            null,
            this.#buildObjectKey(
              num,
              gen,
              this.encryptionKey,
              /* isAes = */ true
            )
          );
        }
        throw new FormatError("Unknown crypto method");
      };
 
      const transform = new CipherTransform(
        resolveCipher,
        this.strf,
        this.stmf
      );
      transform.embeddedFilterName = this.eff;
      return transform;
    }
 
    // algorithms 1 and 2
    /** @type {ResolveCipher} */
    const resolveCipher = () =>
      ARCFourCipher.bind(
        null,
        this.#buildObjectKey(num, gen, this.encryptionKey, /* isAes = */ false)
      );
    return new CipherTransform(resolveCipher);
  }