/// <summary> /// See IDigitalSignatureProvider /// </summary> void IDigitalSignatureProvider.RemoveRequestSignature(Guid spotId) { AssertIsSignable(); XpsSignatureDefinition definition = FindSignatureDefinition(spotId); if (definition != null) { FixedDocument.RemoveSignatureDefinition(definition); FixedDocument.CommitSignatureDefinition(); } // Loop through the signature list and remove the entry for the // requested signature foreach (DigitalSignature signature in DigitalSignatureList) { if (signature.GuidID == spotId) { // We only want to remove unsigned signature definitions // (requested signatures) and not actual signatures. if (signature.SignatureState == SignatureStatus.NotSigned) { DigitalSignatureList.Remove(signature); } // It is safe to remove an element from the list that we're // currently enumerating because we stop enumerating as soon // as we find the element we're looking for. break; } } }
/// <summary> /// See IDigitalSignatureProvider /// </summary> Guid IDigitalSignatureProvider.AddRequestSignature(DigitalSignature digitalSignature) { AssertIsSignable(); // Create guid used for signature ID Guid guidID = Guid.NewGuid(); // Create a new SignatureDefinition XpsSignatureDefinition xpsSignatureDefinition = new XpsSignatureDefinition(); // Use the digSig to setup the SignatureDefinition. xpsSignatureDefinition.RequestedSigner = digitalSignature.SubjectName; xpsSignatureDefinition.Intent = digitalSignature.Reason; xpsSignatureDefinition.SigningLocale = digitalSignature.Location; xpsSignatureDefinition.SignBy = digitalSignature.SignedOn; // Use our new guid to setup the ID xpsSignatureDefinition.SpotId = guidID; // Add the signature definition to the document FixedDocument.AddSignatureDefinition(xpsSignatureDefinition); FixedDocument.CommitSignatureDefinition(); // Set the signature's status to Not Signed before adding to our list digitalSignature.SignatureState = SignatureStatus.NotSigned; // Add the new signature to our list of signatures and definitions DigitalSignatureList.Add(digitalSignature); return(guidID); }
private void SignatureDefinitionCommandHandler(object sender, RoutedEventArgs e) { SignatureDefinition sigDefDialog = new SignatureDefinition(); if (sigDefDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK) { XpsSignatureDefinition signatureDefinition = new XpsSignatureDefinition(); signatureDefinition.RequestedSigner = sigDefDialog.RequestedSigner.Text; signatureDefinition.Intent = sigDefDialog.Intent.Text; signatureDefinition.SigningLocale = sigDefDialog.SigningLocale.Text; try { signatureDefinition.SignBy = DateTime.Parse(sigDefDialog.SignBy.Text); } catch (FormatException) { } signatureDefinition.SpotId = Guid.NewGuid(); IXpsFixedDocumentSequenceReader docSeq = _xpsDocument.FixedDocumentSequenceReader; //_xpsDocument is type System.Windows.Xps.Packaging.XpsDocument IXpsFixedDocumentReader doc = docSeq.FixedDocuments[0]; doc.AddSignatureDefinition(signatureDefinition); doc.CommitSignatureDefinition(); InitializeSignatureDisplay(); } }
private void SignXPS(string inputFile) { try { Licensing.ShowDemoMessage(); DigitalCertificate.LogOnEToken(this.DigitalSignatureCertificate); XpsDocument xpsDocument = new XpsDocument(inputFile, FileAccess.ReadWrite); if (!this.AllowMultipleSignatures) { XpsSignatureDefinition xpsSignatureDefinition = new XpsSignatureDefinition() { Intent = this.SigningIntent, SigningLocale = this.SigningLocation, SpotId = new Guid?(Guid.NewGuid()) }; IXpsFixedDocumentReader item = xpsDocument.FixedDocumentSequenceReader.FixedDocuments[0]; item.AddSignatureDefinition(xpsSignatureDefinition); item.CommitSignatureDefinition(); X509Certificate2 digitalSignatureCertificate = this.DigitalSignatureCertificate; Guid? spotId = xpsSignatureDefinition.SpotId; xpsDocument.SignDigitally(digitalSignatureCertificate, true, XpsDigSigPartAlteringRestrictions.SignatureOrigin, spotId.Value); } else { xpsDocument.SignDigitally(this.DigitalSignatureCertificate, true, XpsDigSigPartAlteringRestrictions.None); } xpsDocument.Close(); } catch { throw; } }
public SignatureDisplayItem AddSignatureItem(XpsSignatureDefinition signatureDefintion) { SignatureDisplayItem item = new SignatureDisplayItem(); if (signatureDefintion != null) { item.Request = signatureDefintion.RequestedSigner; item.Intent = signatureDefintion.Intent; item.SignBy = signatureDefintion.SignBy.ToString(); item.Location = signatureDefintion.SigningLocale; item.SigId = signatureDefintion.SpotId; } this.SignatureList.Items.Add(item); return(item); }
/// <summary> /// Maps an XpsSignatureDefinition to our DigitalSignature. /// </summary> /// <param name="signatureDefinition">The signature definition to /// convert</param> /// <returns>A DigitalSignature representing a requested signature with /// signature status NotSigned</returns> private static DigitalSignature ConvertXpsSignatureDefinition(XpsSignatureDefinition signatureDefinition) { //Create new DigSig. This is a request and will have the status NotSigned. DigitalSignature digitalSignature = new DigitalSignature(); digitalSignature.SignatureState = SignatureStatus.NotSigned; //set fields using the definition. digitalSignature.SubjectName = signatureDefinition.RequestedSigner; digitalSignature.Reason = signatureDefinition.Intent; digitalSignature.SignedOn = signatureDefinition.SignBy; digitalSignature.Location = signatureDefinition.SigningLocale; digitalSignature.GuidID = signatureDefinition.SpotId; return(digitalSignature); }
/// <summary> /// Returns a signature definition in the document that matches a GUID. /// </summary> /// <param name="id">The GUID to match</param> /// <returns>The corresponding signature definition, if one exists. /// </returns> private XpsSignatureDefinition FindSignatureDefinition(Guid id) { XpsSignatureDefinition definition = null; // Loop through our collection of definitions and find the matching // GUID. We only need to look at the fixed document we have saved // (and not the other documents in the sequence) since we always // save signature definitions to that fixed document. foreach (XpsSignatureDefinition signatureDefinition in FixedDocument.SignatureDefinitions) { if (signatureDefinition.SpotId == id) { definition = signatureDefinition; break; } } return(definition); }
private void SignXPSStream(Stream inputStream) { try { Licensing.ShowDemoMessage(); DigitalCertificate.LogOnEToken(this.DigitalSignatureCertificate); using (Package package = Package.Open(inputStream, FileMode.Open, FileAccess.ReadWrite)) { string str = "memorystream://myXps.xps"; Uri uri = new Uri(str); PackageStore.AddPackage(uri, package); XpsDocument xpsDocument = new XpsDocument(package, CompressionOption.Maximum, str); if (!this.AllowMultipleSignatures) { XpsSignatureDefinition xpsSignatureDefinition = new XpsSignatureDefinition() { Intent = this.SigningIntent, SigningLocale = this.SigningLocation, SpotId = new Guid?(Guid.NewGuid()) }; IXpsFixedDocumentReader item = xpsDocument.FixedDocumentSequenceReader.FixedDocuments[0]; item.AddSignatureDefinition(xpsSignatureDefinition); item.CommitSignatureDefinition(); X509Certificate2 digitalSignatureCertificate = this.DigitalSignatureCertificate; Guid? spotId = xpsSignatureDefinition.SpotId; xpsDocument.SignDigitally(digitalSignatureCertificate, true, XpsDigSigPartAlteringRestrictions.SignatureOrigin, spotId.Value); } else { xpsDocument.SignDigitally(this.DigitalSignatureCertificate, true, XpsDigSigPartAlteringRestrictions.None); } PackageStore.RemovePackage(uri); xpsDocument.Close(); } } catch { throw; } }
//------------------------------------------------------ // // Private Methods // //------------------------------------------------------ /// <summary> /// Returns a list of all the DigitalSignature objects from the package. /// </summary> /// <returns>A list of DigitalSignature objects</returns> private IList <DigitalSignature> GetSignaturesFromPackage() { IList <DigitalSignature> signatureList = new List <DigitalSignature>(); // This will contain a mapping of GUIDs to signature definitions so // that we can easily look up the signature definition (if any) that // corresponds with a signature IDictionary <Guid, XpsSignatureDefinition> signatureDefinitionMap = new Dictionary <Guid, XpsSignatureDefinition>(); // This will contain a list of all the signature definitions that do // not have an associated GUID, which means that they have to be // requested signatures IList <XpsSignatureDefinition> requestedSignatureList = new List <XpsSignatureDefinition>(); // Enumerate all the signature definitions in all of the fixed // documents in the XPS document to generate the map of GUIDs to // signature definitions foreach (IXpsFixedDocumentReader fixedDocument in FixedDocumentSequence.FixedDocuments) { ICollection <XpsSignatureDefinition> documentSignatureDefinitionList = fixedDocument.SignatureDefinitions; if (documentSignatureDefinitionList != null) { // Add each signature definition to either the GUID map or // the list of requested signatures foreach (XpsSignatureDefinition signatureDefinition in documentSignatureDefinitionList) { // If the signature definition has a GUID, add it to the map if (signatureDefinition.SpotId != null) { signatureDefinitionMap.Add(signatureDefinition.SpotId.Value, signatureDefinition); } // If it does not have a GUID it cannot match a signature yet, // so add it to the list of requested signatures else { requestedSignatureList.Add(signatureDefinition); } } } } // Now loop through all the XpsDigitalSignatures, matching them with // signature definitions by GUID to get the signature fields that // are only found in signature definitions. foreach (XpsDigitalSignature xpsDigitalSignature in XpsDocument.Signatures) { // Convert the XPS signature into our format DigitalSignature digitalSignature = ConvertXpsDigitalSignature(xpsDigitalSignature); // Check if the signature corresponds to a definition by seeing // if the GUID is in the signature definition map bool definitionFound = xpsDigitalSignature.Id.HasValue && signatureDefinitionMap.ContainsKey(xpsDigitalSignature.Id.Value); // If the signature corresponds to a signature definition, copy // fields from the corresponding definition if (definitionFound) { XpsSignatureDefinition signatureDefinition = signatureDefinitionMap[xpsDigitalSignature.Id.Value]; // Copy SignatureDefinition fields digitalSignature.Reason = signatureDefinition.Intent; digitalSignature.Location = signatureDefinition.SigningLocale; // Now that we have found a signature that matches this // signature definition, it can no longer match any other // signatures by GUID and we can remove it from the map. signatureDefinitionMap.Remove(xpsDigitalSignature.Id.Value); } signatureList.Add(digitalSignature); } // What is left over in the signatureDefinitionMap are definitions // that don't have matching XpsDigSigs. Add these as requested // signatures. foreach (XpsSignatureDefinition signatureDefinition in signatureDefinitionMap.Values) { //Add this request signature to our list. signatureList.Add(ConvertXpsSignatureDefinition(signatureDefinition)); } // Add all the definitions we already knew were requested signatures foreach (XpsSignatureDefinition definition in requestedSignatureList) { //Add this request signature to our list. signatureList.Add(ConvertXpsSignatureDefinition(definition)); } return(signatureList); }