private static void ValidCertificateChain(CertificadoDigital cert)
        {
            if (cert.ErrosValidacaoCadeia != null && cert.ErrosValidacaoCadeia.Any())
            {
                StringBuilder erroMessage = new StringBuilder();

                bool exception = cert.ErrosValidacaoCadeia.Any(e =>
                                                               e.Key == (int)X509ChainStatusFlags.PartialChain ||
                                                               e.Key == (int)X509ChainStatusFlags.RevocationStatusUnknown ||
                                                               e.Key == (int)X509ChainStatusFlags.OfflineRevocation);

                foreach (var erro in cert.ErrosValidacaoCadeia)
                {
                    erroMessage.AppendLine($"Status: {erro.Key} | Status Information: {erro.Value}");
                }

                if (exception)
                {
                    erroMessage.Insert(0, $"Não foi possível validar a cadeia do certificado digital.\n");
                    throw new Exception(erroMessage.ToString());
                }
                else
                {
                    erroMessage.Insert(0, $"Certificado digital com cadeia inválida. {message}\n");
                    throw new Exception(erroMessage.ToString());
                }
            }
        }
        private static void ValidDigitalCertificate(CertificadoDigital cert, PdfPkcs7 pkcs7)
        {
            bool timestampImprint = pkcs7.VerifyTimestampImprint();

            if (!timestampImprint && !cert.PeriodoValido)
            {
                throw new Exception("Este documento possui uma assinatura ICPBrasil inválida.");
            }
        }
        private static void ValidSignatureType(CertificadoDigital cert)
        {
            if (cert.TipoCertificado != TipoCertificadoEnum.eCPF && cert.TipoCertificado != TipoCertificadoEnum.eCNPJ)
            {
                throw new Exception("A assinatura digital deste documento possui um tipo desconhecido.");
            }

            if ((cert.PessoaFisica == null || string.IsNullOrWhiteSpace(cert.PessoaFisica.CPF)) && (cert.PessoaJuridica == null || cert.PessoaJuridica.Responsavel == null || string.IsNullOrWhiteSpace(cert.PessoaJuridica.Responsavel.CPF)))
            {
                throw new Exception("A assinatura digital deste documento não está associada a um CPF ou CNPJ.");
            }

            if ((cert.PessoaFisica == null || string.IsNullOrWhiteSpace(cert.PessoaFisica.CPF)) && (cert.PessoaJuridica == null || cert.PessoaJuridica.Responsavel == null || string.IsNullOrWhiteSpace(cert.PessoaJuridica.Responsavel.Nome)))
            {
                throw new Exception("A assinatura digital deste documento não possui a informação do nome do assinante.");
            }
        }
        public async Task <bool> ValidateDigitalSignatures(byte[] file)
        {
            try
            {
                PdfReader reader = new PdfReader(file);

                // ordenar a lista de assinaturas
                var orderedSignatureNames = GetOrderedSignatureNames(reader);

                // ordernar as posições das tabelas de referência cruzada
                List <int> XrefByteOffsetOrdered = reader.XrefByteOffset.Cast <int>().ToList();
                XrefByteOffsetOrdered.Sort();

                var assinaramTodoDocumentoSN = reader.SignaturesCoverWholeDocument().Cast <string>().ToList();

                List <KeyValuePair <string, string> > naoAssinaramTodoDocumento = new List <KeyValuePair <string, string> >();
                List <KeyValuePair <string, string> > assinaramTodoDocumento    = new List <KeyValuePair <string, string> >();
                foreach (string signatureName in orderedSignatureNames)
                {
                    PdfPkcs7 pkcs7 = reader.AcroFields.VerifySignature(signatureName);

                    var messages = await OnlineChainValidation(
                        pkcs7.SigningCertificate.GetEncoded(),
                        Configuration["OutboundValidacaoCertificado"] + "/certificado/api/validar-certificado"
                        );

                    if (!string.IsNullOrWhiteSpace(messages))
                    {
                        throw new Exception(messages);
                    }

                    CertificadoDigital cert = new CertificadoDigital(pkcs7.SigningCertificate.GetEncoded());

                    // validations
                    ValidCertificateChain(cert);
                    ValidDigitalCertificate(cert, pkcs7);
                    ValidSignatureType(cert);
                    ValidSignatureDate(pkcs7);
                    IsDocumentUnadulterated(pkcs7);

                    // cpf-cnpj, name, signature's date
                    PessoaFisica pessoaFisica = cert.PessoaJuridica?.Responsavel ?? cert.PessoaFisica;
                    string       pessoa       = $"{pessoaFisica.Nome.ToUpper()}";
                    if (cert.PessoaJuridica != null)
                    {
                        pessoa += $" ({cert.PessoaJuridica.RazaoSocial.ToUpper()})";
                    }

                    if (!assinaramTodoDocumentoSN.Contains(signatureName))
                    {
                        naoAssinaramTodoDocumento.Add(new KeyValuePair <string, string>(pessoa, signatureName));
                    }
                    else
                    {
                        assinaramTodoDocumento.Add(new KeyValuePair <string, string>(pessoa, signatureName));
                    }
                }

                // Deixar apenas a última assinatura de cada pessoa/cnpj
                var distinctSignersList = RemoverAssinaturasDuplicadas(assinaramTodoDocumento);
                var distinctNaoAssinaramTodoDocumento = RemoverAssinaturasDuplicadas(naoAssinaramTodoDocumento);

                TodosAssinaramDocumentoPorInteiro(distinctNaoAssinaramTodoDocumento);

                return(true);
            }
            catch (Exception e)
            {
                throw new Exception($"Ocorreu um erro: {e.Message}");
            }
        }