public void ProtectWithScreenReaderRestrictions( [Values( FileAuthentication.Password /*, * Ignore: http://stackoverflow.com/questions/40045745/itextsharp-object-reference-error-on-pdfstamper-for-certificate-protected-file * FileAuthentication.CertificateFile, * FileAuthentication.CertificateStore*/)] FileAuthentication protectAuth, [Values( true, false)] bool allowScreenReaders) { string inputFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.ChangeProtection.Resources.Protect.pdf", this.inputDirectory); string outputFilePath = Path.Combine(this.outputDirectory, "Protect.pdf"); FunctionDesigner designer = ProviderHelpers.CreateDesigner <ChangeProtectionProvider>(); ConfigureInputFileFunctionValues(designer, FileAuthentication.None, inputFilePath); ConfigureProtectFunctionValues(designer, protectAuth, Encryption.AES256, true, true, allowScreenReaders: allowScreenReaders); designer.Properties[Pdf.Common.PropertyNames.OutputFilePath].Value = outputFilePath; var tester = new FunctionTester <ChangeProtectionProvider>(); tester.Execute(designer.GetProperties(), designer.GetParameters()); PdfComparer.AssertProtection(outputFilePath, protectAuth, this.authenticationManager, true, true, expectedAllowScreenReaders: allowScreenReaders); if (protectAuth == FileAuthentication.Password) { using (var permissionsAuthHelper = new AuthenticationManager(permissionsPassword)) { PdfComparer.AssertProtectionAllRights(outputFilePath, FileAuthentication.Password, permissionsAuthHelper, true, true); } } }
public PdfReader GetReader(string filePath, FileAuthentication fileAuth) { CheckFileExists(filePath); switch (fileAuth) { case FileAuthentication.None: return(new PdfReader(filePath)); case FileAuthentication.Password: return(new PdfReader(filePath, Encoding.UTF8.GetBytes(Password))); case FileAuthentication.CertificateFile: case FileAuthentication.CertificateStore: if (!Certificate.HasPrivateKey) { throw new NotSupportedException("Certificate must have a private key."); } return(new PdfReader(filePath, DotNetUtilities.FromX509Certificate(Certificate), DotNetUtilities.GetKeyPair(Certificate.PrivateKey).Private)); default: throw new NotSupportedException("Invalid FileAuthentication specified."); } }
public void AddWatermark( [Values( FileAuthentication.None, FileAuthentication.Password /*, * Ignore: http://stackoverflow.com/questions/40045745/itextsharp-object-reference-error-on-pdfstamper-for-certificate-protected-file * FileAuthentication.CertificateFile, * FileAuthentication.CertificateStore*/)] FileAuthentication inputAuth, [Values( WatermarkPosition.Above, WatermarkPosition.Below)] WatermarkPosition position) { string inputFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.AddWatermark.Resources.Watermark.pdf", this.inputDirectory); string watermarkFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.AddWatermark.Resources.Overlay.pdf", this.inputDirectory); string outputFilePath = Path.Combine(this.outputDirectory, "Watermark.pdf"); FunctionDesigner designer = ProviderHelpers.CreateDesigner <AddWatermarkProvider>(); ConfigureInputFileFunctionValues(designer, inputAuth, inputFilePath); var watermarkPages = "4;1-2,2,2"; ConfigureWatermarkFunctionValues(designer, FileAuthentication.None, watermarkFilePath, position, watermarkPages); designer.Properties[Pdf.Common.PropertyNames.OutputFilePath].Value = outputFilePath; var tester = new FunctionTester <AddWatermarkProvider>(); tester.Execute(designer.GetProperties(), designer.GetParameters()); PdfComparer.AssertText(outputFilePath, inputAuth, this.authenticationManager, "1\nWatermark\r\n2\nWatermark\r\n3\r\n4\nWatermark", null); }
public void Protect(string filePath, FileAuthentication fileAuth) { CheckFileExists(filePath); if (fileAuth == FileAuthentication.None) { return; } string outputFilePath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); using (var reader = new PdfReader(filePath)) using (var outputStream = new FileStream(outputFilePath, FileMode.CreateNew, FileAccess.Write, FileShare.None)) using (var stamper = new PdfStamper(reader, outputStream)) { switch (fileAuth) { case FileAuthentication.Password: stamper.SetEncryption(PdfWriter.ENCRYPTION_AES_256, Password, Password, 0); break; case FileAuthentication.CertificateFile: case FileAuthentication.CertificateStore: var certificates = new Org.BouncyCastle.X509.X509Certificate[] { DotNetUtilities.FromX509Certificate(new X509Certificate2(CertificateFilePath, CertificateFilePassword)) }; stamper.SetEncryption(certificates, new int[] { 0 }, PdfWriter.ENCRYPTION_AES_256); break; default: throw new NotSupportedException("Invalid FileAuthentication specified."); } } File.Delete(filePath); File.Move(outputFilePath, filePath); }
public void SignWithInvisibleSignature( [Values( FileAuthentication.None, FileAuthentication.Password /*, * Ignore: http://stackoverflow.com/questions/40045745/itextsharp-object-reference-error-on-pdfstamper-for-certificate-protected-file * FileAuthentication.CertificateFile, * FileAuthentication.CertificateStore*/)] FileAuthentication inputAuth, [Values( FileAuthentication.CertificateFile, FileAuthentication.CertificateStore)] FileAuthentication signAuth, [Values( "Sign.pdf", "SignXFA.pdf")] string fileName) { string inputFilePath = ResourceHelpers.WriteResourceToFile($"Twenty57.Linx.Components.Pdf.Tests.Sign.Resources.{fileName}", this.inputDirectory); string outputFilePath = Path.Combine(this.outputDirectory, fileName); this.lockDocument = !this.lockDocument; FunctionDesigner designer = ProviderHelpers.CreateDesigner <SignProvider>(); ConfigureInputFileFunctionValues(designer, inputAuth, inputFilePath); ConfigureSignCertificateProperties(designer, signAuth, this.lockDocument); designer.Properties[PropertyNames.Placement].Value = SignaturePosition.Hidden; designer.Properties[Pdf.Common.PropertyNames.OutputFilePath].Value = outputFilePath; var tester = new FunctionTester <SignProvider>(); tester.Execute(designer.GetProperties(), designer.GetParameters()); PdfComparer.AssertPageSignature(outputFilePath, inputAuth, this.authenticationManager, signName, signLocation, signReason, this.lockDocument, 1, 0, 0, 0, 0); }
private void ConfigureSignCertificateProperties(FunctionDesigner designer, FileAuthentication signAuth, bool lockDocument) { designer.Properties[PropertyNames.Operation].Value = Operation.Sign; switch (signAuth) { case FileAuthentication.CertificateFile: designer.Properties[PropertyNames.SignCertificateSource].Value = CertificateSource.File; designer.Properties[PropertyNames.SignCertificateFilePath].Value = this.authenticationManager.CertificateFilePath; designer.Properties[PropertyNames.SignCertificateFilePassword].Value = this.authenticationManager.CertificateFilePassword; break; case FileAuthentication.CertificateStore: designer.Properties[PropertyNames.SignCertificateSource].Value = CertificateSource.Store; designer.Properties[PropertyNames.SignCertificate].Value = this.authenticationManager.StoredCertificate; break; default: throw new NotSupportedException(); } designer.Properties[PropertyNames.SignSignedAt].Value = signLocation; designer.Properties[PropertyNames.SignReason].Value = signReason; designer.Properties[PropertyNames.SignLockAfterSigning].Value = lockDocument; }
private void AssertOutputFile(string outputFilePath, FileAuthentication outputAuth, string expectedFilePath, int expectedNumberOfPages, string expectedText) { Assert.IsTrue(File.Exists(outputFilePath)); Assert.AreEqual(expectedFilePath, outputFilePath); PdfComparer.AssertPageCount(outputFilePath, outputAuth, this.authenticationManager, expectedNumberOfPages); PdfComparer.AssertText(outputFilePath, outputAuth, this.authenticationManager, expectedText, null); }
public static void AssertProtection(string filePath, FileAuthentication fileAuth, AuthenticationManager authenticationManager, bool expectedIsEncrypted, bool expectedDontEncryptMetadata, bool expectedAllowAssembly = false, bool expectedAllowCopy = false, bool expectedAllowDegradedPrinting = false, bool expectedAllowFillIn = false, bool expectedAllowModifyAnnotations = false, bool expectedAllowModifyContents = false, bool expectedAllowPrinting = false, bool expectedAllowScreenReaders = false) { using (var comparer = new PdfComparer(filePath, fileAuth, authenticationManager)) { Assert.AreEqual(expectedIsEncrypted, comparer.pdfReader.IsEncrypted()); Assert.AreEqual(expectedDontEncryptMetadata, !comparer.pdfReader.IsMetadataEncrypted()); if (expectedAllowAssembly && expectedAllowCopy && expectedAllowDegradedPrinting && expectedAllowFillIn && expectedAllowModifyAnnotations && expectedAllowModifyContents && expectedAllowPrinting && expectedAllowScreenReaders) { Assert.IsTrue(comparer.pdfReader.IsOpenedWithFullPermissions); } else { Assert.AreEqual(expectedAllowAssembly, PdfEncryptor.IsAssemblyAllowed((int)comparer.pdfReader.Permissions)); Assert.AreEqual(expectedAllowCopy, PdfEncryptor.IsCopyAllowed((int)comparer.pdfReader.Permissions)); Assert.AreEqual(expectedAllowDegradedPrinting, PdfEncryptor.IsDegradedPrintingAllowed((int)comparer.pdfReader.Permissions)); Assert.AreEqual(expectedAllowFillIn, PdfEncryptor.IsFillInAllowed((int)comparer.pdfReader.Permissions)); Assert.AreEqual(expectedAllowModifyAnnotations, PdfEncryptor.IsModifyAnnotationsAllowed((int)comparer.pdfReader.Permissions)); Assert.AreEqual(expectedAllowModifyContents, PdfEncryptor.IsModifyContentsAllowed((int)comparer.pdfReader.Permissions)); Assert.AreEqual(expectedAllowPrinting, PdfEncryptor.IsPrintingAllowed((int)comparer.pdfReader.Permissions)); Assert.AreEqual(expectedAllowScreenReaders, PdfEncryptor.IsScreenReadersAllowed((int)comparer.pdfReader.Permissions)); } } }
public void AddWatermarkWithAuthentication( [Values( FileAuthentication.None, FileAuthentication.Password, FileAuthentication.CertificateFile, FileAuthentication.CertificateStore)] FileAuthentication watermarkAuth) { string inputFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.AddWatermark.Resources.Watermark.pdf", this.inputDirectory); string watermarkFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.AddWatermark.Resources.Overlay.pdf", this.inputDirectory); string outputFilePath = Path.Combine(this.outputDirectory, "Watermark.pdf"); FunctionDesigner designer = ProviderHelpers.CreateDesigner <AddWatermarkProvider>(); ConfigureInputFileFunctionValues(designer, FileAuthentication.None, inputFilePath); var watermarkPages = string.Empty; ConfigureWatermarkFunctionValues(designer, watermarkAuth, watermarkFilePath, WatermarkPosition.Below, watermarkPages); designer.Properties[Pdf.Common.PropertyNames.OutputFilePath].Value = outputFilePath; var tester = new FunctionTester <AddWatermarkProvider>(); tester.Execute(designer.GetProperties(), designer.GetParameters()); PdfComparer.AssertText(outputFilePath, FileAuthentication.None, this.authenticationManager, "1\nWatermark\r\n2\nWatermark\r\n3\nWatermark\r\n4\nWatermark", null); }
public static void AssertPageCount(string filePath, FileAuthentication fileAuth, AuthenticationManager authenticationManager, int expectedNumberOfPages) { using (var comparer = new PdfComparer(filePath, fileAuth, authenticationManager)) { Assert.AreEqual(expectedNumberOfPages, comparer.pdfReader.NumberOfPages); } }
public void ProtectWithPrintRestrictions( [Values( FileAuthentication.Password /*, * Ignore: http://stackoverflow.com/questions/40045745/itextsharp-object-reference-error-on-pdfstamper-for-certificate-protected-file * FileAuthentication.CertificateFile, * FileAuthentication.CertificateStore*/)] FileAuthentication protectAuth, [Values( Printing.None, Printing.LowResolution, Printing.HighResolution)] Printing printing) { string inputFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.ChangeProtection.Resources.Protect.pdf", this.inputDirectory); string outputFilePath = Path.Combine(this.outputDirectory, "Protect.pdf"); FunctionDesigner designer = ProviderHelpers.CreateDesigner <ChangeProtectionProvider>(); ConfigureInputFileFunctionValues(designer, FileAuthentication.None, inputFilePath); ConfigureProtectFunctionValues(designer, protectAuth, Encryption.AES256, true, true, printing: printing); designer.Properties[Pdf.Common.PropertyNames.OutputFilePath].Value = outputFilePath; var tester = new FunctionTester <ChangeProtectionProvider>(); tester.Execute(designer.GetProperties(), designer.GetParameters()); bool allowDegradedPrinting = false; bool allowPrinting = false; switch (printing) { case Printing.None: break; case Printing.LowResolution: allowDegradedPrinting = true; break; case Printing.HighResolution: allowDegradedPrinting = true; allowPrinting = true; break; default: throw new NotSupportedException("Invalid Printing specified."); } PdfComparer.AssertProtection(outputFilePath, protectAuth, this.authenticationManager, true, true, expectedAllowDegradedPrinting: allowDegradedPrinting, expectedAllowPrinting: allowPrinting); if (protectAuth == FileAuthentication.Password) { using (var permissionsAuthHelper = new AuthenticationManager(permissionsPassword)) { PdfComparer.AssertProtectionAllRights(outputFilePath, FileAuthentication.Password, permissionsAuthHelper, true, true); } } }
public static void AssertFieldSignature(string filePath, FileAuthentication fileAuth, AuthenticationManager authenticationManager, string expectedFieldName, string expectedSignName, string expectedLocation, string expectedReason, bool expectedLockDocument) { using (var comparer = new PdfComparer(filePath, fileAuth, authenticationManager)) { string signatureName = comparer.GetSignatureName(); Assert.AreEqual(expectedFieldName, signatureName); comparer.AssertCertificationLevel(expectedLockDocument); comparer.AssertSignatureDetails(signatureName, expectedSignName, expectedLocation, expectedReason); } }
public static void AssertPageSignature(string filePath, FileAuthentication fileAuth, AuthenticationManager authenticationManager, string expectedSignName, string expectedLocation, string expectedReason, bool expectedLockDocument, int expectedPage, float expectedLeft, float expectedTop, float expectedWidth, float expectedHeight) { using (var comparer = new PdfComparer(filePath, fileAuth, authenticationManager)) { string signatureName = comparer.GetSignatureName(); comparer.AssertCertificationLevel(expectedLockDocument); comparer.AssertSignatureDetails(signatureName, expectedSignName, expectedLocation, expectedReason); comparer.AssertSignaturePosition(signatureName, expectedPage, expectedLeft, expectedTop, expectedWidth, expectedHeight); } }
private void ConfigureInputFileFunctionValues(FunctionDesigner designer, FileAuthentication inputAuth, string inputFilePath) { ConfigureInputFileFunctionValues( designer, inputAuth, inputFilePath, PropertyNames.PdfFilePath, PropertyNames.AuthenticationType, PropertyNames.PdfPassword, PropertyNames.CertificateSource, PropertyNames.CertificateFilePath, PropertyNames.CertificateFilePassword, PropertyNames.Certificate); }
public static void AssertText(string filePath, FileAuthentication fileAuth, AuthenticationManager authenticationManager, string expectedText, string expectedJavaScript) { using (var comparer = new PdfComparer(filePath, fileAuth, authenticationManager)) { var pageText = new List <string>(); for (int pageIndex = 1; pageIndex <= comparer.pdfReader.NumberOfPages; pageIndex++) { pageText.Add(PdfTextExtractor.GetTextFromPage(comparer.pdfReader, pageIndex)); } var pagesText = string.Join(Environment.NewLine, pageText); Assert.AreEqual(expectedText, pagesText); Assert.AreEqual(expectedJavaScript, comparer.pdfReader.JavaScript); } }
public static void AssertFields(string filePath, FileAuthentication fileAuth, AuthenticationManager authenticationManager, IReadOnlyDictionary <string, string> expectedFieldValues) { using (var comparer = new PdfComparer(filePath, fileAuth, authenticationManager)) { if (comparer.pdfReader.AcroFields.Xfa.XfaPresent) { Dictionary <string, string> fieldValues = comparer.pdfReader.AcroFields.Xfa.DatasetsSom.Name2Node.ToDictionary(field => field.Key, field => field.Value.InnerText); Assert.AreEqual(expectedFieldValues, fieldValues); } else { Dictionary <string, string> fieldValues = comparer.pdfReader.AcroFields.Fields.Keys.ToDictionary(key => key, key => comparer.pdfReader.AcroFields.GetField(key)); Assert.AreEqual(expectedFieldValues, fieldValues); } } }
public void ReadWithNoOutput( [Values( FileAuthentication.None, FileAuthentication.Password, FileAuthentication.CertificateFile, FileAuthentication.CertificateStore)] FileAuthentication inputAuth) { string inputFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.Read.Resources.Blank.pdf", this.inputDirectory); FunctionDesigner designer = ProviderHelpers.CreateDesigner<ReadProvider>(); ConfigureInputFileFunctionValues(designer, inputAuth, inputFilePath); designer.Properties[PropertyNames.ReadText].Value = false; designer.Properties[PropertyNames.ReadFormData].Value = false; designer.Properties[PropertyNames.ReadSignature].Value = false; var tester = new FunctionTester<ReadProvider>(); Assert.DoesNotThrow(() => tester.Execute(designer.GetProperties(), designer.GetParameters())); }
public void Split( [Values( FileAuthentication.None, FileAuthentication.Password, FileAuthentication.CertificateFile, FileAuthentication.CertificateStore)] FileAuthentication inputAuth, [Values( true, false)] bool loopResults) { string inputFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.PdfOperations.Resources.Split.pdf", this.inputDirectory); string outputFilePath = Path.Combine(this.outputDirectory, "Split.pdf"); FunctionDesigner designer = ProviderHelpers.CreateDesigner <PdfOperationsProvider>(); ConfigureInputFileFunctionValues(designer, inputAuth, inputFilePath); designer.Properties[PropertyNames.Operation].Value = Operation.Split; designer.Properties[PropertyNames.SplitLoopResults].Value = loopResults; designer.Properties[PropertyNames.OutputFilePath].Value = outputFilePath; var tester = new FunctionTester <PdfOperationsProvider>(); FunctionResult result = tester.Execute(designer.GetProperties(), designer.GetParameters()); Assert.AreEqual(2, result.Value.NumberOfPages); if (loopResults) { Assert.AreEqual(2, result.ExecutionPathResult.Count()); NextResult nextResult = result.ExecutionPathResult.ElementAt(0); Assert.AreEqual(ExecutionPathNames.PageFiles, nextResult.Name); AssertOutputFile(nextResult.Value, inputAuth, Path.Combine(this.outputDirectory, "Split_1.pdf"), 1, "1"); nextResult = result.ExecutionPathResult.ElementAt(1); Assert.AreEqual(ExecutionPathNames.PageFiles, nextResult.Name); AssertOutputFile(nextResult.Value, inputAuth, Path.Combine(this.outputDirectory, "Split_2.pdf"), 1, "2"); } else { Assert.AreEqual(2, result.Value.PageFiles.Count); string pageFile = result.Value.PageFiles[0]; AssertOutputFile(pageFile, inputAuth, Path.Combine(this.outputDirectory, "Split_1.pdf"), 1, "1"); pageFile = result.Value.PageFiles[1]; AssertOutputFile(pageFile, inputAuth, Path.Combine(this.outputDirectory, "Split_2.pdf"), 1, "2"); } }
private void ConfigureWatermarkFunctionValues(FunctionDesigner designer, FileAuthentication watermarkAuth, string watermarkFilePath, WatermarkPosition position, string watermarkPages) { designer.Properties[PropertyNames.Position].Value = position; designer.Properties[PropertyNames.Pages].Value = watermarkPages; ConfigureInputFileFunctionValues( designer, watermarkAuth, watermarkFilePath, PropertyNames.FilePath, PropertyNames.AuthenticationType, PropertyNames.Password, PropertyNames.CertificateSource, PropertyNames.CertificateFilePath, PropertyNames.CertificateFilePassword, PropertyNames.Certificate); }
protected void ConfigureInputFileFunctionValues( FunctionDesigner designer, FileAuthentication inputAuth, string inputFilePath, string inputFilePathPropertyName, string authenticationTypePropertyName, string inputPasswordPropertyName, string certificateSourcePropertyName, string certificateFilePathPropertyName, string certificateFilePasswordPropertyName, string certificatePropertyName) { this.authenticationManager.Protect(inputFilePath, inputAuth); designer.Properties[inputFilePathPropertyName].Value = inputFilePath; switch (inputAuth) { case FileAuthentication.None: designer.Properties[authenticationTypePropertyName].Value = AuthenticationType.None; break; case FileAuthentication.Password: designer.Properties[authenticationTypePropertyName].Value = AuthenticationType.Password; designer.Properties[inputPasswordPropertyName].Value = this.authenticationManager.Password; break; case FileAuthentication.CertificateFile: designer.Properties[authenticationTypePropertyName].Value = AuthenticationType.Certificate; designer.Properties[certificateSourcePropertyName].Value = CertificateSource.File; designer.Properties[certificateFilePathPropertyName].Value = this.authenticationManager.CertificateFilePath; designer.Properties[certificateFilePasswordPropertyName].Value = this.authenticationManager.Password; break; case FileAuthentication.CertificateStore: designer.Properties[authenticationTypePropertyName].Value = AuthenticationType.Certificate; designer.Properties[certificateSourcePropertyName].Value = CertificateSource.Store; designer.Properties[certificatePropertyName].Value = this.authenticationManager.StoredCertificate; break; default: throw new NotSupportedException("Invalid FileAuthentication specified."); } }
public void FillFormXfa( [Values( FileAuthentication.None, FileAuthentication.Password /*, * Ignore: http://stackoverflow.com/questions/40045745/itextsharp-object-reference-error-on-pdfstamper-for-certificate-protected-file * FileAuthentication.CertificateFile, * FileAuthentication.CertificateStore*/)] FileAuthentication inputAuth) { string inputFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.PdfOperations.Resources.FillFormXFA.pdf", this.inputDirectory); string outputFilePath = Path.Combine(this.outputDirectory, "FillXfa.pdf"); var formData = new { form1_910_93_46FullName_910_93 = "John", form1_910_93_46Surname_910_93 = "Doe", form1_910_93_46Email_910_93 = "*****@*****.**", form1_910_93_46EmailMe_910_93 = true }; FunctionDesigner designer = ProviderHelpers.CreateDesigner <PdfOperationsProvider>(); ConfigureInputFileFunctionValues(designer, inputAuth, inputFilePath); designer.Properties[PropertyNames.Operation].Value = Operation.FillForm; designer.Properties[PropertyNames.FillFormFormData].Value = formData; designer.Properties[PropertyNames.OutputFilePath].Value = outputFilePath; var tester = new FunctionTester <PdfOperationsProvider>(); tester.Execute(designer.GetProperties(), designer.GetParameters()); var formValues = new Dictionary <string, string> { { "form1[0].FullName[0]", formData.form1_910_93_46FullName_910_93 }, { "form1[0].Surname[0]", formData.form1_910_93_46Surname_910_93 }, { "form1[0].Email[0]", formData.form1_910_93_46Email_910_93 }, { "form1[0].EmailMe[0]", (formData.form1_910_93_46EmailMe_910_93) ? "Yes" : "No" }, { "form1[0]", "*****@*****.**" } }; PdfComparer.AssertFields(outputFilePath, inputAuth, this.authenticationManager, formValues); }
public void ProtectWithNoRestrictions( [Values( FileAuthentication.Password, FileAuthentication.CertificateFile, FileAuthentication.CertificateStore)] FileAuthentication protectAuth) { string inputFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.ChangeProtection.Resources.Protect.pdf", this.inputDirectory); string outputFilePath = Path.Combine(this.outputDirectory, "Protect.pdf"); FunctionDesigner designer = ProviderHelpers.CreateDesigner <ChangeProtectionProvider>(); ConfigureInputFileFunctionValues(designer, FileAuthentication.None, inputFilePath); ConfigureProtectFunctionValues(designer, protectAuth, Encryption.AES256, true); designer.Properties[Pdf.Common.PropertyNames.OutputFilePath].Value = outputFilePath; var tester = new FunctionTester <ChangeProtectionProvider>(); tester.Execute(designer.GetProperties(), designer.GetParameters()); PdfComparer.AssertProtectionAllRights(outputFilePath, protectAuth, this.authenticationManager, true, true); }
private void ConfigureProtectFunctionValues(FunctionDesigner designer, FileAuthentication protectAuth, Encryption encryption, bool dontEncryptMetadata, bool addDocumentRestrictions = false, Printing printing = Printing.None, Changes changes = Changes.None, bool allowCopy = false, bool allowScreenReaders = false) { designer.Properties[PropertyNames.Operation].Value = Operation.Protect; switch (protectAuth) { case FileAuthentication.None: designer.Properties[PropertyNames.ProtectProtection].Value = AuthenticationType.None; return; case FileAuthentication.Password: designer.Properties[PropertyNames.ProtectProtection].Value = AuthenticationType.Password; designer.Properties[PropertyNames.ProtectDocumentOpenPassword].Value = this.authenticationManager.Password; designer.Properties[PropertyNames.ProtectPermissionsPassword].Value = permissionsPassword; break; case FileAuthentication.CertificateFile: designer.Properties[PropertyNames.ProtectProtection].Value = AuthenticationType.Certificate; designer.Properties[PropertyNames.ProtectCertificateSource].Value = CertificateSource.File; designer.Properties[PropertyNames.ProtectCertificateFilePath].Value = this.authenticationManager.CertificateFilePath; designer.Properties[PropertyNames.ProtectCertificateFilePassword].Value = this.authenticationManager.CertificateFilePassword; break; case FileAuthentication.CertificateStore: designer.Properties[PropertyNames.ProtectProtection].Value = AuthenticationType.Certificate; designer.Properties[PropertyNames.ProtectCertificateSource].Value = CertificateSource.Store; designer.Properties[PropertyNames.ProtectCertificate].Value = this.authenticationManager.StoredCertificate; break; } designer.Properties[PropertyNames.ProtectEncryption].Value = encryption; designer.Properties[PropertyNames.ProtectDontEncryptMetadata].Value = dontEncryptMetadata; designer.Properties[PropertyNames.ProtectAddDocumentRestrictions].Value = addDocumentRestrictions; designer.Properties[PropertyNames.ProtectAllowPrinting].Value = printing; designer.Properties[PropertyNames.ProtectAllowChanges].Value = changes; designer.Properties[PropertyNames.ProtectAllowCopying].Value = allowCopy; designer.Properties[PropertyNames.ProtectAllowScreenReaders].Value = allowScreenReaders; }
public void FillFormAcro( [Values( FileAuthentication.None, FileAuthentication.Password /*, * Ignore: http://stackoverflow.com/questions/40045745/itextsharp-object-reference-error-on-pdfstamper-for-certificate-protected-file * FileAuthentication.CertificateFile, * FileAuthentication.CertificateStore*/)] FileAuthentication inputAuth) { string inputFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.PdfOperations.Resources.FillForm.pdf", this.inputDirectory); string outputFilePath = Path.Combine(this.outputDirectory, "Fill.pdf"); var formData = new { First_32Name = "Jane", Surname = "Woods", Gender = "Female", AcceptTCs = true }; FunctionDesigner designer = ProviderHelpers.CreateDesigner <PdfOperationsProvider>(); ConfigureInputFileFunctionValues(designer, inputAuth, inputFilePath); designer.Properties[PropertyNames.Operation].Value = Operation.FillForm; designer.Properties[PropertyNames.FillFormFormData].Value = formData; designer.Properties[PropertyNames.OutputFilePath].Value = outputFilePath; var tester = new FunctionTester <PdfOperationsProvider>(); tester.Execute(designer.GetProperties(), designer.GetParameters()); var formValues = new Dictionary <string, string> { { "First Name", formData.First_32Name }, { "Surname", formData.Surname }, { "Gender", formData.Gender }, { "AcceptTCs", (formData.AcceptTCs)? "Yes" : "No" } }; PdfComparer.AssertFields(outputFilePath, inputAuth, this.authenticationManager, formValues); }
public void ProtectWithRemoveProtection( [Values( FileAuthentication.None, FileAuthentication.Password, FileAuthentication.CertificateFile, FileAuthentication.CertificateStore)] FileAuthentication inputAuth) { string inputFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.PdfOperations.Resources.Protect.pdf", this.inputDirectory); string outputFilePath = Path.Combine(this.outputDirectory, "Protect.pdf"); FunctionDesigner designer = ProviderHelpers.CreateDesigner <PdfOperationsProvider>(); ConfigureInputFileFunctionValues(designer, inputAuth, inputFilePath); ConfigureProtectFunctionValues(designer, FileAuthentication.None, Encryption.AES128, false); designer.Properties[PropertyNames.OutputFilePath].Value = outputFilePath; var tester = new FunctionTester <PdfOperationsProvider>(); tester.Execute(designer.GetProperties(), designer.GetParameters()); PdfComparer.AssertText(outputFilePath, FileAuthentication.None, this.authenticationManager, "Text on page 1", null); }
public void ProtectWithChangeRestrictions( [Values( FileAuthentication.Password /*, * Ignore: http://stackoverflow.com/questions/40045745/itextsharp-object-reference-error-on-pdfstamper-for-certificate-protected-file * FileAuthentication.CertificateFile, * FileAuthentication.CertificateStore*/)] FileAuthentication protectAuth, [Values( Changes.None, Changes.Assembly, Changes.FillIn, Changes.AnnotateAndFillIn, Changes.AnyExpectExtract)] Changes changes) { string inputFilePath = ResourceHelpers.WriteResourceToFile("Twenty57.Linx.Components.Pdf.Tests.PdfOperations.Resources.Protect.pdf", this.inputDirectory); string outputFilePath = Path.Combine(this.outputDirectory, "Protect.pdf"); FunctionDesigner designer = ProviderHelpers.CreateDesigner <PdfOperationsProvider>(); ConfigureInputFileFunctionValues(designer, FileAuthentication.None, inputFilePath); ConfigureProtectFunctionValues(designer, protectAuth, Encryption.AES256, true, true, changes: changes); designer.Properties[PropertyNames.OutputFilePath].Value = outputFilePath; var tester = new FunctionTester <PdfOperationsProvider>(); tester.Execute(designer.GetProperties(), designer.GetParameters()); bool allowAssembly = false; bool allowFillIn = false; bool allowModifyAnnotations = false; bool allowModifyContents = false; switch (changes) { case Changes.None: break; case Changes.Assembly: allowAssembly = true; break; case Changes.FillIn: allowFillIn = true; break; case Changes.AnnotateAndFillIn: allowModifyAnnotations = true; allowFillIn = true; break; case Changes.AnyExpectExtract: allowModifyContents = true; allowModifyAnnotations = true; allowFillIn = true; break; default: throw new NotSupportedException("Invalid Changes specified."); } PdfComparer.AssertProtection(outputFilePath, protectAuth, this.authenticationManager, true, true, expectedAllowAssembly: allowAssembly, expectedAllowFillIn: allowFillIn, expectedAllowModifyAnnotations: allowModifyAnnotations, expectedAllowModifyContents: allowModifyContents); if (protectAuth == FileAuthentication.Password) { using (var permissionsAuthHelper = new AuthenticationManager(permissionsPassword)) { PdfComparer.AssertProtectionAllRights(outputFilePath, FileAuthentication.Password, permissionsAuthHelper, true, true); } } }
private PdfComparer(string filePath, FileAuthentication fileAuth, AuthenticationManager authenticationManager) { this.pdfReader = authenticationManager.GetReader(filePath, fileAuth); }
public static void AssertProtectionAllRights(string filePath, FileAuthentication fileAuth, AuthenticationManager authenticationManager, bool expectedIsEncrypted, bool expectedDontEncryptMetadata) { AssertProtection(filePath, fileAuth, authenticationManager, expectedIsEncrypted, expectedDontEncryptMetadata, true, true, true, true, true, true, true, true); }