/// <summary>
/// Generazione timestamp con il vecchio metodo di IT
/// </summary>
/// <param name="TimeStampQuery">Struttura contente le informazioni per la generazione della marca</param>
/// <returns>Struttura contente le informazioni della marca generata</returns>
public OutputResponseMarca getTimeStamp(InputMarca TimeStampQuery)
{
logger.Debug("Chiamato DocsPa_TSAuthority_InfoTN");
OutputResponseMarca resultMarca = new OutputResponseMarca();
marcatura.InputMarca inputMarca = new DocsPa_TSAuthority_InfoTN.marcatura.InputMarca();
marcatura.OutputResponseMarca outMarca = new DocsPa_TSAuthority_InfoTN.marcatura.OutputResponseMarca();
marcatura.marcatura Marca = new DocsPa_TSAuthority_InfoTN.marcatura.marcatura();
string urlTSA = string.Empty;
if (!string.IsNullOrEmpty(ConfigurationManager.AppSettings["URL_TSA"]))
{
urlTSA = ConfigurationManager.AppSettings["URL_TSA"].ToString();
Marca.Url = urlTSA;
}
inputMarca.applicazione = TimeStampQuery.applicazione;
inputMarca.file_p7m = TimeStampQuery.file_p7m;
inputMarca.riferimento = TimeStampQuery.riferimento;
outMarca = Marca.getTSR(inputMarca);
//mapping del risultato sull'oggetto di DocsPa
resultMarca.descrizioneErrore = outMarca.descrizioneErrore;
resultMarca.docm = outMarca.docm;
resultMarca.dsm = outMarca.dsm;
resultMarca.esito = outMarca.esito;
resultMarca.fhash = outMarca.fhash;
resultMarca.marca = outMarca.marca;
resultMarca.sernum = outMarca.sernum;
resultMarca.TSA = new TSARFC2253();
resultMarca.TSA.TSARFC2253Name = outMarca.TSA;
return(resultMarca);
}
public OutputResponseMarca VerificaMarca(byte[] filep7m, byte[] fileTSR)
{
OutputResponseMarca outputMarca = new OutputResponseMarca();
BusinessLogic.Documenti.DigitalSignature.VerifyTimeStamp checkMarca = new BusinessLogic.Documenti.DigitalSignature.VerifyTimeStamp();
outputMarca = checkMarca.Verify(filep7m, fileTSR);
return(outputMarca);
}
/// <summary>
/// Funzione di generazione della marca temporale.
/// </summary>
/// <param name="inMarca">Struttura contente le informazioni per la generazione della marca</param>
/// <param name="svcUrl">Url del webservice tibco della marca temporale</param>
/// <returns></returns>
public OutputResponseMarca getMarcaByFile(InputMarca inMarca, string svcUrl)
{
logger.DebugFormat("INIZIO {0} - {1}", inMarca.file_p7m, svcUrl);
byte[] fileContent = String_To_Bytes(inMarca.file_p7m); //System.IO.File.ReadAllBytes(inMarca.file_p7m);
OutputResponseMarca retval = new OutputResponseMarca();
retval.TSA = new TSARFC2253();
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls | System.Net.SecurityProtocolType.Ssl3;
MarcaturaTemporale.MarcaturaTemporalePortTypeClient client = createClient(svcUrl);
try
{
MarcaturaTemporale.MarcaType mt = client.EmissioneMarcaTemporale(fileContent);
retval.marca = Convert.ToBase64String(mt.marca);
retval.sernum = mt.serialNumber.ToString();
retval.TSA.TSARFC2253Name = mt.timestampAuthority;
retval.docm_date = mt.dataOraMarca.ToString();
retval.esito = "OK";
logger.DebugFormat("Generazione Marca per file MarcaBase64 len:{2} Val [{0}] DATATA {1}", retval.marca, retval.docm_date.ToString(), mt.marca.Length);
//Per la generazione del fhash.. ma non è richiesto per il funzionamento
SHA256Managed sha256 = new SHA256Managed();
byte[] hash = sha256.ComputeHash(fileContent);
string hexHash = BitConverter.ToString(hash);
hexHash = hexHash.Replace("-", "");
retval.fhash = hexHash;
}
catch (FaultException <MarcaturaTemporale.FaultType> f)
{
logger.Error(String.Format("Errore {0} code {1}", f.Detail.userMessage, f.Code));
//Console.WriteLine(String.Format("Errore {0} code {1}", f.Detail.userMessage, f.Code));
retval.descrizioneErrore = f.Detail.userMessage;
retval.esito = "KO";
}
catch (Exception e)
{
logger.Error(String.Format("Errore {0} code {1}", e.Message, e.Data));
// Console.WriteLine(String.Format("Errore {0} code {1}", pe.Message, pe.Data));
retval.descrizioneErrore = e.Message;
retval.esito = "KO";
}
return(retval);
}
public OutputResponseMarca getTSR(InputMarca richiesta, InfoUtente utente)
{
OutputResponseMarca resultMarca = new OutputResponseMarca();
//Se l'oggetto infoUtente non è valorizzato non eseguo alcuna operazione e restituisco solo
//il messaggio di errore dell'oggetto OutputResponseMarca
if (utente == null)
{
logger.Debug("InfoUtente nullo o non valido.");
resultMarca.esito = "KO";
resultMarca.descrizioneErrore = "Utente nullo o non autorizzato!";
return(resultMarca);
}
try
{
//Scelta del tipo di implementazione per la richiesta della marca temporale
string typeName = System.Configuration.ConfigurationManager.AppSettings["TYPE_TSA"];
Type instanceType = Type.GetType(typeName, false);
if (instanceType == null)
{
throw new ApplicationException(string.Format("Tipo non valido per la configurazione '{0}'", "TYPE_TSA"));
}
DocsPa_I_TSAuthority.I_TSR_Request instance = (DocsPa_I_TSAuthority.I_TSR_Request)Activator.CreateInstance(instanceType);
//ottengo una marca temporale in base alla specifica implementazione settata nel web.config
resultMarca = instance.getTimeStamp(richiesta);
//genero l'array di byte per il file p7m e TSR
byte[] p7m = String_To_Bytes(richiesta.file_p7m);
byte[] TSR = Convert.FromBase64String(resultMarca.marca);
//verifico la marca e completo l'oggetto OutputResponseMarca
resultMarca = VerificaMarca(p7m, TSR);
}
catch (Exception eMarca)
{
resultMarca.esito = "KO";
resultMarca.descrizioneErrore = "richiesta della marca fallita: " + eMarca.Message;
logger.Debug("richiesta della marca fallita: " + eMarca.Message);
}
return(resultMarca);
}
/// <summary>
/// Funzione di verifica della marca temporale
/// </summary>
/// <param name="base64Marca">Marca temporale il formato stringa Base64</param>
/// <param name="base64File">File marcato temporalmente in formato stringa Base64</param>
/// <param name="svcUrl">Url del webservice tibco della marca temporale</param>
/// <returns></returns>
public OutputResponseMarca verificaTimeStamp(string base64Marca, string base64File, string svcUrl)
{
logger.DebugFormat("INIZIO {0}", svcUrl);
OutputResponseMarca retval = new OutputResponseMarca();
retval.TSA = new TSARFC2253();
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls | System.Net.SecurityProtocolType.Ssl3;
MarcaturaTemporale.MarcaturaTemporalePortTypeClient client = createClient(svcUrl);
try
{
byte[] marca = Convert.FromBase64String(base64Marca);
byte[] file = Convert.FromBase64String(base64File);
Console.WriteLine("marca " + marca.Length + " file " + file.Length);
MarcaturaTemporale.MarcaType mt = client.VerificaMarcatura(marca, file);
retval.marca = Convert.ToBase64String(mt.marca);
retval.sernum = mt.serialNumber.ToString();
retval.TSA.TSARFC2253Name = mt.timestampAuthority;
retval.docm_date = mt.dataOraMarca.ToString();
retval.esito = "OK";
logger.DebugFormat("Verifica Marca OK DATATA {1}", retval.docm_date.ToString());
}
catch (FaultException <MarcaturaTemporale.FaultType> f)
{
logger.Error(String.Format("Errore {0} code {1}", f.Detail.userMessage, f.Code));
Console.WriteLine(String.Format("Errore {0} code {1}", f.Detail.userMessage, f.Code));
retval.descrizioneErrore = f.Detail.userMessage;
retval.esito = "KO";
}
catch (Exception e)
{
logger.Error(String.Format("Errore {0} code {1}", e.Message, e.Data));
Console.WriteLine(String.Format("Errore {0} code {1}", e.Message, e.Data));
retval.descrizioneErrore = e.Message;
retval.esito = "KO";
}
return(retval);
}
/// <summary>
/// metodo che costruisce un html contenente le informazioni in chiaro della marca temporale,
/// tale html viene restituito sotto forma di array di byte.
/// </summary>
/// <param name="timestamp">timestamp formattato come data</param>
/// <param name="hexHash">hash del file al quale è associata la marca, sotto forma di stringa esadecimale</param>
/// <returns></returns>
protected byte[] contentMarca(OutputResponseMarca resultMarca)
{
string marcaHtml = string.Empty;
marcaHtml = "<HTML>" +
"<font face='Verdana' size=2>" +
"<HEAD>" +
"<TITLE> Marca temporale </TITLE>" +
"</HEAD>" +
"<body>" +
"<p align='center'><b>Marca Temporale</b><br /></p>" +
"<table frame='border' style='border-style: double; border-width: inherit; width:90%; font-family: Verdana; font-size: 11pt;'>" +
"<tr>" +
"<td width='40%'>" +
"Verifica:</td>" +
"<td>" +
resultMarca.esito + " </td>" +
"</tr>" +
"<tr>" +
"<td>" +
"Num. serie:</td>" +
"<td>" +
resultMarca.sernum + " </td>" +
"</tr>" +
"<tr>" +
"<td>" +
"Data ed ora (Locale):</td>" +
"<td>" +
resultMarca.docm_date + " </td>" +
"</tr>" +
"<tr>" +
"<td>" +
"Algoritmo certificato:</td>" +
"<td>" +
resultMarca.algCertificato + " </td>" +
"</tr>" +
"<tr>" +
"<td>" +
"S.N. certificato:</td>" +
"<td>" +
resultMarca.snCertificato + " </td>" +
"</tr>" +
"<tr>" +
"<td>" +
"Valido dal:</td>" +
"<td>" +
resultMarca.fromDate + " </td>" +
"</tr>" +
"<tr>" +
"<td>" +
"Valido sino al:</td>" +
"<td>" +
resultMarca.dsm + " </td>" +
"</tr>" +
"<tr>" +
"<td>" +
"Algoritmo di hash:</td>" +
"<td>" +
resultMarca.algHash + " </td>" +
"</tr>" +
"<tr>" +
"<td>" +
"Impronta del documento associato:</td>" +
"<td>" +
resultMarca.fhash + " </td>" +
"</tr>" +
"<tr>" +
"<td>" +
"Id del documento associato:</td>" +
"<td>" +
resultMarca.timestampedDoc + " </td>" +
"</tr>" +
"<tr>" +
"<td>" +
"Soggetto:</td>" +
"<td>" +
resultMarca.TSA.O + " </td>" +
"</tr>" +
"<tr>" +
"<td>" +
"Paese:</td>" +
"<td>" +
resultMarca.TSA.C + " </td>" +
"</tr>" +
"</table>" +
"</body>" +
"</font>" +
"</html>";
return(System.Text.ASCIIEncoding.ASCII.GetBytes(marcaHtml));
}
/// <summary>
/// Questo metodo verifica se l'associazione fra marca e file è valida, verifica inoltre la
/// validità del certificato firmatario della marca e la data di scadenza della marca; infine
/// restituisce (se le verifiche vanno a buon fine) tutti i dati contenuti nella marca.
/// </summary>
/// <param name="tsRes"></param>
/// <param name="tsReq"></param>
/// <returns></returns>
protected OutputResponseMarca checkMarca(TimeStampResponse tsRes, TimeStampRequest tsReq)
{
OutputResponseMarca outTSR = new OutputResponseMarca();
try
{
tsRes.Validate(tsReq);
outTSR.esito = "OK";
outTSR.descrizioneErrore = string.Empty;
}
catch (TspException e)
{
outTSR.esito = "KO";
outTSR.descrizioneErrore = "verifica della marca fallita: " + e.Message;
logger.Debug("verifica della marca fallita: " + e.Message);
//return outTSR;
}
TimeStampToken tsToken = tsRes.TimeStampToken;
//Verifica data scadenza marca secondo l'ora locale
Org.BouncyCastle.X509.Store.IX509Store store = tsToken.GetCertificates("Collection");
Org.BouncyCastle.X509.X509Certificate cert = (Org.BouncyCastle.X509.X509Certificate) new ArrayList(store.GetMatches(tsToken.SignerID))[0];
//se la data attuale è maggiore di quella di scadenza del certificato che ha firmato la marca
//allora la marca è scaduta!!!
if (DateTime.Now.CompareTo(cert.NotAfter.ToLocalTime()) > 0)
{
//outTSR.esito = "KO";
outTSR.descrizioneErrore = "marca temporale scaduta";
logger.Debug("marca temporale scaduta");
//return outTSR;
}
try
{
//estrazione delle informazioni dalla marca
outTSR.dsm = cert.NotAfter.ToLocalTime().ToString();
outTSR.sernum = tsToken.TimeStampInfo.SerialNumber.ToString();
outTSR.fhash = byteArrayToHexa(tsToken.TimeStampInfo.TstInfo.MessageImprint.GetHashedMessage());
outTSR.docm = tsToken.TimeStampInfo.TstInfo.GenTime.TimeString;
outTSR.docm_date = tsToken.TimeStampInfo.GenTime.ToLocalTime().ToString();
outTSR.marca = Convert.ToBase64String(tsRes.GetEncoded());
outTSR.algCertificato = cert.SigAlgName;
outTSR.fromDate = cert.NotBefore.ToLocalTime().ToString();
outTSR.snCertificato = cert.SerialNumber.ToString();
//Algoritmo hash utilizzato per l'impronta
string algHashOid = tsToken.TimeStampInfo.MessageImprintAlgOid;
if (!string.IsNullOrEmpty(algHashOid))
{
System.Security.Cryptography.Oid oidHash = new System.Security.Cryptography.Oid(algHashOid);
outTSR.algHash = oidHash.FriendlyName;
}
outTSR.TSA = new TSARFC2253();
//Con le TSA di test potrebbe non essere valorizzato l'oggetto TSA
logger.Debug("Controllo TSA : " + tsToken.TimeStampInfo.Tsa);
try
{
if (tsToken.TimeStampInfo.Tsa != null)
{
string oid = string.Empty;
string oidValue = string.Empty;
logger.Debug("TagNo: " + tsToken.TimeStampInfo.Tsa.TagNo);
for (int n = 0; n < tsToken.TimeStampInfo.Tsa.TagNo; n++)
{
logger.Debug("Tag: " + n);
Org.BouncyCastle.Asn1.Asn1Sequence seq = (Org.BouncyCastle.Asn1.Asn1Sequence)tsToken.TimeStampInfo.Tsa.Name.ToAsn1Object();
//Obsoleto
//Org.BouncyCastle.Asn1.Asn1Object obj = (Org.BouncyCastle.Asn1.Asn1Object)seq.GetObjectAt(n);
Org.BouncyCastle.Asn1.Asn1Object obj = (Org.BouncyCastle.Asn1.Asn1Object)seq[n];
Org.BouncyCastle.Asn1.Asn1Set set1 = (Org.BouncyCastle.Asn1.Asn1Set)obj.ToAsn1Object();
//Obsoleto
//seq = (Org.BouncyCastle.Asn1.Asn1Sequence)set1.GetObjectAt(0);
//obj = (Org.BouncyCastle.Asn1.Asn1Object)seq.GetObjectAt(0);
seq = (Org.BouncyCastle.Asn1.Asn1Sequence)set1[0];
obj = (Org.BouncyCastle.Asn1.Asn1Object)seq[0];
oid = obj.ToString();
//Obsoleto
//obj = (Org.BouncyCastle.Asn1.Asn1Object)seq.GetObjectAt(1);
obj = (Org.BouncyCastle.Asn1.Asn1Object)seq[1];
oidValue = obj.ToString();
System.Security.Cryptography.Oid oid_obj = new System.Security.Cryptography.Oid(oid);
string friendly = oid_obj.FriendlyName;
logger.Debug("oid: " + oid + " friendly: " + friendly);
switch (friendly)
{
case "CN":
outTSR.TSA.CN = oidValue;
break;
case "OU":
outTSR.TSA.OU = oidValue;
break;
case "O":
outTSR.TSA.O = oidValue;
break;
case "C":
outTSR.TSA.C = oidValue;
break;
}
}
outTSR.TSA.TSARFC2253Name = "CN=" + outTSR.TSA.CN + ",OU=" + outTSR.TSA.OU + ",O=" + outTSR.TSA.O + ",C=" + outTSR.TSA.C;
}
}
catch (Exception e)
{
logger.Debug("Eccezione controllo TSA : " + e.Message);
}
logger.Debug("Fine Controllo TSA");
}
catch (Exception eTsp)
{
outTSR.esito = "KO";
outTSR.descrizioneErrore = "estrazione delle informazioni dalla marca fallita: " + eTsp.Message;
logger.Debug("estrazione delle informazioni dalla marca fallita: " + eTsp.Message);
//return outTSR;
}
//verifico l'esistenza del documento al quale è associata la marca temporale
//Commentata perchè l'impronta del documento è ancora calcolata con SHA1 invece che SHA256
//DocsPaDB.Query_DocsPAWS.Documenti documento = new DocsPaDB.Query_DocsPAWS.Documenti();
//outTSR.timestampedDoc = documento.GetDocNumberByImpronta(outTSR.fhash);
//if (string.IsNullOrEmpty(outTSR.timestampedDoc))
//{
// outTSR.timestampedDoc = "Non esiste alcun documento associato alla marca temporale.";
//}
//costruisco l'oggetto rappresentante il contenuto in chiaro della marca
outTSR.DecryptedTSR = new Marca();
outTSR.DecryptedTSR.content = contentMarca(outTSR);
outTSR.DecryptedTSR.contentType = "text/html"; //"application/x-html";
outTSR.DecryptedTSR.length = outTSR.DecryptedTSR.content.Length;
return(outTSR);
}
/// <summary>
///
/// </summary>
/// <param name="TimeStampQuery"></param>
/// <returns></returns>
public OutputResponseMarca getTimeStamp(InputMarca TimeStampQuery)
{
OutputResponseMarca outputMarca = new OutputResponseMarca();
byte[] dati = String_To_Bytes(TimeStampQuery.file_p7m);
//SHA1 sha1 = SHA1CryptoServiceProvider.Create();
//byte[] hash = sha1.ComputeHash(dati);
SHA256Managed sha256 = new SHA256Managed();
byte[] hash = sha256.ComputeHash(dati);
TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator();
reqGen.SetCertReq(true);
//Funzione randomica per il Nonce.
//RandomNumberGenerator nRand = new RNGCryptoServiceProvider();
long casuale = (long)nRandom.Next();
//TimeStampRequest tsReq = reqGen.Generate(TspAlgorithms.Sha1, hash, BigInteger.ValueOf(casuale));
TimeStampRequest tsReq = reqGen.Generate(TspAlgorithms.Sha256, hash, BigInteger.ValueOf(casuale));
byte[] tsData = tsReq.GetEncoded();
string urlTSA = string.Empty;
if (!string.IsNullOrEmpty(ConfigurationManager.AppSettings["URL_TSA"]))
{
urlTSA = ConfigurationManager.AppSettings["URL_TSA"].ToString();
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(urlTSA);
req.Method = "POST";
req.ContentType = "application/timestamp-query";
//Username e password per accedere alla Time Stamping Authority
string pwd = string.Empty;
if (!string.IsNullOrEmpty(ConfigurationManager.AppSettings["PASSWORD_UTENTE_TSA"]))
{
pwd = ConfigurationManager.AppSettings["PASSWORD_UTENTE_TSA"].ToString();
req.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(Encoding.ASCII.GetBytes(pwd)));
}
req.ContentLength = tsData.Length;
Stream reqStream = req.GetRequestStream();
reqStream.Write(tsData, 0, tsData.Length);
reqStream.Close();
HttpWebResponse res = (HttpWebResponse)req.GetResponse();
if (res == null)
{
outputMarca.esito = "KO";
outputMarca.descrizioneErrore = "Impossibile contattare la TSA o autorizzazione negata";
return(outputMarca);
}
else
{
Stream resStream = new BufferedStream(res.GetResponseStream());
TimeStampResponse tsRes = new TimeStampResponse(resStream);
resStream.Close();
BusinessLogic.Documenti.DigitalSignature.VerifyTimeStamp checkMarca = new BusinessLogic.Documenti.DigitalSignature.VerifyTimeStamp();
outputMarca = checkMarca.Verify(tsReq, tsRes);
}
}
else
{
outputMarca.esito = "KO";
outputMarca.descrizioneErrore = "Impossibile contattare la TSA o url configurata errata!";
return(outputMarca);
}
return(outputMarca);
}
protected void BtnTimestampAssignsTSR_Click(object sender, EventArgs e)
{
try
{
ScriptManager.RegisterStartupScript(this.Page, this.GetType(), "function", "<script>reallowOp();</script>", false);
DocsPaWR.SchedaDocumento sch = NttDataWA.UIManager.DocumentManager.getSelectedRecord();
FileDocumento fileDocumento = FileManager.getInstance(sch.systemId).GetFile(this, FileReq, false, true);
DocsPaWR.InfoUtente infoUtente = UserManager.GetInfoUser();
string stringFile = BitConverter.ToString(fileDocumento.content);
stringFile = stringFile.Replace("-", "");
DocsPaWR.InputMarca inputMarca = new DocsPaWR.InputMarca();
inputMarca.applicazione = infoUtente.urlWA;
inputMarca.file_p7m = stringFile;
inputMarca.riferimento = infoUtente.userId;
OutputResponseMarca outputResponseMarca = DocumentManager.executeAndSaveTSR(infoUtente, inputMarca, FileReq);
string message = "OK";
if (outputResponseMarca == null)
{
message = "TimestampErrorServiceNotAvailable";
}
if (outputResponseMarca != null && string.IsNullOrEmpty(outputResponseMarca.esito))
{
message = "TimestampErrorServiceNotAvailable";
}
if (outputResponseMarca != null && outputResponseMarca.esito == "KO")
{
message = outputResponseMarca.descrizioneErrore;
}
if (message == "OK")
{
TimestampsDoc = DocumentManager.getTimestampsDoc(infoUtente, FileReq);
if (TimestampsDoc.Count == 1)
{
this.containerDetailsTimestamp.Visible = true;
this.BtnTimestampCreatesTSD.Enabled = true;
this.UpPnlButtons.Update();
UpdateImageTimestamp = true;
}
GrdTimestamp_Bind();
this.UpdatePanelGrdTimestamp.Update();
}
else
{
if (outputResponseMarca != null && outputResponseMarca.esito == "KO")
{
ScriptManager.RegisterStartupScript(this, this.GetType(), "ajaxDialogModal", "parent.ajaxDialogModal('TimestampErrorAssignsTSR', 'error', '','" + message + "');", true);
}
else
{
ScriptManager.RegisterStartupScript(this, this.GetType(), "ajaxDialogModal", "parent.ajaxDialogModal('" + message + "', 'error', '','');", true);
}
return;
}
}
catch (System.Exception ex)
{
UIManager.AdministrationManager.DiagnosticError(ex);
return;
}
}
