public async Task <ActionResult> Start(int id)
        {
            // Get an instance of the PadesSignatureStarter class, responsible for receiving the signature
            // elements and start the signature process.
            var signatureStarter = new PadesSignatureStarter(Util.GetRestPkiClient())
            {
                // Set the unit of measurement used to edit the pdf marks and visual representations.
                MeasurementUnits = PadesMeasurementUnits.Centimeters,

                // Set the signature policy.
                SignaturePolicyId = StandardPadesSignaturePolicies.Basic,

                // Set the security context to be used to determine trust in the certificate chain. We have
                // encapsulated the security context choice on Util.cs.
                SecurityContextId = Util.GetSecurityContextId(),

                // Set a visual representation for the signature.
                VisualRepresentation = PadesVisualElements.GetVisualRepresentationForRestPki()
            };

            // Set the document to be signed based on its ID (passed to us from the page).
            signatureStarter.SetPdfToSign(StorageMock.GetBatchDocPath(id));

            /*
             *      Optionally, add marks to the PDF before signing. These differ from the signature visual
             *      representation in that they are actually changes done to the document prior to signing, not
             *      binded to any signature. Therefore, any number of marks can be added, for instance one per
             *      page, whereas there can only be one visual representation per signature. However, since the
             *      marks are in reality changes to the PDF, they can only be added to documents which have no
             *      previous signatures, otherwise such signatures would be made invalid by the changes to the
             *      document (see property PadesSignatureStarter.BypassMarksIfSigned). This problem does not
             *      occurr with signature visual representations.
             *
             *      We have encapsulated this code in a method to include several possibilities depending on the
             *      argument passed. Experiment changing the argument to see different examples of PDF marks.
             *      Once you decide which is best for your case, you can place the code directly here.
             */
            //signatureStarter.PdfMarks.Add(PadesVisualElements.GetPdfMark(1));

            // Call the StartWithWebPki() method, which initiates the signature. This yields the token,
            // a 43-character case-sensitive URL-safe string, which identifies this signature process. We'll
            // use this value to call the signWithRestPki() method on the Web PKI component (see
            // batch-signature-form.js) and also to complete the signature on the POST action below (this
            // should not be mistaken with the API access token).
            var token = await signatureStarter.StartWithWebPkiAsync();

            // Return a JSON with the token obtained from REST PKI. (the page will use jQuery to decode this
            // value)
            return(Json(token));
        }
