EnvelopeGenerator/EnvelopeGenerator.Infrastructure.Crypt/Services/PdfDigitalSignatureService.cs

using EnvelopeGenerator.Application.Common.Configurations;
using EnvelopeGenerator.Application.Common.Dto;
using EnvelopeGenerator.Application.Common.Enums;
using EnvelopeGenerator.Application.Common.Interfaces.Services;
using DevExpress.Office.DigitalSignatures;
using DevExpress.Pdf;
using Microsoft.Extensions.Options;
using System.Formats.Asn1;
using System.Security.Cryptography.Pkcs;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.RegularExpressions;

namespace EnvelopeGenerator.Infrastructure.Crypt.Services;

public sealed class PdfDigitalSignatureService(IOptions<Pkcs11Options> options) : IPdfDigitalSignatureService
{
    private static readonly Regex SignatureReasonMetaRegex = new(@"\|\s*SFMETA:v1;doc=(?<doc>[0-9a-fA-F-]{36});sha256=(?<sha>[A-Fa-f0-9]{64})$", RegexOptions.CultureInvariant | RegexOptions.Compiled);

    public async Task SignPdfAsync(Stream inputPdf, Stream outputPdf, PdfSignOptionsDto? optionsModel = null, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(inputPdf);
        ArgumentNullException.ThrowIfNull(outputPdf);
        cancellationToken.ThrowIfCancellationRequested();

        var (workingInput, ownsWorkingInput) = await EnsureSeekableInputAsync(inputPdf, cancellationToken);

        try
        {
            workingInput.Position = 0;
            var sourceHashHex = Convert.ToHexString(await SHA256.HashDataAsync(workingInput, cancellationToken));
            workingInput.Position = 0;

            var pkcs11Options = options.Value;
            var request = optionsModel ?? new PdfSignOptionsDto();
            var uuid = ResolveUuid(request.UUID);
            var reasonWithMeta = BuildReasonWithMeta(request.Reason ?? pkcs11Options.DefaultReason, uuid, sourceHashHex);

            using var signer = new PdfDocumentSigner(workingInput);

            var digestCalculator = new DigestCalculator(HashAlgorithmType.SHA256);
            var signerInfo = new ExternalSignerInfo(PdfSignatureType.Pkcs7, 32768, digestCalculator);
            var signatureFieldInfo = new PdfSignatureFieldInfo(1)
            {
                Name = $"Sig_{DateTimeOffset.UtcNow:yyyyMMddHHmmss}"
            };

            var builder = new PdfDeferredSignatureBuilder(signerInfo, signatureFieldInfo)
            {
                Name = request.Name ?? pkcs11Options.CertificateLabel,
                Reason = reasonWithMeta,
                Location = request.Location,
                ContactInfo = BuildContactInfo(request.Email, request.Phone),
                SigningTime = pkcs11Options.UseUtcSigningTime ? DateTimeOffset.UtcNow : DateTimeOffset.Now,
                ApplicationName = pkcs11Options.ApplicationName,
                CertificationLevel = ToDevExpressCertificationLevel(request.CertificationLevel)
                    ?? ToDevExpressCertificationLevel(pkcs11Options.DefaultCertificationLevel)
                    ?? PdfCertificationLevel.NoCertification
            };

            var deferredSigner = signer.SignDeferred(builder);
            var externalSigner = new Pkcs11ExternalSigner(pkcs11Options);
            deferredSigner.Sign(outputPdf, externalSigner.BuildSignature(deferredSigner.HashValue, digestCalculator.AlgorithmOid));
        }
        finally
        {
            if (ownsWorkingInput)
                await workingInput.DisposeAsync();
        }
    }

    public async Task SignPdfAsync(Stream inputPdf, Stream outputPdf, IReadOnlyList<PdfSignOptionsDto> optionsList, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(inputPdf);
        ArgumentNullException.ThrowIfNull(outputPdf);
        ArgumentNullException.ThrowIfNull(optionsList);
        cancellationToken.ThrowIfCancellationRequested();

        if (optionsList.Count == 0)
        {
            await inputPdf.CopyToAsync(outputPdf, cancellationToken);
            return;
        }

        var (currentInput, ownsCurrentInput) = await EnsureSeekableInputAsync(inputPdf, cancellationToken);

        try
        {
            for (var i = 0; i < optionsList.Count; i++)
            {
                cancellationToken.ThrowIfCancellationRequested();
                var isLast = i == optionsList.Count - 1;

                if (isLast)
                {
                    await SignPdfAsync(currentInput, outputPdf, optionsList[i], cancellationToken);
                    continue;
                }

                var intermediateOutput = new MemoryStream();
                await SignPdfAsync(currentInput, intermediateOutput, optionsList[i], cancellationToken);

                if (ownsCurrentInput)
                    await currentInput.DisposeAsync();

                intermediateOutput.Position = 0;
                currentInput = intermediateOutput;
                ownsCurrentInput = true;
            }
        }
        finally
        {
            if (ownsCurrentInput)
                await currentInput.DisposeAsync();
        }
    }

