smart redaction (#6195)

Co-authored-by: James Brunton <[email protected]>

app/core/src/main/java/stirling/software/SPDF/controller/api/EditTextController.java

@@ -39,7 +39,9 @@ import stirling.software.common.util.GeneralUtils;
 import stirling.software.common.util.TempFile;
 import stirling.software.common.util.TempFileManager;
 import stirling.software.common.util.WebResponseUtils;
-import stirling.software.common.util.propertyeditor.StringToArrayListPropertyEditor;
+import stirling.software.common.util.propertyeditor.JsonListPropertyEditor;
+
+import tools.jackson.core.type.TypeReference;
 
 /**
  * Find/replace text editing for PDFs. Round-trips through {@link PdfJsonConversionService}: the
@@ -73,7 +75,7 @@ public class EditTextController {
         binder.registerCustomEditor(
                 List.class,
                 "edits",
-                new StringToArrayListPropertyEditor<>(EditTextOperation.class));
+                new JsonListPropertyEditor<>(new TypeReference<List<EditTextOperation>>() {}));
     }
 
     @AutoJobPostMapping(

app/core/src/main/java/stirling/software/SPDF/controller/api/security/AllTextLineExtractor.java

@@ -0,0 +1,127 @@
+package stirling.software.SPDF.controller.api.security;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.text.PDFTextStripper;
+import org.apache.pdfbox.text.TextPosition;
+
+/**
+ * PDFTextStripper subclass that collects all text positions and groups them into line-level
+ * bounding boxes.
+ *
+ * <p>Two outputs are maintained in parallel:
+ *
+ * <ul>
+ *   <li>{@link #getLineBoxes()} returns {@code [x1, pdfYbottom, x2, pdfYtop]} in PDF user-space
+ *       (origin bottom-left, Y up). This is what existing callers expect.
+ *   <li>{@link #getScreenLineBoxes()} returns {@code [x1, screenYtop, x2, screenYbottom]} computed
+ *       directly from glyph positions without a PDF↔screen round-trip — used by column-aware
+ *       redaction where ulp-level drift in the round-trip caused false rejects against anchors.
+ * </ul>
+ *
+ * <p>Lines are flushed not only on Y jumps but also on large X gaps within the same Y row. That way
+ * left-column glyphs and right-column glyphs that happen to share a baseline (common in IEEE
+ * conference templates) get emitted as two distinct line boxes instead of one wide merged box.
+ */
+final class AllTextLineExtractor extends PDFTextStripper {
+
+    /** Min vertical jump (screen Y) before the next glyph is treated as a new line. */
+    private static final float LINE_Y_TOLERANCE = 3.0f;
+
+    /**
+     * Min horizontal gap (screen X) between consecutive glyphs on the same Y that indicates a
+     * column boundary. Chosen large enough to not split normal inter-word spacing (~6–10pt for 11pt
+     * text) but small enough to catch standard column gutters (typically ≥15pt).
+     */
+    private static final float COLUMN_GAP_X = 14f;
+
+    private final float pageHeight;
+    private final List<float[]> lineBoxes = new ArrayList<>();
+    private final List<float[]> screenLineBoxes = new ArrayList<>();
+
+    private final List<TextPosition> currentLine = new ArrayList<>();
+    private float lastScreenY = Float.NaN;
+    private float lastGlyphRight = Float.NaN;
+
+    AllTextLineExtractor(int pageNumber, float pageHeight) throws IOException {
+        this.pageHeight = pageHeight;
+        setStartPage(pageNumber);
+        setEndPage(pageNumber);
+        setSortByPosition(true);
+    }
+
+    List<float[]> getLineBoxes() {
+        return lineBoxes;
+    }
+
+    /**
+     * Returns line boxes as {@code [x1, screenYtop, x2, screenYbottom]}. {@code screenYtop} is the
+     * minimum {@code TextPosition.getY() - getHeight()} on the line and {@code screenYbottom} is
+     * the maximum {@code getY()} (the line's baseline). These values come straight from PDFBox
+     * without going through {@code pageHeight - …}, so they're stable for ulp-sensitive comparisons
+     * against anchor screen Ys.
+     */
+    List<float[]> getScreenLineBoxes() {
+        return screenLineBoxes;
+    }
+
+    @Override
+    protected void writeString(String text, List<TextPosition> positions) {
+        for (TextPosition tp : positions) {
+            // Skip whitespace-only positions (spaces, newline markers, indent characters).
+            // These have a TextPosition but no visible glyph; including them causes
+            // space-only "lines" to produce degenerate segments that appear as thin
+            // black bars after redaction.
+            String unicode = tp.getUnicode();
+            if (unicode == null || unicode.isBlank()) {
+                continue;
+            }
+            float screenY = tp.getY();
+            float screenX = tp.getX();
+            boolean yJump =
+                    !Float.isNaN(lastScreenY) && Math.abs(screenY - lastScreenY) > LINE_Y_TOLERANCE;
+            boolean xJump =
+                    !Float.isNaN(lastGlyphRight) && (screenX - lastGlyphRight) > COLUMN_GAP_X;
+            if (yJump || xJump) {
+                flushLine();
+            }
+            lastScreenY = screenY;
+            lastGlyphRight = screenX + tp.getWidth();
+            currentLine.add(tp);
+        }
+    }
+
+    @Override
+    protected void endPage(PDPage page) throws IOException {
+        flushLine();
+        super.endPage(page);
+    }
+
+    private void flushLine() {
+        if (currentLine.isEmpty()) {
+            return;
+        }
+        float minX = Float.MAX_VALUE, maxX = -Float.MAX_VALUE;
+        float minScreenY = Float.MAX_VALUE, maxScreenY = -Float.MAX_VALUE;
+        for (TextPosition tp : currentLine) {
+            minX = Math.min(minX, tp.getX());
+            maxX = Math.max(maxX, tp.getX() + tp.getWidth());
+            minScreenY = Math.min(minScreenY, tp.getY() - tp.getHeight());
+            maxScreenY = Math.max(maxScreenY, tp.getY());
+        }
+        emitSegment(minX, maxX, minScreenY, maxScreenY);
+        currentLine.clear();
+        lastScreenY = Float.NaN;
+        lastGlyphRight = Float.NaN;
+    }
+
+    private void emitSegment(float minX, float maxX, float minScreenY, float maxScreenY) {
+        float pdfY1 = pageHeight - maxScreenY; // bottom in PDF coords
+        float pdfY2 = pageHeight - minScreenY; // top in PDF coords
+        lineBoxes.add(new float[] {minX, pdfY1, maxX, pdfY2});
+        screenLineBoxes.add(new float[] {minX, minScreenY, maxX, maxScreenY});
+    }
+}

app/core/src/main/java/stirling/software/SPDF/controller/api/security/ManualRedactionService.java

@@ -0,0 +1,403 @@
+package stirling.software.SPDF.controller.api.security;
+
+import java.awt.Color;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.pdmodel.PDPageContentStream;
+import org.apache.pdfbox.pdmodel.PDPageTree;
+import org.apache.pdfbox.pdmodel.common.PDRectangle;
+import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotation;
+import org.springframework.stereotype.Service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+import stirling.software.SPDF.model.PDFText;
+import stirling.software.SPDF.model.api.security.ManualRedactPdfRequest;
+import stirling.software.SPDF.pdf.parser.PageImageLocator;
+import stirling.software.common.model.api.security.RedactionArea;
+import stirling.software.common.util.GeneralUtils;
+import stirling.software.common.util.PdfUtils;
+import stirling.software.common.util.TempFile;
+import stirling.software.common.util.TempFileManager;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+class ManualRedactionService {
+
+    private static final float DEFAULT_TEXT_PADDING_MULTIPLIER = 0.6f;
+    private static final float REDACTION_WIDTH_REDUCTION_FACTOR = 0.9f;
+
+    private final TempFileManager tempFileManager;
+
+    // -----------------------------------------------------------------------
+    // Area and page redaction
+    // -----------------------------------------------------------------------
+
+    void redactAreas(List<RedactionArea> redactionAreas, PDDocument document, PDPageTree allPages)
+            throws IOException {
+
+        if (redactionAreas == null || redactionAreas.isEmpty()) {
+            return;
+        }
+
+        Map<Integer, List<RedactionArea>> redactionsByPage = new HashMap<>();
+
+        for (RedactionArea redactionArea : redactionAreas) {
+            if (redactionArea.getPage() == null
+                    || redactionArea.getPage() <= 0
+                    || redactionArea.getHeight() == null
+                    || redactionArea.getHeight() <= 0.0D
+                    || redactionArea.getWidth() == null
+                    || redactionArea.getWidth() <= 0.0D) {
+                continue;
+            }
+
+            redactionsByPage
+                    .computeIfAbsent(redactionArea.getPage(), k -> new ArrayList<>())
+                    .add(redactionArea);
+        }
+
+        for (Map.Entry<Integer, List<RedactionArea>> entry : redactionsByPage.entrySet()) {
+            Integer pageNumber = entry.getKey();
+            List<RedactionArea> areasForPage = entry.getValue();
+
+            if (pageNumber > allPages.getCount()) {
+                continue;
+            }
+
+            PDPage page = allPages.get(pageNumber - 1);
+
+            try (PDPageContentStream contentStream =
+                    new PDPageContentStream(
+                            document, page, PDPageContentStream.AppendMode.APPEND, true, true)) {
+
+                contentStream.saveGraphicsState();
+                for (RedactionArea redactionArea : areasForPage) {
+                    Color redactColor = decodeOrDefault(redactionArea.getColor());
+
+                    contentStream.setNonStrokingColor(redactColor);
+
+                    float x = redactionArea.getX().floatValue();
+                    float y = redactionArea.getY().floatValue();
+                    float width = redactionArea.getWidth().floatValue();
+                    float height = redactionArea.getHeight().floatValue();
+
+                    float pdfY = page.getBBox().getHeight() - y - height;
+
+                    contentStream.addRect(x, pdfY, width, height);
+                    contentStream.fill();
+                }
+                contentStream.restoreGraphicsState();
+            }
+        }
+    }
+
+    void redactPages(ManualRedactPdfRequest request, PDDocument document, PDPageTree allPages)
+            throws IOException {
+
+        Color redactColor = decodeOrDefault(request.getPageRedactionColor());
+        List<Integer> pageNumbers = getPageNumbers(request, allPages.getCount());
+
+        for (Integer pageNumber : pageNumbers) {
+            PDPage page = allPages.get(pageNumber);
+
+            try (PDPageContentStream contentStream =
+                    new PDPageContentStream(
+                            document, page, PDPageContentStream.AppendMode.APPEND, true, true)) {
+                contentStream.setNonStrokingColor(redactColor);
+
+                PDRectangle box = page.getBBox();
+                contentStream.addRect(0, 0, box.getWidth(), box.getHeight());
+                contentStream.fill();
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Overlay drawing
+    // -----------------------------------------------------------------------
+
+    void redactFoundText(
+            PDDocument document,
+            List<PDFText> blocks,
+            float customPadding,
+            Color redactColor,
+            boolean isTextRemovalMode)
+            throws IOException {
+
+        var allPages = document.getDocumentCatalog().getPages();
+
+        Map<Integer, List<PDFText>> blocksByPage = new HashMap<>();
+        for (PDFText block : blocks) {
+            blocksByPage.computeIfAbsent(block.getPageIndex(), k -> new ArrayList<>()).add(block);
+        }
+
+        for (Map.Entry<Integer, List<PDFText>> entry : blocksByPage.entrySet()) {
+            Integer pageIndex = entry.getKey();
+            List<PDFText> pageBlocks = entry.getValue();
+
+            if (pageIndex >= allPages.getCount()) {
+                continue;
+            }
+
+            var page = allPages.get(pageIndex);
+            try (PDPageContentStream contentStream =
+                    new PDPageContentStream(
+                            document, page, PDPageContentStream.AppendMode.APPEND, true, true)) {
+
+                contentStream.saveGraphicsState();
+
+                try {
+                    contentStream.setNonStrokingColor(redactColor);
+                    PDRectangle pageBox = page.getBBox();
+
+                    for (PDFText block : pageBlocks) {
+                        float padding =
+                                (block.getY2() - block.getY1()) * DEFAULT_TEXT_PADDING_MULTIPLIER
+                                        + customPadding;
+
+                        float originalWidth = block.getX2() - block.getX1();
+                        float boxWidth;
+                        float boxX;
+
+                        if (isTextRemovalMode) {
+                            boxWidth = originalWidth * REDACTION_WIDTH_REDUCTION_FACTOR;
+                            float widthReduction = originalWidth - boxWidth;
+                            boxX = block.getX1() + (widthReduction / 2);
+                        } else {
+                            boxWidth = originalWidth;
+                            boxX = block.getX1();
+                        }
+
+                        contentStream.addRect(
+                                boxX,
+                                pageBox.getHeight() - block.getY2() - padding,
+                                boxWidth,
+                                block.getY2() - block.getY1() + 2 * padding);
+                    }
+
+                    contentStream.fill();
+
+                } finally {
+                    contentStream.restoreGraphicsState();
+                }
+            }
+
+            // Remove annotations whose bounding rect overlaps a redacted block, to prevent
+            // users from hovering over redacted URLs and seeing the underlying destination.
+            try {
+                float pageH = page.getBBox().getHeight();
+                List<PDAnnotation> kept = new ArrayList<>();
+                for (PDAnnotation ann : page.getAnnotations()) {
+                    PDRectangle ar = ann.getRectangle();
+                    boolean overlaps = false;
+                    if (ar != null) {
+                        for (PDFText block : pageBlocks) {
+                            float padding =
+                                    (block.getY2() - block.getY1())
+                                                    * DEFAULT_TEXT_PADDING_MULTIPLIER
+                                            + customPadding;
+                            float bx1 = block.getX1();
+                            float bx2 = block.getX2();
+                            float by1 = pageH - block.getY2() - padding;
+                            float by2 = pageH - block.getY1() + padding;
+                            if (ar.getLowerLeftX() < bx2
+                                    && ar.getUpperRightX() > bx1
+                                    && ar.getLowerLeftY() < by2
+                                    && ar.getUpperRightY() > by1) {
+                                overlaps = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (!overlaps) {
+                        kept.add(ann);
+                    }
+                }
+                page.setAnnotations(kept);
+            } catch (Exception e) {
+                log.debug(
+                        "[redact] could not remove annotations on page {}: {}",
+                        pageIndex,
+                        e.getMessage());
+            }
+        }
+    }
+
+    void redactImageBoxes(PDDocument document, List<float[]> imageBoxes, Color color)
+            throws IOException {
+        Map<Integer, List<float[]>> byPage = new HashMap<>();
+        for (float[] box : imageBoxes) {
+            byPage.computeIfAbsent((int) box[0], k -> new ArrayList<>()).add(box);
+        }
+        PDPageTree pages = document.getDocumentCatalog().getPages();
+        for (Map.Entry<Integer, List<float[]>> entry : byPage.entrySet()) {
+            int pageIdx = entry.getKey();
+            if (pageIdx < 0 || pageIdx >= pages.getCount()) {
+                log.warn("[redact/execute] image box references out-of-range page {}", pageIdx);
+                continue;
+            }
+            PDPage page = pages.get(pageIdx);
+            try (PDPageContentStream cs =
+                    new PDPageContentStream(
+                            document, page, PDPageContentStream.AppendMode.APPEND, true, true)) {
+                cs.saveGraphicsState();
+                cs.setNonStrokingColor(color);
+                for (float[] box : entry.getValue()) {
+                    float x1 = box[1], y1 = box[2], x2 = box[3], y2 = box[4];
+                    cs.addRect(x1, y1, x2 - x1, y2 - y1);
+                }
+                cs.fill();
+                cs.restoreGraphicsState();
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Page element extraction
+    // -----------------------------------------------------------------------
+
+    /**
+     * Returns bounding boxes for every text line and image on {@code page} in PDF user-space
+     * coordinates: {@code [x1, y1, x2, y2]} (origin bottom-left, Y increases upward).
+     */
+    List<float[]> extractPageElementBoxes(PDDocument document, PDPage page, int pageIndex)
+            throws IOException {
+        List<float[]> boxes = new ArrayList<>();
+
+        AllTextLineExtractor textExtractor =
+                new AllTextLineExtractor(pageIndex + 1, page.getBBox().getHeight());
+        textExtractor.getText(document);
+        boxes.addAll(textExtractor.getLineBoxes());
+
+        PageImageLocator imgLocator = new PageImageLocator(page, pageIndex);
+        imgLocator.processPage(page);
+        for (PageImageLocator.ImageBox imgBox : imgLocator.getImageBoxes()) {
+            boxes.add(new float[] {imgBox.x1(), imgBox.y1(), imgBox.x2(), imgBox.y2()});
+        }
+
+        return boxes;
+    }
+
+    // -----------------------------------------------------------------------
+    // Finalization
+    // -----------------------------------------------------------------------
+
+    TempFile finalizeRedaction(
+            PDDocument document,
+            Map<Integer, List<PDFText>> allFoundTextsByPage,
+            String colorString,
+            float customPadding,
+            Boolean convertToImage,
+            boolean isTextRemovalMode)
+            throws IOException {
+
+        List<PDFText> allFoundTexts = new ArrayList<>();
+        for (List<PDFText> pageTexts : allFoundTextsByPage.values()) {
+            allFoundTexts.addAll(pageTexts);
+        }
+
+        if (!allFoundTexts.isEmpty()) {
+            Color redactColor = decodeOrDefault(colorString);
+            redactFoundText(document, allFoundTexts, customPadding, redactColor, isTextRemovalMode);
+            cleanDocumentMetadata(document);
+        }
+
+        if (Boolean.TRUE.equals(convertToImage)) {
+            try (PDDocument convertedPdf = PdfUtils.convertPdfToPdfImage(document)) {
+                cleanDocumentMetadata(convertedPdf);
+
+                TempFile tempOut = tempFileManager.createManagedTempFile(".pdf");
+                try {
+                    convertedPdf.save(tempOut.getFile());
+                } catch (IOException e) {
+                    tempOut.close();
+                    throw e;
+                }
+
+                log.info(
+                        "Redaction finalized (image mode): {} pages ➜ {} KB",
+                        convertedPdf.getNumberOfPages(),
+                        tempOut.getFile().length() / 1024);
+
+                return tempOut;
+            }
+        }
+
+        TempFile tempOut = tempFileManager.createManagedTempFile(".pdf");
+        try {
+            document.save(tempOut.getFile());
+        } catch (IOException e) {
+            tempOut.close();
+            throw e;
+        }
+
+        log.info(
+                "Redaction finalized: {} pages ➜ {} KB",
+                document.getNumberOfPages(),
+                tempOut.getFile().length() / 1024);
+
+        return tempOut;
+    }
+
+    private void cleanDocumentMetadata(PDDocument document) {
+        try {
+            var documentInfo = document.getDocumentInformation();
+            if (documentInfo != null) {
+                documentInfo.setAuthor(null);
+                documentInfo.setSubject(null);
+                documentInfo.setKeywords(null);
+                documentInfo.setModificationDate(java.util.Calendar.getInstance());
+                log.debug("Cleaned document metadata for security");
+            }
+
+            if (document.getDocumentCatalog() != null) {
+                try {
+                    document.getDocumentCatalog().setMetadata(null);
+                } catch (Exception e) {
+                    log.debug("Could not clear XMP metadata: {}", e.getMessage());
+                }
+            }
+
+        } catch (Exception e) {
+            log.warn("Failed to clean document metadata: {}", e.getMessage());
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Utilities
+    // -----------------------------------------------------------------------
+
+    static Color decodeOrDefault(String hex) {
+        if (hex == null) {
+            return Color.BLACK;
+        }
+
+        String colorString = hex.startsWith("#") ? hex : "#" + hex;
+
+        try {
+            return Color.decode(colorString);
+        } catch (NumberFormatException e) {
+            return Color.BLACK;
+        }
+    }
+
+    private List<Integer> getPageNumbers(ManualRedactPdfRequest request, int pagesCount) {
+        String pageNumbersInput = request.getPageNumbers();
+        String[] parsedPageNumbers =
+                pageNumbersInput != null ? pageNumbersInput.split(",") : new String[0];
+        List<Integer> pageNumbers =
+                GeneralUtils.parsePageList(parsedPageNumbers, pagesCount, false);
+        Collections.sort(pageNumbers);
+        return pageNumbers;
+    }
+}

app/core/src/main/java/stirling/software/SPDF/controller/api/security/MultiPatternTextFinder.java

@@ -0,0 +1,174 @@
+package stirling.software.SPDF.controller.api.security;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.text.PDFTextStripper;
+import org.apache.pdfbox.text.TextPosition;
+
+import lombok.extern.slf4j.Slf4j;
+
+import stirling.software.SPDF.model.PDFText;
+
+/**
+ * Scans a PDF document once and matches all provided patterns in a single pass, collecting
+ * bounding-box positions for every match. Use in place of creating one {@code TextFinder} per
+ * search term to avoid O(n) full-document scans.
+ */
+@Slf4j
+final class MultiPatternTextFinder extends PDFTextStripper {
+
+    private static final long REGEX_MATCH_TIMEOUT_SECONDS = 30;
+    private static final ExecutorService REGEX_EXECUTOR =
+            Executors.newVirtualThreadPerTaskExecutor();
+
+    private final List<Pattern> patterns;
+    private final Map<Integer, List<PDFText>> foundTextsByPage = new HashMap<>();
+
+    private final List<TextPosition> pageTextPositions = new ArrayList<>();
+    private final StringBuilder pageTextBuilder = new StringBuilder();
+
+    MultiPatternTextFinder(List<Pattern> patterns) throws IOException {
+        this.patterns = patterns;
+        this.setWordSeparator(" ");
+        this.setLineSeparator("\n");
+    }
+
+    Map<Integer, List<PDFText>> getFoundTextsByPage() {
+        return foundTextsByPage;
+    }
+
+    @Override
+    protected void startPage(PDPage page) throws IOException {
+        super.startPage(page);
+        pageTextPositions.clear();
+        pageTextBuilder.setLength(0);
+    }
+
+    @Override
+    protected void writeString(String text, List<TextPosition> textPositions) {
+        pageTextBuilder.append(text);
+        pageTextPositions.addAll(textPositions);
+    }
+
+    @Override
+    protected void writeWordSeparator() {
+        pageTextBuilder.append(getWordSeparator());
+        pageTextPositions.add(null);
+    }
+
+    @Override
+    protected void writeLineSeparator() {
+        pageTextBuilder.append(getLineSeparator());
+        pageTextPositions.add(null);
+    }
+
+    @Override
+    protected void endPage(PDPage page) throws IOException {
+        String text = pageTextBuilder.toString();
+        if (!text.isEmpty()) {
+            int pageIndex = getCurrentPageNo() - 1;
+            for (Pattern pattern : patterns) {
+                Matcher matcher = pattern.matcher(text);
+                while (safeFind(matcher)) {
+                    PDFText pdfText = resolveMatchPosition(matcher, pageIndex);
+                    if (pdfText != null) {
+                        foundTextsByPage
+                                .computeIfAbsent(pageIndex, k -> new ArrayList<>())
+                                .add(pdfText);
+                    }
+                }
+            }
+        }
+        super.endPage(page);
+    }
+
+    /**
+     * Wraps a single {@code matcher.find()} call with a {@value #REGEX_MATCH_TIMEOUT_SECONDS}
+     * second timeout. Prevents pathological regex backtracking from blocking the request
+     * indefinitely; per-match timeout so fast legitimate scans are unaffected.
+     */
+    private static boolean safeFind(Matcher matcher) throws IOException {
+        Future<Boolean> future =
+                REGEX_EXECUTOR.submit((java.util.concurrent.Callable<Boolean>) matcher::find);
+        try {
+            return future.get(REGEX_MATCH_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+        } catch (TimeoutException e) {
+            future.cancel(true);
+            throw new IOException(
+                    "Regex match timed out after "
+                            + REGEX_MATCH_TIMEOUT_SECONDS
+                            + "s — pattern may cause catastrophic backtracking");
+        } catch (InterruptedException e) {
+            future.cancel(true);
+            Thread.currentThread().interrupt();
+            throw new IOException("Regex match interrupted", e);
+        } catch (ExecutionException e) {
+            Throwable cause = e.getCause();
+            if (cause instanceof IOException ioEx) throw ioEx;
+            throw new IOException("Regex match failed: " + cause.getMessage(), cause);
+        }
+    }
+
+    private PDFText resolveMatchPosition(Matcher matcher, int pageIndex) {
+        int matchStart = matcher.start();
+        int matchEnd = matcher.end();
+
+        float minX = Float.MAX_VALUE;
+        float minY = Float.MAX_VALUE;
+        float maxX = Float.MIN_VALUE;
+        float maxY = Float.MIN_VALUE;
+        boolean foundPosition = false;
+
+        for (int i = matchStart; i < matchEnd; i++) {
+            if (i >= pageTextPositions.size()) break;
+            TextPosition pos = pageTextPositions.get(i);
+            if (pos != null) {
+                foundPosition = true;
+                minX = Math.min(minX, pos.getX());
+                maxX = Math.max(maxX, pos.getX() + pos.getWidth());
+                minY = Math.min(minY, pos.getY() - pos.getHeight());
+                maxY = Math.max(maxY, pos.getY());
+            }
+        }
+
+        if (!foundPosition && matchStart < pageTextPositions.size()) {
+            for (int i = Math.max(0, matchStart - 5);
+                    i < Math.min(pageTextPositions.size(), matchEnd + 5);
+                    i++) {
+                TextPosition pos = pageTextPositions.get(i);
+                if (pos != null) {
+                    foundPosition = true;
+                    minX = Math.min(minX, pos.getX());
+                    maxX = Math.max(maxX, pos.getX() + pos.getWidth());
+                    minY = Math.min(minY, pos.getY() - pos.getHeight());
+                    maxY = Math.max(maxY, pos.getY());
+                    break;
+                }
+            }
+        }
+
+        if (!foundPosition) {
+            log.warn(
+                    "Found text match '{}' but no valid position data at {}-{}",
+                    matcher.group(),
+                    matchStart,
+                    matchEnd);
+            return null;
+        }
+
+        return new PDFText(pageIndex, minX, minY, maxX, maxY, matcher.group());
+    }
+}

app/core/src/main/java/stirling/software/SPDF/controller/api/security/RedactExecuteService.java

@@ -0,0 +1,850 @@
+package stirling.software.SPDF.controller.api.security;
+
+import java.awt.Color;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+import org.apache.pdfbox.cos.COSName;
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.pdmodel.PDPageContentStream;
+import org.apache.pdfbox.pdmodel.PDPageTree;
+import org.apache.pdfbox.pdmodel.PDResources;
+import org.apache.pdfbox.pdmodel.common.PDRectangle;
+import org.springframework.stereotype.Service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+import stirling.software.SPDF.model.PDFText;
+import stirling.software.SPDF.model.api.security.RedactExecuteRequest;
+import stirling.software.SPDF.model.api.security.RedactExecuteRequest.ImageBox;
+import stirling.software.SPDF.model.api.security.RedactExecuteRequest.RedactStyle;
+import stirling.software.SPDF.model.api.security.RedactExecuteRequest.TextRange;
+import stirling.software.SPDF.pdf.parser.PageColumnLayout;
+import stirling.software.SPDF.pdf.parser.PageImageLocator;
+import stirling.software.common.service.CustomPDFDocumentFactory;
+import stirling.software.common.util.ExceptionUtils;
+import stirling.software.common.util.TempFile;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+class RedactExecuteService {
+
+    private final CustomPDFDocumentFactory pdfDocumentFactory;
+    private final ManualRedactionService manualRedactionService;
+    private final TextRedactionService textRedactionService;
+
+    TempFile execute(RedactExecuteRequest request) throws IOException {
+        RedactStyle style = request.getStyle() != null ? request.getStyle() : new RedactStyle();
+        List<String> textValues = orEmpty(request.getTextValues());
+        List<String> regexPatterns = orEmpty(request.getRegexPatterns());
+        List<Integer> wipePages = orEmpty(request.getWipePages());
+        List<TextRange> ranges = orEmpty(request.getRanges());
+        List<ImageBox> imageBoxes = orEmpty(request.getImageBoxes());
+
+        boolean hasTargets =
+                !textValues.isEmpty()
+                        || !regexPatterns.isEmpty()
+                        || !wipePages.isEmpty()
+                        || !ranges.isEmpty()
+                        || !imageBoxes.isEmpty()
+                        || request.getRedactImagePages() != null;
+
+        if (!hasTargets) {
+            throw ExceptionUtils.createIllegalArgumentException(
+                    "error.redaction.no.targets", "No redaction targets provided");
+        }
+
+        boolean overlayOnly =
+                RedactExecuteRequest.RedactionStrategy.OVERLAY_ONLY.equals(style.getStrategy());
+        boolean imageFinalize =
+                RedactExecuteRequest.RedactionStrategy.IMAGE_FINALIZE.equals(style.getStrategy());
+        boolean convertToImage = imageFinalize || style.isConvertToImage();
+
+        boolean hasTextOps = !textValues.isEmpty() || !regexPatterns.isEmpty();
+
+        log.info(
+                "[redact/execute] strategy={} textValues={} regexPatterns={} wipePages={} ranges={} imageBoxes={} imagePages={}",
+                style.getStrategy(),
+                textValues.size(),
+                regexPatterns.size(),
+                wipePages.size(),
+                ranges.size(),
+                imageBoxes.size(),
+                request.getRedactImagePages());
+
+        if (request.getFileInput() == null) {
+            throw ExceptionUtils.createFileNullOrEmptyException();
+        }
+
+        PDDocument document = null;
+        try {
+            document = pdfDocumentFactory.load(request.getFileInput());
+
+            // Single-pass text scan: collect all text-based targets so we run the PDF
+            // stripper only once across the entire execute() call rather than once per target.
+            Map<Integer, List<PDFText>> foundTexts =
+                    hasTextOps ? collectTextMatches(document, request) : new HashMap<>();
+
+            int totalMatches = foundTexts.values().stream().mapToInt(List::size).sum();
+            log.info(
+                    "[redact/execute] scan complete: {} text matches across {} pages",
+                    totalMatches,
+                    foundTexts.size());
+
+            // Text removal (content-stream rewriting) — skipped in overlay-only mode.
+            boolean needsOverlayOnly = overlayOnly;
+            if (hasTextOps && !foundTexts.isEmpty() && !overlayOnly) {
+                needsOverlayOnly = applyTextRemoval(document, request);
+            } else if (overlayOnly) {
+                log.info(
+                        "[redact/execute] overlay-only mode requested — skipping content-stream rewriting");
+            }
+
+            // Reload fresh document on fallback so we overlay onto clean content.
+            if (needsOverlayOnly && !foundTexts.isEmpty()) {
+                log.info("[redact/execute] reloading document for clean overlay pass");
+                document.close();
+                document = pdfDocumentFactory.load(request.getFileInput());
+                foundTexts.clear();
+                if (hasTextOps) {
+                    foundTexts.putAll(collectTextMatches(document, request));
+                }
+            }
+
+            // Non-text operations.
+            Map<Integer, PageColumnLayout> layoutCache = new HashMap<>();
+
+            if (!wipePages.isEmpty()) {
+                applyPageWipe(document, wipePages, style);
+            }
+
+            for (TextRange range : ranges) {
+                applyRangeRedaction(document, range, style, layoutCache);
+            }
+
+            for (ImageBox box : imageBoxes) {
+                applyImageBoxRedaction(document, box, style);
+            }
+
+            if (request.getRedactImagePages() != null) {
+                applyAllImagesRedaction(document, request.getRedactImagePages(), style);
+            }
+
+            return manualRedactionService.finalizeRedaction(
+                    document,
+                    foundTexts,
+                    style.getColor(),
+                    style.getPadding(),
+                    convertToImage,
+                    !needsOverlayOnly);
+
+        } catch (Exception e) {
+            log.error("Execute redaction failed: {}", e.getMessage(), e);
+            throw new RuntimeException("Failed to perform PDF redaction: " + e.getMessage(), e);
+        } finally {
+            if (document != null) {
+                try {
+                    document.close();
+                } catch (IOException e) {
+                    log.warn("Failed to close document: {}", e.getMessage());
+                }
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Single-pass text scan (one stripper pass per execute() call)
+    // -----------------------------------------------------------------------
+
+    /**
+     * Runs a single PDF text-stripper pass over all text-based targets and returns the merged hit
+     * map.
+     */
+    private Map<Integer, List<PDFText>> collectTextMatches(
+            PDDocument document, RedactExecuteRequest request) {
+        Map<Integer, List<PDFText>> found = new HashMap<>();
+
+        String[] terms = cleanStrings(request.getTextValues());
+        if (terms.length > 0) {
+            textRedactionService
+                    .findTextToRedact(document, terms, false, false)
+                    .forEach(
+                            (page, hits) ->
+                                    found.computeIfAbsent(page, k -> new ArrayList<>())
+                                            .addAll(hits));
+        }
+
+        String[] patterns = cleanStrings(request.getRegexPatterns());
+        if (patterns.length > 0) {
+            textRedactionService
+                    .findTextToRedact(document, patterns, true, false)
+                    .forEach(
+                            (page, hits) ->
+                                    found.computeIfAbsent(page, k -> new ArrayList<>())
+                                            .addAll(hits));
+        }
+
+        return found;
+    }
+
+    // -----------------------------------------------------------------------
+    // Text removal (content-stream rewriting)
+    // -----------------------------------------------------------------------
+
+    /**
+     * Attempts content-stream text removal for all text/regex targets. Returns {@code true} if the
+     * document fell back to overlay-only mode.
+     */
+    private boolean applyTextRemoval(PDDocument document, RedactExecuteRequest request) {
+        try {
+            boolean fallback = false;
+
+            String[] terms = cleanStrings(request.getTextValues());
+            if (terms.length > 0) {
+                Map<Integer, List<PDFText>> exactFound =
+                        textRedactionService.findTextToRedact(document, terms, false, false);
+                if (!exactFound.isEmpty()) {
+                    fallback |=
+                            textRedactionService.performTextReplacement(
+                                    document, exactFound, terms, false, false);
+                }
+            }
+
+            String[] patterns = cleanStrings(request.getRegexPatterns());
+            if (patterns.length > 0) {
+                Map<Integer, List<PDFText>> regexFound =
+                        textRedactionService.findTextToRedact(document, patterns, true, false);
+                if (!regexFound.isEmpty()) {
+                    fallback |=
+                            textRedactionService.performTextReplacement(
+                                    document, regexFound, patterns, true, false);
+                }
+            }
+
+            if (fallback) {
+                log.warn(
+                        "[redact/execute] font compatibility issue — falling back to overlay-only");
+            } else {
+                log.info("[redact/execute] content-stream text removal applied successfully");
+            }
+            return fallback;
+        } catch (Exception e) {
+            log.warn(
+                    "[redact/execute] text removal failed, falling back to overlay: {}",
+                    e.getMessage());
+            return true;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Per-operation dispatch methods
+    // -----------------------------------------------------------------------
+
+    private void applyPageWipe(PDDocument document, List<Integer> pageNumbers, RedactStyle style)
+            throws IOException {
+        List<Integer> pageIndices = toZeroBasedIndices(pageNumbers);
+        if (pageIndices.isEmpty()) return;
+
+        PDPageTree allPages = document.getDocumentCatalog().getPages();
+        Color pageColor = ManualRedactionService.decodeOrDefault(style.getColor());
+        Collections.sort(pageIndices);
+        log.info("[redact/execute] full-page wipe: {} pages ({})", pageIndices.size(), pageIndices);
+
+        Map<Integer, List<float[]>> pageElementBoxes = new HashMap<>();
+        for (Integer idx : pageIndices) {
+            if (idx >= 0 && idx < allPages.getCount()) {
+                try {
+                    pageElementBoxes.put(
+                            idx,
+                            manualRedactionService.extractPageElementBoxes(
+                                    document, allPages.get(idx), idx));
+                } catch (Exception e) {
+                    log.warn(
+                            "[redact/execute] element extraction failed for page {}: {}",
+                            idx,
+                            e.getMessage());
+                }
+            }
+        }
+
+        for (Integer idx : pageIndices) {
+            if (idx >= 0 && idx < allPages.getCount()) {
+                PDPage page = allPages.get(idx);
+                List<float[]> elementBoxes =
+                        pageElementBoxes.getOrDefault(idx, Collections.emptyList());
+                page.getCOSObject().removeItem(COSName.CONTENTS);
+                page.setResources(new PDResources());
+                try (PDPageContentStream cs = new PDPageContentStream(document, page)) {
+                    cs.setNonStrokingColor(pageColor);
+                    if (elementBoxes.isEmpty()) {
+                        PDRectangle box = page.getBBox();
+                        cs.addRect(0, 0, box.getWidth(), box.getHeight());
+                    } else {
+                        log.info(
+                                "[redact/execute] page {}: drawing {} element boxes",
+                                idx + 1,
+                                elementBoxes.size());
+                        for (float[] r : elementBoxes) {
+                            cs.addRect(r[0], r[1], r[2] - r[0], r[3] - r[1]);
+                        }
+                    }
+                    cs.fill();
+                }
+            }
+        }
+    }
+
+    private void applyRangeRedaction(
+            PDDocument document,
+            TextRange range,
+            RedactStyle style,
+            Map<Integer, PageColumnLayout> layoutCache)
+            throws IOException {
+        String rangeStart = trimOrEmpty(range.startString());
+        String rangeEnd = trimOrEmpty(range.endString());
+        log.info("[redact/execute] range redaction: start='{}' end='{}'", rangeStart, rangeEnd);
+        try {
+            List<PDFText> blocks = collectRangeBlocks(document, rangeStart, rangeEnd, layoutCache);
+            if (!blocks.isEmpty()) {
+                manualRedactionService.redactFoundText(
+                        document,
+                        blocks,
+                        style.getPadding(),
+                        ManualRedactionService.decodeOrDefault(style.getColor()),
+                        false);
+            } else {
+                log.warn(
+                        "[redact/execute] range not found: start='{}' end='{}'",
+                        rangeStart,
+                        rangeEnd);
+            }
+        } catch (Exception e) {
+            log.warn("[redact/execute] range redaction failed: {}", e.getMessage());
+        }
+    }
+
+    private void applyImageBoxRedaction(PDDocument document, ImageBox box, RedactStyle style)
+            throws IOException {
+        List<float[]> boxes =
+                List.of(
+                        new float[] {
+                            (float) box.pageIndex(), box.x1(), box.y1(), box.x2(), box.y2()
+                        });
+        log.info("[redact/execute] image box overlay on page {}", box.pageIndex());
+        Color boxColor = ManualRedactionService.decodeOrDefault(style.getColor());
+        manualRedactionService.redactImageBoxes(document, boxes, boxColor);
+    }
+
+    private void applyAllImagesRedaction(
+            PDDocument document, List<Integer> pageNumbers, RedactStyle style) throws IOException {
+        PDPageTree allPages = document.getDocumentCatalog().getPages();
+        Color imgColor = ManualRedactionService.decodeOrDefault(style.getColor());
+
+        List<Integer> imagePageIndices = toZeroBasedIndices(pageNumbers);
+        if (imagePageIndices.isEmpty()) {
+            imagePageIndices = new ArrayList<>();
+            for (int i = 0; i < allPages.getCount(); i++) {
+                imagePageIndices.add(i);
+            }
+        }
+
+        List<float[]> detectedBoxes = new ArrayList<>();
+        for (int pageIdx : imagePageIndices) {
+            if (pageIdx < 0 || pageIdx >= allPages.getCount()) continue;
+            try {
+                PDPage page = allPages.get(pageIdx);
+                PageImageLocator locator = new PageImageLocator(page, pageIdx);
+                locator.processPage(page);
+                for (PageImageLocator.ImageBox ib : locator.getImageBoxes()) {
+                    detectedBoxes.add(new float[] {pageIdx, ib.x1(), ib.y1(), ib.x2(), ib.y2()});
+                }
+            } catch (Exception e) {
+                log.warn(
+                        "[redact/execute] image detection failed for page {}: {}",
+                        pageIdx + 1,
+                        e.getMessage());
+            }
+        }
+
+        log.info(
+                "[redact/execute] auto image detection: {} images across {} pages",
+                detectedBoxes.size(),
+                imagePageIndices.size());
+
+        if (!detectedBoxes.isEmpty()) {
+            manualRedactionService.redactImageBoxes(document, detectedBoxes, imgColor);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Range collection helpers
+    // -----------------------------------------------------------------------
+
+    /**
+     * Locates {@code startStr} in the document and returns {@link PDFText} blocks for every text
+     * line and image from that point up to (but NOT including) the line where {@code endStr}
+     * begins. If {@code endStr} is blank, redacts from {@code startStr} to the end of the document.
+     *
+     * <p>Multi-column pages follow reading order: down the start column, jump to the top of the
+     * next column, continue to the end anchor. Single-column pages reduce to a plain Y-band check.
+     */
+    List<PDFText> collectRangeBlocks(
+            PDDocument document,
+            String startStr,
+            String endStr,
+            Map<Integer, PageColumnLayout> layoutCache)
+            throws IOException {
+
+        PDPageTree allPages = document.getDocumentCatalog().getPages();
+        int totalPages = allPages.getCount();
+
+        Map<Integer, List<PDFText>> startMatchesByPage = findWithFallbacks(document, startStr);
+        if (startMatchesByPage.isEmpty()) {
+            log.warn("[redact/execute] range start not found: '{}'", startStr);
+            return Collections.emptyList();
+        }
+
+        List<Anchor> starts = toAnchors(document, startMatchesByPage, layoutCache);
+        starts.sort(READING_ORDER);
+        log.info(
+                "[redact/execute] start='{}' matched {} anchor(s): {}",
+                startStr,
+                starts.size(),
+                anchorSummary(starts));
+
+        boolean openEnded = (endStr == null || endStr.isBlank());
+        List<Anchor> ends = new ArrayList<>();
+        if (!openEnded) {
+            Map<Integer, List<PDFText>> endMatchesByPage = findWithFallbacks(document, endStr);
+            if (endMatchesByPage.isEmpty()) {
+                log.warn(
+                        "[redact/execute] range end '{}' not found in document - skipping range"
+                                + " (start='{}')",
+                        endStr,
+                        startStr);
+                return Collections.emptyList();
+            }
+            ends = toAnchors(document, endMatchesByPage, layoutCache);
+            ends.sort(READING_ORDER);
+            log.info(
+                    "[redact/execute] end='{}' matched {} anchor(s): {}",
+                    endStr,
+                    ends.size(),
+                    anchorSummary(ends));
+        }
+
+        List<PDFText> blocks = new ArrayList<>();
+        for (Anchor start : starts) {
+            Anchor end = null;
+            int endPage;
+            if (openEnded) {
+                endPage = totalPages - 1;
+            } else {
+                for (Anchor candidate : ends) {
+                    if (READING_ORDER.compare(candidate, start) > 0) {
+                        end = candidate;
+                        break;
+                    }
+                }
+                if (end == null) {
+                    log.warn(
+                            "[redact/execute] no end anchor after start at (page={}, col={}, y={}) — skipping",
+                            start.page + 1,
+                            start.col,
+                            start.y);
+                    continue;
+                }
+                endPage = end.page;
+            }
+
+            log.info(
+                    "[redact/execute] range pages {}-{}: start='{}' (col {}) end='{}'",
+                    start.page + 1,
+                    endPage + 1,
+                    startStr,
+                    start.col,
+                    openEnded ? "<end of document>" : endStr);
+
+            collectBlocksForRange(document, allPages, start, end, openEnded, blocks, layoutCache);
+        }
+
+        log.info(
+                "[redact/execute] range '{}'→'{}': {} total blocks",
+                startStr,
+                openEnded ? "<end of document>" : endStr,
+                blocks.size());
+        return blocks;
+    }
+
+    /**
+     * Collects all redactable content (text line segments and images) between two anchor positions.
+     *
+     * <p>Line boxes are cached per page number in {@code lineBoxCache} and reused across range
+     * iterations within one execute() call, avoiding redundant {@link AllTextLineExtractor} passes.
+     */
+    private void collectBlocksForRange(
+            PDDocument document,
+            PDPageTree allPages,
+            Anchor start,
+            Anchor end,
+            boolean openEnded,
+            List<PDFText> blocks,
+            Map<Integer, PageColumnLayout> layoutCache)
+            throws IOException {
+
+        int startPage = start.page;
+        int endPage = openEnded ? allPages.getCount() - 1 : end.page;
+        int endCol =
+                openEnded ? layoutFor(document, endPage, layoutCache).columnCount() - 1 : end.col;
+        float startY = start.y;
+        // Use bottom of end anchor so the end anchor line itself is included (inclusive range).
+        float endY = openEnded ? Float.POSITIVE_INFINITY : end.text.getY2();
+
+        // Line-box cache: populated lazily per page, reused across range iterations.
+        // Cannot use computeIfAbsent because AllTextLineExtractor's constructor throws IOException.
+        Map<Integer, List<float[]>> lineBoxCache = new HashMap<>();
+
+        for (int pageIdx = startPage; pageIdx <= endPage; pageIdx++) {
+            PDPage page = allPages.get(pageIdx);
+            float pageHeight = page.getBBox().getHeight();
+            PageColumnLayout layout = layoutFor(document, pageIdx, layoutCache);
+
+            List<float[]> screenLineBoxes = lineBoxCache.get(pageIdx);
+            if (screenLineBoxes == null) {
+                AllTextLineExtractor textExtractor =
+                        new AllTextLineExtractor(pageIdx + 1, pageHeight);
+                textExtractor.getText(document);
+                screenLineBoxes = textExtractor.getScreenLineBoxes();
+                lineBoxCache.put(pageIdx, screenLineBoxes);
+            }
+
+            for (float[] sb : screenLineBoxes) {
+                emitColumnSlices(
+                        pageIdx, layout, sb[0], sb[2], sb[1], sb[3], start.col, startPage, startY,
+                        endCol, endPage, endY, blocks);
+            }
+
+            PageImageLocator imgLocator = new PageImageLocator(page, pageIdx);
+            imgLocator.processPage(page);
+            for (PageImageLocator.ImageBox ib : imgLocator.getImageBoxes()) {
+                // ImageBox coordinates are in PDF user-space (Y up); convert to screen-Y (Y down).
+                float screenY1 = pageHeight - ib.y2();
+                float screenY2 = pageHeight - ib.y1();
+                emitColumnSlices(
+                        pageIdx, layout, ib.x1(), ib.x2(), screenY1, screenY2, start.col, startPage,
+                        startY, endCol, endPage, endY, blocks);
+            }
+        }
+    }
+
+    /** Emits each per-column sub-box accepted by the reading-order predicate. */
+    private static void emitColumnSlices(
+            int pageIdx,
+            PageColumnLayout layout,
+            float x1,
+            float x2,
+            float yTop,
+            float yBottom,
+            int startCol,
+            int startPage,
+            float startY,
+            int endCol,
+            int endPage,
+            float endY,
+            List<PDFText> blocks) {
+        int[] cols = layout.columnsCrossing(x1, x2);
+        if (cols.length == 1) {
+            if (inColumnZone(
+                    pageIdx, cols[0], yTop, yBottom, startPage, startCol, startY, endPage, endCol,
+                    endY)) {
+                blocks.add(new PDFText(pageIdx, x1, yTop, x2, yBottom, ""));
+            }
+            return;
+        }
+        for (int col : cols) {
+            if (!inColumnZone(
+                    pageIdx, col, yTop, yBottom, startPage, startCol, startY, endPage, endCol,
+                    endY)) {
+                return;
+            }
+        }
+        blocks.add(new PDFText(pageIdx, x1, yTop, x2, yBottom, ""));
+    }
+
+    /**
+     * Reading-order predicate: true when (col, yBottom) on page {@code pageIdx} sits between the
+     * start anchor (inclusive) and end anchor (inclusive).
+     */
+    static boolean inColumnZone(
+            int pageIdx,
+            int col,
+            float yTop,
+            float yBottom,
+            int startPage,
+            int startCol,
+            float startY,
+            int endPage,
+            int endCol,
+            float endY) {
+        if (pageIdx > startPage && pageIdx < endPage) return true;
+        if (pageIdx == startPage && pageIdx == endPage) {
+            if (startCol == endCol) {
+                return col == startCol && yBottom >= startY && yBottom <= endY;
+            }
+            if (startCol < endCol) {
+                if (col < startCol || col > endCol) return false;
+                if (col == startCol) return yBottom >= startY;
+                if (col == endCol) return yBottom <= endY;
+                return true;
+            }
+            return col == startCol && yBottom >= startY;
+        }
+        if (pageIdx == startPage) {
+            if (col == startCol) return yBottom >= startY;
+            return col > startCol;
+        }
+        if (pageIdx == endPage) {
+            if (col == endCol) return yBottom <= endY;
+            return col < endCol;
+        }
+        return false;
+    }
+
+    /** Lazily builds and caches the column layout for a single page. */
+    private PageColumnLayout layoutFor(
+            PDDocument document, int pageIdx, Map<Integer, PageColumnLayout> cache)
+            throws IOException {
+        PageColumnLayout cached = cache.get(pageIdx);
+        if (cached != null) return cached;
+        PDPage page = document.getDocumentCatalog().getPages().get(pageIdx);
+        float pageWidth = page.getBBox().getWidth();
+        float pageHeight = page.getBBox().getHeight();
+        AllTextLineExtractor extractor = new AllTextLineExtractor(pageIdx + 1, pageHeight);
+        extractor.getText(document);
+        PageColumnLayout layout =
+                PageColumnLayout.fromLineBoxes(extractor.getLineBoxes(), pageWidth);
+        if (layout.columnCount() > 1) {
+            float[] g = layout.gutters().get(0);
+            log.info(
+                    "[redact/execute] page {} layout: 2 cols, gutter x=[{}, {}]",
+                    pageIdx + 1,
+                    g[0],
+                    g[1]);
+        } else {
+            log.info("[redact/execute] page {} layout: 1 col (single-column mode)", pageIdx + 1);
+        }
+        cache.put(pageIdx, layout);
+        return layout;
+    }
+
+    private List<Anchor> toAnchors(
+            PDDocument document,
+            Map<Integer, List<PDFText>> matchesByPage,
+            Map<Integer, PageColumnLayout> layoutCache)
+            throws IOException {
+        List<Anchor> out = new ArrayList<>();
+        for (int page : matchesByPage.keySet().stream().sorted().toList()) {
+            PageColumnLayout layout = layoutFor(document, page, layoutCache);
+            for (PDFText hit : matchesByPage.get(page)) {
+                int col = layout.columnOf(hit.getX1(), hit.getX2());
+                out.add(new Anchor(page, col, hit.getY1(), hit));
+            }
+        }
+        return out;
+    }
+
+    /** Lexicographic ordering by (page, column, screenY). */
+    private static final Comparator<Anchor> READING_ORDER =
+            Comparator.comparingInt((Anchor a) -> a.page)
+                    .thenComparingInt(a -> a.col)
+                    .thenComparingDouble(a -> a.y);
+
+    private static String anchorSummary(List<Anchor> anchors) {
+        StringBuilder sb = new StringBuilder();
+        int max = Math.min(anchors.size(), 5);
+        for (int i = 0; i < max; i++) {
+            Anchor a = anchors.get(i);
+            if (i > 0) sb.append(", ");
+            sb.append(String.format("(p=%d,c=%d,y=%.1f)", a.page + 1, a.col, a.y));
+        }
+        if (anchors.size() > max) sb.append(", …");
+        return sb.toString();
+    }
+
+    private record Anchor(int page, int col, float y, PDFText text) {}
+
+    /**
+     * Tries progressively more permissive variants: raw (regex then literal), letter-spacing
+     * collapsed, then a punctuation-tolerant regex over alphanumeric runs.
+     */
+    private Map<Integer, List<PDFText>> findWithFallbacks(PDDocument document, String raw) {
+        String trimmed = raw.trim();
+        String collapsed = collapseLetterSpacing(trimmed);
+        String tolerant = punctuationTolerantRegex(trimmed);
+
+        List<Candidate> candidates = new ArrayList<>();
+        candidates.add(new Candidate(trimmed, true));
+        candidates.add(new Candidate(trimmed, false));
+        if (!collapsed.equals(trimmed)) {
+            candidates.add(new Candidate(collapsed, true));
+            candidates.add(new Candidate(collapsed, false));
+        }
+        if (tolerant != null && !tolerant.equals(trimmed)) {
+            candidates.add(new Candidate(tolerant, true));
+        }
+
+        // If the anchor spans multiple lines (model provided entire paragraph instead of a short
+        // phrase), try just the first non-empty line — it's usually sufficient to locate the
+        // position and avoids mismatches from mid-paragraph text extraction artifacts.
+        if (trimmed.contains("\n")) {
+            String firstLine =
+                    Arrays.stream(trimmed.split("\n"))
+                            .map(String::trim)
+                            .filter(s -> !s.isEmpty())
+                            .findFirst()
+                            .orElse(null);
+            if (firstLine != null && firstLine.length() >= 4) {
+                String firstLineCollapsed = collapseLetterSpacing(firstLine);
+                String firstLineTolerant = punctuationTolerantRegex(firstLine);
+                candidates.add(new Candidate(firstLine, false));
+                if (!firstLineCollapsed.equals(firstLine)) {
+                    candidates.add(new Candidate(firstLineCollapsed, false));
+                }
+                if (firstLineTolerant != null && !firstLineTolerant.equals(firstLine)) {
+                    candidates.add(new Candidate(firstLineTolerant, true));
+                }
+            }
+        }
+
+        for (Candidate c : candidates) {
+            Map<Integer, List<PDFText>> m =
+                    textRedactionService.findTextToRedact(
+                            document, new String[] {c.pattern}, c.useRegex, false);
+            if (!m.isEmpty()) {
+                if (!c.pattern.equals(trimmed)) {
+                    log.info(
+                            "[redact/execute] range boundary matched via fallback: '{}' → '{}'",
+                            trimmed,
+                            c.pattern);
+                }
+                return m;
+            }
+        }
+        return Collections.emptyMap();
+    }
+
+    private record Candidate(String pattern, boolean useRegex) {}
+
+    // -----------------------------------------------------------------------
+    // Static helpers
+    // -----------------------------------------------------------------------
+
+    /**
+     * Joins {@code raw}'s alphanumeric runs with {@code \W*} so anchors match across punctuation
+     * drift. Returns {@code null} when fewer than two tokens exist.
+     */
+    private static String punctuationTolerantRegex(String raw) {
+        List<String> tokens = new ArrayList<>();
+        StringBuilder current = new StringBuilder();
+        for (int i = 0; i < raw.length(); i++) {
+            char ch = raw.charAt(i);
+            if (Character.isLetterOrDigit(ch)) {
+                current.append(ch);
+            } else if (current.length() > 0) {
+                tokens.add(current.toString());
+                current.setLength(0);
+            }
+        }
+        if (current.length() > 0) tokens.add(current.toString());
+        if (tokens.size() < 2) return null;
+        StringBuilder out = new StringBuilder();
+        for (int i = 0; i < tokens.size(); i++) {
+            if (i > 0) out.append("\\W*");
+            out.append(Pattern.quote(tokens.get(i)));
+        }
+        return out.toString();
+    }
+
+    /**
+     * Collapses letter-spaced text produced by position-sorted text extraction.
+     *
+     * <p>When a PDF text stripper runs with {@code setSortByPosition(true)}, letter-spaced headings
+     * come out as {@code "T a b l e o f c o n t e n t s"}. This method converts the spaced form
+     * back to words.
+     */
+    private static String collapseLetterSpacing(String text) {
+        String[] tokens = text.split(" ", -1);
+        StringBuilder result = new StringBuilder();
+        StringBuilder current = new StringBuilder();
+        for (String token : tokens) {
+            if (token.isEmpty()) {
+                if (current.length() > 0) {
+                    if (result.length() > 0) result.append(' ');
+                    result.append(current);
+                    current.setLength(0);
+                }
+            } else if (token.length() == 1) {
+                current.append(token);
+            } else {
+                if (current.length() > 0) {
+                    if (result.length() > 0) result.append(' ');
+                    result.append(current);
+                    current.setLength(0);
+                }
+                if (result.length() > 0) result.append(' ');
+                result.append(token);
+            }
+        }
+        if (current.length() > 0) {
+            if (result.length() > 0) result.append(' ');
+            result.append(current);
+        }
+        return result.toString().trim();
+    }
+
+    private static <T> List<T> orEmpty(List<T> list) {
+        return list != null ? list : List.of();
+    }
+
+    private static String[] cleanStrings(List<String> input) {
+        if (input == null || input.isEmpty()) {
+            return new String[0];
+        }
+        return input.stream()
+                .filter(s -> s != null)
+                .map(String::trim)
+                .filter(s -> !s.isEmpty())
+                .toArray(String[]::new);
+    }
+
+    /**
+     * Converts 1-based page numbers from the request to the 0-based indices used internally.
+     * Out-of-range and non-positive values are silently dropped.
+     */
+    private static List<Integer> toZeroBasedIndices(List<Integer> oneBasedPageNumbers) {
+        if (oneBasedPageNumbers == null || oneBasedPageNumbers.isEmpty()) {
+            return new ArrayList<>();
+        }
+        List<Integer> result = new ArrayList<>();
+        for (Integer page : oneBasedPageNumbers) {
+            if (page != null && page > 0) {
+                result.add(page - 1);
+            }
+        }
+        return result;
+    }
+
+    private static String trimOrEmpty(String s) {
+        return s == null ? "" : s.trim();
+    }
+}

app/core/src/main/java/stirling/software/SPDF/model/api/security/RedactExecuteRequest.java

@@ -0,0 +1,132 @@
+package stirling.software.SPDF.model.api.security;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import stirling.software.common.model.api.PDFFile;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class RedactExecuteRequest extends PDFFile {
+
+    @Schema(
+            description =
+                    "Exact strings to find and black out. One entry per phrase to redact."
+                            + " Best for known names, identifiers, and specific text found in the document.")
+    private List<String> textValues = new ArrayList<>();
+
+    @Schema(
+            description =
+                    "Regex patterns to match and redact. Each match anywhere in the document is blacked out."
+                            + " Uses Java/PCRE regex syntax. Well-suited for strings that follow known patterns, like"
+                            + " phone numbers, email addresses, national ID numbers, or"
+                            + " dates (which can appear with different separators, optional country codes,"
+                            + " etc.). For fixed known strings such as names, use textValues instead.")
+    private List<String> regexPatterns = new ArrayList<>();
+
+    @Schema(
+            description =
+                    "1-indexed page numbers to wipe entirely (all content removed from those pages).")
+    private List<Integer> wipePages = new ArrayList<>();
+
+    @Schema(
+            description =
+                    "Text ranges to redact by specifying a start and end anchor phrase. All"
+                            + " content between the two phrases (inclusive) is redacted. Anchors"
+                            + " work best when short and unique. They must appear"
+                            + " verbatim in the document.")
+    private List<TextRange> ranges = new ArrayList<>();
+
+    @Schema(
+            description =
+                    "Rectangular areas to black out, each defined by a page number and bounding box coordinates.")
+    private List<ImageBox> imageBoxes = new ArrayList<>();
+
+    @Schema(
+            description =
+                    "1-indexed page numbers to redact all detected images from. Pass an empty list to redact images from every page. Omit or pass null to skip image redaction entirely.")
+    private List<Integer> redactImagePages;
+
+    @Schema(description = "Redaction style options")
+    private RedactStyle style = new RedactStyle();
+
+    public record TextRange(
+            @Schema(
+                            description =
+                                    "A short, distinctive phrase (5–15 words) that marks where"
+                                            + " redaction begins (inclusive). Must appear verbatim in"
+                                            + " the document — e.g. a section heading or a unique"
+                                            + " sentence fragment.",
+                            requiredMode = Schema.RequiredMode.REQUIRED,
+                            minLength = 1)
+                    String startString,
+            @Schema(
+                            description =
+                                    "A short, distinctive phrase (5–15 words) that marks where"
+                                            + " redaction ends (inclusive). Must appear verbatim in the"
+                                            + " document. Shorter phrases match more reliably.",
+                            requiredMode = Schema.RequiredMode.REQUIRED,
+                            minLength = 1)
+                    String endString) {
+        public TextRange {
+            if (endString == null) endString = "";
+        }
+    }
+
+    public record ImageBox(
+            @Schema(
+                            description = "0-indexed page number (first page = 0).",
+                            requiredMode = Schema.RequiredMode.REQUIRED)
+                    int pageIndex,
+            @Schema(
+                            description =
+                                    "Left x coordinate of the redaction rectangle in PDF user-space points.",
+                            requiredMode = Schema.RequiredMode.REQUIRED)
+                    float x1,
+            @Schema(
+                            description =
+                                    "Top y coordinate of the redaction rectangle in PDF user-space points.",
+                            requiredMode = Schema.RequiredMode.REQUIRED)
+                    float y1,
+            @Schema(
+                            description =
+                                    "Right x coordinate of the redaction rectangle in PDF user-space points.",
+                            requiredMode = Schema.RequiredMode.REQUIRED)
+                    float x2,
+            @Schema(
+                            description =
+                                    "Bottom y coordinate of the redaction rectangle in PDF user-space points.",
+                            requiredMode = Schema.RequiredMode.REQUIRED)
+                    float y2) {}
+
+    public enum RedactionStrategy {
+        AUTO,
+        OVERLAY_ONLY,
+        IMAGE_FINALIZE
+    }
+
+    @Data
+    public static class RedactStyle {
+        @Schema(description = "Hex redaction box color", defaultValue = "#000000")
+        private String color = "#000000";
+
+        @Schema(
+                description = "Extra padding around each box in points",
+                type = "number",
+                defaultValue = "0")
+        private float padding = 0f;
+
+        @Schema(description = "Rasterize output to prevent text extraction", defaultValue = "false")
+        private boolean convertToImage = false;
+
+        @Schema(
+                description = "Execution strategy hint for the redaction pipeline",
+                defaultValue = "AUTO")
+        private RedactionStrategy strategy = RedactionStrategy.AUTO;
+    }
+}