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));
}
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
}));
}
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
}));
}
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));
}