예제 #2
0
        public async Task <string> Start(string userfile)
        {
            var storage = new Storage(hostingEnvironment);
            var client  = Util.GetRestPkiClient(restPkiConfig);

            // Get an instance of the PadesSignatureStarter class, responsible for receiving the signature elements and start the
            // signature process
            var signatureStarter = new PadesSignatureStarter(client)
            {
                // Set the unit of measurement used to edit the pdf marks and visual representations
                MeasurementUnits = PadesMeasurementUnits.Centimeters,

                // Set the signature policy
                SignaturePolicyId = StandardPadesSignaturePolicies.PkiBrazil.BasicWithPkiBrazilCerts,
                // Note: Depending on the signature policy chosen above, setting the security context below may be mandatory (this is not
                // the case for ICP-Brasil policies, which will automatically use the PkiBrazil security context if none is passed)

                // Optionally, set a SecurityContext to be used to determine trust in the certificate chain
                //SecurityContextId = new Guid("ID OF YOUR CUSTOM SECURITY CONTEXT"),
                // For instance, to use the test certificates on Lacuna Test PKI (for development purposes only!):
                //SecurityContextId = new Guid("803517ad-3bbc-4169-b085-60053a8f6dbf"),

                // Set a visual representation for the signature
                VisualRepresentation = new PadesVisualRepresentation()
                {
                    // The tags {{name}} and {{br_cpf_formatted}} will be substituted according to the user's certificate
                    //
                    //		name             : full name of the signer
                    //		br_cpf_formatted : if the certificate is ICP-Brasil, contains the signer's CPF
                    //
                    // For a full list of the supported tags, see: https://github.com/LacunaSoftware/RestPkiSamples/blob/master/PadesTags.md
                    Text = new PadesVisualText("Signed by {{name}} ({{br_cpf_formatted}})")
                    {
                        // Specify that the signing time should also be rendered
                        IncludeSigningTime = true,

                        // Optionally set the horizontal alignment of the text ('Left' or 'Right'), if not set the default is Left
                        HorizontalAlign = PadesTextHorizontalAlign.Left
                    },

                    // We'll use as background the image in Content/PdfStamp.png
                    Image = new PadesVisualImage(storage.GetPdfStampContent(), "image/png")
                    {
                        // Opacity is an integer from 0 to 100 (0 is completely transparent, 100 is completely opaque).
                        Opacity = 50,

                        // Align the image to the right
                        HorizontalAlign = PadesHorizontalAlign.Right
                    },

                    // Position of the visual representation. We have encapsulated this code in a method to include several
                    // possibilities depending on the argument passed. Experiment changing the argument to see different examples
                    // of signature positioning. Once you decide which is best for your case, you can place the code directly here.
                    Position = PadesVisualElements.GetVisualPositioning(client, 1)
                }
            };

            // Below we'll either set the PDF file to be signed. Prefer passing a path or a stream instead of the file's contents
            // as a byte array to prevent memory allocation issues with large files.

            // If the "userfile" URL argument is set, it will contain the filename under the "App_Data" folder. Otherwise
            // (signature with server file), we'll sign a sample document.
            if (string.IsNullOrEmpty(userfile))
            {
                signatureStarter.SetPdfToSign(storage.GetSampleDocPath());
            }
            else
            {
                Stream userFileStream;
                if (!storage.TryOpenRead(userfile, out userFileStream))
                {
                    throw new Exception("File not found");
                }
                signatureStarter.SetPdfToSign(userFileStream);
            }

            /*
             *      Optionally, add marks to the PDF before signing. These differ from the signature visual representation in that
             *      they are actually changes done to the document prior to signing, not binded to any signature. Therefore, any number
             *      of marks can be added, for instance one per page, whereas there can only be one visual representation per signature.
             *      However, since the marks are in reality changes to the PDF, they can only be added to documents which have no previous
             *      signatures, otherwise such signatures would be made invalid by the changes to the document (see property
             *      PadesSignatureStarter.BypassMarksIfSigned). This problem does not occurr with signature visual representations.
             *
             *      We have encapsulated this code in a method to include several possibilities depending on the argument passed.
             *      Experiment changing the argument to see different examples of PDF marks. Once you decide which is best for your case,
             *      you can place the code directly here.
             */
            //signatureStarter.PdfMarks.Add(PadesVisualElements.GetPdfMark(storage, 1));

            // Call the StartWithWebPkiAsync() method, which initiates the signature. This yields the token, a 43-character
            // case-sensitive URL-safe string, which identifies this signature process. We'll use this value to call the
            // signWithRestPki() method on the Web PKI component (see javascript on the angular controller) and also to complete
            // the signature on the POST action below (this should not be mistaken with the API access token).
            var token = await signatureStarter.StartWithWebPkiAsync();

            return(token);
        }
        public async Task <ActionResult> Index(string userfile)
        {
            // Verify if the userfile exists and get its absolute path.
            string userfilePath;

            if (!StorageMock.TryGetFile(userfile, out userfilePath))
            {
                return(HttpNotFound());
            }

            // Get an instance of the PadesSignatureStarter class, responsible for receiving the signature
            // elements and start the signature process.
            var signatureStarter = new PadesSignatureStarter(Util.GetRestPkiClient())
            {
                // Set the unit of measurement used to edit the pdf marks and visual representations.
                MeasurementUnits = PadesMeasurementUnits.Centimeters,

                // Set the signature policy.
                SignaturePolicyId = StandardPadesSignaturePolicies.Basic,

                // Set the security context to be used to determine trust in the certificate chain. We have
                // encapsulated the security context choice on Util.cs.
                SecurityContextId = Util.GetSecurityContextId(),

                // Set a visual representation for the signature.
                VisualRepresentation = PadesVisualElements.GetVisualRepresentationForRestPki()
            };

            // Set the file to be signed.
            signatureStarter.SetPdfToSign(userfilePath);

            /*
             *      Optionally, add marks to the PDF before signing. These differ from the signature visual
             *      representation in that they are actually changes done to the document prior to signing, not
             *      binded to any signature. Therefore, any number of marks can be added, for instance one per
             *      page, whereas there can only be one visual representation per signature. However, since the
             *      marks are in reality changes to the PDF, they can only be added to documents which have no
             *      previous signatures, otherwise such signatures would be made invalid by the changes to the
             *      document (see property PadesSignatureStarter.BypassMarksIfSigned). This problem does not
             *      occurr with signature visual representations.
             *
             *      We have encapsulated this code in a method to include several possibilities depending on the
             *      argument passed. Experiment changing the argument to see different examples of PDF marks.
             *      Once you decide which is best for your case, you can place the code directly here.
             */
            //signatureStarter.PdfMarks.Add(PadesVisualElements.GetPdfMark(1));

            // Call the StartWithWebPki() method, which initiates the signature. This yields the token, a
            // 43-character case-sensitive URL-safe string, which identifies this signature process. We'll
            // use this value to call the signWithRestPki() method on the Web PKI component (see
            // signature-forms.js) and also to complete the signature on the POST action below (this should
            // not be mistaken with the API access token).
            var token = await signatureStarter.StartWithWebPkiAsync();

            // The token acquired above can only be used for a single signature attempt. In order to retry
            // the signature it is necessary to get a new token. This can be a problem if the user uses the
            // back button of the browser, since the browser might show a cached page that we rendered
            // previously, with a now stale token. To prevent this from happening, we call the method
            // SetNoCacheHeaders() (in BaseController) which sets HTTP headers to prevent caching of the
            // page.
            base.SetNoCacheHeaders();

            // Render the signature page with the token obtained from REST PKI.
            return(View(new SignatureModel()
            {
                Token = token,
                UserFile = userfile
            }));
        }