    public async Task<PdfSignatureCheckResultDto> CheckPdfSignatureAsync(Stream inputPdf, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(inputPdf);
        cancellationToken.ThrowIfCancellationRequested();

        var pdfBytes = await ReadAllBytesAsync(inputPdf, cancellationToken);

        using var pdfStream = new MemoryStream(pdfBytes);
        using var signer = new PdfDocumentSigner(pdfStream);
        var signatures = signer.GetSignatureInfo();
        var byteRanges = ParseByteRanges(pdfBytes);

        if (signatures is null || signatures.Count == 0)
        {
            return new PdfSignatureCheckResultDto(
                Signed: false,
                Signatures: []);
        }

        var items = new List<PdfSignatureCheckItemDto>(signatures.Count);

        for (var i = 0; i < signatures.Count; i++)
        {
            var signature = signatures[i];
            try
            {
                var pkcs7 = signer.GetPdfPkcs7Signature(signature.FieldName);
                bool valid = pkcs7.VerifySignature();
                var byteRange = i < byteRanges.Count ? byteRanges[i] : null;
                var coversWholeDocument = CoversWholeDocument(byteRange, pdfBytes.LongLength);
                var certificate = pkcs7.GetSignatureCertificate();
                var issuedTo = ParsePrincipal(certificate?.Subject);
                var issuedBy = ParsePrincipal(certificate?.Issuer);
                var reasonMeta = ParseReasonMeta(signature.Reason);
                var contact = ParseContactInfo(signature.ContactInfo);

                items.Add(new PdfSignatureCheckItemDto(
                    CoversWholeDoc: coversWholeDocument,
                    Reason: signature.Reason,
                    BusinessReason: reasonMeta.BusinessReason,
                    Location: signature.Location,
                    DeclaredName: signature.SignerName,
                    ContactInfo: signature.ContactInfo,
                    Email: contact.Email,
                    Phone: contact.Phone,
                    DigestAlgorithm: InferDigestAlgorithm(certificate),
                    SignatureAlgorithm: InferSignatureAlgorithm(certificate),
                    SignerName: issuedTo.CommonName ?? signature.SignerName,
                    Issuer: issuedBy.Full,
                    SerialNumber: ToColonSerial(certificate?.SerialNumber),
                    ValidFrom: certificate is null ? null : new DateTimeOffset(certificate.NotBefore).ToUniversalTime(),
                    ValidTo: certificate is null ? null : new DateTimeOffset(certificate.NotAfter).ToUniversalTime(),
                    ExpiryCheckedAgainst: "now",
                    Certificates: [BuildCertificateInfo(certificate, DateTimeOffset.UtcNow)],
                    Unchanged: valid && coversWholeDocument,
                    FieldName: signature.FieldName,
                    IsCryptographicallyValid: valid,
                    SigningTime: signature.SigningTime?.ToUniversalTime().ToString("O"),
                    Filter: signature.Filter,
                    SubFilter: signature.SubFilter,
                    ApplicationName: null,
                    UUID: reasonMeta.UUID,
                    OriginalDocumentSha256: reasonMeta.OriginalDocumentSha256,
                    MessageDigestHex: TryExtractMessageDigestHex(signature.Contents),
                    Error: null));
            }
            catch (Exception ex)
            {
                var reasonMeta = ParseReasonMeta(signature.Reason);
                var contact = ParseContactInfo(signature.ContactInfo);

                items.Add(new PdfSignatureCheckItemDto(
                    CoversWholeDoc: false,
                    Reason: signature.Reason,
                    BusinessReason: reasonMeta.BusinessReason,
                    Location: signature.Location,
                    DeclaredName: signature.SignerName,
                    ContactInfo: signature.ContactInfo,
                    Email: contact.Email,
                    Phone: contact.Phone,
                    DigestAlgorithm: null,
                    SignatureAlgorithm: null,
                    SignerName: signature.SignerName,
                    Issuer: null,
                    SerialNumber: null,
                    ValidFrom: null,
                    ValidTo: null,
                    ExpiryCheckedAgainst: "now",
                    Certificates: [],
                    Unchanged: false,
                    FieldName: signature.FieldName,
                    IsCryptographicallyValid: false,
                    SigningTime: signature.SigningTime?.ToUniversalTime().ToString("O"),
                    Filter: signature.Filter,
                    SubFilter: signature.SubFilter,
                    ApplicationName: null,
                    UUID: reasonMeta.UUID,
                    OriginalDocumentSha256: reasonMeta.OriginalDocumentSha256,
                    MessageDigestHex: null,
                    Error: ex.Message));
            }
        }

        return new PdfSignatureCheckResultDto(
            Signed: true,
            Signatures: items);
    }

