Encrypt & Decrypt PDFs - C++ Sample Code

1//
2// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
3//
4
5using System;
6using pdftron;
7using pdftron.Common;
8using pdftron.Filters;
9using pdftron.SDF;
10using pdftron.PDF;
11
12namespace EncTestCS
13{
14	// A custom security handler used to obtain document password dynamically via user feedback. 
15	class MySecurityHandler : StdSecurityHandler
16	{
17		public MySecurityHandler (Int32 key_len, Int32 enc_code) : base(key_len, enc_code) {}
18		public MySecurityHandler (MySecurityHandler s) : base(s) {}
19
20		// In this callback ask the user for password/authorization data. 
21		// This may involve a dialog box used to collect authorization data or something else.
22		override public bool GetAuthorizationData (SecurityHandler.Permission p) 
23		{ 
24			Console.WriteLine("The input file requires user password.");
25			Console.WriteLine("Please enter the password:");
26			String pass = Console.ReadLine();
27			InitPassword(pass);
28			return true; 
29		}
30
31		// This callback could be used to customize security handler preferences.
32		override public bool EditSecurityData(SDFDoc doc) { return false; }
33
34		// This callback is used when authorization process fails. 
35		override public void AuthorizeFailed() 
36		{
37			Console.WriteLine("Authorize failed...");
38		}
39
40		public static SecurityHandler Create(String name, Int32 key_len, Int32 enc_code) { return new MySecurityHandler(key_len, enc_code); }
41
42		override public SecurityHandler Clone() { return new MySecurityHandler(this); }
43	}
44
45	/// <summary>
46	//---------------------------------------------------------------------------------------
47	// This sample shows encryption support in PDFNet. The sample reads an encrypted document and 
48	// sets a new SecurityHandler. The sample also illustrates how password protection can 
49	// be removed from an existing PDF document.
50	//---------------------------------------------------------------------------------------
51	/// </summary>
52	class Class1
53	{
54		private static pdftron.PDFNetLoader pdfNetLoader = pdftron.PDFNetLoader.Instance();
55		static Class1() {}
56		
57		static void Main(string[] args)
58		{
59			PDFNet.Initialize(PDFTronLicense.Key);
60
61			// Relative path to the folder containing test files.
62			string input_path =  "../../../../TestFiles/";
63			string output_path = "../../../../TestFiles/Output/";
64
65			// Example 1: Securing a document with password protection and adjusting permissions 
66			// on the document.
67			try
68			{
69				// Open the test file
70				Console.WriteLine("-------------------------------------------------");
71				Console.WriteLine("Securing an existing document...");
72				using (PDFDoc doc = new PDFDoc(input_path + "fish.pdf"))
73				{
74
75					if (!doc.InitSecurityHandler()) 
76					{
77						Console.WriteLine("Document authentication error...");
78						return;
79					}
80					
81					// Perform some operation on the document. In this case we use low level SDF API
82					// to replace the content stream of the first page with contents of file 'my_stream.txt'
83					if (true)  // Optional
84					{
85						Console.WriteLine("Replacing the content stream, use flate compression...");
86
87						// Get the first page dictionary using the following path: trailer/Root/Pages/Kids/0
88						Obj page_dict = doc.GetTrailer().Get("Root").Value().
89							Get("Pages").Value().Get("Kids").Value().GetAt(0);
90
91						// Embed a custom stream (file mystream.txt) using Flate compression.
92						MappedFile embed_file = new MappedFile(input_path + "my_stream.txt");
93						FilterReader mystm = new FilterReader(embed_file);
94						page_dict.Put("Contents", doc.CreateIndirectStream(mystm));
95						embed_file.Close();
96					}
97				
98					// Apply a new security handler with given security settings. 
99					// In order to open saved PDF you will need a user password 'test'.
100					StdSecurityHandler new_handler = new StdSecurityHandler();
101
102					// Set a new password required to open a document
103					string my_password = "test";				
104					new_handler.ChangeUserPassword(my_password);
105
106					// Set Permissions
107					new_handler.SetPermission (SecurityHandler.Permission.e_print, true);
108					new_handler.SetPermission (SecurityHandler.Permission.e_extract_content, false);
109
110					// Note: document takes the ownership of new_handler.
111					doc.SetSecurityHandler(new_handler);
112
113					// Save the changes.
114					Console.WriteLine("Saving modified file...");
115					doc.Save(output_path + "secured.pdf", 0);
116				}
117
118				Console.WriteLine("Done. Result saved in secured.pdf");
119			}
120			catch (PDFNetException e)
121			{
122				Console.WriteLine(e.Message);
123			}
124
125			// Example 2: Reading password protected document without user feedback.
126			try
127			{
128				// In this sample case we will open an encrypted document that 
129				// requires a user password in order to access the content.
130				Console.WriteLine("-------------------------------------------------");
131				Console.WriteLine("Open the password protected document from the first example...");
132				using (PDFDoc doc = new PDFDoc(output_path + "secured.pdf"))	// Open the encrypted document that we saved in the first example. 
133				{
134
135					Console.WriteLine("Initializing security handler without any user interaction...");
136					
137					// At this point MySecurityHandler callbacks will be invoked. 
138					// MySecurityHandler.GetAuthorizationData() should collect the password and 
139					// AuthorizeFailed() is called if user repeatedly enters a wrong password.
140					if (!doc.InitStdSecurityHandler("test")) 
141					{
142						Console.WriteLine("Document authentication error...");
143						Console.WriteLine("The password is not valid.");
144						return;
145					}
146					else 
147					{
148						Console.WriteLine("The password is correct! Document can now be used for reading and editing");
149
150						// Remove the password security and save the changes to a new file.
151						doc.RemoveSecurity();
152						doc.Save(output_path + "secured_nomore1.pdf", 0);
153						Console.WriteLine("Done. Result saved in secured_nomore1.pdf");
154					}
155
156				}
157			}
158			catch (PDFNetException e)
159			{
160				Console.WriteLine(e.Message);
161			}
162
163			// Example 3:
164			// Encrypt/Decrypt a PDF using PDFTron custom security handler
165			try
166			{
167				Console.WriteLine("-------------------------------------------------");
168				Console.WriteLine("Encrypt a document using PDFTron Custom Security handler with a custom id and password...");
169				PDFDoc doc = new PDFDoc(input_path + "BusinessCardTemplate.pdf");
170
171				// Create PDFTron custom security handler with a custom id. Replace this with your own integer
172				int custom_id = 123456789;
173				PDFTronCustomSecurityHandler custom_handler = new PDFTronCustomSecurityHandler(custom_id);
174
175				// Add a password to the custom security handler
176				String pass = "test";
177				custom_handler.ChangeUserPassword(pass);
178
179				// Save the encrypted document
180				doc.SetSecurityHandler(custom_handler);
181				doc.Save(output_path + "BusinessCardTemplate_enc.pdf", 0);
182
183				Console.WriteLine("Decrypt the PDFTron custom security encrypted document above...");
184				// Register the PDFTron Custom Security handler with the same custom id used in encryption
185				PDFNet.AddPDFTronCustomHandler(custom_id);
186
187				PDFDoc doc_enc = new PDFDoc(output_path + "BusinessCardTemplate_enc.pdf");
188				doc_enc.InitStdSecurityHandler(pass);
189				doc_enc.RemoveSecurity();
190				// Save the decrypted document
191				doc_enc.Save(output_path + "BusinessCardTemplate_enc_dec.pdf", 0);
192				Console.WriteLine("Done. Result saved in BusinessCardTemplate_enc_dec.pdf");
193			}
194			catch (PDFNetException e)
195			{
196				Console.WriteLine(e.Message);
197			}
198
199			// Example 4: Reading password protected document with user feedback.
200			try
201			{
202				// Register standard security. Reguired only once per application session.
203				CreateDelegate del = new CreateDelegate(MySecurityHandler.Create);
204				SecurityManagerSingleton.Instance().RegisterSecurityHandler("Standard", 
205					new SecurityDescriptor("Standard Security", del));
206
207				Console.WriteLine("-------------------------------------------------");
208				Console.WriteLine("Open the password protected document from the first example...");
209				using (PDFDoc doc = new PDFDoc(output_path + "secured.pdf")) // Open the encrypted document that we saved in the first example. 
210				{
211
212					Console.WriteLine("Initializing security handler. The password will now be collected from the user");
213					Console.WriteLine("Enter 'test' as the password.");
214
215					// At this point MySecurityHandler callbacks will be invoked. 
216					// MySecurityHandler.GetAuthorizationData() should collect the password and 
217					// AuthorizeFailed() is called if user repeatedly enters a wrong password.
218					if (!doc.InitSecurityHandler()) 
219					{
220						Console.WriteLine("Document authentication error...");
221						Console.WriteLine("The password is not valid.");
222						return;
223					}
224					else 
225					{
226						Console.WriteLine("The password is correct! Document can now be used for reading and editing");
227
228						// Remove the password security and save the changes to a new file.
229						doc.RemoveSecurity();
230						doc.Save(output_path + "secured_nomore2.pdf", 0);
231						Console.WriteLine("Done. Result saved in secured_nomore2.pdf");
232					}
233				}
234			}
235			catch (PDFNetException e)
236			{
237				Console.WriteLine(e.Message);
238			}
239			PDFNet.Terminate();
240			Console.WriteLine("-------------------------------------------------");
241			Console.WriteLine("Tests completed.");
242
243		}
244	}
245}