예제 #4
0
        public async Task <ActionResult> Index(string userfile)
        {
            // Get an instance of the PadesSignatureStarter class, responsible for receiving the signature
            // elements and start the signature process.
            var signatureStarter = new PadesSignatureStarter(Util.GetRestPkiClient())
            {
                // Set the unit of measurement used to edit the pdf marks and visual representations.
                MeasurementUnits = PadesMeasurementUnits.Centimeters,

                // Set the signature policy.
                SignaturePolicyId = StandardPadesSignaturePolicies.Basic,

                // Set a SecurityContext to be used to determine trust in the certificate chain.
                SecurityContextId = Util.GetSecurityContextId(),

                // Set a visual representation for the signature.
                VisualRepresentation = new PadesVisualRepresentation()
                {
                    // The tags {{name}} and {{national_id}} will be substituted according to the user's
                    // certificate:
                    //
                    //		name        : full name of the signer;
                    //		national_id : if the certificate is ICP-Brasil, contains the signer's CPF.
                    //
                    // For a full list of the supported tags, see:
                    // https://github.com/LacunaSoftware/RestPkiSamples/blob/master/PadesTags.md
                    Text = new PadesVisualText("Signed by {{name}} ({{national_id}})")
                    {
                        // Specify that the signing time should also be rendered.
                        IncludeSigningTime = true,

                        // Optionally set the horizontal alignment of the text ('Left' or 'Right'), if not
                        // set the default is Left.
                        HorizontalAlign = PadesTextHorizontalAlign.Left
                    },

                    // We'll use as background the image in Content/PdfStamp.png.
                    Image = new PadesVisualImage(Util.GetPdfStampContent(), "image/png")
                    {
                        // Opacity is an integer from 0 to 100 (0 is completely transparent, 100 is
                        // completely opaque).
                        Opacity = 50,

                        // Align the image to the right.
                        HorizontalAlign = PadesHorizontalAlign.Right
                    },

                    // Position of the visual representation. We have encapsulated this code in a method to
                    // include several possibilities depending on the argument passed. Experiment changing
                    // the argument to see different examples of signature positioning. Once you decide which
                    // is best for your case, you can place the code directly here.
                    Position = PadesVisualElements.GetVisualPositioning(1)
                },
            };

            // If the user was redirected here by UploadController (signature with file uploaded by user),
            // the "userfile" URL argument will contain the filename under the "App_Data" folder. Otherwise
            // (signature with server file), we'll sign a sample.
            // document.
            if (string.IsNullOrEmpty(userfile))
            {
                // Set the PDF to be signed
                signatureStarter.SetPdfToSign(Util.GetSampleDocPath());
            }
            else
            {
                // Set the path of the file to be signed
                signatureStarter.SetPdfToSign(Server.MapPath("~/App_Data/" + userfile.Replace("_", ".")));
                // Note: we're receiving the userfile argument with "_" as "." because of limitations of
                // ASP.NET MVC.
            }

            /*
             *                  Optionally, add marks to the PDF before signing. These differ from the signature visual
             *  representation in that they are actually changes done to the document prior to signing, not
             *  binded to any signature. Therefore, any number of marks can be added, for instance one per
             *  page, whereas there can only be one visual representation per signature. However, since the
             *  marks are in reality changes to the PDF, they can only be added to documents which have no
             *  previous signatures, otherwise such signatures would be made invalid by the changes to the
             *  document (see property PadesSignatureStarter.BypassMarksIfSigned). This problem does not
             *  occurr with signature visual representations.
             *
             *                  We have encapsulated this code in a method to include several possibilities depending on the
             *  argument passed. Experiment changing the argument to see different examples of PDF marks.
             *  Once you decide which is best for your case, you can place the code directly here.
             */
            //signatureStarter.PdfMarks.Add(PadesVisualElements.GetPdfMark(1));

            // Call the StartWithWebPki() method, which initiates the signature. This yields the token, a
            // 43-character case-sensitive URL-safe string, which identifies this signature process. We'll
            // use this value to call the signWithRestPki() method on the Web PKI component (see javascript
            // on the view) and also to complete the signature on the POST action below (this should not be
            // mistaken with the API access token).
            var token = await signatureStarter.StartWithWebPkiAsync();

            // The token acquired above can only be used for a single signature attempt. In order to retry
            // the signature it is necessary to get a new token. This can be a problem if the user uses the
            // back button of the browser, since the browser might show a cached page that we rendered
            // previously, with a now stale token. To prevent this from happening, we call the method
            // SetNoCacheHeaders() (in BaseController) which sets HTTP headers to prevent caching of the
            // page.
            base.SetNoCacheHeaders();

            // Render the signature page with the token obtained from REST PKI.
            return(View(new Models.PadesSignatureModel()
            {
                Token = token,
                UserFile = userfile
            }));
        }