    public async Task ExtractOriginalPdfAsync(Stream inputPdf, Stream outputPdf, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(inputPdf);
        ArgumentNullException.ThrowIfNull(outputPdf);
        cancellationToken.ThrowIfCancellationRequested();

        var pdfBytes = await ReadAllBytesAsync(inputPdf, cancellationToken);

        var byteRanges = ParseByteRanges(pdfBytes);
        if (byteRanges.Count == 0)
        {
            await outputPdf.WriteAsync(pdfBytes, cancellationToken);
            return;
        }

        var revisionLength = byteRanges
            .Select(GetSignedRevisionLength)
            .Where(x => x > 0)
            .DefaultIfEmpty(pdfBytes.LongLength)
            .Min();

        if (revisionLength > pdfBytes.LongLength)
            throw new InvalidOperationException("Invalid ByteRange in signed PDF.");

        await outputPdf.WriteAsync(pdfBytes.AsMemory(0, (int)revisionLength), cancellationToken);
    }

    private static async Task<(Stream Stream, bool OwnsStream)> EnsureSeekableInputAsync(Stream input, CancellationToken cancellationToken)
    {
        if (input.CanSeek)
        {
            input.Position = 0;
            return (input, false);
        }

        var buffered = new MemoryStream();
        await input.CopyToAsync(buffered, cancellationToken);
        buffered.Position = 0;
        return (buffered, true);
    }

    private static async Task<byte[]> ReadAllBytesAsync(Stream input, CancellationToken cancellationToken)
    {
        if (input is MemoryStream memory && memory.TryGetBuffer(out var buffer))
            return buffer.AsSpan(0, (int)memory.Length).ToArray();

        if (input.CanSeek)
            input.Position = 0;

        using var ms = new MemoryStream();
        await input.CopyToAsync(ms, cancellationToken);
        return ms.ToArray();
    }

    private static PdfSignatureCertificateInfoDto BuildCertificateInfo(X509Certificate2? certificate, DateTimeOffset now)
    {
        if (certificate is null)
        {
            return new PdfSignatureCertificateInfoDto(
                IssuedTo: new PdfSignaturePrincipalDto(null, null, null, null),
                IssuedBy: new PdfSignaturePrincipalDto(null, null, null, null),
                SerialNumber: null,
                ValidFrom: null,
                ValidTo: null,
                SelfSigned: false,
                Expired: false,
                NotYetValid: false,
                IsSigner: true,
                Version: null,
                KeyAlgorithm: null,
                SignatureAlgorithm: null,
                Pem: null,
                KeySizeBits: null);
        }

        var issuedTo = ParsePrincipal(certificate.Subject);
        var issuedBy = ParsePrincipal(certificate.Issuer);
        var validFrom = new DateTimeOffset(certificate.NotBefore).ToUniversalTime();
        var validTo = new DateTimeOffset(certificate.NotAfter).ToUniversalTime();

        return new PdfSignatureCertificateInfoDto(
            IssuedTo: issuedTo,
            IssuedBy: issuedBy,
            SerialNumber: ToColonSerial(certificate.SerialNumber),
            ValidFrom: validFrom,
            ValidTo: validTo,
            SelfSigned: string.Equals(certificate.Subject, certificate.Issuer, StringComparison.OrdinalIgnoreCase),
            Expired: validTo < now,
            NotYetValid: validFrom > now,
            IsSigner: true,
            Version: certificate.Version,
            KeyAlgorithm: certificate.PublicKey.Oid?.FriendlyName ?? certificate.PublicKey.Oid?.Value,
            SignatureAlgorithm: certificate.SignatureAlgorithm.FriendlyName ?? certificate.SignatureAlgorithm.Value,
            Pem: ToPem(certificate.RawData),
            KeySizeBits: TryGetKeySize(certificate));
    }

    private static int? TryGetKeySize(X509Certificate2 certificate)
    {
        try
        {
            return certificate.PublicKey.Key.KeySize;
        }
        catch
        {
            return null;
        }
    }