1//---------------------------------------------------------------------------------------
2// Copyright (c) 2001-2021 by PDFTron Systems Inc. All Rights Reserved.
3// Consult LICENSE.txt regarding license information.
4//---------------------------------------------------------------------------------------
5
6package main
7import (
8	"fmt"
9	"strconv"
10	. "pdftron"
11)
12
13import  "pdftron/Samples/LicenseKey/GO"
14
15//---------------------------------------------------------------------------------------
16// This sample shows encryption support in PDFNet. The sample reads an encrypted document and 
17// sets a new SecurityHandler. The sample also illustrates how password protection can 
18// be removed from an existing PDF document.
19//---------------------------------------------------------------------------------------
20
21func main(){
22    PDFNetInitialize(PDFTronLicense.Key)
23    
24    // Relative path to the folder containing the test files.
25    inputPath := "../../TestFiles/"
26    outputPath := "../../TestFiles/Output/"
27    
28    // Example 1: 
29    // secure a PDF document with password protection and adjust permissions
30    
31    // Open the test file
32    fmt.Println("Securing an existing document...")
33    
34    doc := NewPDFDoc(inputPath + "fish.pdf")
35    doc.InitSecurityHandler()
36    
37    // Perform some operation on the document. In this case we use low level SDF API
38    // to replace the content stream of the first page with contents of file 'my_stream.txt'
39    if true{    // Optional
40        fmt.Println("Replacing the content stream, use Flate compression...")
41        
42        // Get the page dictionary using the following path: trailer/Root/Pages/Kids/0
43        pageDict := (doc.GetTrailer().Get("Root").Value().Get("Pages").Value().Get("Kids").Value().GetAt(0))
44        
45        // Embed a custom stream (file mystream.txt) using Flate compression.
46        embedFile := NewMappedFile(inputPath + "my_stream.txt")
47        mystm := NewFilterReader(embedFile)
48        pageDict.Put("Contents", doc.CreateIndirectStream(mystm, NewFilter()))
49    }   
50    // encrypt the document
51    
52    // Apply a new security handler with given security settings.
53    // In order to open saved PDF you will need a user password 'test'.
54    newHandler := NewSecurityHandler()
55    
56    // Set a new password required to open a document
57    userPassword := "test"
58    newHandler.ChangeUserPassword(userPassword)
59    
60    // Set permissions
61    newHandler.SetPermission(SecurityHandlerE_print, true)
62    newHandler.SetPermission(SecurityHandlerE_extract_content, false)
63    
64    // Note: document takes the ownership of newHandler.
65    doc.SetSecurityHandler(newHandler)
66    
67    // save the changes.
68    fmt.Println("Saving modified file...")
69    doc.Save(outputPath + "secured.pdf", uint(0))
70    doc.Close()
71    
72    // Example 2:
73    // Opens an encrypted PDF document and removes its security.
74    
75    doc = NewPDFDoc(outputPath + "secured.pdf")
76    
77    // If the document is encrypted prompt for the password
78    if !doc.InitSecurityHandler(){
79        success := false
80        fmt.Println("The password is: test")
81        count := 0
82        for count < 3{
83            fmt.Println("A password required to open the document.")
84            var password string
85            fmt.Print("Please enter the password: \n")
86            fmt.Scanf("%s", &password)
87            fmt.Println(password)
88                
89            if doc.InitStdSecurityHandler(password, len(password)){
90                success = true
91                fmt.Println("The password is correct.")
92                break
93            }else if count < 3{
94                fmt.Println("The password is incorrect, please try again")
95            }
96            count = count + 1
97        }    
98        if !success{
99            fmt.Println("Document authentication error....")
100            return
101        }
102        hdlr := doc.GetSecurityHandler()
103        fmt.Println("Document Open Password: " + strconv.FormatBool(hdlr.IsUserPasswordRequired()))
104        fmt.Println("Permissions Password: " + strconv.FormatBool(hdlr.IsMasterPasswordRequired()))
105        fmt.Println(("Permissions: " + 
106                "\n\tHas 'owner' permissions: " + strconv.FormatBool(hdlr.GetPermission(SecurityHandlerE_owner)) + 
107                "\n\tOpen and decrypt the document: " + strconv.FormatBool(hdlr.GetPermission(SecurityHandlerE_doc_open)) +
108                "\n\tAllow content extraction: " + strconv.FormatBool(hdlr.GetPermission(SecurityHandlerE_extract_content)) +
109                "\n\tAllow full document editing: " + strconv.FormatBool(hdlr.GetPermission(SecurityHandlerE_doc_modify) ) +
110                "\n\tAllow printing: " + strconv.FormatBool(hdlr.GetPermission(SecurityHandlerE_print)) + 
111                "\n\tAllow high resolution printing: " + strconv.FormatBool(hdlr.GetPermission(SecurityHandlerE_print_high)) + 
112                "\n\tAllow annotation editing: " + strconv.FormatBool(hdlr.GetPermission(SecurityHandlerE_mod_annot)) + 
113                "\n\tAllow form fill: " + strconv.FormatBool(hdlr.GetPermission(SecurityHandlerE_fill_forms)) + 
114                "\n\tAllow content extraction for accessibility: " + strconv.FormatBool(hdlr.GetPermission(SecurityHandlerE_access_support)) + 
115                "\n\tAllow document assembly: " + strconv.FormatBool(hdlr.GetPermission(SecurityHandlerE_assemble_doc))))
116    }
117    
118    // remove all security on the document
119    doc.RemoveSecurity()
120    doc.Save(outputPath + "not_secured.pdf", uint(0))
121    doc.Close()
122    
123    PDFNetTerminate()
124    fmt.Println("Test completed.")
125}