예제 #5
0
        public async Task <ActionResult> Start(int id)
        {
            // Get an instance of the PadesSignatureStarter class, responsible for receiving the signature
            // elements and start the signature process.
            var signatureStarter = new PadesSignatureStarter(Util.GetRestPkiClient())
            {
                // Set the signature policy.
                SignaturePolicyId = StandardPadesSignaturePolicies.Basic,

                // Set a SecurityContext to be used to determine trust in the certificate chain. We have
                // encapsulated the security context choice on Util.cs.
                SecurityContextId = Util.GetSecurityContextId(),

                // Set a visual representation for the signature.
                VisualRepresentation = new PadesVisualRepresentation()
                {
                    // The tags {{name}} and {{national_id}} will be substituted according to the user's
                    // certificate:
                    //
                    //      name        : Full name of the signer;
                    //      national_id : If the certificate is ICP-Brasil, contains the signer's CPF.
                    //
                    // For a full list of the supported tags, see:
                    // https://github.com/LacunaSoftware/RestPkiSamples/blob/master/PadesTags.md
                    Text = new PadesVisualText("Signed by {{name}} ({{national_id}})")
                    {
                        // Specify that the signing time should also be rendered.
                        IncludeSigningTime = true,

                        // Optionally set the horizontal alignment of the text ('Left' or 'Right'), if not
                        // set the default is Left.
                        HorizontalAlign = PadesTextHorizontalAlign.Left
                    },

                    // We'll use as background the image in Content/PdfStamp.png.
                    Image = new PadesVisualImage(Util.GetPdfStampContent(), "image/png")
                    {
                        // Opacity is an integer from 0 to 100 (0 is completely transparent, 100 is
                        // completely opaque).
                        Opacity = 50,

                        // Align the image to the right
                        HorizontalAlign = PadesHorizontalAlign.Right
                    },

                    // Position of the visual representation. We have encapsulated this code in a method to
                    // include several possibilities depending on the argument passed. Experiment changing
                    // the argument to see different examples of signature positioning. Once you decide which
                    // is best for your case, you can place the code directly here.
                    Position = PadesVisualElements.GetVisualPositioning(1)
                }
            };

            // Set the document to be signed based on its ID. (passed to us from the page)
            signatureStarter.SetPdfToSign(Util.GetBatchDocPath(id));

            /*
             *                  Optionally, add marks to the PDF before signing. These differ from the signature visual
             *  representation in that they are actually changes done to the document prior to signing, not
             *  binded to any signature. Therefore, any number of marks can be added, for instance one per
             *  page, whereas there can only be one visual representation per signature. However, since the
             *  marks are in reality changes to the PDF, they can only be added to documents which have no
             *  previous signatures, otherwise such signatures would be made invalid by the changes to the
             *  document (see property PadesSignatureStarter.BypassMarksIfSigned). This problem does not
             *  occurr with signature visual representations.
             *
             *                  We have encapsulated this code in a method to include several possibilities depending on the
             *  argument passed. Experiment changing the argument to see different examples of PDF marks.
             *  Once you decide which is best for your case, you can place the code directly here.
             */
            //signatureStarter.PdfMarks.Add(PadesVisualElements.GetPdfMark(1));

            // Call the StartWithWebPkiAsync() method, which initiates the signature. This yields the token,
            // a 43-character case-sensitive URL-safe string, which identifies this signature process. We'll
            // use this value to call the signWithRestPki() method on the Web PKI component (see javascript
            // on the view) and also to complete the signature on the POST action below (this should not be
            // mistaken with the API access token).
            var token = await signatureStarter.StartWithWebPkiAsync();

            // Notice: it is not necessary to call SetNoCacheHeaders() because this action is a POST action,
            // therefore no caching of the response will be made by browsers.

            // Return a JSON with the token obtained from REST PKI. (the page will use jQuery to decode this
            // value)
            return(Json(token));
        }