Merge branch 'feature/DEVSIX-1213' into develop

Autoported commit.
Original commit hash: [7cb1896c4]

Author: IdamkinI

itext.tests/itext.kernel.tests/itext/kernel/crypto/UnencryptedWrapperTest.cs

@@ -0,0 +1,106 @@
+using System;
+using System.IO;
+using iText.IO.Source;
+using iText.Kernel.Font;
+using iText.Kernel.Pdf;
+using iText.Kernel.Pdf.Canvas;
+using iText.Kernel.Pdf.Filespec;
+using iText.Kernel.Utils;
+using iText.Test;
+
+namespace iText.Kernel.Crypto {
+    public class UnencryptedWrapperTest : ExtendedITextTest {
+        public static readonly String destinationFolder = NUnit.Framework.TestContext.CurrentContext.TestDirectory
+             + "/test/itext/kernel/crypto/UnencryptedWrapperTest/";
+
+        public static readonly String sourceFolder = iText.Test.TestUtil.GetParentProjectDirectory(NUnit.Framework.TestContext
+            .CurrentContext.TestDirectory) + "/resources/itext/kernel/crypto/UnencryptedWrapperTest/";
+
+        [NUnit.Framework.OneTimeSetUp]
+        public static void BeforeClass() {
+            CreateOrClearDestinationFolder(destinationFolder);
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        /// <exception cref="System.Exception"/>
+        [NUnit.Framework.Test]
+        public virtual void CreateSimpleWrapperDocumentTest() {
+            CreateWrapper("customEncryptedDocument.pdf", "simpleUnencryptedWrapper.pdf", "iText");
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        /// <exception cref="System.Exception"/>
+        [NUnit.Framework.Test]
+        public virtual void ExtractCustomEncryptedDocumentTest() {
+            ExtractEncrypted("customEncryptedDocument.pdf", "simpleUnencryptedWrapper.pdf", null);
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        /// <exception cref="System.Exception"/>
+        [NUnit.Framework.Test]
+        public virtual void CreateWrapperForStandardEncryptedTest() {
+            CreateWrapper("standardEncryptedDocument.pdf", "standardUnencryptedWrapper.pdf", "Standard");
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        /// <exception cref="System.Exception"/>
+        [NUnit.Framework.Test]
+        public virtual void ExtractStandardEncryptedDocumentTest() {
+            ExtractEncrypted("standardEncryptedDocument.pdf", "standardUnencryptedWrapper.pdf", "World".GetBytes(iText.IO.Util.EncodingUtil.ISO_8859_1
+                ));
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        /// <exception cref="System.Exception"/>
+        private void CreateWrapper(String encryptedName, String wrapperName, String cryptoFilter) {
+            String inPath = sourceFolder + "cmp_" + encryptedName;
+            String cmpPath = sourceFolder + "cmp_" + wrapperName;
+            String outPath = destinationFolder + wrapperName;
+            String diff = "diff_" + wrapperName + "_";
+            PdfDocument document = new PdfDocument(new PdfWriter(outPath, new WriterProperties().SetPdfVersion(PdfVersion
+                .PDF_2_0)));
+            PdfFileSpec fs = PdfEncryptedPayloadFileSpecFactory.Create(document, inPath, new PdfEncryptedPayload(cryptoFilter
+                ));
+            document.SetEncryptedPayload(fs);
+            PdfFont font = PdfFontFactory.CreateFont();
+            PdfCanvas canvas = new PdfCanvas(document.AddNewPage());
+            canvas.SaveState().BeginText().MoveText(36, 750).SetFontAndSize(font, 30).ShowText("Hi! I'm wrapper document."
+                ).EndText().RestoreState();
+            canvas.Release();
+            document.Close();
+            NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outPath, cmpPath, destinationFolder, diff
+                ));
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        /// <exception cref="System.Exception"/>
+        private void ExtractEncrypted(String encryptedName, String wrapperName, byte[] password) {
+            String inPath = sourceFolder + "cmp_" + wrapperName;
+            String cmpPath = sourceFolder + "cmp_" + encryptedName;
+            String outPath = destinationFolder + encryptedName;
+            String diff = "diff_" + encryptedName + "_";
+            PdfDocument document = new PdfDocument(new PdfReader(inPath));
+            PdfEncryptedPayloadDocument encryptedDocument = document.GetEncryptedPayloadDocument();
+            byte[] encryptedDocumentBytes = encryptedDocument.GetDocumentBytes();
+            FileStream fos = new FileStream(outPath, FileMode.Create);
+            fos.Write(encryptedDocumentBytes);
+            fos.Dispose();
+            document.Close();
+            PdfEncryptedPayload ep = encryptedDocument.GetEncryptedPayload();
+            NUnit.Framework.Assert.AreEqual(PdfEncryptedPayloadFileSpecFactory.GenerateFileDisplay(ep), encryptedDocument
+                .GetName());
+            if (password != null) {
+                NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outPath, cmpPath, destinationFolder, diff
+                    , password, password));
+            }
+            else {
+                RandomAccessFileOrArray raf = new RandomAccessFileOrArray(new RandomAccessSourceFactory().CreateBestSource
+                    (cmpPath));
+                byte[] cmpBytes = new byte[(int)raf.Length()];
+                raf.ReadFully(cmpBytes);
+                raf.Close();
+                NUnit.Framework.Assert.AreEqual(cmpBytes, encryptedDocumentBytes);
+            }
+        }
+    }
+}

itext.tests/itext.kernel.tests/resources/itext/kernel/crypto/UnencryptedWrapperTest/cmp_customEncryptedDocument.pdf

@@ -78,6 +78,8 @@ public sealed class LogMessageConstant {
 
         public const String CLIP_ELEMENT = "Element content was clipped because some height properties are set.";
 
+        public const String COLLECTION_DICTIONARY_ALREADY_EXISTS_IT_WILL_BE_MODIFIED = "Collection dictionary already exists. It will be modified.";
+
         public const String COLORANT_INTENSITIES_INVALID = "Some of colorant intensities are invalid: they are bigger than 1 or less than 0. We will force them to become 1 or 0 respectively.";
 
         public const String COLOR_ALPHA_CHANNEL_IS_IGNORED = "Alpha channel {0} was ignored during color creation. Note that opacity can be achieved in some places by using 'setOpacity' method or 'TransparentColor' class";
@@ -104,6 +106,9 @@ public sealed class LogMessageConstant {
 
         public const String ENCOUNTERED_INVALID_MCR = "Corrupted tag structure: encountered invalid marked content reference - it doesn't refer to any page or any mcid. This content reference will be ignored.";
 
+        public const String ENCRYPTED_PAYLOAD_FILE_SPEC_SHALL_HAVE_AFRELATIONSHIP_FILED_EQUAL_TO_ENCRYPTED_PAYLOAD
+             = "Encrypted payload file spec shall have 'AFRelationship' filed equal to 'EncryptedPayload'";
+
         public const String ENCRYPTION_ENTRIES_P_AND_ENCRYPT_METADATA_NOT_CORRESPOND_PERMS_ENTRY = "Encryption dictionary entries P and EncryptMetadata have value that does not correspond to encrypted values in Perms key.";
 
         public const String EXCEPTION_WHILE_CREATING_DEFAULT_FONT = "Exception while creating default font (Helvetica, WinAnsi)";

itext.tests/itext.kernel.tests/resources/itext/kernel/crypto/UnencryptedWrapperTest/cmp_simpleUnencryptedWrapper.pdf

@@ -164,6 +164,10 @@ public class PdfException : Exception {
 
         public const String CannotSetDataToPdfstreamWhichWasCreatedByInputStream = "Cannot set data to PdfStream which was created by InputStream.";
 
+        public const String CannotSetEncryptedPayloadToDocumentOpenedInReadingMode = "Cannot set encrypted payload to a document opened in read only mode.";
+
+        public const String CannotSetEncryptedPayloadToEncryptedDocument = "Cannot set encrypted payload to an encrypted document.";
+
         public const String CannotSplitDocumentThatIsBeingWritten = "Cannot split document that is being written.";
 
         public const String CannotWriteToPdfStream = "Cannot write to PdfStream.";
@@ -216,6 +220,18 @@ public class PdfException : Exception {
 
         public const String ErrorWhileReadingObjectStream = "Error while reading Object Stream.";
 
+        public const String EncryptedPayloadFileSpecDoesntHaveEncryptedPayloadDictionary = "Encrypted payload file spec shall have encrypted payload dictionary.";
+
+        public const String EncryptedPayloadFileSpecShallBeIndirect = "Encrypted payload file spec shall be indirect.";
+
+        public const String EncryptedPayloadFileSpecShallHaveEFDictionary = "Encrypted payload file spec shall have 'EF' key. The value of such key shall be a dictionary that contains embedded file stream.";
+
+        public const String EncryptedPayloadFileSpecShallHaveTypeEqualToFilespec = "Encrypted payload file spec shall have 'Type' key. The value of such key shall be 'Filespec'.";
+
+        public const String EncryptedPayloadShallHaveTypeEqualsToEncryptedPayloadIfPresent = "Encrypted payload dictionary shall have field 'Type' equal to 'EncryptedPayload' if present";
+
+        public const String EncryptedPayloadShallHaveSubtype = "Encrypted payload shall have 'Subtype' field specifying crypto filter";
+
         public const String FailedToGetTsaResponseFrom1 = "Failed to get TSA response from {0}.";
 
         public const String FieldFlatteningIsNotSupportedInAppendMode = "Field flattening is not supported in append mode.";

itext.tests/itext.kernel.tests/resources/itext/kernel/crypto/UnencryptedWrapperTest/cmp_standardEncryptedDocument.pdf

@@ -283,6 +283,23 @@ public virtual void AddDeveloperExtension(PdfDeveloperExtension extension) {
             extensions.Put(extension.GetPrefix(), extension.GetDeveloperExtensions());
         }
 
+        /// <summary>
+        /// Gets collection dictionary that a conforming reader shall use to enhance the presentation of file attachments
+        /// stored in the PDF document.
+        /// </summary>
+        /// <returns>
+        /// 
+        /// <see cref="iText.Kernel.Pdf.Collection.PdfCollection"/>
+        /// wrapper of collection dictionary.
+        /// </returns>
+        public virtual PdfCollection GetCollection() {
+            PdfDictionary collectionDictionary = GetPdfObject().GetAsDictionary(PdfName.Collection);
+            if (collectionDictionary != null) {
+                return new PdfCollection(collectionDictionary);
+            }
+            return null;
+        }
+
         /// <summary>
         /// Sets collection dictionary that a conforming reader shall use to enhance the presentation of file attachments
         /// stored in the PDF document.

itext.tests/itext.kernel.tests/resources/itext/kernel/crypto/UnencryptedWrapperTest/cmp_standardUnencryptedWrapper.pdf

@@ -56,6 +56,7 @@ source product.
 using iText.Kernel.Numbering;
 using iText.Kernel.Pdf.Annot;
 using iText.Kernel.Pdf.Canvas;
+using iText.Kernel.Pdf.Collection;
 using iText.Kernel.Pdf.Filespec;
 using iText.Kernel.Pdf.Navigation;
 using iText.Kernel.Pdf.Tagging;
@@ -214,8 +215,7 @@ public PdfDocument(PdfReader reader, PdfWriter writer, StampingProperties proper
             this.reader = reader;
             this.writer = writer;
             this.properties = properties;
-            bool writerHasEncryption = writer.properties.IsStandardEncryptionUsed() || writer.properties.IsPublicKeyEncryptionUsed
-                ();
+            bool writerHasEncryption = WriterHasEncryption();
             if (properties.appendMode && writerHasEncryption) {
                 ILog logger = LogManager.GetLogger(typeof(iText.Kernel.Pdf.PdfDocument));
                 logger.Warn(iText.IO.LogMessageConstant.WRITER_ENCRYPTION_IS_IGNORED_APPEND);
@@ -1432,6 +1432,86 @@ public virtual PdfArray GetAssociatedFiles() {
             return catalog.GetPdfObject().GetAsArray(PdfName.AF);
         }
 
+        /// <summary>
+        /// Gets the encrypted payload of this document,
+        /// or returns
+        /// <see langword="null"/>
+        /// if this document isn't an unencrypted wrapper document.
+        /// </summary>
+        /// <returns>encrypted payload of this document.</returns>
+        public virtual PdfEncryptedPayloadDocument GetEncryptedPayloadDocument() {
+            if (GetReader() != null && GetReader().IsEncrypted()) {
+                return null;
+            }
+            PdfCollection collection = GetCatalog().GetCollection();
+            if (collection != null && collection.IsViewHidden()) {
+                PdfString documentName = collection.GetInitialDocument();
+                PdfNameTree embeddedFiles = GetCatalog().GetNameTree(PdfName.EmbeddedFiles);
+                String documentNameUnicode = documentName.ToUnicodeString();
+                PdfObject fileSpecObject = embeddedFiles.GetNames().Get(documentNameUnicode);
+                if (fileSpecObject != null && fileSpecObject.IsDictionary()) {
+                    try {
+                        PdfFileSpec fileSpec = PdfEncryptedPayloadFileSpecFactory.Wrap((PdfDictionary)fileSpecObject);
+                        if (fileSpec != null) {
+                            PdfDictionary embeddedDictionary = ((PdfDictionary)fileSpec.GetPdfObject()).GetAsDictionary(PdfName.EF);
+                            PdfStream stream = embeddedDictionary.GetAsStream(PdfName.UF);
+                            if (stream == null) {
+                                stream = embeddedDictionary.GetAsStream(PdfName.F);
+                            }
+                            if (stream != null) {
+                                return new PdfEncryptedPayloadDocument(stream, fileSpec, documentNameUnicode);
+                            }
+                        }
+                    }
+                    catch (PdfException e) {
+                        LogManager.GetLogger(GetType()).Error(e.Message);
+                    }
+                }
+            }
+            return null;
+        }
+
+        /// <summary>Sets an encrypted payload, making this document an unencrypted wrapper document.</summary>
+        /// <remarks>
+        /// Sets an encrypted payload, making this document an unencrypted wrapper document.
+        /// The file spec shall include the AFRelationship key with a value of EncryptedPayload,
+        /// and shall include an encrypted payload dictionary.
+        /// </remarks>
+        /// <param name="fs">
+        /// encrypted payload file spec.
+        /// <see cref="iText.Kernel.Pdf.Filespec.PdfEncryptedPayloadFileSpecFactory"/>
+        /// can produce one.
+        /// </param>
+        public virtual void SetEncryptedPayload(PdfFileSpec fs) {
+            if (GetWriter() == null) {
+                throw new PdfException(PdfException.CannotSetEncryptedPayloadToDocumentOpenedInReadingMode);
+            }
+            if (WriterHasEncryption()) {
+                throw new PdfException(PdfException.CannotSetEncryptedPayloadToEncryptedDocument);
+            }
+            if (!PdfName.EncryptedPayload.Equals(((PdfDictionary)fs.GetPdfObject()).Get(PdfName.AFRelationship))) {
+                LogManager.GetLogger(GetType()).Error(iText.IO.LogMessageConstant.ENCRYPTED_PAYLOAD_FILE_SPEC_SHALL_HAVE_AFRELATIONSHIP_FILED_EQUAL_TO_ENCRYPTED_PAYLOAD
+                    );
+            }
+            PdfEncryptedPayload encryptedPayload = PdfEncryptedPayload.ExtractFrom(fs);
+            if (encryptedPayload == null) {
+                throw new PdfException(PdfException.EncryptedPayloadFileSpecDoesntHaveEncryptedPayloadDictionary);
+            }
+            PdfCollection collection = GetCatalog().GetCollection();
+            if (collection != null) {
+                LogManager.GetLogger(GetType()).Warn(iText.IO.LogMessageConstant.COLLECTION_DICTIONARY_ALREADY_EXISTS_IT_WILL_BE_MODIFIED
+                    );
+            }
+            else {
+                collection = new PdfCollection();
+                GetCatalog().SetCollection(collection);
+            }
+            collection.SetView(PdfCollection.HIDDEN);
+            String displayName = PdfEncryptedPayloadFileSpecFactory.GenerateFileDisplay(encryptedPayload);
+            collection.SetInitialDocument(displayName);
+            AddAssociatedFile(displayName, fs);
+        }
+
         /// <summary>This method retrieves the page labels from a document as an array of String objects.</summary>
         /// <returns>
         /// 
@@ -2148,6 +2228,10 @@ private long GetDocumentId() {
             return documentId;
         }
 
+        private bool WriterHasEncryption() {
+            return writer.properties.IsStandardEncryptionUsed() || writer.properties.IsPublicKeyEncryptionUsed();
+        }
+
         /// <summary>A structure storing documentId, object number and generation number.</summary>
         /// <remarks>
         /// A structure storing documentId, object number and generation number. This structure is using to calculate

itext/itext.io/itext/io/LogMessageConstant.cs

@@ -0,0 +1,68 @@
+using System;
+using iText.Kernel;
+using iText.Kernel.Pdf.Filespec;
+
+namespace iText.Kernel.Pdf {
+    public class PdfEncryptedPayload : PdfObjectWrapper<PdfDictionary> {
+        public PdfEncryptedPayload(String subtype)
+            : this(new PdfDictionary()) {
+            GetPdfObject().Put(PdfName.Type, PdfName.EncryptedPayload);
+            SetSubtype(subtype);
+        }
+
+        private PdfEncryptedPayload(PdfDictionary pdfObject)
+            : base(pdfObject) {
+        }
+
+        public static iText.Kernel.Pdf.PdfEncryptedPayload ExtractFrom(PdfFileSpec fileSpec) {
+            if (fileSpec != null && fileSpec.GetPdfObject().IsDictionary()) {
+                return iText.Kernel.Pdf.PdfEncryptedPayload.Wrap(((PdfDictionary)fileSpec.GetPdfObject()).GetAsDictionary(
+                    PdfName.EP));
+            }
+            return null;
+        }
+
+        public static iText.Kernel.Pdf.PdfEncryptedPayload Wrap(PdfDictionary dictionary) {
+            PdfName type = dictionary.GetAsName(PdfName.Type);
+            if (type != null && !type.Equals(PdfName.EncryptedPayload)) {
+                throw new PdfException(PdfException.EncryptedPayloadShallHaveTypeEqualsToEncryptedPayloadIfPresent);
+            }
+            if (dictionary.GetAsName(PdfName.Subtype) == null) {
+                throw new PdfException(PdfException.EncryptedPayloadShallHaveSubtype);
+            }
+            return new iText.Kernel.Pdf.PdfEncryptedPayload(dictionary);
+        }
+
+        public virtual PdfName GetSubtype() {
+            return GetPdfObject().GetAsName(PdfName.Subtype);
+        }
+
+        public virtual iText.Kernel.Pdf.PdfEncryptedPayload SetSubtype(String subtype) {
+            return SetSubtype(new PdfName(subtype));
+        }
+
+        public virtual iText.Kernel.Pdf.PdfEncryptedPayload SetSubtype(PdfName subtype) {
+            SetModified();
+            GetPdfObject().Put(PdfName.Subtype, subtype);
+            return this;
+        }
+
+        public virtual PdfName GetVersion() {
+            return GetPdfObject().GetAsName(PdfName.Version);
+        }
+
+        public virtual iText.Kernel.Pdf.PdfEncryptedPayload SetVersion(String version) {
+            return SetVersion(new PdfName(version));
+        }
+
+        public virtual iText.Kernel.Pdf.PdfEncryptedPayload SetVersion(PdfName version) {
+            SetModified();
+            GetPdfObject().Put(PdfName.Version, version);
+            return this;
+        }
+
+        protected internal override bool IsWrappedObjectMustBeIndirect() {
+            return false;
+        }
+    }
+}