Latest release (December 2025)

The release of GroupDocs.Signature version 25.12 adds new features and enhancements.

Full list of changes in this release

Major Features

Image digital signature support and validation

🌐 This release introduces comprehensive support for embedding digital signatures directly into raster images using steganography (LSB - Least Significant Bit technique). This method embeds signature data invisibly into image pixels, making the signature undetectable to the naked eye while maintaining image quality. The feature supports signing and verifying PNG and JPG image formats with password protection.

Key benefits for developers:

• Invisible signatures: Signatures are embedded directly into image pixels using steganography, preserving image quality
• Password protection: Signatures are protected with a password (minimum 4 characters) for security
• Format support: Works with PNG and JPG image formats
• Full validation support: Verify embedded signatures using password-based authentication with configurable detection thresholds
• Stream support: Can sign and verify images from streams or file paths

How it works:

The signature data is embedded into the least significant bits of image pixels. Changes to LSBs are imperceptible to the human eye, ensuring the image quality remains virtually unchanged while providing cryptographic security.

Signing an image:

using GroupDocs.Signature;
using GroupDocs.Signature.Options;

string inputFile = "image.png";
string outputFile = "signed_image.png";
string password = "MySecurePassword123";

// Sign the image
using (Signature signature = new Signature(inputFile))
{
    ImageDigitalSignOptions signOptions = new ImageDigitalSignOptions
    {
        Password = password
    };

    SignResult signResult = signature.Sign(outputFile, signOptions);
    
    if (signResult.Succeeded != null && signResult.Succeeded.Count > 0)
    {
        Console.WriteLine($"Image signed successfully!");
        Console.WriteLine($"Signatures added: {signResult.Succeeded.Count}");
    }
}

Verifying a signed image:

using GroupDocs.Signature;
using GroupDocs.Signature.Options;

string signedFile = "signed_image.png";
string password = "MySecurePassword123";

// Verify the signed image
using (Signature signature = new Signature(signedFile))
{
    ImageDigitalVerifyOptions verifyOptions = new ImageDigitalVerifyOptions
    {
        Password = password,
        DetectionThresholdPercent = 75  // Optional: detection threshold (0-100%)
    };

    VerificationResult verifyResult = signature.Verify(verifyOptions);
    
    if (verifyResult.IsValid)
    {
        Console.WriteLine("Digital signature is valid!");
        Console.WriteLine($"Verified signatures: {verifyResult.Succeeded.Count}");
    }
    else
    {
        Console.WriteLine("Digital signature is invalid or not found.");
    }
}

Advanced verification with full data extraction:

using (Signature signature = new Signature("signed_image.png"))
{
    ImageDigitalVerifyOptions verifyOptions = new ImageDigitalVerifyOptions
    {
        Password = "MySecurePassword123",
        UseFullDataExtraction = true,  // Enable full extraction for maximum accuracy
        DetectionThresholdPercent = 85
    };

    VerificationResult verifyResult = signature.Verify(verifyOptions);
    
    if (verifyResult.IsValid && verifyOptions.DetectedProbability.HasValue)
    {
        Console.WriteLine($"Signature detected with {verifyOptions.DetectedProbability.Value}% probability");
    }
}

Requirements:

• Image size: Minimum 8x8 pixels, minimum 16,384 total pixels
• Password: Minimum 4 characters (case-sensitive)
• Supported formats: PNG and JPG/JPEG

LINQ queries optimization for signature operations

🌐 We’ve analyzed and refactored LINQ queries used throughout signature operations to improve performance, reduce memory allocation, and enhance overall efficiency. This optimization includes enhanced support for predicate-based filtering in Search and Verify methods, allowing developers to filter signatures more efficiently before processing.

Performance improvements:

• Reduced memory footprint: Optimized LINQ queries now use more efficient memory patterns, reducing garbage collection pressure.
• Faster signature processing: Improved query execution times, especially noticeable when working with documents containing multiple signatures.
• Better scalability: Enhanced performance when processing large batches of documents or documents with many signatures.
• Predicate-based filtering: Signatures are filtered before verification, skipping unnecessary operations and improving performance.

What this means for developers:

• Predicate functions for Search: Filter signatures during search operations using lambda expressions
• Predicate functions for Verify: Filter signatures before verification to optimize performance
• Better performance: Filtering happens before expensive operations, reducing processing time
• More flexible: Apply custom filtering criteria based on any signature property

Search with predicate example:

using GroupDocs.Signature;
using GroupDocs.Signature.Options;
using GroupDocs.Signature.Domain;

using (Signature signature = new Signature("document.pdf"))
{
    // Search for text signatures and filter by content
    List<SearchOptions> searchOptions = new List<SearchOptions>
    {
        new TextSearchOptions()
    };
    
    // Filter to only signatures containing "Approved"
    SearchResult result = signature.Search(searchOptions, 
        sig => sig is TextSignature textSig && textSig.Text.Contains("Approved"));
    
    foreach (BaseSignature sig in result.Signatures)
    {
        Console.WriteLine($"Found: {((TextSignature)sig).Text}");
    }
}

Verify with predicate example:

using (Signature signature = new Signature("signed_document.pdf"))
{
    TextVerifyOptions verifyOptions = new TextVerifyOptions("John Smith");
    
    // Verify only signatures on page 1 (filtering happens before verification)
    List<BaseSignature> result = signature.Verify(verifyOptions, 
        sig => sig.PageNumber == 1);
    
    Console.WriteLine($"Found {result.Count} verified signatures on page 1");
}

Affected operations:

• Signature search and filtering operations with predicate functions
• Signature verification workflows with predicate functions
• Document processing with multiple signatures
• Batch signature operations

Fixed GeneratePreview() type initializer exception with DOC format on Linux

🐛 Fixed a critical issue where calling GeneratePreview() with DOC (Microsoft Word) format documents would throw a TypeInitializerException when running on Linux systems.