1//---------------------------------------------------------------------------------------
2// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
3// Consult legal.txt regarding legal and license information.
4//---------------------------------------------------------------------------------------
5
6import java.io.BufferedReader;
7import java.io.IOException;
8import java.io.InputStreamReader;
9
10import com.pdftron.common.PDFNetException;
11import com.pdftron.filters.FilterReader;
12import com.pdftron.filters.FlateEncode;
13import com.pdftron.filters.MappedFile;
14import com.pdftron.pdf.*;
15import com.pdftron.sdf.*;
16
17
18//---------------------------------------------------------------------------------------
19// This sample shows encryption support in PDFNet. The sample reads an encrypted document and 
20// sets a new SecurityHandler. The sample also illustrates how password protection can 
21// be removed from an existing PDF document.
22//---------------------------------------------------------------------------------------
23public class EncTest {
24    public static void main(String[] args) {
25        PDFNet.initialize(PDFTronLicense.Key());
26
27        // Relative path to the folder containing test files.
28        String input_path = "../../TestFiles/";
29        String output_path = "../../TestFiles/Output/";
30
31        // Example 1:
32        // secure a document with password protection and
33        // adjust permissions
34
35        // Open the test file
36        System.out.println("Securing an existing document ...");
37        try (PDFDoc doc = new PDFDoc((input_path + "fish.pdf"))) {
38            doc.initSecurityHandler();
39
40            // Perform some operation on the document. In this case we use low level SDF API
41            // to replace the content stream of the first page with contents of file 'my_stream.txt'
42            if (true)  // Optional
43            {
44                System.out.println("Replacing the content stream, use flate compression...");
45
46                // Get the page dictionary using the following path: trailer/Root/Pages/Kids/0
47                Obj page_dict = doc.getTrailer().get("Root").value()
48                        .get("Pages").value()
49                        .get("Kids").value()
50                        .getAt(0);
51
52                // Embed a custom stream (file mystream.txt) using Flate compression.
53                MappedFile embed_file = new MappedFile((input_path + "my_stream.txt"));
54                FilterReader mystm = new FilterReader(embed_file);
55                page_dict.put("Contents",
56                        doc.createIndirectStream(mystm,
57                                new FlateEncode(null)));
58            }
59
60            //encrypt the document
61
62            // Apply a new security handler with given security settings.
63            // In order to open saved PDF you will need a user password 'test'.
64            SecurityHandler new_handler = new SecurityHandler();
65
66            // Set a new password required to open a document
67            String user_password = "test";
68            new_handler.changeUserPassword(user_password);
69
70            // Set Permissions
71            new_handler.setPermission(SecurityHandler.e_print, true);
72            new_handler.setPermission(SecurityHandler.e_extract_content, false);
73
74            // Note: document takes the ownership of new_handler.
75            doc.setSecurityHandler(new_handler);
76
77            // Save the changes.
78            System.out.println("Saving modified file...");
79            doc.save((output_path + "secured.pdf"), SDFDoc.SaveMode.NO_FLAGS, null);
80        } catch (PDFNetException e) {
81            e.printStackTrace();
82        }
83
84        // Example 2:
85        // Opens the encrypted document and removes all of
86        // its security.
87        try (PDFDoc doc = new PDFDoc((output_path + "secured.pdf"))) {
88            //If the document is encrypted prompt for the password
89            if (!doc.initSecurityHandler()) {
90                boolean success = false;
91                System.out.println("The password is: test");
92                for (int count = 0; count < 3; count++) {
93                    BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
94                    System.out.println("A password required to open the document.");
95                    System.out.print("Please enter the password: ");
96                    String password = r.readLine();
97                    if (doc.initStdSecurityHandler(password)) {
98                        success = true;
99                        System.out.println("The password is correct.");
100                        break;
101                    } else if (count < 3) {
102                        System.out.println("The password is incorrect, please try again");
103                    }
104                }
105                if (!success) {
106                    System.out.println("Document authentication error....");
107                    PDFNet.terminate();
108                }
109            }
110
111            //remove all security on the document
112            doc.removeSecurity();
113            doc.save(output_path + "not_secured.pdf", SDFDoc.SaveMode.NO_FLAGS, null);
114        } catch (Exception e) {
115            e.printStackTrace();
116        }
117
118        // Example 3:
119        // Encrypt/Decrypt a PDF using PDFTron custom security handler
120        System.out.println("-------------------------------------------------");
121        System.out.println("Encrypt a document using PDFTron Custom Security handler with a custom id and password...");
122        try (PDFDoc doc = new PDFDoc(input_path + "BusinessCardTemplate.pdf"))
123        {   
124            // Create PDFTron custom security handler with a custom id. Replace this with your own integer
125            int custom_id = 123456789;
126            PDFTronCustomSecurityHandler custom_handler = new PDFTronCustomSecurityHandler(custom_id);
127
128            // Add a password to the custom security handler
129            String pass = "test";
130            custom_handler.changeUserPassword(pass);
131
132            // Save the encrypted document
133            doc.setSecurityHandler(custom_handler);
134            doc.save(output_path + "BusinessCardTemplate_enc.pdf", SDFDoc.SaveMode.NO_FLAGS, null);
135                    
136            System.out.println("Decrypt the PDFTron custom security encrypted document above...");
137            // Register the PDFTron Custom Security handler with the same custom id used in encryption
138            PDFNet.addPDFTronCustomHandler(custom_id);
139
140            PDFDoc doc_enc = new PDFDoc(output_path + "BusinessCardTemplate_enc.pdf");
141            doc_enc.initStdSecurityHandler(pass);
142            doc_enc.removeSecurity();
143            // Save the decrypted document
144            doc_enc.save(output_path + "BusinessCardTemplate_enc_dec.pdf", SDFDoc.SaveMode.NO_FLAGS, null);
145            System.out.println("Done. Result saved in BusinessCardTemplate_enc_dec.pdf");
146        } catch (Exception e) {
147            e.printStackTrace();
148        }
149        System.out.println("-------------------------------------------------");
150        System.out.println("Tests completed.");
151        PDFNet.terminate();
152    }
153}

