[RELEASE] iText pdfSweep 5.0.0

Author: iText-CI

SECURITY.md

@@ -0,0 +1,39 @@
+# iText Security Policy
+
+## Reporting a Vulnerability
+
+We are committed to maintaining the security of our software. If you discover a security vulnerability, we encourage you to report it to us as soon as possible.
+
+To report a vulnerability, please visit our [Vulnerability Reporting Page](https://itextpdf.com/report-vulnerability), or email [[email protected]]([email protected]). If you do not receive a response in 2 business days, please follow up as we may not have received your message.
+
+We follow the procedure of Coordinated Vulnerability Disclosure (CVD) and, to protect the ecosystem, we request that those reporting do the same. Please visit the above page for more information, and follow the steps below to ensure that your report is handled promptly and appropriately:
+
+1. **Do not disclose the vulnerability publicly** until we have had a chance to address it.
+2. **Provide a detailed description** of the vulnerability, including steps to reproduce it, if possible.
+3. **Include any relevant information** such as the version of pdfSweep you are using, your operating system, and any other pertinent details.
+
+## Security Updates and Patches
+
+ When a vulnerability is reported, we will:
+
+1. **Investigate and verify** the vulnerability.
+2. **Develop and test** a fix for the vulnerability.
+3. **Release a patch** as soon as possible.
+
+## Known Vulnerabilities
+
+The iText Knowledge Base has a page for known [Common Vulnerabilities and Exposures](https://kb.itextpdf.com/itext/cves) (CVEs), please check it to ensure your vulnerability has not already been disclosed or addressed.
+
+## Supported product lines
+
+See [Compatibility Matrix](https://kb.itextpdf.com/itext/compatibility-matrix)
+
+## Security Best Practices
+
+To help ensure the security of your applications using pdfSweep, we recommend the following best practices:
+
+1. **Keep pdfSweep up to date** by regularly checking for and applying updates.
+2. **Review and follow** our security guidelines for secure usage.
+3. **Monitor your applications** for any unusual activity and investigate any anomalies promptly.
+
+Thank you for helping us keep iText secure!

pom.xml

@@ -5,12 +5,12 @@
   <parent>
     <groupId>com.itextpdf</groupId>
     <artifactId>root</artifactId>
-    <version>8.0.5</version>
+    <version>9.0.0</version>
     <relativePath />
   </parent>
 
   <artifactId>cleanup</artifactId>
-  <version>4.0.3</version>
+  <version>5.0.0</version>
 
   <name>pdfSweep</name>
   <description>Redact PDF documents. If you have to share PDFs with different departments or send them out of house, but they

src/main/java/com/itextpdf/pdfcleanup/CleanUpProperties.java

@@ -33,6 +33,7 @@ public class CleanUpProperties {
     private IMetaInfo metaInfo;
     private boolean processAnnotations;
     private Double overlapRatio;
+    private PathOffsetApproximationProperties offsetProperties = new PathOffsetApproximationProperties();
 
     /**
      * Creates default CleanUpProperties instance.
@@ -54,9 +55,12 @@ IMetaInfo getMetaInfo() {
      * Sets additional meta info.
      *
      * @param metaInfo the meta info to set
+     *
+     * @return this {@link CleanUpProperties} instance
      */
-    public void setMetaInfo(IMetaInfo metaInfo) {
+    public CleanUpProperties setMetaInfo(IMetaInfo metaInfo) {
         this.metaInfo = metaInfo;
+        return this;
     }
 
     /**
@@ -74,9 +78,12 @@ public boolean isProcessAnnotations() {
      * Default processing behaviour: remove annotation if there is overlap with a redaction region.
      *
      * @param processAnnotations is page annotations will be processed
+     *
+     * @return this {@link CleanUpProperties} instance
      */
-    public void setProcessAnnotations(boolean processAnnotations) {
+    public CleanUpProperties setProcessAnnotations(boolean processAnnotations) {
         this.processAnnotations = processAnnotations;
+        return this;
     }
 
     /**
@@ -98,16 +105,42 @@ public Double getOverlapRatio() {
      * Example: if the overlap ratio is set to 0.3, the content region will be removed if it overlaps with
      * the redaction area by at least 30%.
      *
-     * @param overlapRatio The overlap ratio to set.
+     * @param overlapRatio the overlap ratio to set
+     *
+     * @return this {@link CleanUpProperties} instance
      */
-    public void setOverlapRatio(Double overlapRatio) {
+    public CleanUpProperties setOverlapRatio(Double overlapRatio) {
         if (overlapRatio == null) {
             this.overlapRatio = null;
-            return;
+            return this;
         }
         if (overlapRatio <= 0 || overlapRatio > 1) {
             throw new IllegalArgumentException(CleanupExceptionMessageConstant.OVERLAP_RATIO_SHOULD_BE_IN_RANGE);
         }
         this.overlapRatio = overlapRatio;
+        return this;
+    }
+
+    /**
+     * Get {@link PathOffsetApproximationProperties} specifying approximation parameters for
+     * {@link com.itextpdf.kernel.pdf.canvas.parser.clipper.ClipperOffset} operations.
+     *
+     * @return {@link PathOffsetApproximationProperties} parameters
+     */
+    public PathOffsetApproximationProperties getOffsetProperties() {
+        return offsetProperties;
+    }
+
+    /**
+     * Set {@link PathOffsetApproximationProperties} specifying approximation parameters for
+     * {@link com.itextpdf.kernel.pdf.canvas.parser.clipper.ClipperOffset} operations.
+     *
+     * @param offsetProperties {@link PathOffsetApproximationProperties} to set
+     *
+     * @return this {@link CleanUpProperties} instance
+     */
+    public CleanUpProperties setOffsetProperties(PathOffsetApproximationProperties offsetProperties) {
+        this.offsetProperties = offsetProperties;
+        return this;
     }
 }

src/main/java/com/itextpdf/pdfcleanup/PathOffsetApproximationProperties.java

@@ -0,0 +1,105 @@
+/*
+    This file is part of the iText (R) project.
+    Copyright (c) 1998-2024 Apryse Group NV
+    Authors: Apryse Software.
+
+    This program is offered under a commercial and under the AGPL license.
+    For commercial licensing, contact us at https://itextpdf.com/sales.  For AGPL licensing, see below.
+
+    AGPL licensing:
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.itextpdf.pdfcleanup;
+
+import com.itextpdf.kernel.pdf.canvas.parser.clipper.ClipperBridge;
+
+/**
+ * Contains properties for {@link com.itextpdf.kernel.pdf.canvas.parser.clipper.ClipperOffset} operations.
+ */
+public class PathOffsetApproximationProperties {
+    private double arcTolerance = 0.0025;
+    private boolean calculateOffsetMultiplierDynamically = false;
+
+    /**
+     * Creates new {@link PathOffsetApproximationProperties} instance.
+     */
+    public PathOffsetApproximationProperties() {
+        // Empty constructor.
+    }
+
+    /**
+     * Specifies if floatMultiplier should be calculated dynamically. Default value is {@code false}.
+     *
+     * <p>
+     * When a document with line arts is being cleaned up, there are a lot of calculations with floating point numbers.
+     * All of them are translated into fixed point numbers by multiplying by this floatMultiplier coefficient.
+     * It is possible to dynamically adjust the preciseness of the calculations.
+     *
+     * @param calculateDynamically {@code true} if floatMultiplier should be calculated dynamically,
+     *                             {@code false} for default value specified by {@link ClipperBridge#ClipperBridge()}
+     *
+     * @return this {@link PathOffsetApproximationProperties} instance
+     */
+    public PathOffsetApproximationProperties calculateOffsetMultiplierDynamically(boolean calculateDynamically) {
+        this.calculateOffsetMultiplierDynamically = calculateDynamically;
+        return this;
+    }
+
+    /**
+     * Checks whether floatMultiplier should be calculated dynamically.
+     *
+     * <p>
+     * When a document with line arts is being cleaned up, there are a lot of calculations with floating point numbers.
+     * All of them are translated into fixed point numbers by multiplying by this floatMultiplier coefficient.
+     * It is possible to dynamically adjust the preciseness of the calculations.
+     *
+     * @return {@code true} if floatMultiplier should be calculated dynamically, {@code false} for default value
+     */
+    public boolean calculateOffsetMultiplierDynamically() {
+        return this.calculateOffsetMultiplierDynamically;
+    }
+
+    /**
+     * Gets arc tolerance which is the maximum difference between the true and the faceted representation of curves
+     * (arcs) in units. Used as the criterion of a good approximation of rounded line joins and line caps.
+     *
+     * <p>
+     * Since flattened paths can never perfectly represent arcs, this field/property specifies a maximum acceptable
+     * imprecision (tolerance) when arcs are approximated in an offsetting operation. Smaller values will increase
+     * smoothness up to a point though at a cost of performance and in creating more vertices to construct the arc.
+     *
+     * @return arc tolerance specifying maximum difference between the true and the faceted representation of arcs
+     */
+    public double getArcTolerance() {
+        return arcTolerance;
+    }
+
+    /**
+     * Sets arc tolerance which is the maximum difference between the true and the faceted representation of curves
+     * (arcs) in units. Used as the criterion of a good approximation of rounded line joins and line caps.
+     *
+     * <p>
+     * Since flattened paths can never perfectly represent arcs, this field/property specifies a maximum acceptable
+     * imprecision (tolerance) when arcs are approximated in an offsetting operation. Smaller values will increase
+     * smoothness up to a point though at a cost of performance and in creating more vertices to construct the arc.
+     *
+     * @param arcTolerance maximum difference between the true and the faceted representation of arcs
+     *
+     * @return this {@link PathOffsetApproximationProperties} instance
+     */
+    public PathOffsetApproximationProperties setArcTolerance(double arcTolerance) {
+        this.arcTolerance = arcTolerance;
+        return this;
+    }
+}