# Sign and Verify Office and ODF Files

Add digital signatures to DOCX, XLSX, PPTX and ODT/ODS/ODP files with OfficeIMO.Security, validate existing signatures, and set a trust policy.

**Packages**

- [OfficeIMO.Security](https://www.nuget.org/packages/OfficeIMO.Security) `dotnet add package OfficeIMO.Security`
- [OfficeIMO.Word](https://www.nuget.org/packages/OfficeIMO.Word) `dotnet add package OfficeIMO.Word`
- [OfficeIMO.OpenDocument](https://www.nuget.org/packages/OfficeIMO.OpenDocument) `dotnet add package OfficeIMO.OpenDocument`

**Works with**

- .NET

**Target frameworks**

netstandard2.0, net8.0, net10.0, net472

**APIs**

- [`OfficeSecurityProvider`](/api/security/officeimo-security-officesecurityprovider/)
- [`OdfDocument`](/api/open-document/officeimo-opendocument-odfdocument/)
- [`OfficePackageSignatureValidationReport`](/api/core/officeimo-security-officepackagesignaturevalidationreport/)
- [`WordDocument`](/api/word/officeimo-word-worddocument/)
- [`ExcelDocument`](/api/excel/officeimo-excel-exceldocument/)
- [`PowerPointDocument`](/api/powerpoint/officeimo-powerpoint-powerpointdocument/)
- [`CertificateValidationOptions`](/api/core/officeimo-security-certificatevalidationoptions/)
- [`IOfficeSecurityProvider`](/api/core/officeimo-security-iofficesecurityprovider/)
- [`OdtDocument`](/api/open-document/officeimo-opendocument-odtdocument/)
- [`OfficePackageSignatureValidationOptions`](/api/core/officeimo-security-officepackagesignaturevalidationoptions/)
- [`OfficeXmlPackageEntryDigestResult`](/api/core/officeimo-security-officexmlpackageentrydigestresult/)
- [`OfficeXmlPackageSignatureOptions`](/api/core/officeimo-security-officexmlpackagesignatureoptions/)

**Limits**

Signing works on saved files; editing a signed package afterwards invalidates its signatures, and format packages refuse such saves unless you remove the signatures explicitly. [OfficeIMO.Word support matrix](/compatibility/#package-word), [OfficeIMO.OpenDocument support matrix](/compatibility/#package-opendocument)

**Verified**

Examples compiled against the source on 2026-11-14

**Data**

- [OfficeIMO.Security API index](/api/security/index.json)
- [OfficeIMO.Word API index](/api/word/index.json)
- [OfficeIMO.OpenDocument API index](/api/open-document/index.json)
- [Capability catalog (JSON)](/data/capabilities.json)

Each format package owns its signature structure and passes the cryptography to the provider you supply, usually `OfficeSecurityProvider.Default` from `OfficeIMO.Security`. Word, Excel, PowerPoint and Visio packages get OPC (Open Packaging Conventions) signatures; OpenDocument packages get an XML signature over the package manifest. Signing reads the signature back and verifies it before the call returns.

The examples create a throwaway self-signed certificate in memory. In production, load your signing certificate the way your application manages keys; the provider never searches certificate stores for you.

## Sign and verify a Word document

### C#

```csharp
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using OfficeIMO.Security;
using OfficeIMO.Word;

using (WordDocument document = WordDocument.Create("contract.docx")) {
    document.AddParagraph("Signed contract text.");
    document.Save();
}

using X509Certificate2 certificate = CreateTestCertificate("CN=Contoso Signing Test");
IOfficeSecurityProvider security = OfficeSecurityProvider.Default;

WordPackageSigningResult signed = WordDocument.SignPackage("contract.docx", security, certificate);
Console.WriteLine($"Signed {signed.SignedPartCount} parts");

using WordDocument loaded = WordDocument.Load("contract.docx");
var options = new WordSignatureValidationOptions();
options.CertificateValidation.ChainEvaluator = (cert, chain) => cert.Thumbprint == certificate.Thumbprint;   // trust only this test certificate

WordSignatureValidationReport validation = loaded.ValidateSignatures(security, options);
Console.WriteLine($"Cryptography: {validation.CryptographicStatus}, chain: {validation.CertificateChainStatus}");
Console.WriteLine(validation.IsValidUnderPolicy ? "Valid" : string.Join(Environment.NewLine, validation.Findings));

static X509Certificate2 CreateTestCertificate(string subject) {
    using RSA rsa = RSA.Create(2048);
    var request = new CertificateRequest(subject, rsa, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
    request.CertificateExtensions.Add(new X509KeyUsageExtension(X509KeyUsageFlags.DigitalSignature, critical: true));
    return request.CreateSelfSigned(DateTimeOffset.UtcNow.AddMinutes(-5), DateTimeOffset.UtcNow.AddDays(1));
}
```

The report keeps package structure, XML signature, cryptographic, certificate chain, revocation, timestamp and signed-part coverage outcomes separate, so you can tell "the bytes changed" from "the signer is not trusted".

## Sign Excel and PowerPoint files

Excel, PowerPoint and Visio share one OPC signing engine. Validation returns an `OfficePackageSignatureValidationReport` with `IsCryptographicallyValid` and `IsValidUnderPolicy`.

### C#

```csharp
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using OfficeIMO.Excel;
using OfficeIMO.PowerPoint;
using OfficeIMO.Security;

using (ExcelDocument workbook = ExcelDocument.Create("budget.xlsx")) {
    workbook.AddSheet("Budget").Cell(1, 1).SetValue("Approved");
    workbook.Save();
}
using (PowerPointDocument deck = PowerPointDocument.Create("deck.pptx")) {
    deck.Save();
}

using X509Certificate2 certificate = CreateTestCertificate("CN=Contoso Signing Test");
IOfficeSecurityProvider security = OfficeSecurityProvider.Default;

ExcelDocument.SignPackageSignature("budget.xlsx", security, certificate);
PowerPointDocument.SignPackage("deck.pptx", security, certificate);

// Check that the content is intact without deciding whether the signer is trusted.
var options = new OfficePackageSignatureValidationOptions { ValidateCertificateTrust = false };
OfficePackageSignatureValidationReport excel = ExcelDocument.ValidatePackageSignatures("budget.xlsx", security, options);
OfficePackageSignatureValidationReport powerPoint = PowerPointDocument.ValidateSignatures("deck.pptx", security, options);
Console.WriteLine($"budget.xlsx: {excel.IsCryptographicallyValid}, deck.pptx: {powerPoint.IsCryptographicallyValid}");

static X509Certificate2 CreateTestCertificate(string subject) {
    using RSA rsa = RSA.Create(2048);
    var request = new CertificateRequest(subject, rsa, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
    request.CertificateExtensions.Add(new X509KeyUsageExtension(X509KeyUsageFlags.DigitalSignature, critical: true));
    return request.CreateSelfSigned(DateTimeOffset.UtcNow.AddMinutes(-5), DateTimeOffset.UtcNow.AddDays(1));
}
```

`TrySignPackage` and `TrySignPackageSignature` return a result with `Succeeded` and `Details` instead of throwing.

## Sign and verify an OpenDocument file

`OdfDocument.SignPackage` writes `META-INF/documentsignatures.xml` and commits the file atomically. Validation recomputes the digest of every signed package entry, so a change to `content.xml` after signing is reported per entry.

### C#

```csharp
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using OfficeIMO.OpenDocument;
using OfficeIMO.Security;

using (OdtDocument document = OdtDocument.Create()) {
    document.AddParagraph("Signed policy text.");
    document.Save("policy.odt");
}

using X509Certificate2 certificate = CreateTestCertificate("CN=Contoso Signing Test");
IOfficeSecurityProvider security = OfficeSecurityProvider.Default;

var options = new OfficeXmlPackageSignatureOptions();
options.CertificateValidation.ChainEvaluator = (cert, chain) => cert.Thumbprint == certificate.Thumbprint;

OfficeXmlPackageSigningResult signed = OdfDocument.SignPackage("policy.odt", security, certificate, options);
Console.WriteLine(signed.Succeeded ? "Signed" : string.Join(Environment.NewLine, signed.Findings));

OfficeXmlPackageSignatureValidationReport validation = OdfDocument.ValidateSignatures("policy.odt", security, options);
foreach (OfficeXmlPackageSignatureResult signature in validation.Signatures) {
    Console.WriteLine($"{signature.SignatureId}: {signature.CryptographicStatus}, chain {signature.CertificateChainStatus}");
    foreach (OfficeXmlPackageEntryDigestResult entry in signature.Entries) Console.WriteLine($"  {entry.Path}: {entry.Status}");
}

static X509Certificate2 CreateTestCertificate(string subject) {
    using RSA rsa = RSA.Create(2048);
    var request = new CertificateRequest(subject, rsa, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
    request.CertificateExtensions.Add(new X509KeyUsageExtension(X509KeyUsageFlags.DigitalSignature, critical: true));
    return request.CreateSelfSigned(DateTimeOffset.UtcNow.AddMinutes(-5), DateTimeOffset.UtcNow.AddDays(1));
}
```

This creates the OfficeIMO package-manifest signature profile. Signatures from other ODF producers are detected and preserved; changing a signed package fails by default rather than silently invalidating them.

## Choose a trust policy

Validation separates "the signature matches the content" from "the signer is trusted". Certificate trust follows `CertificateValidationOptions`:

| Setting | Default | Use it to |
|---|---|---|
| `ValidateChain` | `true` | Build the platform certificate chain. |
| `ChainEvaluator` | none | Decide trust yourself, for example by pinning a thumbprint or a private root. |
| `RevocationMode` | `NoCheck` | Turn on online or offline revocation checking. |
| `DisableCertificateDownloads` | `true` | Allow the platform to fetch missing issuer certificates. |
| `VerificationTime` | now | Validate the chain as of the signing time. |
| `ExtraCertificates` | empty | Supply intermediates. They are chain-building candidates, not trust anchors. |

Set `ValidateCertificateTrust = false` on the package validation options when you only need to know whether the content changed after signing.

<!-- PowerForge markdown source sha256:0C8461F4E05625C500BD6BF0ECB36ED99244E5BEAD4DE522B0A83BF8C53D9CA5; title=True -->

<!-- PowerForge markdown artifact sha256:D6109290A48B7F67DE2F3F8DEE6D2B51E824B0EC0A15FA8B33CB43A0B2A39803 -->