1//---------------------------------------------------------------------------------------
2// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
3// Consult legal.txt regarding legal and license information.
4//---------------------------------------------------------------------------------------
5
6//---------------------------------------------------------------------------------------
7// This sample shows encryption support in PDFNet. The sample reads an encrypted document and 
8// sets a new SecurityHandler. The sample also illustrates how password protection can 
9// be removed from an existing PDF document.
10//---------------------------------------------------------------------------------------
11const { PDFNet } = require('@pdftron/pdfnet-node');
12const PDFTronLicense = require('../LicenseKey/LicenseKey');
13
14((exports) => {
15  exports.runEncTest = () => {
16
17    const main = async () => {
18      let ret = 0;
19      // Relative path to the folder containing test files.
20      const inputPath = '../TestFiles/';
21      const outputPath = inputPath + 'Output/';
22      // Example 1:
23      // secure a PDF document with password protection and adjust permissions
24      try {
25        // Open the test file
26        console.log('-------------------------------------------------/nSecuring an existing document...');
27        const doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'fish.pdf');
28        if (!(await doc.initSecurityHandler())) {
29          console.log('Document authentication error...');
30          ret = 1;
31        }
32
33        const performOperation = true; // optional parameter
34
35        // Perform some operation on the document. In this case we use low level SDF API
36        // to replace the content stream of the first page with contents of file 'my_stream.txt'
37        // Results in fish.pdf becoming a pair of feathers.
38        if (performOperation) {
39          console.log('Replacing the content stream, use Flate compression...');
40          // Get the page dictionary using the following path: trailer/Root/Pages/Kids/0
41          const pageTrailer = await doc.getTrailer();
42          const pageRoot = await pageTrailer.get('Root');
43          const pageRootValue = await pageRoot.value();
44          const pages = await pageRootValue.get('Pages');
45          const pagesVal = await pages.value();
46          const kids = await pagesVal.get('Kids');
47          const kidsVal = await kids.value();
48          const pageDict = await kidsVal.getAt(0);
49
50          const embedFile = await PDFNet.Filter.createMappedFileFromUString(inputPath + 'my_stream.txt');
51          const mystm = await PDFNet.FilterReader.create(embedFile);
52
53          const flateEncode = await PDFNet.Filter.createFlateEncode();
54
55          const indStream = await doc.createIndirectStreamFromFilter(mystm, flateEncode);
56          await pageDict.put('Contents', indStream);
57        }
58
59        // Encrypt the document
60        // Apply a new security handler with given security settings.
61        // In order to open saved PDF you will need a user password 'test'.
62        const newHandler = await PDFNet.SecurityHandler.createDefault();
63
64        // Set a new password required to open a document
65        newHandler.changeUserPasswordUString('test');
66
67        // Set Permissions
68        newHandler.setPermission(PDFNet.SecurityHandler.Permission.e_print, true);
69        await newHandler.setPermission(PDFNet.SecurityHandler.Permission.e_extract_content, false);
70
71        // Note: document takes the ownership of newHandler.
72        doc.setSecurityHandler(newHandler);
73
74        // Save the changes
75        console.log('Saving modified file...');
76        await doc.save(outputPath + 'secured.pdf', 0);
77        console.log('Done. Result saved in secured.pdf');
78      } catch (err) {
79        console.log(err);
80        console.log(err.stack);
81        ret = 1;
82      }
83
84      // Example 2:
85      // Opens an encrypted PDF document and removes its security.
86      try {
87        console.log('-------------------------------------------------');
88        console.log('Open the password protected document from the first example...');
89        const securedDoc = await PDFNet.PDFDoc.createFromFilePath(outputPath + 'secured.pdf');
90        console.log('Initializing security handler without any user interaction...');
91
92        // At this point MySecurityHandler callbacks will be invoked. 
93        // MySecurityHandler.GetAuthorizationData() should collect the password and 
94        // AuthorizeFailed() is called if user repeatedly enters a wrong password.
95        if (!(await securedDoc.initStdSecurityHandlerUString('test'))) {
96          console.log('Document authentication error.../nThe password is not valid.');
97          ret = 1;
98          return ret;
99        }
100
101        console.log('The password is correct! Document can now be used for reading and editing');
102
103        // Remove the password security and save the changes to a new file.
104        securedDoc.removeSecurity();
105        await securedDoc.save(outputPath + 'secured_nomore1.pdf', 0);
106        console.log('Done. Result saved in secured_nomore1.pdf');
107
108        /*
109        const hdlr = await securedDoc.getSecurityHandler();
110
111        console.log('Document Open Password: ' + (await hdlr.isUserPasswordRequired()));
112        console.log('Permissions Password: ' + (await hdlr.isMasterPasswordRequired()));
113        console.log('Permissions: ');
114        console.log("\tHas 'owner' permissions: " + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_owner)));
115
116        console.log('\tOpen and decrypt the document: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_doc_open)));
117        console.log('\tAllow content extraction: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_extract_content)));
118        console.log('\tAllow full document editing: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_doc_modify)));
119        console.log('\tAllow printing: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_print)));
120        console.log('\tAllow high resolution printing: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_print_high)));
121        console.log('\tAllow annotation editing: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_mod_annot)));
122        console.log('\tAllow form fill: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_fill_forms)));
123        console.log('\tAllow content extraction for accessibility: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_access_support)));
124        console.log('\tAllow document assembly: ' + (await hdlr.getPermission(PDFNet.SecurityHandler.Permission.e_assemble_doc)));
125        */
126      } catch (err) {
127        console.log(err.stack);
128        ret = 1;
129      }
130
131      // Example 3:
132      // Encrypt/Decrypt a PDF using PDFTron custom security handler
133      try {
134        console.log('-------------------------------------------------');
135        console.log('Encrypt a document using PDFTron Custom Security handler with a custom id and password...');
136        const doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + "BusinessCardTemplate.pdf");
137
138        // Create PDFTron custom security handler with a custom id. Replace this with your own integer
139        const custom_id = 123456789;
140        const custom_handler = await PDFNet.PDFTronCustomSecurityHandler.create(custom_id);
141
142        // Add a password to the custom security handler
143        const pass = 'test';
144        await custom_handler.changeUserPasswordUString(pass);
145
146        // Save the encrypted document
147        doc.setSecurityHandler(custom_handler);
148        await doc.save(outputPath + 'BusinessCardTemplate_enc.pdf', PDFNet.SDFDoc.SaveOptions.e_linearized);
149
150        console.log('Decrypt the PDFTron custom security encrypted document above...');
151        // Register the PDFTron Custom Security handler with the same custom id used in encryption
152        await PDFNet.addPDFTronCustomHandler(custom_id);
153
154        const doc_enc = await PDFNet.PDFDoc.createFromFilePath(outputPath + 'BusinessCardTemplate_enc.pdf');
155        doc_enc.initStdSecurityHandlerUString(pass);
156        doc_enc.removeSecurity();
157        // Save the decrypted document
158        await doc_enc.save(outputPath + 'BusinessCardTemplate_enc_dec.pdf', PDFNet.SDFDoc.SaveOptions.e_linearized);
159        console.log('Done. Result saved in BusinessCardTemplate_enc_dec.pdf');
160      } catch (err) {
161        console.log(err.stack);
162        ret = 1;
163      }
164
165      console.log('-------------------------------------------------');
166      console.log('Tests completed.');
167
168      return ret;
169    };
170
171    PDFNet.runWithCleanup(main, PDFTronLicense.Key).catch(function (error) { console.log('Error: ' + JSON.stringify(error)); }).then(function () { return PDFNet.shutdown(); });
172  };
173  exports.runEncTest();
174})(exports);
175// eslint-disable-next-line spaced-comment
176//# sourceURL=EncTest.js

