From 92a2fe880af08785354858d5e42a0d38b885df8f Mon Sep 17 00:00:00 2001
From: Matt Van Horn <455140+mvanhorn@users.noreply.github.com>
Date: Thu, 16 Jul 2026 00:56:07 -0700
Subject: [PATCH] Guard find_nonembedded_cid_fonts against non-dictionary
 resources

A malformed PDF can store a non-dictionary object under a page's /Font or
/XObject resource. find_nonembedded_cid_fonts() iterated .values() on that
object outside the per-entry try/except, so scanning such a page raised
(TypeError/AttributeError depending on the pikepdf version) instead of
producing output. This surfaced as a PDF/A conversion crash.

Route both resource lookups through a small helper that returns an empty
list when the resource is missing or not a dictionary, so a garbage entry
is simply treated as having no fonts. Add a regression test covering a
non-dictionary /Font and /XObject.
---
 src/ocrmypdf/pdfa.py | 41 ++++++++++++++++++++++++++++-------------
 tests/test_pdfa.py   | 16 ++++++++++++++++
 2 files changed, 44 insertions(+), 13 deletions(-)

diff --git a/src/ocrmypdf/pdfa.py b/src/ocrmypdf/pdfa.py
index 6d79722a..264b16fe 100644
--- a/src/ocrmypdf/pdfa.py
+++ b/src/ocrmypdf/pdfa.py
@@ -148,6 +148,23 @@ def _cid_font_is_embedded(type0_font: Dictionary) -> bool:
     return False
 
 
+def _dict_entries(resource):
+    """Return the values of a PDF resource sub-dictionary, tolerating garbage.
+
+    A ``/Font`` or ``/XObject`` resource is expected to be a dictionary, but a
+    malformed PDF -- common in OCR workloads -- may store a non-dictionary
+    object (an array, a name, an empty value) there. Calling ``.values()`` on a
+    non-dictionary raises, so return an empty list in that case rather than
+    letting the scan crash (issue #1713).
+    """
+    if resource is None:
+        return []
+    try:
+        return list(resource.values())
+    except (AttributeError, TypeError):
+        return []
+
+
 def find_nonembedded_cid_fonts(pdf: Pdf) -> set[str]:
     """Find CID-keyed (Type0) fonts that lack embedded glyph data.
 
@@ -175,21 +192,19 @@ def find_nonembedded_cid_fonts(pdf: Pdf) -> set[str]:
         if resources is None or depth > 10:
             return
         fonts = resources.get(Name.Font, None)
-        if fonts is not None:
-            for font in fonts.values():
-                try:
-                    if font.get(Name.Subtype) != Name.Type0:
-                        continue
-                    if not _cid_font_is_embedded(font):
-                        basefont = str(font.get(Name.BaseFont, '/(unnamed)'))
-                        found.add(basefont.lstrip('/'))
-                except (AttributeError, TypeError, KeyError):
+        for font in _dict_entries(fonts):
+            try:
+                if font.get(Name.Subtype) != Name.Type0:
                     continue
+                if not _cid_font_is_embedded(font):
+                    basefont = str(font.get(Name.BaseFont, '/(unnamed)'))
+                    found.add(basefont.lstrip('/'))
+            except (AttributeError, TypeError, KeyError):
+                continue
         xobjects = resources.get(Name.XObject, None)
-        if xobjects is not None:
-            for xobj in xobjects.values():
-                if xobj.get(Name.Subtype) == Name.Form and Name.Resources in xobj:
-                    scan_resources(xobj[Name.Resources], depth + 1)
+        for xobj in _dict_entries(xobjects):
+            if xobj.get(Name.Subtype) == Name.Form and Name.Resources in xobj:
+                scan_resources(xobj[Name.Resources], depth + 1)
 
     for page in pdf.pages:
         scan_resources(page.get(Name.Resources, None))
diff --git a/tests/test_pdfa.py b/tests/test_pdfa.py
index e5ee6ccb..0f984650 100644
--- a/tests/test_pdfa.py
+++ b/tests/test_pdfa.py
@@ -94,6 +94,22 @@ class TestFindNonembeddedCidFonts:
         with pikepdf.open(path) as pdf:
             assert find_nonembedded_cid_fonts(pdf) == {'ZZZ+Hidden'}
 
+    def test_non_dictionary_font_and_xobject_resources_are_ignored(self, tmp_path):
+        # A malformed PDF may carry a /Font or /XObject resource that is not a
+        # dictionary (an array, a name, an empty value). Scanning must skip it
+        # rather than raise when iterating its values (regression test for the
+        # crash reported in issue #1713).
+        path = tmp_path / 'malformed_resources.pdf'
+        with pikepdf.new() as pdf:
+            page = pdf.add_blank_page()
+            page.Resources = pikepdf.Dictionary(
+                Font=pikepdf.Array([]),
+                XObject=pikepdf.Array([]),
+            )
+            pdf.save(path)
+        with pikepdf.open(path) as pdf:
+            assert find_nonembedded_cid_fonts(pdf) == set()
+
 
 @pytest.fixture
 def nonembedded_cid_pdf(tmp_path):