/// <summary>
/// Verifica la marca ottenuta in risposta ed estrae tutti i dati dalla marca completando i dati dell'oggetto OutputResponseMarca con quelli letti direttamente dalla marca!
/// </summary>
/// <param name="filep7m"></param>
/// <param name="fileTSR"></param>
/// <returns></returns>
private static DocsPaVO.areaConservazione.OutputResponseMarca VerificaMarca(byte[] filep7m, byte[] fileTSR)
{
DocsPaVO.areaConservazione.OutputResponseMarca outputMarca = new DocsPaVO.areaConservazione.OutputResponseMarca();
DigitalSignature.VerifyTimeStamp checkMarca = new DigitalSignature.VerifyTimeStamp();
outputMarca = checkMarca.Verify(filep7m, fileTSR);
return(outputMarca);
}
/// <summary>
/// Associa un TSR a un documento ricevuto
/// </summary>
/// <param name="path">path dove sono presenti i file ricevuti in mail</param>
/// <param name="fr">filerequest</param>
/// <param name="fd">filedocumento</param>
/// <param name="infoUtente">infoutente</param>
/// <returns>False in caso di fallimento</returns>
public static bool MatchTSR(string path, DocsPaVO.documento.FileRequest fr, DocsPaVO.documento.FileDocumento fd, DocsPaVO.utente.InfoUtente infoUtente)
{
bool retval = false;
string[] tsrFiles = Directory.GetFiles(path, "*.tsr");
//se non ci sono TSR
if (tsrFiles.Length == 0)
{
return(false);
}
if (Path.GetExtension(fr.fileName).ToLowerInvariant() == ".tsr")
{
//logger.DebugFormat ("Il file è un TSR, non associo un TSR a un TSR");
return(false);
}
BusinessLogic.Documenti.DigitalSignature.VerifyTimeStamp vts = new Documenti.DigitalSignature.VerifyTimeStamp();
string fdFileName = path + "\\" + fr.fileName;
foreach (string file in tsrFiles)
{
// byte[] tsrFile = File.ReadAllBytes(file);
byte[] tsrFile;
if (fdFileName.ToLowerInvariant().Equals(file.ToLowerInvariant()))
{
tsrFile = fd.content;
}
else
{
System.IO.FileStream fsAll = new System.IO.FileStream(file, System.IO.FileMode.Open, FileAccess.Read, FileShare.Read);
tsrFile = new byte[fsAll.Length];
fsAll.Read(tsrFile, 0, (int)fsAll.Length);
fsAll.Close();
}
try
{
if (vts.machTSR(tsrFile, fd.content))
{
logger.DebugFormat("Provo TSR {0}", file);
DocsPaVO.areaConservazione.OutputResponseMarca resultMarca = vts.Verify(fd.content, tsrFile);
if (resultMarca.esito == "OK")
{
DocsPaDB.Query_DocsPAWS.TimestampDoc timestampDoc = new DocsPaDB.Query_DocsPAWS.TimestampDoc();
timestampDoc.saveTSR(infoUtente, resultMarca, fr);
logger.DebugFormat("Associato TSR al documento {0} {1}", fr.docNumber, fr.versionId);
retval = true;
}
}
}
catch (Exception e1)
{
logger.ErrorFormat("Errore Cercando di associare il TSR {0} : {1}", e1.Message, e1.StackTrace);
}
}
return(retval);
}
public static bool MatchTSR(byte[] tsrFile, byte[] content)
{
try
{
BusinessLogic.Documenti.DigitalSignature.VerifyTimeStamp vts = new Documenti.DigitalSignature.VerifyTimeStamp();
if (vts.machTSR(tsrFile, content))
{
DocsPaVO.areaConservazione.OutputResponseMarca resultMarca = vts.Verify(content, tsrFile);
if (resultMarca.esito == "OK")
{
return(true);
}
}
}
catch (Exception e)
{
logger.ErrorFormat("Errore verificando il TSR {0} {1}", e.Message, e.StackTrace);
}
return(false);
}
public void saveTSR(DocsPaVO.utente.InfoUtente infoUtente, DocsPaVO.areaConservazione.OutputResponseMarca resultMarca, DocsPaVO.documento.FileRequest fileRequest)
{
DocsPaDB.DBProvider dbProvider = new DBProvider();
try
{
if (resultMarca != null)
{
logger.Debug("Marca non nulla");
}
else
{
logger.Debug("Marca nulla");
}
if (fileRequest != null)
{
logger.Debug("FileRequest non nullo");
}
else
{
logger.Debug("FileRequest nullo");
}
DocsPaUtils.Query queryMng = DocsPaUtils.InitQuery.getInstance().getQuery("I_DPA_TIMESTAMP_DOC");
queryMng.setParam("colID", DocsPaDbManagement.Functions.Functions.GetSystemIdColName());
queryMng.setParam("id", DocsPaDbManagement.Functions.Functions.GetSystemIdNextVal("DPA_TIMESTAMP_DOC"));
if (!string.IsNullOrEmpty(fileRequest.docNumber))
{
queryMng.setParam("docNumber", fileRequest.docNumber);
}
else
{
queryMng.setParam("docNumber", "");
}
if (!string.IsNullOrEmpty(fileRequest.versionId))
{
queryMng.setParam("versionId", fileRequest.versionId);
}
else
{
queryMng.setParam("versionId", "");
}
if (!string.IsNullOrEmpty(infoUtente.idPeople))
{
queryMng.setParam("idPeople", infoUtente.idPeople);
}
else
{
queryMng.setParam("idPeople", "");
}
if (!string.IsNullOrEmpty(resultMarca.docm_date))
{
queryMng.setParam("dataCreazione", DocsPaDbManagement.Functions.Functions.ToDate(resultMarca.docm_date));
}
else
{
queryMng.setParam("dataCreazione", "");
}
if (!string.IsNullOrEmpty(resultMarca.dsm))
{
queryMng.setParam("dataScadenza", DocsPaDbManagement.Functions.Functions.ToDate(resultMarca.dsm));
}
else
{
queryMng.setParam("dataScadenza", "");
}
if (!string.IsNullOrEmpty(resultMarca.sernum))
{
queryMng.setParam("numSerie", resultMarca.sernum);
}
else
{
queryMng.setParam("numSerie", "");
}
if (!string.IsNullOrEmpty(resultMarca.snCertificato))
{
queryMng.setParam("snCertificato", resultMarca.snCertificato);
}
else
{
queryMng.setParam("snCertificato", "");
}
if (!string.IsNullOrEmpty(resultMarca.algHash))
{
queryMng.setParam("algHash", resultMarca.algHash.Replace("'", "''"));
}
else
{
queryMng.setParam("algHash", "SHA256");
}
if (!string.IsNullOrEmpty(resultMarca.TSA.O))
{
queryMng.setParam("soggetto", resultMarca.TSA.O.Replace("'", "''"));
}
else
{
queryMng.setParam("soggetto", "");
}
if (!string.IsNullOrEmpty(resultMarca.TSA.C))
{
queryMng.setParam("paese", resultMarca.TSA.C);
}
else
{
queryMng.setParam("paese", "");
}
string commandText = queryMng.getSQL();
System.Diagnostics.Debug.WriteLine("SQL - saveTSR - DocsPaDB/TimestampDoc.cs - QUERY : " + commandText);
logger.Debug("SQL - saveTSR - DocsPaDB/TimestampDoc.cs - QUERY : " + commandText);
dbProvider.BeginTransaction();
dbProvider.ExecuteNonQuery(commandText);
string sql = DocsPaDbManagement.Functions.Functions.GetQueryLastSystemIdInserted("DPA_TIMESTAMP_DOC");
string id = string.Empty;
System.Diagnostics.Debug.WriteLine("SQL - saveTSR - DocsPaDB/TimestampDoc.cs - QUERY : " + sql);
logger.Debug("SQL - saveTSR - DocsPaDB/TimestampDoc.cs - QUERY : " + sql);
dbProvider.ExecuteScalar(out id, sql);
if (!string.IsNullOrEmpty(id))
{
dbProvider.SetLargeText("DPA_TIMESTAMP_DOC", id, "TSR_FILE", resultMarca.marca);
}
dbProvider.CommitTransaction();
}
catch (Exception ex)
{
logger.Debug("SQL - setTimestamp - DocsPaDB/TimestampDoc.cs - Exception : " + ex.Message);
dbProvider.RollbackTransaction();
}
finally
{
dbProvider.Dispose();
}
}
public static DocsPaVO.areaConservazione.OutputResponseMarca executeAndSaveTSR(DocsPaVO.utente.InfoUtente infoUtente, DocsPaVO.areaConservazione.InputMarca richiesta, DocsPaVO.documento.FileRequest fileRequest)
{
// La marca temporale da restituire
DocsPaVO.areaConservazione.OutputResponseMarca resultMarca = null;
try
{
//Scelta del tipo di implementazione per la richiesta della marca temporale
string typeName = System.Configuration.ConfigurationManager.AppSettings["TYPE_TSA"];
logger.Debug("Istanza TYPE_TSA = " + typeName);
Type instanceType = Type.GetType(typeName, false);
if (instanceType != null)
{
logger.Debug("Istanza TYPE_TSA = " + typeName + " non nulla");
DocsPa_I_TSAuthority.I_TSR_Request instance = (DocsPa_I_TSAuthority.I_TSR_Request)Activator.CreateInstance(instanceType);
resultMarca = new DocsPaVO.areaConservazione.OutputResponseMarca();
//Ottengo una marca temporale in base alla specifica implementazione settata nel web.config
logger.Debug("Richiesta marca temporale");
resultMarca = instance.getTimeStamp(richiesta);
logger.Debug("Fine richiesta marca temporale");
//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
logger.Debug("Verifica marca temporale");
resultMarca = VerificaMarca(p7m, TSR);
logger.Debug("Fine verifica marca temporale");
//Salvo la marca generata sul database
using (DocsPaDB.TransactionContext transactionContext = new DocsPaDB.TransactionContext())
{
try
{
logger.Debug("Salvataggio TSR");
DocsPaDB.Query_DocsPAWS.TimestampDoc timestampDoc = new DocsPaDB.Query_DocsPAWS.TimestampDoc();
timestampDoc.saveTSR(infoUtente, resultMarca, fileRequest);
transactionContext.Complete();
FileManager.processFileInformation(fileRequest, infoUtente);
logger.Debug("Fine Salvataggio TSR");
}
catch (Exception e)
{
logger.DebugFormat("ERRORE : Salvataggio marca temporale sul database : {0} \r\nstk\r\n{1}" + e.Message, e.StackTrace);
}
}
}
else
{
logger.Debug("Istanza TYPE_TSA = " + typeName + " nulla");
}
}
catch (Exception eMarca)
{
logger.DebugFormat("ERRORE : Richiesta marca temporale :{0} \r\nstk{1}\r\n " + eMarca.Message, eMarca.StackTrace);
}
return(resultMarca);
}
/// <summary>
/// Metodo per il download di un file associato ad un documento
/// </summary>
/// <param name="documentInfo">Informazioni sul documento</param>
/// <param name="senderAdministrationId">Id dell'amministrazione</param>
/// <param name="fileRequest">Informazioni sul file richiesto</param>
/// <param name="userInfo">Informazioni sull'utente con cui recuperare il file</param>
/// <param name="senderFileManagerUrl">Url del servizio per la gestione dei file</param>
public static void DownloadFile(DocumentInfo documentInfo, String senderAdministrationId, FileRequest fileRequest, InfoUtente userInfo, String senderFileManagerUrl, out string errPutFile)
{
logger.Debug("BEGIN");
// Reperimento del file
InteroperabilityController interoperabilityController = new InteroperabilityController();
Interoperability.Service.Library.FileServiceReference.RemoteFileInfo fileResponse = interoperabilityController.DownloadFile(
new Interoperability.Service.Library.FileServiceReference.SendFileRequest(
senderAdministrationId,
documentInfo.DocumentNumber,
documentInfo.DocumentServerLocation,
documentInfo.FileName,
documentInfo.FilePath,
documentInfo.Version,
documentInfo.VersionId,
documentInfo.VersionLabel),
senderFileManagerUrl);
// Caricamento del file in DocsPa
byte[] documentContent = ReadFileContent(fileResponse.FileData, (int)fileResponse.FileTransferInfo.FileLength);
FileDocumento fileDocument = new FileDocumento()
{
content = documentContent,
length = (int)fileResponse.FileTransferInfo.FileLength,
name = fileResponse.FileTransferInfo.FileName
};
String err = String.Empty;
//Gestione TSDis (DOC+TSR)
//Siccome non si possono mandare piu file allo stesso tempo, ne è possibile alterare la struttura
//si è pensato in fase di invio, in caso di documenti con TSR associato, l'invio dello stesso un formato
//TSD, come marca verrà presa l'ultima disponibile, e unita al documento, creadno un file con estensione TSDis
//In fase di ricezione il TsdIs, sarà poi spacchettato, il TSR messo in DPA_TIMESTAMP dopo verifica hash e
//infine il payload messo in documentale con la putfile.
DocsPaVO.areaConservazione.OutputResponseMarca resultMarca = null;
if (Path.GetExtension(fileDocument.name) == ".TSDis")
{
try
{
Documenti.DigitalSignature.PKCS_Utils.tsd tsdMgr = new Documenti.DigitalSignature.PKCS_Utils.tsd();
tsdMgr.explode(fileDocument.content);
fileDocument.content = tsdMgr.Data.Content;
fileDocument.length = (int)fileDocument.content.Length;
fileDocument.name = fileDocument.name.Replace(".TSDis", string.Empty);
Documenti.DigitalSignature.VerifyTimeStamp vts = new Documenti.DigitalSignature.VerifyTimeStamp();
byte[] tsrFile = tsdMgr.TSR.FirstOrDefault().Content;
if (vts.machTSR(tsrFile, fileDocument.content))
{
resultMarca = vts.Verify(fileDocument.content, tsrFile);
}
}
catch (Exception e)
{
logger.ErrorFormat("Errore gestendo il TSDis {0} {1}", e.Message, e.StackTrace);
//manca il loggher pdpdpdpdp
}
}
FileManager.putFile(ref fileRequest, fileDocument, userInfo, out errPutFile, false);
if (resultMarca != null && resultMarca.esito == "OK")
{
DocsPaDB.Query_DocsPAWS.TimestampDoc timestampDoc = new DocsPaDB.Query_DocsPAWS.TimestampDoc();
timestampDoc.saveTSR(userInfo, resultMarca, fileRequest);
}
logger.Debug("END");
}