    private static string? InferDigestAlgorithm(X509Certificate2? certificate)
    {
        if (certificate?.SignatureAlgorithm is null)
            return null;

        var source = (certificate.SignatureAlgorithm.FriendlyName ?? certificate.SignatureAlgorithm.Value ?? string.Empty).ToUpperInvariant();
        if (source.Contains("SHA512", StringComparison.Ordinal)) return "SHA-512";
        if (source.Contains("SHA384", StringComparison.Ordinal)) return "SHA-384";
        if (source.Contains("SHA256", StringComparison.Ordinal)) return "SHA-256";
        if (source.Contains("SHA1", StringComparison.Ordinal)) return "SHA-1";
        return certificate.SignatureAlgorithm.FriendlyName ?? certificate.SignatureAlgorithm.Value;
    }

    private static string? InferSignatureAlgorithm(X509Certificate2? certificate)
    {
        var oidName = certificate?.PublicKey.Oid?.FriendlyName?.ToUpperInvariant();
        if (oidName is not null && oidName.Contains("RSA", StringComparison.Ordinal))
            return "RSA";
        if (oidName is not null && oidName.Contains("ECDSA", StringComparison.Ordinal))
            return "ECDSA";
        return certificate?.PublicKey.Oid?.FriendlyName ?? certificate?.PublicKey.Oid?.Value;
    }

    private static PdfSignaturePrincipalDto ParsePrincipal(string? dn)
    {
        if (string.IsNullOrWhiteSpace(dn))
            return new PdfSignaturePrincipalDto(null, null, null, dn);

        string? commonName = null;
        string? organization = null;
        string? country = null;

        foreach (var part in dn.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries))
        {
            var equalsIndex = part.IndexOf('=');
            if (equalsIndex <= 0 || equalsIndex >= part.Length - 1)
                continue;

            var key = part[..equalsIndex].Trim();
            var value = part[(equalsIndex + 1)..].Trim();

            if (key.Equals("CN", StringComparison.OrdinalIgnoreCase)) commonName = value;
            else if (key.Equals("O", StringComparison.OrdinalIgnoreCase)) organization = value;
            else if (key.Equals("C", StringComparison.OrdinalIgnoreCase)) country = value;
        }

