ppt2pptx 0.3.1__py3-none-any.whl

ppt2pptx/__init__.py

@@ -0,0 +1,6 @@
+"""Public API for ppt2pptx."""
+
+from .converter import ConversionResult, convert, inspect_ppt
+
+__all__ = ["ConversionResult", "convert", "inspect_ppt"]
+__version__ = "0.3.1"

ppt2pptx/__main__.py

@@ -0,0 +1,2 @@
+from .cli import main
+raise SystemExit(main())

ppt2pptx/cfb.py

@@ -0,0 +1,115 @@
+"""Small bounded reader for CFB/OLE compound files used by legacy PPT."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import struct
+
+from .errors import InvalidPpt
+
+FREE, END, FAT, DIF = 0xFFFFFFFF, 0xFFFFFFFE, 0xFFFFFFFD, 0xFFFFFFFC
+
+@dataclass(frozen=True, slots=True)
+class Limits:
+    max_input_bytes: int = 512 * 1024 * 1024
+    max_stream_bytes: int = 256 * 1024 * 1024
+
+class CompoundFile:
+    def __init__(self, data: bytes, limits: Limits | None = None) -> None:
+        self.limits = limits or Limits()
+        if len(data) > self.limits.max_input_bytes or len(data) < 512:
+            raise InvalidPpt("invalid or oversized compound file")
+        if data[:8] != b"\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1":
+            raise InvalidPpt("not a Compound File Binary container")
+        self.data = data
+        major = struct.unpack_from("<H", data, 26)[0]
+        self.sector_size = 512 if major == 3 else 4096 if major == 4 else 0
+        if not self.sector_size or len(data) < self.sector_size:
+            raise InvalidPpt("unsupported compound file version")
+        self.mini_sector_size = 64
+        self.mini_cutoff = struct.unpack_from("<I", data, 56)[0]
+        self.first_dir = struct.unpack_from("<I", data, 48)[0]
+        self.first_mini_fat = struct.unpack_from("<I", data, 60)[0]
+        self.num_mini_fat = struct.unpack_from("<I", data, 64)[0]
+        self._sectors = (len(data) - self.sector_size) // self.sector_size
+        self.fat = self._load_fat()
+        self.entries = self._read_directory()
+        self.by_name = {name.casefold(): entry for name, entry in self.entries.items()}
+        self.mini_fat = self._read_chain_values(self.first_mini_fat, self.num_mini_fat)
+        self._mini_stream: bytes | None = None
+
+    @classmethod
+    def from_path(cls, path: str | Path, limits: Limits | None = None) -> "CompoundFile":
+        p = Path(path)
+        actual = limits or Limits()
+        if p.stat().st_size > actual.max_input_bytes:
+            raise InvalidPpt("input exceeds configured size limit")
+        return cls(p.read_bytes(), actual)
+
+    def _sector(self, index: int) -> bytes:
+        if index >= self._sectors or index in (FREE, END, FAT, DIF):
+            raise InvalidPpt("compound file sector reference is invalid")
+        start = (index + 1) * self.sector_size
+        return self.data[start:start + self.sector_size]
+
+    def _load_fat(self) -> tuple[int, ...]:
+        count = struct.unpack_from("<I", self.data, 44)[0]
+        ids = [x for x in struct.unpack_from("<109I", self.data, 76) if x != FREE]
+        next_difat, difat_count = struct.unpack_from("<II", self.data, 68)
+        for _ in range(difat_count):
+            block = self._sector(next_difat)
+            values = struct.unpack("<%dI" % (self.sector_size // 4), block)
+            ids.extend(x for x in values[:-1] if x != FREE)
+            next_difat = values[-1]
+        if len(ids) < count:
+            raise InvalidPpt("compound file FAT is truncated")
+        values: list[int] = []
+        for index in ids[:count]: values.extend(struct.unpack("<%dI" % (self.sector_size // 4), self._sector(index)))
+        return tuple(values)
+
+    def _chain(self, start: int, table: tuple[int, ...], limit: int | None = None) -> list[int]:
+        result, seen, current = [], set(), start
+        while current != END:
+            if current in seen or current >= len(table) or current in (FREE, FAT, DIF):
+                raise InvalidPpt("compound file sector chain is invalid")
+            seen.add(current); result.append(current)
+            if len(result) > (limit or len(table) + 1): raise InvalidPpt("compound file sector chain is unbounded")
+            current = table[current]
+        return result
+
+    def _read_chain_values(self, start: int, declared: int) -> tuple[int, ...]:
+        if not declared: return ()
+        raw = b"".join(self._sector(i) for i in self._chain(start, self.fat, declared))
+        return struct.unpack("<%dI" % (len(raw) // 4), raw)
+
+    def _read_directory(self) -> dict[str, tuple[int, int, int]]:
+        raw = b"".join(self._sector(i) for i in self._chain(self.first_dir, self.fat))
+        entries: list[tuple[str, int, int, int]] = []
+        for offset in range(0, len(raw) - 127, 128):
+            name_len = struct.unpack_from("<H", raw, offset + 64)[0]
+            kind = raw[offset + 66]
+            if kind not in (2, 5) or name_len < 2 or name_len > 64: continue
+            name = raw[offset:offset + name_len - 2].decode("utf-16le", "replace")
+            start, size = struct.unpack_from("<IQ", raw, offset + 116)
+            entries.append((name, kind, start, size))
+        return {name: (kind, start, size) for name, kind, start, size in entries}
+
+    def open_stream(self, name: str) -> bytes:
+        entry = self.by_name.get(name.casefold())
+        if entry is None: raise InvalidPpt(f"required stream is missing: {name}")
+        kind, start, size = entry
+        if kind != 2 or size > self.limits.max_stream_bytes: raise InvalidPpt(f"invalid stream: {name}")
+        if not size: return b""
+        if size < self.mini_cutoff:
+            if self._mini_stream is None:
+                root = next((x for x in self.entries.values() if x[0] == 5), None)
+                if root is None: raise InvalidPpt("compound file root storage is missing")
+                self._mini_stream = self._read_regular(root[1], root[2])
+            chunks = []
+            for idx in self._chain(start, self.mini_fat):
+                pos = idx * self.mini_sector_size; chunks.append(self._mini_stream[pos:pos+self.mini_sector_size])
+            return b"".join(chunks)[:size]
+        return self._read_regular(start, size)
+
+    def _read_regular(self, start: int, size: int) -> bytes:
+        return b"".join(self._sector(i) for i in self._chain(start, self.fat))[:size]

ppt2pptx/cli.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from . import __version__
+from .cfb import Limits
+from .converter import convert, inspect_ppt
+from .diagnostics import write_json_file
+from .errors import Ppt2PptxError
+
+def _positive_int(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("value must be positive")
+    return parsed
+
+def _common(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--max-input-bytes", type=_positive_int, default=Limits().max_input_bytes)
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("--password", help="password for an encrypted presentation")
+    group.add_argument("--password-file", type=Path, help="UTF-8 file containing the password")
+
+def _password(args: argparse.Namespace) -> str | None:
+    if args.password is not None:
+        return args.password
+    if args.password_file is None:
+        return None
+    if args.password_file.stat().st_size > 4096:
+        raise OSError("password file exceeds 4096 bytes")
+    return args.password_file.read_text(encoding="utf-8").removesuffix("\n").removesuffix("\r")
+
+def _conversion_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="ppt2pptx", description="Convert PowerPoint 97–2003 .ppt files to .pptx")
+    parser.add_argument("input", type=Path)
+    parser.add_argument("-o", "--output", type=Path)
+    parser.add_argument("--report", type=Path)
+    parser.add_argument("--version", action="version", version=__version__)
+    _common(parser)
+    return parser
+
+def _inspection_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="ppt2pptx inspect", description="Inspect slides and editable text without converting")
+    parser.add_argument("input", type=Path)
+    parser.add_argument("--json", action="store_true", dest="as_json")
+    _common(parser)
+    return parser
+
+def _batch_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="ppt2pptx batch", description="Convert a directory of PowerPoint 97–2003 .ppt files")
+    parser.add_argument("input", type=Path)
+    parser.add_argument("-o", "--output", type=Path, required=True)
+    parser.add_argument("--recursive", action="store_true")
+    parser.add_argument("--report", type=Path)
+    _common(parser)
+    return parser
+
+def _same_path(left: Path, right: Path) -> bool:
+    return left.resolve().as_posix().casefold() == right.resolve().as_posix().casefold()
+
+def _batch_sources(root: Path, recursive: bool) -> list[Path]:
+    iterator = root.rglob("*") if recursive else root.iterdir()
+    return sorted(
+        (path for path in iterator if path.is_file() and path.suffix.casefold() == ".ppt" and not path.name.startswith("~$")),
+        key=lambda path: path.relative_to(root).as_posix().casefold(),
+    )
+
+def _run_batch(args: argparse.Namespace) -> int:
+    source_root, output_root = args.input, args.output
+    if not source_root.is_dir():
+        print(f"ppt2pptx: error: batch input is not a directory: {source_root}", file=sys.stderr)
+        return 2
+    sources = _batch_sources(source_root, args.recursive)
+    password = _password(args)
+    if not sources:
+        print(f"ppt2pptx: error: no .ppt files found in {source_root}", file=sys.stderr)
+        return 2
+    destinations = [output_root / source.relative_to(source_root).with_suffix(".pptx") for source in sources]
+    if args.report and any(_same_path(args.report, path) for path in (*sources, *destinations)):
+        print("ppt2pptx: error: report path would overwrite an input or output", file=sys.stderr)
+        return 2
+    results: list[dict[str, object]] = []
+    succeeded = failed = warning_count = 0
+    seen_destinations: set[str] = set()
+    for source, destination in zip(sources, destinations):
+        destination_key = destination.resolve().as_posix().casefold()
+        if destination_key in seen_destinations:
+            error = f"multiple inputs map to the same output {destination}"
+            print(f"Failed {source}: {error}", file=sys.stderr)
+            results.append({"source": str(source), "destination": str(destination), "status": "failed", "error": error})
+            failed += 1
+            continue
+        seen_destinations.add(destination_key)
+        try:
+            result = convert(source, destination, limits=Limits(max_input_bytes=args.max_input_bytes), password=password)
+        except (Ppt2PptxError, OSError) as exc:
+            print(f"Failed {source}: {exc}", file=sys.stderr)
+            results.append({"source": str(source), "destination": str(destination), "status": "failed", "error": str(exc)})
+            failed += 1
+            continue
+        warnings = len(result.report.warnings)
+        warning_count += warnings
+        succeeded += 1
+        print(f"Converted {source} -> {destination}")
+        results.append({"source": str(source), "destination": str(destination), "status": "converted", "slide_count": result.slide_count, "warning_count": warnings, "report": result.report.to_dict()})
+    summary = {"input": str(source_root), "output": str(output_root), "recursive": bool(args.recursive), "file_count": len(sources), "succeeded": succeeded, "failed": failed, "warning_count": warning_count, "results": results}
+    if args.report:
+        write_json_file(args.report, summary)
+    print(f"Batch complete: {succeeded} converted, {failed} failed")
+    return 1 if failed else 0
+
+def main(argv: list[str] | None = None) -> int:
+    raw = list(sys.argv[1:] if argv is None else argv)
+    mode = raw.pop(0) if raw and raw[0] in ("inspect", "batch") else "convert"
+    parser = {"inspect": _inspection_parser, "batch": _batch_parser}.get(mode, _conversion_parser)()
+    args = parser.parse_args(raw)
+    if mode == "batch":
+        try:
+            return _run_batch(args)
+        except (Ppt2PptxError, OSError) as exc:
+            print(f"ppt2pptx: error: {exc}", file=sys.stderr)
+            return 2
+    try:
+        limits = Limits(max_input_bytes=args.max_input_bytes)
+        password = _password(args)
+        if mode == "inspect":
+            result = inspect_ppt(args.input, limits=limits, password=password)
+            print(json.dumps(result, ensure_ascii=False, indent=2) if args.as_json else f"{result['slide_count']} slides; {result['text_box_count']} text boxes")
+            return 0
+        output = args.output or args.input.with_suffix(".pptx")
+        if args.report and (_same_path(args.report, args.input) or _same_path(args.report, output)):
+            print("ppt2pptx: error: report path would overwrite an input or output", file=sys.stderr)
+            return 2
+        result = convert(args.input, args.output, limits=limits, password=password)
+        if args.report:
+            write_json_file(args.report, result.report.to_dict())
+        print(f"Converted {args.input} -> {result.output_path} ({result.slide_count} slides)")
+        return 0
+    except (Ppt2PptxError, OSError) as exc:
+        print(f"ppt2pptx: error: {exc}", file=sys.stderr)
+        return 2
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ppt2pptx/converter.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from pathlib import Path
+
+from .cfb import CompoundFile, Limits
+from .diagnostics import ConversionReport
+from .encryption import decrypt_powerpoint_document
+from .errors import EncryptedPresentationError, InvalidPpt, UnsupportedPptVersionError, UnsafeOutputPathError
+from .ooxml import write_pptx
+from .oleps import read_summary_information
+from .ppt import Presentation, extract_presentation
+
+@dataclass(frozen=True, slots=True)
+class ConversionResult:
+    output_path: Path
+    report: ConversionReport
+    slide_count: int
+    presentation: Presentation
+
+def _load(source: str | Path, limits: Limits | None = None, report: ConversionReport | None = None, password: str | None = None) -> Presentation:
+    compound = CompoundFile.from_path(source, limits)
+    current_user = compound.open_stream("Current User")
+    document_stream = compound.open_stream("PowerPoint Document")
+    if len(current_user) >= 16 and current_user[12:16] == b"\xdf\xc4\xd1\xf3":
+        document_stream = decrypt_powerpoint_document(document_stream, current_user, password)
+        if report is not None and "encryptedsummary" in compound.by_name:
+            report.warning("ENCRYPTED_METADATA_OMITTED", "encrypted document properties were not copied")
+    if len(current_user) < 8 or current_user[2:4] != b"\xf6\x0f":
+        raise UnsupportedPptVersionError("PowerPoint 95 and earlier presentations are outside the PowerPoint 97–2003 format")
+    pictures = compound.open_stream("Pictures") if "pictures" in compound.by_name else None
+    presentation = extract_presentation(document_stream, pictures)
+    if "\x05summaryinformation" in compound.by_name:
+        try:
+            properties = read_summary_information(compound.open_stream("\x05SummaryInformation"))
+            presentation = replace(presentation, core_properties=properties)
+        except InvalidPpt as exc:
+            if report is not None:
+                report.warning("SUMMARY_INFORMATION_MALFORMED", "malformed optional presentation metadata was omitted", reason=str(exc))
+    return presentation
+
+def inspect_ppt(source: str | Path, *, limits: Limits | None = None, password: str | None = None) -> dict[str, object]:
+    presentation = _load(source, limits, password=password)
+    return {
+        "source": str(source),
+        "slide_count": len(presentation.slides),
+        "slide_size": {"width": presentation.width, "height": presentation.height},
+        "text_box_count": sum(len(slide.text_boxes) for slide in presentation.slides),
+        "picture_count": sum(len(slide.pictures) for slide in presentation.slides),
+        "shape_count": sum(len(slide.shapes) for slide in presentation.slides),
+        "comment_count": sum(len(slide.comments) for slide in presentation.slides),
+        "note_count": sum(len(slide.notes) for slide in presentation.slides),
+        "core_properties": {
+            name: value for name in presentation.core_properties.__dataclass_fields__
+            if (value := getattr(presentation.core_properties, name)) is not None
+        },
+        "slides": [
+            {
+                "index": i + 1,
+                "text_boxes": [
+                    {"text": box.text, "left": box.left, "top": box.top,
+                     "width": box.width, "height": box.height,
+                     "paragraph_alignments": box.paragraph_alignments,
+                     "paragraph_bullets": box.paragraph_bullets,
+                     "rotation": box.rotation, "flip_horizontal": box.flip_horizontal,
+                     "flip_vertical": box.flip_vertical,
+                     "runs": [
+                         {"text": run.text, "bold": run.bold, "italic": run.italic,
+                          "underline": run.underline, "font_size": run.font_size,
+                          "color": run.color, "typeface": run.typeface,
+                          "hyperlink": run.hyperlink}
+                         for run in box.runs
+                     ]}
+                    for box in slide.text_boxes
+                ],
+                "pictures": [
+                    {"extension": picture.extension, "content_type": picture.content_type,
+                     "byte_count": len(picture.data), "left": picture.left,
+                     "top": picture.top, "width": picture.width, "height": picture.height,
+                     "crop_left": picture.crop_left, "crop_top": picture.crop_top,
+                     "crop_right": picture.crop_right, "crop_bottom": picture.crop_bottom,
+                     "rotation": picture.rotation, "flip_horizontal": picture.flip_horizontal,
+                     "flip_vertical": picture.flip_vertical}
+                    for picture in slide.pictures
+                ],
+                "shapes": [
+                    {"preset": shape.preset, "left": shape.left, "top": shape.top,
+                     "width": shape.width, "height": shape.height,
+                     "fill_color": shape.fill_color, "line_color": shape.line_color,
+                     "rotation": shape.rotation, "flip_horizontal": shape.flip_horizontal,
+                     "flip_vertical": shape.flip_vertical}
+                    for shape in slide.shapes
+                ],
+                "background_color": slide.background_color,
+                "background_color_end": slide.background_color_end,
+                "hidden": slide.hidden,
+                "notes": list(slide.notes),
+                "header_footer": ({
+                    "date_text": slide.header_footer.date_text,
+                    "date_is_auto": slide.header_footer.date_is_auto,
+                    "header_text": slide.header_footer.header_text,
+                    "footer_text": slide.header_footer.footer_text,
+                    "show_slide_number": slide.header_footer.show_slide_number,
+                } if slide.header_footer else None),
+                "comments": [
+                    {"author": comment.author, "initials": comment.initials,
+                     "text": comment.text, "left": comment.left,
+                     "top": comment.top, "created": comment.created}
+                    for comment in slide.comments
+                ],
+            }
+            for i, slide in enumerate(presentation.slides)
+        ],
+    }
+
+def convert(source: str | Path, destination: str | Path | None = None, *, limits: Limits | None = None, password: str | None = None) -> ConversionResult:
+    source_path = Path(source)
+    output = Path(destination) if destination is not None else source_path.with_suffix(".pptx")
+    if output.suffix.casefold() != ".pptx": raise UnsafeOutputPathError("destination must use the .pptx extension")
+    if source_path.resolve() == output.resolve(): raise UnsafeOutputPathError("destination must not overwrite the source presentation")
+    report = ConversionReport(str(source_path), str(output))
+    presentation = _load(source_path, limits, report, password)
+    report.warning("ADVANCED_FEATURES_APPROXIMATED", "charts, animations, audio/video, and complex freeform master geometry may be omitted or approximated")
+    if not presentation.slides: report.warning("NO_SLIDES_FOUND", "no normal slide records could be recovered from the presentation")
+    elif any(not (slide.text_boxes or slide.pictures or slide.shapes or slide.header_footer or slide.notes)
+             for slide in presentation.slides):
+        report.warning("EMPTY_SLIDE_CONTENT", "one or more slides had no recoverable editable content")
+    write_pptx(output, presentation)
+    return ConversionResult(output, report, len(presentation.slides), presentation)

ppt2pptx/diagnostics.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import json
+from pathlib import Path
+
+
+@dataclass(slots=True)
+class ConversionReport:
+    source: str
+    destination: str | None = None
+    warnings: list[dict[str, object]] = field(default_factory=list)
+
+    def warning(self, code: str, message: str, **details: object) -> None:
+        self.warnings.append({"code": code, "message": message, **details})
+
+    def to_dict(self) -> dict[str, object]:
+        return {"source": self.source, "destination": self.destination,
+                "warning_count": len(self.warnings), "warnings": self.warnings}
+
+
+def write_json_file(path: str | Path, value: object) -> None:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    temporary = target.with_name(f".{target.name}.tmp")
+    temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    temporary.replace(target)

ppt2pptx/encryption.py

@@ -0,0 +1,153 @@
+"""RC4 CryptoAPI decryption for password-protected PowerPoint streams."""
+from __future__ import annotations
+
+import hashlib
+import hmac
+import struct
+
+from .errors import EncryptedPresentationError, InvalidPpt
+
+RT_USER_EDIT_ATOM = 4085
+RT_PERSIST_DIRECTORY_ATOM = 6002
+RT_DOCUMENT_ENCRYPTION_ATOM = 12052
+
+
+def _rc4(key: bytes, data: bytes) -> bytes:
+    if not key:
+        raise InvalidPpt("PowerPoint encryption key is empty")
+    state = list(range(256))
+    j = 0
+    for index in range(256):
+        j = (j + state[index] + key[index % len(key)]) & 0xFF
+        state[index], state[j] = state[j], state[index]
+    output = bytearray(len(data))
+    i = j = 0
+    for position, value in enumerate(data):
+        i = (i + 1) & 0xFF
+        j = (j + state[i]) & 0xFF
+        state[i], state[j] = state[j], state[i]
+        output[position] = value ^ state[(state[i] + state[j]) & 0xFF]
+    return bytes(output)
+
+
+def _cryptoapi_key(secret: bytes, block: int, key_bits: int) -> bytes:
+    digest = hashlib.sha1(secret + struct.pack("<I", block)).digest()
+    if key_bits == 40:
+        return digest[:5] + bytes(11)
+    return digest[: key_bits // 8]
+
+
+def _record(data: bytes, offset: int, expected_type: int | None = None) -> tuple[int, bytes]:
+    if offset < 0 or offset + 8 > len(data):
+        raise InvalidPpt("PowerPoint record offset is outside the document stream")
+    _, record_type, length = struct.unpack_from("<HHI", data, offset)
+    end = offset + 8 + length
+    if end > len(data):
+        raise InvalidPpt("PowerPoint record extends beyond the document stream")
+    if expected_type is not None and record_type != expected_type:
+        raise InvalidPpt(f"expected PowerPoint record {expected_type} at offset {offset}, found {record_type}")
+    return record_type, data[offset + 8:end]
+
+
+def _persist_mappings(data: bytes, current_user: bytes) -> tuple[dict[int, int], int]:
+    if len(current_user) < 20:
+        raise InvalidPpt("encrypted Current User stream is truncated")
+    user_edit_offset = struct.unpack_from("<I", current_user, 16)[0]
+    mappings: dict[int, int] = {}
+    encryption_persist_id: int | None = None
+    seen: set[int] = set()
+    while user_edit_offset:
+        if user_edit_offset in seen or len(seen) >= 4096:
+            raise InvalidPpt("PowerPoint user edit chain is cyclic or unbounded")
+        seen.add(user_edit_offset)
+        _, edit = _record(data, user_edit_offset, RT_USER_EDIT_ATOM)
+        if len(edit) not in (28, 32):
+            raise InvalidPpt("encrypted PowerPoint UserEditAtom has an invalid size")
+        previous_edit, persist_offset = struct.unpack_from("<II", edit, 8)
+        if encryption_persist_id is None and len(edit) == 32:
+            candidate = struct.unpack_from("<I", edit, 28)[0]
+            if candidate != 0xFFFFFFFF:
+                encryption_persist_id = candidate
+        _, persist = _record(data, persist_offset, RT_PERSIST_DIRECTORY_ATOM)
+        cursor = 0
+        while cursor < len(persist):
+            if cursor + 4 > len(persist):
+                raise InvalidPpt("PowerPoint persist directory is truncated")
+            info = struct.unpack_from("<I", persist, cursor)[0]
+            cursor += 4
+            count, first = info >> 20, info & 0xFFFFF
+            if not count or cursor + count * 4 > len(persist):
+                raise InvalidPpt("PowerPoint persist directory entry is invalid")
+            for index in range(count):
+                offset = struct.unpack_from("<I", persist, cursor)[0]
+                cursor += 4
+                mappings.setdefault(first + index, offset)
+        user_edit_offset = previous_edit
+    if encryption_persist_id is None:
+        raise InvalidPpt("encrypted PowerPoint file has no encryption session reference")
+    return mappings, encryption_persist_id
+
+
+def _encryption_parameters(payload: bytes, password: str) -> tuple[bytes, int]:
+    if len(payload) < 72:
+        raise InvalidPpt("PowerPoint encryption information is truncated")
+    major, minor, outer_flags, header_size = struct.unpack_from("<HHII", payload)
+    if (major, minor) not in ((2, 2), (3, 2), (4, 2)):
+        raise EncryptedPresentationError(f"unsupported PowerPoint encryption version {major}.{minor}")
+    header_end = 12 + header_size
+    if header_size < 32 or header_end + 60 > len(payload):
+        raise InvalidPpt("PowerPoint CryptoAPI encryption header is truncated")
+    flags, size_extra, algorithm_id, hash_id, key_bits, provider_type, _, reserved2 = struct.unpack_from(
+        "<8I", payload, 12
+    )
+    if flags != outer_flags or not flags & 0x04 or flags & 0x30:
+        raise InvalidPpt("PowerPoint CryptoAPI flags are inconsistent")
+    if size_extra != 0 or algorithm_id not in (0, 0x6801) or hash_id not in (0, 0x8004):
+        raise EncryptedPresentationError("unsupported PowerPoint CryptoAPI cipher or hash algorithm")
+    key_bits = key_bits or 40
+    if key_bits < 40 or key_bits > 128 or key_bits % 8 or provider_type not in (0, 1) or reserved2:
+        raise InvalidPpt("PowerPoint CryptoAPI key or provider fields are invalid")
+    salt_size = struct.unpack_from("<I", payload, header_end)[0]
+    if salt_size != 16:
+        raise InvalidPpt("PowerPoint CryptoAPI salt must contain 16 bytes")
+    salt = payload[header_end + 4:header_end + 20]
+    encrypted_verifier = payload[header_end + 20:header_end + 36]
+    hash_size = struct.unpack_from("<I", payload, header_end + 36)[0]
+    encrypted_hash = payload[header_end + 40:header_end + 60]
+    if hash_size != 20 or len(encrypted_hash) != 20:
+        raise InvalidPpt("PowerPoint CryptoAPI verifier hash is invalid")
+    secret = hashlib.sha1(salt + password[:255].encode("utf-16le")).digest()
+    verifier_data = _rc4(_cryptoapi_key(secret, 0, key_bits), encrypted_verifier + encrypted_hash)
+    if not hmac.compare_digest(hashlib.sha1(verifier_data[:16]).digest(), verifier_data[16:]):
+        raise EncryptedPresentationError("incorrect password for encrypted PowerPoint presentation")
+    return secret, key_bits
+
+
+def decrypt_powerpoint_document(data: bytes, current_user: bytes, password: str | None) -> bytes:
+    """Decrypt persisted records while leaving edit and directory records intact."""
+    if password is None:
+        raise EncryptedPresentationError("password-protected PowerPoint presentation; provide --password")
+    mappings, encryption_persist_id = _persist_mappings(data, current_user)
+    encryption_offset = mappings.get(encryption_persist_id)
+    if encryption_offset is None:
+        raise InvalidPpt("PowerPoint encryption record is missing from the persist directory")
+    _, encryption_payload = _record(data, encryption_offset, RT_DOCUMENT_ENCRYPTION_ATOM)
+    secret, key_bits = _encryption_parameters(encryption_payload, password)
+    output = bytearray(data)
+    occupied_until = 0
+    for persist_id, offset in sorted(mappings.items(), key=lambda item: item[1]):
+        if persist_id == encryption_persist_id:
+            continue
+        if offset < occupied_until:
+            continue
+        key = _cryptoapi_key(secret, persist_id, key_bits)
+        header = _rc4(key, data[offset:offset + 8])
+        if len(header) != 8:
+            raise InvalidPpt("encrypted PowerPoint record header is truncated")
+        length = struct.unpack_from("<I", header, 4)[0]
+        end = offset + 8 + length
+        if length > len(data) or end > len(data):
+            raise InvalidPpt("decrypted PowerPoint record has an invalid size")
+        output[offset:end] = _rc4(key, data[offset:end])
+        occupied_until = end
+    return bytes(output)

ppt2pptx/errors.py

@@ -0,0 +1,18 @@
+class Ppt2PptxError(Exception):
+    """Base error for expected conversion failures."""
+
+
+class InvalidPpt(Ppt2PptxError):
+    """The input is not a supported PowerPoint binary presentation."""
+
+
+class UnsafeOutputPathError(Ppt2PptxError):
+    """An output path could overwrite an input or has the wrong extension."""
+
+
+class EncryptedPresentationError(Ppt2PptxError):
+    """The presentation is encrypted and needs password support."""
+
+
+class UnsupportedPptVersionError(Ppt2PptxError):
+    """The file predates the PowerPoint 97 binary record format."""