1<?php
2//---------------------------------------------------------------------------------------
3// Copyright (c) 2001-2023 by Apryse Software Inc. All Rights Reserved.
4// Consult LICENSE.txt regarding license information.
5//---------------------------------------------------------------------------------------
6if(file_exists("../../../PDFNetC/Lib/PDFNetPHP.php"))
7include("../../../PDFNetC/Lib/PDFNetPHP.php");
8include("../../LicenseKey/PHP/LicenseKey.php");
9
10//---------------------------------------------------------------------------------------
11// This sample shows encryption support in PDFNet. The sample reads an encrypted document and 
12// sets a new SecurityHandler. The sample also illustrates how password protection can 
13// be removed from an existing PDF document.
14//---------------------------------------------------------------------------------------
15	PDFNet::Initialize($LicenseKey);
16	PDFNet::GetSystemFontList();    // Wait for fonts to be loaded if they haven't already. This is done because PHP can run into errors when shutting down if font loading is still in progress.
17	
18	// Relative path to the folder containing the test files.
19	$input_path = getcwd()."/../../TestFiles/";
20	$output_path = $input_path."Output/";
21
22	// Example 1: 
23	// secure a PDF document with password protection and adjust permissions
24
25	// Open the test file
26	echo "Securing an existing document ...\n";
27	$doc = new PDFDoc($input_path."fish.pdf");
28	$doc->InitSecurityHandler();
29
30	// Perform some operation on the document. In this case we use low level SDF API
31	// to replace the content stream of the first page with contents of file 'my_stream.txt'
32	if (true)  // Optional
33	{
34		echo "Replacing the content stream, use Flate compression...\n";
35
36		// Get the page dictionary using the following path: trailer/Root/Pages/Kids/0
37		$page_dict = $doc->GetTrailer()->Get("Root")->Value()
38			->Get("Pages")->Value()
39			->Get("Kids")->Value()
40			->GetAt(0);
41
42		// Embed a custom stream (file mystream.txt) using Flate compression.
43		$embed_file = new MappedFile($input_path."my_stream.txt");
44		$mystm = new FilterReader($embed_file);
45		$page_dict->Put("Contents", $doc->CreateIndirectStream($mystm, new FlateEncode(new Filter())));
46	}
47
48	//encrypt the document
49	
50	// Apply a new security handler with given security settings. 
51	// In order to open saved PDF you will need a user password 'test'.
52	$new_handler = new SecurityHandler();
53
54	// Set a new password required to open a document
55	$user_password="test";
56	$new_handler->ChangeUserPassword($user_password);
57
58	// Set Permissions
59	$new_handler->SetPermission (SecurityHandler::e_print, true);
60	$new_handler->SetPermission (SecurityHandler::e_extract_content, false);
61
62	// Note: document takes the ownership of new_handler.
63	$doc->SetSecurityHandler($new_handler);
64
65	// Save the changes.
66	echo "Saving modified file...\n";
67	$doc->Save($output_path."secured.pdf", 0);
68	$doc->Close();
69
70	// Example 2:
71	// Opens an encrypted PDF document and removes its security.
72
73	$doc = new PDFDoc($output_path."secured.pdf");
74
75	//If the document is encrypted prompt for the password
76	if (!$doc->InitSecurityHandler()) 
77	{
78		$success=false;
79		echo "The password is: test\n";
80		for($count=0; $count<3;$count++)
81		{
82			echo "A password required to open the document.\n"
83				."Please enter the password:";
84			
85			$password = trim(fgets(STDIN));
86			if($doc->InitStdSecurityHandler($password, strlen($password)))
87			{
88				$success=true;
89				echo "The password is correct.\n";
90				break;
91			}
92			else if($count<3)
93			{
94				echo "The password is incorrect, please try again\n";
95			}
96		}
97		if(!$success)
98		{
99			echo "Document authentication error....\n";
100			PDFNet::Terminate();
101			return;
102		}
103
104		$hdlr = $doc->GetSecurityHandler(); 
105		echo "Document Open Password: ".$hdlr->IsUserPasswordRequired()."\n";
106		echo "Permissions Password: ".$hdlr->IsMasterPasswordRequired()."\n";
107		echo "Permissions: " 
108			."\n\tHas 'owner' permissions: ".$hdlr->GetPermission(SecurityHandler::e_owner)
109			."\n\tOpen and decrypt the document: ".$hdlr->GetPermission(SecurityHandler::e_doc_open)
110			."\n\tAllow content extraction: ".$hdlr->GetPermission(SecurityHandler::e_extract_content) 
111			."\n\tAllow full document editing: ".$hdlr->GetPermission(SecurityHandler::e_doc_modify) 
112			."\n\tAllow printing: ".$hdlr->GetPermission(SecurityHandler::e_print) 
113			."\n\tAllow high resolution printing: ".$hdlr->GetPermission(SecurityHandler::e_print_high) 
114			."\n\tAllow annotation editing: ".$hdlr->GetPermission(SecurityHandler::e_mod_annot) 
115			."\n\tAllow form fill: ".$hdlr->GetPermission(SecurityHandler::e_fill_forms) 
116			."\n\tAllow content extraction for accessibility: ".$hdlr->GetPermission(SecurityHandler::e_access_support) 
117			."\n\tAllow document assembly: ".$hdlr->GetPermission(SecurityHandler::e_assemble_doc) 
118			."\n";   
119	}
120
121	// remove all security on the document
122	$doc->RemoveSecurity();
123	$doc->Save($output_path."not_secured.pdf", 0);
124	$doc->Close();
125
126	// Example 3: 
127	echo "-------------------------------------------------\n";
128	echo "Encrypt a document using PDFTron Custom Security handler with a custom id and password...\n";
129	$doc = new PDFDoc($input_path . "BusinessCardTemplate.pdf");
130
131	// Create PDFTron custom security handler with a custom id. Replace this with your own integer
132	$custom_id = 123456789;
133	$custom_handler = new PDFTronCustomSecurityHandler($custom_id);
134
135	// Add a password to the custom security handler
136	$pass = "test";
137	$custom_handler->ChangeUserPassword($pass);
138
139	// Save the encrypted document
140	$doc->SetSecurityHandler($custom_handler);
141	$doc->Save($output_path . "BusinessCardTemplate_enc.pdf", 0);
142	$doc->Close();
143
144	echo "Decrypt the PDFTron custom security encrypted document above...\n";
145	// Register the PDFTron Custom Security handler with the same custom id used in encryption
146	PDFNet::AddPDFTronCustomHandler($custom_id);
147
148	$doc_enc = new PDFDoc($output_path . "BusinessCardTemplate_enc.pdf");
149	$doc_enc->InitStdSecurityHandler($pass);
150	$doc_enc->RemoveSecurity();
151	// Save the decrypted document
152	$doc_enc->Save($output_path . "BusinessCardTemplate_enc_dec.pdf", 0);
153	$doc->Close();
154	PDFNet::Terminate();
155	echo "Done. Result saved in BusinessCardTemplate_enc_dec.pdf\n";
156	echo "-------------------------------------------------\n";
157	echo "Test Completed.\n";
158?>