        return new PdfSignaturePrincipalDto(commonName, organization, country, dn);
    }

    private static PdfCertificationLevel? ToDevExpressCertificationLevel(PdfSignatureCertificationLevel? value)
    {
        return value is null ? null : (PdfCertificationLevel)(int)value.Value;
    }

    private static string? ToColonSerial(string? raw)
    {
        if (string.IsNullOrWhiteSpace(raw))
            return null;

        var normalized = raw.Replace(":", string.Empty, StringComparison.Ordinal).Trim();
        if (normalized.Length % 2 != 0)
            return normalized;

        return string.Join(':', Enumerable.Range(0, normalized.Length / 2).Select(i => normalized.Substring(i * 2, 2).ToUpperInvariant()));
    }

    private static string ToPem(byte[] der)
    {
        var base64 = Convert.ToBase64String(der, Base64FormattingOptions.InsertLineBreaks);
        var sb = new StringBuilder();
        sb.AppendLine("-----BEGIN CERTIFICATE-----");
        sb.AppendLine(base64);
        sb.Append("-----END CERTIFICATE-----");
        return sb.ToString();
    }

    private static string? TryExtractMessageDigestHex(byte[]? signatureContents)
    {
        if (signatureContents is null || signatureContents.Length == 0)
            return null;

        try
        {
            var cms = new SignedCms();
            cms.Decode(signatureContents);

            var signerInfo = cms.SignerInfos.Count > 0 ? cms.SignerInfos[0] : null;
            if (signerInfo is null)
                return null;

            foreach (CryptographicAttributeObject attr in signerInfo.SignedAttributes)
            {
                if (!string.Equals(attr.Oid?.Value, "1.2.840.113549.1.9.4", StringComparison.Ordinal))
                    continue;

                foreach (var value in attr.Values)
                {
                    var octets = TryReadOctetString(value.RawData);
                    if (octets is not null && octets.Length > 0)
                        return Convert.ToHexString(octets);
                }
            }
        }
        catch
        {
            return null;
        }

        return null;
    }

    private static byte[]? TryReadOctetString(byte[] rawData)
    {
        try
        {
            var reader = new AsnReader(rawData, AsnEncodingRules.BER);
            var octets = reader.ReadOctetString();
            if (reader.HasData)
                return null;
            return octets;
        }
        catch
        {
            return null;
        }
    }

    private static List<long[]> ParseByteRanges(byte[] pdfBytes)
    {
        var text = Encoding.Latin1.GetString(pdfBytes);
        var matches = Regex.Matches(text, @"/ByteRange\s*\[(?<values>[\d\s]+)\]", RegexOptions.CultureInvariant);
        var ranges = new List<long[]>(matches.Count);

        foreach (Match match in matches)
        {
            var raw = match.Groups["values"].Value;
            var parts = raw.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries);
            var values = new long[parts.Length];
            var ok = true;

            for (var i = 0; i < parts.Length; i++)
            {
                if (!long.TryParse(parts[i], out values[i]))
                {
                    ok = false;
                    break;
                }
            }

            if (ok && values.Length >= 4 && values.Length % 2 == 0)
                ranges.Add(values);
        }

        return ranges;
    }

    private static bool CoversWholeDocument(long[]? byteRange, long fileLength)
    {
        if (byteRange is null || byteRange.Length < 4 || byteRange.Length % 2 != 0)
            return false;

        if (byteRange[0] != 0)
            return false;

        long previousEnd = -1;
        for (var i = 0; i < byteRange.Length; i += 2)
        {
            var start = byteRange[i];
            var length = byteRange[i + 1];
            if (start < 0 || length < 0)
                return false;

            var end = start + length;
            if (previousEnd > start)
                return false;

            previousEnd = end;
        }

        return previousEnd == fileLength;
    }

    private static long GetSignedRevisionLength(long[] byteRange)
    {
        if (byteRange.Length < 2)
            return -1;

        var start = byteRange[^2];
        var length = byteRange[^1];
        if (start < 0 || length < 0)
            return -1;

        return start + length;
    }

    private static string ResolveUuid(string? uuid)
    {
        return Guid.TryParse(uuid, out var parsed)
            ? parsed.ToString()
            : Guid.NewGuid().ToString();
    }

    private static string BuildReasonWithMeta(string? businessReason, string uuid, string sourceHashHex)
    {
        var trimmedReason = string.IsNullOrWhiteSpace(businessReason) ? null : businessReason.Trim();
        var prefix = string.IsNullOrWhiteSpace(trimmedReason) ? string.Empty : trimmedReason + " ";
        return $"{prefix}| SFMETA:v1;doc={uuid};sha256={sourceHashHex}";
    }

    private static string? BuildContactInfo(string? email, string? phone)
    {
        var normalizedEmail = string.IsNullOrWhiteSpace(email) ? null : email.Trim();
        var normalizedPhone = string.IsNullOrWhiteSpace(phone) ? null : phone.Trim();

        if (normalizedEmail is null && normalizedPhone is null)
            return null;

        if (normalizedEmail is null)
            return $"tel:{normalizedPhone}";

        if (normalizedPhone is null)
            return $"mailto:{normalizedEmail}";

        return $"mailto:{normalizedEmail};tel:{normalizedPhone}";
    }

    private static (string? Email, string? Phone) ParseContactInfo(string? contactInfo)
    {
        if (string.IsNullOrWhiteSpace(contactInfo))
            return (null, null);

        string? email = null;
        string? phone = null;

        foreach (var part in contactInfo.Split(';', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries))
        {
            if (part.StartsWith("mailto:", StringComparison.OrdinalIgnoreCase))
            {
                email = part[7..].Trim();
                continue;
            }

            if (part.StartsWith("tel:", StringComparison.OrdinalIgnoreCase))
            {
                phone = part[4..].Trim();
                continue;
            }

            if (email is null && part.Contains('@', StringComparison.Ordinal))
            {
                email = part.Trim();
                continue;
            }

            if (phone is null)
                phone = part.Trim();
        }

        return (
            string.IsNullOrWhiteSpace(email) ? null : email,
            string.IsNullOrWhiteSpace(phone) ? null : phone);
    }

    private static (string? BusinessReason, string? UUID, string? OriginalDocumentSha256) ParseReasonMeta(string? reason)
    {
        if (string.IsNullOrWhiteSpace(reason))
            return (reason, null, null);

        var match = SignatureReasonMetaRegex.Match(reason);
        if (!match.Success)
            return (reason, null, null);

        var businessReason = reason[..match.Index].Trim();
        if (string.IsNullOrWhiteSpace(businessReason))
            businessReason = null;

        return (
            businessReason,
            match.Groups["doc"].Value,
            match.Groups["sha"].Value.ToUpperInvariant());
    }
}