Make RUPS open document in read-only mode by default

Since the iText library upgrade we have an issue, that some of the
information is missing from the trailer. For example, the /Info
dictionary is always missing, if the PDF document is opened in the
read-write mode. But even before that, there were some modifications
happening to the data, like the modification date changing.

As a workaround for now we will start opening all the files in the
read-only mode by default. In this case it should show data much closer
to what is in the original document.

If you want to edit the document, you can use the "Reopen as Owner"
option, which reuses the code added for user/owner password protection
handling.

This still leave the issue, that in the read-write mode the data doesn't
match, but it would take more effort to solve...

Author: Eswcvlad

src/main/java/com/itextpdf/rups/model/PdfFile.java

@@ -112,7 +112,6 @@ public static PdfFile openAsOwner(File file, byte[] content) throws IOException
         return openAsOwner(file, content, DialogPasswordProvider.ownerPassword());
     }
 
-
     public static PdfFile openAsOwner(File file, byte[] content, IPasswordProvider passwordProvider)
             throws IOException {
         final PdfFile pdfFile = new PdfFile(file, content);
@@ -148,24 +147,18 @@ public ByteArrayOutputStream getByteArrayOutputStream() {
     private void openDocument(IPasswordProvider passwordProvider, boolean requireEditable)
             throws IOException {
         /*
-         * This should pass in the majority of cases (i.e. if the document is
-         * non-encrypted).
-         */
-        if (openDocumentReadWrite()) {
-            return;
-        }
-
-        /*
-         * If it is, actually, protected, we will try to open it in a read-only
-         * mode. This should pass, if the document is protected, but there is no
-         * user password.
+         * This block should succeed, if there is no password protection.
          *
-         * In this case any editing operations in RUPS should be disabled.
+         * By default, editing operations in RUPS should be disabled. Ideally
+         * we would just open the document in the read-write mode everytime
+         * for convenience. But, annoyingly, in iText, if you open the document
+         * in the read-write mode, some of the original information will get
+         * lost, like, for example, the /Info dictionary.
          *
-         * If the requireEditable flag is set to true, we skip trying to open
-         * the document in a read-only mode.
+         * If the requireEditable flag is set to true, we only try to open the
+         * document in the read-write mode.
          */
-        if (!requireEditable && openDocumentReadOnly()) {
+        if (openDocument(requireEditable)) {
             return;
         }
 
@@ -174,23 +167,17 @@ private void openDocument(IPasswordProvider passwordProvider, boolean requireEdi
          * password provider to get the password and will try to use it to open
          * the document.
          *
-         * Since user can provide any of the two password, we will try first to
-         * open as an owner (read/write) and then, if failed, as a user
-         * (read-only). If both failed, we will keep asking for the correct
-         * password until password provider signals cancellation.
-         *
-         * If the requireEditable flag is set to true, we skip trying to open
-         * the document in a read-only mode.
+         * Since user can provide any of the two passwords, if editing was
+         * requested, but only a user password was provided, it will fail.
+         * We will keep asking for the correct password until password
+         * provider signals cancellation.
          */
         while (true) {
             final byte[] password = passwordProvider.get(getOriginalFile());
             if (password == null) {
                 throw new BadPasswordException(Language.ERROR_MISSING_PASSWORD.getString());
             }
-            if (openDocumentReadWrite(password)) {
-                return;
-            }
-            if (!requireEditable && openDocumentReadOnly(password)) {
+            if (openDocument(password, requireEditable)) {
                 return;
             }
             /*
@@ -203,6 +190,41 @@ private void openDocument(IPasswordProvider passwordProvider, boolean requireEdi
         }
     }
 
+    /**
+     * Tries to open the PDF document without a password. Read-only or
+     * read-write mode depends on the requireEditable parameter.
+     * If the document is encrypted, returns {@code false}.
+     *
+     * @param requireEditable {@code true}, if document should be opened in a
+     *                        read-write mode
+     *
+     * @return {@code true} on success; {@code false} if encrypted
+     */
+    private boolean openDocument(boolean requireEditable) throws IOException {
+        if (requireEditable) {
+            return openDocumentReadWrite();
+        }
+        return openDocumentReadOnly();
+    }
+
+    /**
+     * Tries to open the PDF document with the provided password. Read-only or
+     * read-write mode depends on the requireEditable parameter.
+     * If the password is incorrect, returns {@code false}.
+     *
+     * @param password password to use, when decrypting
+     * @param requireEditable {@code true}, if document should be opened in a
+     *                        read-write mode
+     *
+     * @return {@code true} on success; {@code false} if encrypted
+     */
+    private boolean openDocument(byte[] password, boolean requireEditable) throws IOException {
+        if (requireEditable) {
+            return openDocumentReadWrite(password);
+        }
+        return openDocumentReadOnly(password);
+    }
+
     /**
      * Tries to open the PDF document in a read/write mode without a password.
      * If the document is encrypted, returns {@code false}.

src/test/java/com/itextpdf/rups/model/PdfFileTest.java

@@ -68,10 +68,10 @@ class PdfFileTest {
     void open_RegularFileTest() throws IOException {
         PdfFile openedFile = openTestFile("regular.pdf", "");
         /*
-         * Should be opened as owner (i.e. read/write), as it is not encrypted.
+         * Should be opened in the read-only mode, as this is the default.
          */
-        Assertions.assertTrue(openedFile.isOpenedAsOwner());
-        Assertions.assertNotNull(openedFile.getByteArrayOutputStream());
+        Assertions.assertFalse(openedFile.isOpenedAsOwner());
+        Assertions.assertNull(openedFile.getByteArrayOutputStream());
         // Sanity check, that it opened the document properly
         Assertions.assertEquals(
                 "REGULAR",
@@ -83,8 +83,7 @@ void open_RegularFileTest() throws IOException {
     void open_OwnerProtectedFileWithoutPasswordTest() throws IOException {
         PdfFile openedFile = openTestFile("protected_with_owner_password.pdf", null);
         /*
-         * Should be opened as user (i.e. read-only), as it is protected, and
-         * we did not provide any password.
+         * Should be opened in the read-only mode, as this is the default.
          */
         Assertions.assertFalse(openedFile.isOpenedAsOwner());
         Assertions.assertNull(openedFile.getByteArrayOutputStream());
@@ -99,8 +98,7 @@ void open_OwnerProtectedFileWithoutPasswordTest() throws IOException {
     void open_OwnerProtectedFileWithIncorrectPasswordTest() throws IOException {
         PdfFile openedFile = openTestFile("protected_with_owner_password.pdf", "incorrect");
         /*
-         * Should be opened as user (i.e. read-only), as it is protected, and
-         * we did not provide a correct password.
+         * Should be opened in the read-only mode, as this is the default.
          */
         Assertions.assertFalse(openedFile.isOpenedAsOwner());
         Assertions.assertNull(openedFile.getByteArrayOutputStream());
@@ -115,9 +113,7 @@ void open_OwnerProtectedFileWithIncorrectPasswordTest() throws IOException {
     void open_OwnerProtectedFileWithCorrectPasswordTest() throws IOException {
         PdfFile openedFile = openTestFile("protected_with_owner_password.pdf", OWNER_PASSWORD);
         /*
-         * Should still be opened as user (i.e. read-only), as it is protected,
-         * and the open method does not request a password, if the file can be
-         * opened in a read-only mode.
+         * Should be opened in the read-only mode, as this is the default.
          */
         Assertions.assertFalse(openedFile.isOpenedAsOwner());
         Assertions.assertNull(openedFile.getByteArrayOutputStream());
@@ -156,8 +152,7 @@ void open_UserProtectedFileWithIncorrectPasswordTest() {
     void open_UserProtectedFileWithUserPasswordTest() throws IOException {
         PdfFile openedFile = openTestFile("protected_with_both_passwords.pdf", USER_PASSWORD);
         /*
-         * Should be opened as user (i.e. read-only), as it is protected, and
-         * we only provided the user password.
+         * Should be opened in the read-only mode, as this is the default.
          */
         Assertions.assertFalse(openedFile.isOpenedAsOwner());
         Assertions.assertNull(openedFile.getByteArrayOutputStream());
@@ -172,11 +167,10 @@ void open_UserProtectedFileWithUserPasswordTest() throws IOException {
     void open_UserProtectedFileWithOwnerPasswordTest() throws IOException {
         PdfFile openedFile = openTestFile("protected_with_both_passwords.pdf", OWNER_PASSWORD);
         /*
-         * Should be opened as owner (i.e. read/write), as it is protected, and
-         * we provided the owner password.
+         * Should be opened in the read-only mode, as this is the default.
          */
-        Assertions.assertTrue(openedFile.isOpenedAsOwner());
-        Assertions.assertNotNull(openedFile.getByteArrayOutputStream());
+        Assertions.assertFalse(openedFile.isOpenedAsOwner());
+        Assertions.assertNull(openedFile.getByteArrayOutputStream());
         // Sanity check, that it opened the document properly
         Assertions.assertEquals(
                 "DIFFERENT USER AND OWNER PASSWORDS",
@@ -195,7 +189,7 @@ void openAsOwner_RegularFileTest() throws IOException {
     }
 
     @Test
-    void openAsOwner_OwnerProtectedFileWithoutPasswordTest() throws IOException {
+    void openAsOwner_OwnerProtectedFileWithoutPasswordTest() {
         /*
          * Here it should throw a bad password error, as it won't get opened as
          * an owner without a password.
@@ -207,7 +201,7 @@ void openAsOwner_OwnerProtectedFileWithoutPasswordTest() throws IOException {
     }
 
     @Test
-    void openAsOwner_OwnerProtectedFileWithIncorrectPasswordTest() throws IOException {
+    void openAsOwner_OwnerProtectedFileWithIncorrectPasswordTest() {
         /*
          * Here it should throw a bad password error, as it won't get opened as
          * an owner with an incorrect password.