private static FirmaDigitale extractFirmaDigitale(DocsPaVO.documento.FileDocumento fileDoc)
{
VerifySignature verifySignature = new VerifySignature();
string inputDirectory = verifySignature.GetPKCS7InputDirectory();
// Creazione cartella di appoggio nel caso non esista
if (!System.IO.Directory.Exists(inputDirectory))
{
System.IO.Directory.CreateDirectory(inputDirectory);
}
string inputFile = string.Concat(inputDirectory, fileDoc.name);
// Copia del file firmato dalla cartella del documentale
// alla cartella di input utilizzata dal ws della verifica
CopySignedFileToInputFolder(fileDoc, inputFile);
fileDoc.signatureResult = verifySignature.Verify(fileDoc.name);
try
{
// Rimozione del file firmato dalla cartella di input
System.IO.File.Delete(inputFile);
}
catch
{
}
if (fileDoc.signatureResult == null)
{
return(null);
}
FirmaDigitale fd = null;
if (fileDoc.signatureResult.PKCS7Documents != null)
{
fd = new FirmaDigitale();
foreach (PKCS7Document p7m in fileDoc.signatureResult.PKCS7Documents)
{
if (p7m.SignersInfo != null)
{
DocsPaVO.documento.SignerInfo si = p7m.SignersInfo.FirstOrDefault();
CnipaParser cp = new CnipaParser();
cp.ParseCNIPASubjectInfo(ref si.SubjectInfo, si.CertificateInfo.SubjectName);
fd.Certificato = String.Format("{0} {1} {2}", "<![CDATA[", Utils.SerializeObject <CertificateInfo>(si.CertificateInfo, true), "]]>");
fd.DatiFirma = String.Format("{0} {1} {2}", "<![CDATA[", Utils.SerializeObject <SubjectInfo>(si.SubjectInfo, true), "]]>");
fd.Titolare = new Titolare
{
CodiceFiscale = si.SubjectInfo.CodiceFiscale,
Nome = si.SubjectInfo.Nome,
Cognome = si.SubjectInfo.Cognome
};
}
}
}
return(fd);
}
public DocsPaVO.documento.SignerInfo ExtractSignerInfo(X509Certificate2 cert)
{
DocsPaVO.documento.SignerInfo signerInfo = new DocsPaVO.documento.SignerInfo();
signerInfo.CertificateInfo.RevocationStatus = CheckCertificate(cert);
//signerInfo.CertificateInfo.X509Certificate = cert1.GetEncoded();
signerInfo.CertificateInfo.RevocationStatusDescription = DecodeStatus(signerInfo.CertificateInfo.RevocationStatus);
ParseCNIPASubjectInfo(ref signerInfo.SubjectInfo, cert.SubjectName.Name);
signerInfo.CertificateInfo.IssuerName = cert.IssuerName.Name;
signerInfo.CertificateInfo.SerialNumber = cert.SerialNumber;
signerInfo.CertificateInfo.SignatureAlgorithm = cert.SignatureAlgorithm.FriendlyName;
signerInfo.CertificateInfo.SubjectName = cert.SubjectName.Name;
signerInfo.CertificateInfo.ValidFromDate = cert.NotBefore;
signerInfo.CertificateInfo.ValidToDate = cert.NotAfter;
signerInfo.CertificateInfo.ThumbPrint = cert.Thumbprint;
StringBuilder sb = new StringBuilder();
sb.AppendFormat("CertificateInfo.IssuerName: '{0}'", signerInfo.CertificateInfo.IssuerName);
sb.AppendFormat("CertificateInfo.SerialNumber: '{0}'", signerInfo.CertificateInfo.SerialNumber);
sb.AppendFormat("CertificateInfo.SignatureAlgorithm: '{0}'", signerInfo.CertificateInfo.SignatureAlgorithm);
sb.AppendFormat("CertificateInfo.SubjectName: '{0}'", signerInfo.CertificateInfo.SubjectName);
sb.AppendFormat("CertificateInfo.ValidFromDate: '{0}'", signerInfo.CertificateInfo.ValidFromDate);
sb.AppendFormat("CertificateInfo.ValidToDate: '{0}'", signerInfo.CertificateInfo.ValidToDate);
sb.AppendFormat("CertificateInfo.ThumbPrint: '{0}'", signerInfo.CertificateInfo.ThumbPrint);
return(signerInfo);
}
private static DocsPaVO.documento.SignerInfo ExtractSignerInfo(EsitoVerificaStatus status, FirmaDigitale.DatiFirmaType firmatario, FirmaDigitale.MarcaType marcaFirma)
{
DocsPaVO.documento.SignerInfo si = new DocsPaVO.documento.SignerInfo();
if (firmatario != null)
{
// firmatari
si.CertificateInfo = new DocsPaVO.documento.CertificateInfo
{
ValidFromDate = firmatario.dataInizioValiditaCert,
ValidToDate = firmatario.dataFineValiditaCert,
RevocationStatusDescription = status.ToString(),
RevocationStatus = (int)status,
IssuerName = "CN=" + firmatario.cnCertAuthority,
SerialNumber = firmatario.serialNumber,
SubjectName = firmatario.commonName,
SignatureAlgorithm = "N.D.",
ThumbPrint = "N.D"
};
if (firmatario.dataRevocaCertificato != DateTime.MinValue)
{
si.CertificateInfo.RevocationStatus = 4; //Revocato
si.CertificateInfo.RevocationDate = firmatario.dataRevocaCertificato;
}
si.SubjectInfo = new DocsPaVO.documento.SubjectInfo
{
CodiceFiscale = firmatario.codiceFiscale,
CommonName = firmatario.commonName,
CertId = firmatario.distinguishName,
Organizzazione = firmatario.organizzazione,
SerialNumber = firmatario.serialNumber,
Nome = firmatario.nome,
Cognome = firmatario.cognome,
Country = firmatario.nazione
};
si.SignatureAlgorithm = convertOidToString(firmatario.digestAlgorithm);
}
if (marcaFirma != null)
{
List <TSInfo> tsList = new List <TSInfo>();
TSInfo tsi = new TSInfo
{
dataInizioValiditaCert = marcaFirma.dataInizioValiditaCert,
dataFineValiditaCert = marcaFirma.dataFineValiditaCert,
TSdateTime = marcaFirma.TSdateTime,
TSimprint = marcaFirma.TSimprint,
TSANameIssuer = marcaFirma.TSANameIssuer,
TSANameSubject = marcaFirma.TSANameSubject,
TSserialNumber = marcaFirma.TSserialNumber,
TSType = TsType.PKCS
};
tsList.Add(tsi);
si.SignatureTimeStampInfo = tsList.ToArray();
}
return(si);
}
private static VerifySignatureResult ConvertToVerifySignatureResult(EsitoVerificaStatus status, FirmaDigitale.DettaglioFirmaDigitaleType d)
{
VerifySignatureResult vsr = new VerifySignatureResult();
List <DocsPaVO.documento.SignerInfo> siLst = new List <DocsPaVO.documento.SignerInfo>();
if (d.datiFirmatari != null)
{
foreach (FirmaDigitale.FirmatarioType ft in d.datiFirmatari)
{
DocsPaVO.documento.SignerInfo si = new DocsPaVO.documento.SignerInfo();
si.CertificateInfo = new DocsPaVO.documento.CertificateInfo
{
ValidFromDate = ft.firmatario.dataInizioValiditaCert,
ValidToDate = ft.firmatario.dataFineValiditaCert,
RevocationDate = ft.firmatario.dataRevocaCertificato,
RevocationStatus = (int)status,
RevocationStatusDescription = status.ToString(),
IssuerName = "CN=" + ft.firmatario.cnCertAuthority,
SignatureAlgorithm = "N.D."
};
si.SubjectInfo = new DocsPaVO.documento.SubjectInfo
{
CodiceFiscale = ft.firmatario.codiceFiscale,
CommonName = ft.firmatario.commonName,
CertId = ft.firmatario.distinguishName,
Organizzazione = ft.firmatario.organizzazione,
SerialNumber = ft.firmatario.serialNumber,
};
si.SignatureAlgorithm = convertOidtoString(ft.firmatario.digestAlgorithm);
siLst.Add(si);
}
}
List <DocsPaVO.documento.PKCS7Document> p7docsLst = new List <DocsPaVO.documento.PKCS7Document>();
DocsPaVO.documento.PKCS7Document p7doc = new DocsPaVO.documento.PKCS7Document
{
SignersInfo = siLst.ToArray(),
DocumentFileName = null,
Level = 0
};
p7docsLst.Add(p7doc);
vsr.PKCS7Documents = p7docsLst.ToArray();
vsr.StatusCode = (int)status;
vsr.StatusDescription = status.ToString();
vsr.CRLOnlineCheck = true;
return(vsr);
}
public DocsPaVO.documento.SignerInfo GetCertSignersInfo(Org.BouncyCastle.X509.X509Certificate cert1)
{
DocsPaVO.documento.SignerInfo retval = new DocsPaVO.documento.SignerInfo();
retval.SubjectInfo = new DocsPaVO.documento.SubjectInfo();
string Subject = buildSubject(cert1.SubjectDN);
ParseCNIPASubjectInfo(ref retval.SubjectInfo, Subject);
retval.CertificateInfo.IssuerName = cert1.IssuerDN.ToString();
retval.CertificateInfo.SerialNumber = BitConverter.ToString(cert1.SerialNumber.ToByteArray()).Replace("-", "");
retval.CertificateInfo.SignatureAlgorithm = cert1.SigAlgName;
retval.CertificateInfo.SubjectName = Subject;
retval.CertificateInfo.ValidFromDate = cert1.NotBefore.ToLocalTime();
retval.CertificateInfo.ValidToDate = cert1.NotAfter.ToLocalTime();
retval.CertificateInfo.ThumbPrint = BitConverter.ToString(System.Security.Cryptography.SHA1.Create().ComputeHash(cert1.GetEncoded())).Replace("-", "");
retval.CertificateInfo.X509Certificate = cert1.GetEncoded();
// controlla revoca
X509Certificate2 cert = new X509Certificate2(cert1.GetEncoded());
retval.CertificateInfo.RevocationStatus = CheckCertificate(cert);
retval.CertificateInfo.RevocationStatusDescription = DecodeStatus(retval.CertificateInfo.RevocationStatus);
return(retval);
}
private static VerifySignatureResult ConvertToVerifySignatureResult(EsitoVerificaStatus status)
{
VerifySignatureResult vsr = new VerifySignatureResult();
List <DocsPaVO.documento.SignerInfo> siLst = new List <DocsPaVO.documento.SignerInfo>();
{
DocsPaVO.documento.SignerInfo si = new DocsPaVO.documento.SignerInfo();
si.CertificateInfo = new DocsPaVO.documento.CertificateInfo
{
ValidFromDate = DateTime.Parse("2011-03-25T13:57:54+01:00"),
ValidToDate = DateTime.Parse("2014-03-25T00:00:00+01:00"),
RevocationStatus = (int)EsitoVerificaStatus.Valid,
RevocationStatusDescription = EsitoVerificaStatus.Valid.ToString()
};
si.SubjectInfo = new DocsPaVO.documento.SubjectInfo
{
CodiceFiscale = "TTVLFF44P28D969E",
CommonName = "Elio Raffaele Ottaviano",
CertId = "2011500471127",
};
siLst.Add(si);
}
{
DocsPaVO.documento.SignerInfo si = new DocsPaVO.documento.SignerInfo();
si.CertificateInfo = new DocsPaVO.documento.CertificateInfo
{
ValidFromDate = DateTime.Parse("2008-09-01T14:09:40+02:00"),
ValidToDate = DateTime.Parse("2013-12-31T18:00:00+01:00"),
RevocationDate = DateTime.Parse("2011-01-21T12:48:17+01:00"),
RevocationStatus = (int)EsitoVerificaStatus.Revoked,
RevocationStatusDescription = EsitoVerificaStatus.Revoked.ToString()
};
si.SubjectInfo = new DocsPaVO.documento.SubjectInfo
{
CodiceFiscale = "TTVLFF44P28D969E",
CommonName = "ELIO RAFFAELE OTTAVIANO",
CertId = "12202828:4330:1",
};
siLst.Add(si);
}
List <DocsPaVO.documento.PKCS7Document> p7docsLst = new List <DocsPaVO.documento.PKCS7Document>();
DocsPaVO.documento.PKCS7Document p7doc = new DocsPaVO.documento.PKCS7Document
{
SignersInfo = siLst.ToArray(),
DocumentFileName = null,
Level = 0
};
p7docsLst.Add(p7doc);
vsr.PKCS7Documents = p7docsLst.ToArray();
vsr.StatusCode = (int)EsitoVerificaStatus.Revoked;
vsr.StatusDescription = status.ToString();
vsr.CRLOnlineCheck = true;
return(vsr);
}
private DocsPaVO.documento.SignerInfo ExtractSignerInfo(List <string> ErrorMessageLst, IX509Store store, SignerInformation signer)
{
DocsPaVO.documento.SignerInfo thisSinger = new DocsPaVO.documento.SignerInfo();
Org.BouncyCastle.X509.X509Certificate cert1 = GetCertificate(signer, store);
try
{
if (!signer.Verify(cert1))
{
ErrorMessageLst.Add("Not valid signature");
}
}
catch (Exception e)
{
ErrorMessageLst.Add(e.Message);
}
thisSinger.isCountersigner = signer.IsCounterSignature;
if (signer.SignedAttributes != null)
{
if (signer.SignedAttributes[Org.BouncyCastle.Asn1.Pkcs.PkcsObjectIdentifiers.IdAASigningCertificateV2] == null)
{
ErrorMessageLst.Add("Id-AA-SigningCertificateV2 not found");
}
if (signer.SignedAttributes[CmsAttributes.MessageDigest] == null)
{
ErrorMessageLst.Add("Pkcs9AtMessageDigest not found");
}
if (!signer.IsCounterSignature) //Pare che i controfirmatari non ncessitino di questo parametro
{
if (signer.SignedAttributes[Org.BouncyCastle.Asn1.Pkcs.PkcsObjectIdentifiers.Pkcs9AtContentType] == null)
{
ErrorMessageLst.Add("Pkcs9AtContentType not found");
}
}
thisSinger.SignatureAlgorithm = Org.BouncyCastle.Security.DigestUtilities.GetAlgorithmName(signer.DigestAlgorithmID.ObjectID);
if (signer.SignedAttributes[CmsAttributes.SigningTime] != null)
{
Org.BouncyCastle.Asn1.Cms.Attribute sigTime = signer.SignedAttributes[CmsAttributes.SigningTime];
if (sigTime.AttrValues.Count > 0)
{
try
{
thisSinger.SigningTime = GetSigningTime(sigTime.AttrValues[0]);
}
catch (Exception e)
{
ErrorMessageLst.Add("Error retriving SigningTime");
}
}
}
}
else
{
ErrorMessageLst.Add("Missing SignedAttributes");
}
if (gestioneTSFirma)
{
List <TSInfo> tsArr = new List <TSInfo>();
if (signer.UnsignedAttributes != null && signer.UnsignedAttributes[Org.BouncyCastle.Asn1.Pkcs.PkcsObjectIdentifiers.IdAASignatureTimeStampToken] != null)
{
ICollection ret = Org.BouncyCastle.Tsp.TspUtil.GetSignatureTimestamps(signer);
foreach (Org.BouncyCastle.Tsp.TimeStampToken token in ret)
{
VerifyTimeStamp verifyTimeStamp = new VerifyTimeStamp();
ICollection certsColl = token.GetCertificates("COLLECTION").GetMatches(null);
TSInfo timeStamp = verifyTimeStamp.getTSCertInfo(certsColl);
timeStamp.TSdateTime = token.TimeStampInfo.GenTime.ToLocalTime();
timeStamp.TSserialNumber = token.TimeStampInfo.SerialNumber.ToString();
timeStamp.TSimprint = Convert.ToBase64String(token.TimeStampInfo.TstInfo.MessageImprint.GetEncoded());
timeStamp.TSdateTime = token.TimeStampInfo.GenTime;
timeStamp.TSType = TsType.PKCS;
tsArr.Add(timeStamp);
}
}
if (tsArr.Count > 0)
{
thisSinger.SignatureTimeStampInfo = tsArr.ToArray();
}
}
X509Certificate2 cert = new X509Certificate2(cert1.GetEncoded());
thisSinger.CertificateInfo.RevocationStatus = CheckCertificate(cert);
thisSinger.CertificateInfo.X509Certificate = cert1.GetEncoded();
thisSinger.CertificateInfo.RevocationStatusDescription = DecodeStatus(thisSinger.CertificateInfo.RevocationStatus);
ParseCNIPASubjectInfo(ref thisSinger.SubjectInfo, cert.SubjectName.Name);
thisSinger.CertificateInfo.IssuerName = cert.IssuerName.Name;
thisSinger.CertificateInfo.SerialNumber = cert.SerialNumber;
thisSinger.CertificateInfo.SignatureAlgorithm = cert.SignatureAlgorithm.FriendlyName;
thisSinger.CertificateInfo.SubjectName = cert.SubjectName.Name;
thisSinger.CertificateInfo.ValidFromDate = cert.NotBefore;
thisSinger.CertificateInfo.ValidToDate = cert.NotAfter;
thisSinger.CertificateInfo.ThumbPrint = cert.Thumbprint;
StringBuilder sb = new StringBuilder();
sb.AppendFormat("CertificateInfo.IssuerName: '{0}'", thisSinger.CertificateInfo.IssuerName);
sb.AppendFormat("CertificateInfo.SerialNumber: '{0}'", thisSinger.CertificateInfo.SerialNumber);
sb.AppendFormat("CertificateInfo.SignatureAlgorithm: '{0}'", thisSinger.CertificateInfo.SignatureAlgorithm);
sb.AppendFormat("CertificateInfo.SubjectName: '{0}'", thisSinger.CertificateInfo.SubjectName);
sb.AppendFormat("CertificateInfo.ValidFromDate: '{0}'", thisSinger.CertificateInfo.ValidFromDate);
sb.AppendFormat("CertificateInfo.ValidToDate: '{0}'", thisSinger.CertificateInfo.ValidToDate);
sb.AppendFormat("CertificateInfo.ThumbPrint: '{0}'", thisSinger.CertificateInfo.ThumbPrint);
//DocsPaUtils.LogsManagement.Debugger.Write(string.Format("SignedDocument.Verify - {0}", sb.ToString()));
//gestione controfirma
if (signer.UnsignedAttributes != null)
{
if (signer.UnsignedAttributes[CmsAttributes.CounterSignature] != null)
{
List <DocsPaVO.documento.SignerInfo> cSigsList = new List <DocsPaVO.documento.SignerInfo>();
List <string> csignErrs = new List <string> ();
SignerInformationStore counterSignatures = signer.GetCounterSignatures();
foreach (SignerInformation conunterSig in counterSignatures.GetSigners())
{
DocsPaVO.documento.SignerInfo cSigs = ExtractSignerInfo(csignErrs, store, conunterSig);
cSigsList.Add(cSigs);
}
if (csignErrs.Count > 0)
{
ErrorMessageLst.AddRange(csignErrs);
}
if (cSigsList.Count > 0)
{
thisSinger.counterSignatures = cSigsList.ToArray();
}
}
}
return(thisSinger);
}
/// <summary>
/// Verify PKCS7 signature
/// </summary>
/// <returns>CAPICOM/CryptoAPI return code or an ApplicationException in file hash doesn't match</returns>
public bool Verify(ref List <string> ErrorMessageLst)
{
bool rc = true;
//DocsPaUtils.LogsManagement.Debugger.Write("SignedDocument.Verify - INIT");
try
{
// Decodifica un messaggio SignedCms codificato.
// Al completamento della decodifica, è possibile recuperare le
// informazioni decodificate dalle proprietà dell'oggetto SignedCms.
CmsSignedData cms = new CmsSignedData(this.GetSignedContent(this._buf));
IX509Store store = cms.GetCertificates("Collection");
SignerInformationStore signers = cms.GetSignerInfos();
SignedData da = SignedData.GetInstance(cms.ContentInfo.Content.ToAsn1Object());
Asn1Sequence DigAlgAsn1 = null;
if (da.DigestAlgorithms.Count > 0)
{
DigAlgAsn1 = da.DigestAlgorithms[0].ToAsn1Object() as Asn1Sequence;
}
if (DigAlgAsn1 != null)
{
this._SignAlgorithm = Org.BouncyCastle.Security.DigestUtilities.GetAlgorithmName(AlgorithmIdentifier.GetInstance(DigAlgAsn1).ObjectID);
}
//DocsPaUtils.LogsManagement.Debugger.Write("SignedDocument.Verify - Decode signed message");
// Verify signature. Do not validate signer
// certificate for the purposes of this example.
// Note that in a production environment, validating
// the signer certificate chain will probably
// be necessary.
/*
* verifica le firme digitali nel messaggio CMS/PKCS #7 firmato e,
* facoltativamente, convalida i certificati del firmatario.
*
* * Se verifySignatureOnly è true, vengono verificate solo le firme digitali.
* Se è false, vengono verificate le firme digitali e vengono convalidati
* i certificati dei firmatari e gli scopi dei certificati.
* Gli scopi di un certificato sono considerati validi se il certificato
* non prevede l'utilizzo della chiave o se l'utilizzo della chiave supporta
* le firme digitali o il non-rifiuto.
*
*/
//_signersInfo = new DocsPaVO.documento.SignerInfo[signers.GetSigners().Count];
//int i = 0;
List <DocsPaVO.documento.SignerInfo> signInfoLst = new List <DocsPaVO.documento.SignerInfo>();
foreach (SignerInformation signer in signers.GetSigners())
{
DocsPaVO.documento.SignerInfo thisSinger = ExtractSignerInfo(ErrorMessageLst, store, signer);
signInfoLst.Add(thisSinger);
}
_signersInfo = signInfoLst.ToArray();
//DocsPaUtils.LogsManagement.Debugger.Write(string.Format("SignedDocument.Verify - CheckSignature OK, signers count: {0}", signers.GetSigners().Count));
CmsProcessable signedContent = cms.SignedContent;
this._content = (byte[])signedContent.GetContent();
if ((this._SignAlgorithm != null) && this._content != null)
{
try
{
this._SignHash = BitConverter.ToString(Org.BouncyCastle.Security.DigestUtilities.CalculateDigest(this._SignAlgorithm, this._content)).Replace("-", "");
}
catch (Exception e)
{
ErrorMessageLst.Add(e.Message);
}
}
//DocsPaUtils.LogsManagement.Debugger.Write(string.Format("SignedDocument.Verify - Extact content, lenght: {0}", this._content.Length));
this._documentFileName = GetDocumentFileName();
this._SignType = "CADES";
//DocsPaUtils.LogsManagement.Debugger.Write(string.Format("SignedDocument.Verify - DocumentFileName: '{0}'", this._documentFileName));
}
catch (Exception ex)
{
rc = false;
//DocsPaUtils.LogsManagement.Debugger.Write("SignedDocument.Verify - Si è verificato un errore nella verifica della firma", ex);
//throw new ApplicationException(ex.Message);
ErrorMessageLst.Add(ex.Message);
}
finally
{
//DocsPaUtils.LogsManagement.Debugger.Write("SignedDocument.Verify - END");
}
return(rc);
}
private static VerifySignatureResult ConvertToVerifySignatureResultUsingInternalStructures(EsitoVerificaStatus status, FirmaDigitale.DettaglioFirmaDigitaleType d)
{
VerifySignatureResult vsr = new VerifySignatureResult();
List <DocsPaVO.documento.SignerInfo> siLst = new List <DocsPaVO.documento.SignerInfo>();
string verbosesgb = ConfigurationManager.AppSettings["VERBOSEDEBUG"];
bool verboseDebug = false;
Boolean.TryParse(verbosesgb, out verboseDebug);
if (verboseDebug)
{
logger.Debug(d.datiGeneraliVerifica);
}
if (d.fileMarcatoSpecified)
{
if (d.dataVerificaFirmaSpecified)
{
logger.InfoFormat("data verifica firma {0}", d.dataVerificaFirma);
}
if (d.fileMarcato)
{
logger.Debug("Marcato");
TSInfo ts = new TSInfo();
if (d.marcaDetached != null)
{
logger.Debug("marcaDetached !=null");
//Gestire la marca
//logger.DebugFormat("TSANameIssuer [{0}]", d.marcaDetached.TSANameIssuer);
//logger.DebugFormat("TSANameSubject [{0}]", d.marcaDetached.TSANameSubject);
//logger.DebugFormat("TSimprint [{0}]", d.marcaDetached.TSimprint);
//logger.DebugFormat("TSserialNumber [{0}]", d.marcaDetached.TSserialNumber);
if (!String.IsNullOrEmpty(d.marcaDetached.TSANameIssuer))
{
ts.TSANameIssuer = d.marcaDetached.TSANameIssuer;
}
if (!String.IsNullOrEmpty(d.marcaDetached.TSANameSubject))
{
ts.TSANameSubject = d.marcaDetached.TSANameSubject;
}
if (!String.IsNullOrEmpty(d.marcaDetached.TSimprint))
{
ts.TSimprint = d.marcaDetached.TSimprint;
}
if (!String.IsNullOrEmpty(d.marcaDetached.TSserialNumber))
{
ts.TSserialNumber = d.marcaDetached.TSserialNumber;
}
if (d.marcaDetached.TSdateTimeSpecified)
{
ts.TSdateTime = d.marcaDetached.TSdateTime;
}
if (d.marcaDetached.dataFineValiditaCertSpecified)
{
ts.dataFineValiditaCert = d.marcaDetached.dataFineValiditaCert;
}
if (d.marcaDetached.dataInizioValiditaCertSpecified)
{
ts.dataInizioValiditaCert = d.marcaDetached.dataInizioValiditaCert;
}
}
else
{
//default nel caso la try sotto desse errore
ts.TSANameIssuer = "Marca non Detached, dati non disponibili";
//se questo dato ce l'ho lo valido
if (d.dataVerificaFirmaSpecified)
{
ts.TSdateTime = d.dataVerificaFirma;
}
}
}
else
{
}
}
if (d.datiFirmatari != null)
{
foreach (FirmaDigitale.FirmatarioType ft in d.datiFirmatari)
{
//firmatari
DocsPaVO.documento.SignerInfo si = ExtractSignerInfo(status, ft.firmatario, ft.marcaFirma);
//controfirmatari
if (ft.controfirmatario != null)
{
List <DocsPaVO.documento.SignerInfo> csiLst = new List <DocsPaVO.documento.SignerInfo>();
foreach (FirmaDigitale.FirmatarioTypeControfirmatario cft in ft.controfirmatario)
{
DocsPaVO.documento.SignerInfo csi = ExtractSignerInfo(status, cft.firma, cft.marca);
csi.isCountersigner = true;
csiLst.Add(csi);
}
if (csiLst.Count > 0)
{
si.counterSignatures = csiLst.ToArray();
}
}
siLst.Add(si);
}
}
List <DocsPaVO.documento.PKCS7Document> p7docsLst = new List <DocsPaVO.documento.PKCS7Document>();
DocsPaVO.documento.PKCS7Document p7doc = new DocsPaVO.documento.PKCS7Document
{
SignersInfo = siLst.ToArray(),
DocumentFileName = null,
Level = 0
};
p7docsLst.Add(p7doc);
vsr.PKCS7Documents = p7docsLst.ToArray();
vsr.CRLOnlineCheck = true;
return(vsr);
}
private static VerifySignatureResult ConvertToVerifySignatureResultUsingDatiGeneraliVerifica(EsitoVerificaStatus status, FirmaDigitale.DettaglioFirmaDigitaleType d)
{
DeSign.deSign design = null;
string verbosesgb = ConfigurationManager.AppSettings["VERBOSEDEBUG"];
bool verboseDebug = false;
Boolean.TryParse(verbosesgb, out verboseDebug);
try
{
if (!String.IsNullOrEmpty(d.datiGeneraliVerifica))
{
if (verboseDebug)
{
logger.InfoFormat("Risposta da infocert {0}", d.datiGeneraliVerifica);
}
design = DeSign.deSign.Deserialize(d.datiGeneraliVerifica);
}
}
catch (Exception e)
{
logger.ErrorFormat("Errore deserializzando i dati da infocert {0} {1}", e.Message, e.StackTrace);
return(null);
}
VerifySignatureResult vsr = new VerifySignatureResult();
List <DocsPaVO.documento.SignerInfo> siLst = new List <SignerInfo>();
List <DocsPaVO.documento.PKCS7Document> p7docsLst = new List <PKCS7Document>();
string digestAlgo = string.Empty;
bool badSignature = false;
foreach (object item in design.signedData)
{
//trattasi di signedData
DeSign.signedData sd = item as DeSign.signedData;
foreach (DeSign.signer signer in sd.signer)
{
DocsPaVO.documento.SignerInfo si = convertToSignerInfo(signer);
if (si.CertificateInfo.RevocationStatus != 0)
{
vsr.StatusCode = si.CertificateInfo.RevocationStatus;
vsr.StatusDescription = si.CertificateInfo.RevocationStatusDescription;
}
digestAlgo = convertOidToString(signer.digestAlgorithm);
if (signer.status == "KO")
{
if (!badSignature)
{
badSignature = true;
}
}
siLst.Add(si);
}
}
List <TSInfo> tsList = new List <TSInfo>();
foreach (object item in design.timeStamp)
{
//trattasi di signedData
DeSign.timeStamp ts = item as DeSign.timeStamp;
TSInfo tsi = new TSInfo
{
dataInizioValiditaCert = convertSimpleDateTime(ts.certNotBefore),
dataFineValiditaCert = convertSimpleDateTime(ts.certNotAfter),
TSdateTime = convertSimpleDateTime(ts.timeStampDate),
TSimprint = ts.timeStampImprint,
TSANameIssuer = ts.issuer.CN,
TSANameSubject = ts.subject.CN,
TSserialNumber = ts.timeStampSerial,
TSType = TsType.PKCS
};
tsList.Add(tsi);
}
if (tsList.Count > 0)
{
vsr.DocumentTimeStampInfo = tsList.ToArray();
}
p7docsLst.Add(new PKCS7Document
{
SignersInfo = siLst.ToArray(),
DocumentFileName = null,
Level = 0
});
vsr.PKCS7Documents = p7docsLst.ToArray();
vsr.CRLOnlineCheck = true;
if ((badSignature) && (vsr.StatusCode == 0))
{
vsr.StatusCode = -1;
}
return(vsr);
}
