public void CreateTimeStampASN1()
{
try
{
DocumentHash documentHash = new DocumentHash();
documentHash.DigestMethod = new DigestMethodType();
documentHash.DigestMethod.Algorithm = "http://www.w3.org/2001/04/xmlenc#sha256";
documentHash.DigestValue = CrearHashTexto("TEXTODEPRUEBA");
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Creando sello de tiempo"));
var timeStamp = _tsaService.CreateTimeStamp(RequestSignatureType.ASN1, documentHash);
string resultado = TestContext.TestRunResultsDirectory + "\\Sello_Base64.txt";
File.WriteAllText(resultado, Convert.ToBase64String(timeStamp.Item as byte[]));
TestContext.AddResultFile(resultado);
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Sello aplicado"));
}
catch (AfirmaResultException afirmaEx)
{
Assert.Fail(string.Format("Error devuelto por @firma: {0}", afirmaEx.Message));
}
catch (Exception ex)
{
Assert.Fail(string.Format("Unexpected exception of type {0} caught: {1}", ex.GetType(), ex.Message));
}
}
public void ValidarSelloXML()
{
// NOTA: el servidor de desarrollo devuelve java.lang.NullPointerException, en producción funciona correctamente
try
{
XmlSerializer serializer = new XmlSerializer(typeof(SignatureType));
SignatureType sello = (SignatureType)serializer.Deserialize(ObtenerStreamRecurso("IntegraAfirmaNet.Test.SellosTiempo.Sello.xml"));
DocumentHash documentHash = new DocumentHash();
documentHash.DigestMethod = new DigestMethodType();
documentHash.DigestMethod.Algorithm = "http://www.w3.org/2001/04/xmlenc#sha256";
documentHash.DigestValue = CrearHashTexto("TEXTODEPRUEBA");
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Validando sello de tiempo"));
Timestamp timeStamp = new Timestamp();
timeStamp.Item = sello;
VerifyResponse resultado = _tsaService.VerifyTimestamp(documentHash, timeStamp);
Assert.AreEqual(ResultType.Success.Uri, resultado.Result.ResultMajor);
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Sello válido"));
}
catch (AfirmaResultException afirmaEx)
{
Assert.Fail(string.Format("Error devuelto por @firma: {0}", afirmaEx.Message));
}
catch (Exception ex)
{
Assert.Fail(string.Format("Unexpected exception of type {0} caught: {1}", ex.GetType(), ex.Message));
}
}
public void ValidarFirmaCadesDetached()
{
try
{
byte[] firma = ObtenerRecurso("IntegraAfirmaNet.Test.Firmas.cades_detached_explicit.csig");
DocumentHash docHash = new DocumentHash();
docHash.DigestMethod = new DigestMethodType();
docHash.DigestMethod.Algorithm = "http://www.w3.org/2001/04/xmlenc#sha256";
docHash.DigestValue = Convert.FromBase64String("11I1LxBkDvUpLwZqf2PHDmlQRM2vpf3t2Bg0kKODA8c=");
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Verificando firma"));
VerifyResponse resultado = _afirmaService.VerifySignature(firma, SignatureFormat.CAdES, true, new DocumentBaseType[] { docHash });
Assert.AreEqual(ResultType.ValidSignature.Uri, resultado.Result.ResultMajor);
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Firma válida"));
}
catch (AfirmaResultException afirmaEx)
{
Assert.Fail(string.Format("Error devuelto por @firma: {0}", afirmaEx.Message));
}
catch (Exception ex)
{
Assert.Fail(string.Format("Unexpected exception of type {0} caught: {1}", ex.GetType(), ex.Message));
}
}
public void ValidarSelloASN1()
{
try
{
string sellob64 = Encoding.UTF8.GetString(ObtenerRecurso("IntegraAfirmaNet.Test.SellosTiempo.Sello_Base64.txt"));
DocumentHash documentHash = new DocumentHash();
documentHash.DigestMethod = new DigestMethodType();
documentHash.DigestMethod.Algorithm = "http://www.w3.org/2001/04/xmlenc#sha256";
documentHash.DigestValue = CrearHashTexto("TEXTODEPRUEBA");
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Validando sello de tiempo"));
Timestamp timeStamp = new Timestamp();
timeStamp.Item = Convert.FromBase64String(sellob64);
VerifyResponse resultado = _tsaService.VerifyTimestamp(documentHash, timeStamp);
Assert.AreEqual(ResultType.Success.Uri, resultado.Result.ResultMajor);
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Sello válido"));
}
catch (AfirmaResultException afirmaEx)
{
Assert.Fail(string.Format("Error devuelto por @firma: {0}", afirmaEx.Message));
}
catch (Exception ex)
{
Assert.Fail(string.Format("Unexpected exception of type {0} caught: {1}", ex.GetType(), ex.Message));
}
}
public async Task GetPublishReportsById()
{
// arrange
IMongoCollection <Schema> schemas =
_mongoResource.CreateCollection <Schema>();
IMongoCollection <SchemaVersion> versions =
_mongoResource.CreateCollection <SchemaVersion>();
IMongoCollection <SchemaPublishReport> publishReports =
_mongoResource.CreateCollection <SchemaPublishReport>();
var initial = new Schema("foo", "bar");
await schemas.InsertOneAsync(initial, options : null, default);
var initialVersion = new SchemaVersion(
initial.Id, "foo",
DocumentHash.FromSourceText("abc"),
Array.Empty <Tag>(),
DateTime.UtcNow);
await versions.InsertOneAsync(initialVersion, options : null, default);
var initialReport = new SchemaPublishReport(
initialVersion.Id, Guid.NewGuid(), Array.Empty <Issue>(),
PublishState.Published, DateTime.UtcNow);
await publishReports.InsertOneAsync(initialReport, options : null, default);
var repository = new SchemaRepository(schemas, versions, publishReports);
// act
IReadOnlyDictionary <Guid, SchemaPublishReport> retrieved =
await repository.GetPublishReportsAsync(new[] { initialReport.Id });
// assert
Assert.True(retrieved.ContainsKey(initialReport.Id));
}
public void AmpliarACadesADetached()
{
try
{
byte[] firma = ObtenerRecurso("IntegraAfirmaNet.Test.Firmas.cades_detached_explicit.csig");
DocumentHash docHash = new DocumentHash();
docHash.DigestMethod = new DigestMethodType();
docHash.DigestMethod.Algorithm = "http://www.w3.org/2001/04/xmlenc#sha256";
docHash.DigestValue = Convert.FromBase64String("11I1LxBkDvUpLwZqf2PHDmlQRM2vpf3t2Bg0kKODA8c=");
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Ampliando firma"));
byte[] firmaAmpliada = _afirmaService.UpgradeSignature(firma, SignatureFormat.CAdES, ReturnUpdatedSignatureType.AdES_A, null, new DocumentBaseType[] { docHash });
string resultado = TestContext.TestRunResultsDirectory + "\\FirmaCades-Detached-A.csig";
File.WriteAllBytes(resultado, firmaAmpliada);
TestContext.AddResultFile(resultado);
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Firma ampliada"));
}
catch (AfirmaResultException afirmaEx)
{
Assert.Fail(string.Format("Error devuelto por @firma: {0}", afirmaEx.Message));
}
catch (Exception ex)
{
Assert.Fail(string.Format("Unexpected exception of type {0} caught: {1}", ex.GetType(), ex.Message));
}
}
public RelayQuery(
string name,
DocumentHash hash,
string sourceText)
{
Name = name;
Hash = hash;
SourceText = sourceText;
}
private async Task HandleInternalAsync(
PublishDocumentMessage message,
CancellationToken cancellationToken)
{
var issueLogger = new IssueLogger(message.SessionId, _eventSender);
try
{
IFileContainer fileContainer =
await _fileStorage.GetContainerAsync(message.SessionId).ConfigureAwait(false);
IEnumerable <IFile> files =
await fileContainer.GetFilesAsync(cancellationToken).ConfigureAwait(false);
IFile schemaFile = files.Single();
DocumentNode?schemaDocument = await TryParseSchemaAsync(
schemaFile, issueLogger, cancellationToken)
.ConfigureAwait(false);
string formattedSourceText = schemaDocument is { }
? PrintSchema(schemaDocument)
: await ReadSchemaSourceTextAsync(
schemaFile, cancellationToken)
.ConfigureAwait(false);
DocumentHash documentHash = DocumentHash.FromSourceText(formattedSourceText);
SchemaVersion?schemaVersion =
await _schemaRepository.GetSchemaVersionByHashAsync(
documentHash.Hash, cancellationToken)
.ConfigureAwait(false);
if (schemaVersion is null)
{
await PublishNewSchemaVersionAsync(
message,
schemaDocument,
formattedSourceText,
issueLogger,
cancellationToken)
.ConfigureAwait(false);
}
else
{
await PublishExistingSchemaVersionAsync(
message,
schemaDocument,
schemaVersion,
issueLogger,
cancellationToken)
.ConfigureAwait(false);
}
await fileContainer.DeleteAsync(cancellationToken).ConfigureAwait(false);
}
public XElement Serialize()
{
return(new XElement(UblNames.Cac + nameof(ExternalReference),
URI.Serialize(nameof(URI)),
DocumentHash.Serialize(nameof(DocumentHash)),
HashAlgorithmMethod.Serialize(nameof(HashAlgorithmMethod)),
ExpiryDate.Serialize(nameof(ExpiryDate)),
ExpiryTime.Serialize(nameof(ExpiryTime)),
MimeCode.Serialize(nameof(MimeCode)),
FormatCode.Serialize(nameof(FormatCode)),
EncodingCode.Serialize(nameof(EncodingCode)),
CharacterSetCode.Serialize(nameof(CharacterSetCode)),
FileName.Serialize(nameof(FileName)),
Description.Serialize(nameof(Description))
));
}
public async Task UpdatePublishReport()
{
// arrange
IMongoCollection <Schema> schemas =
_mongoResource.CreateCollection <Schema>();
IMongoCollection <SchemaVersion> versions =
_mongoResource.CreateCollection <SchemaVersion>();
IMongoCollection <SchemaPublishReport> publishReports =
_mongoResource.CreateCollection <SchemaPublishReport>();
IMongoCollection <PublishedSchema> publishedSchemas =
_mongoResource.CreateCollection <PublishedSchema>();
var initial = new Schema("foo", "bar");
await schemas.InsertOneAsync(initial, options : null, default);
var initialVersion = new SchemaVersion(
initial.Id,
"foo",
DocumentHash.FromSourceText("bar"),
Array.Empty <Tag>(),
DateTime.UtcNow);
await versions.InsertOneAsync(initialVersion, options : null, default);
var initialReport = new SchemaPublishReport(
initialVersion.Id, Guid.NewGuid(), Array.Empty <Issue>(),
PublishState.Published, DateTime.UtcNow);
await publishReports.InsertOneAsync(initialReport, options : null, default);
var repository = new SchemaRepository(
schemas, versions, publishReports, publishedSchemas);
// act
await repository.SetPublishReportAsync(new SchemaPublishReport(
initialReport.Id, initialReport.SchemaVersionId,
initialReport.EnvironmentId, initialReport.Issues,
PublishState.Rejected, DateTime.UtcNow));
// assert
IReadOnlyDictionary <Guid, SchemaPublishReport> retrieved =
await repository.GetPublishReportsAsync(new[] { initialReport.Id });
Assert.Equal(PublishState.Rejected, retrieved[initialReport.Id].State);
}
public async Task GetSchemaVersionAsNode()
{
// arrange
var serializer = new IdSerializer();
var schema = new Schema(Guid.NewGuid(), "abc", "def");
await SchemaRepository.AddSchemaAsync(schema);
var schemaVersion = new SchemaVersion(
Guid.NewGuid(), schema.Id, "abc", DocumentHash.FromSourceText("def"),
Array.Empty <Tag>(), DateTime.UnixEpoch);
await SchemaRepository.AddSchemaVersionAsync(schemaVersion);
string id = serializer.Serialize("SchemaVersion", schemaVersion.Id);
IFileContainer container = await Storage.CreateContainerAsync(
schemaVersion.Id.ToString("N", CultureInfo.InvariantCulture));
byte[] buffer = Encoding.UTF8.GetBytes("SourceTextAbc");
await container.CreateFileAsync("schema.graphql", buffer, 0, buffer.Length);
// act
IExecutionResult result = await Executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"query($id: ID!) {
node(id: $id) {
id
... on SchemaVersion {
sourceText
hash {
hash
}
}
}
}")
.SetVariableValue("id", id)
.Create());
// assert
result.MatchSnapshot(o =>
o.Assert(fo =>
Assert.Equal(id, fo.Field <string>("Data.node.id"))));
}
public void ReSelladoXML()
{
try
{
XmlSerializer serializer = new XmlSerializer(typeof(SignatureType));
SignatureType sello = (SignatureType)serializer.Deserialize(ObtenerStreamRecurso("IntegraAfirmaNet.Test.SellosTiempo.Sello.xml"));
DocumentHash documentHash = new DocumentHash();
documentHash.DigestMethod = new DigestMethodType();
documentHash.DigestMethod.Algorithm = "http://www.w3.org/2001/04/xmlenc#sha256";
documentHash.DigestValue = CrearHashTexto("TEXTODEPRUEBA");
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Validando sello de tiempo"));
Timestamp timeStamp = new Timestamp();
timeStamp.Item = sello;
var newTimestamp = _tsaService.RenewTimeStamp(timeStamp, documentHash);
sello = newTimestamp.Item as SignatureType;
string resultado = TestContext.TestRunResultsDirectory + "\\Sello.xml";
using (XmlWriter writer = XmlWriter.Create(resultado))
{
serializer.Serialize(writer, sello);
}
TestContext.AddResultFile(resultado);
TestContext.WriteLine(string.Format("{0}: {1}", DateTime.Now.ToShortTimeString(), "Sello aplicado"));
}
catch (AfirmaResultException afirmaEx)
{
Assert.Fail(string.Format("Error devuelto por @firma: {0}", afirmaEx.Message));
}
catch (Exception ex)
{
Assert.Fail(string.Format("Unexpected exception of type {0} caught: {1}", ex.GetType(), ex.Message));
}
}
public async Task GetSchemaVersion_By_ExternalId()
{
// arrange
IMongoCollection <Schema> schemas =
_mongoResource.CreateCollection <Schema>();
IMongoCollection <SchemaVersion> versions =
_mongoResource.CreateCollection <SchemaVersion>();
IMongoCollection <SchemaPublishReport> publishReports =
_mongoResource.CreateCollection <SchemaPublishReport>();
IMongoCollection <PublishedSchema> publishedSchemas =
_mongoResource.CreateCollection <PublishedSchema>();
var repository = new SchemaRepository(
schemas, versions, publishReports, publishedSchemas);
var schema = new Schema("foo", "bar");
await repository.AddSchemaAsync(schema);
var schemaVersion = new SchemaVersion(
schema.Id,
"bar",
DocumentHash.FromSourceText("bar"),
new[]
{
new Tag("a", "b", DateTime.UtcNow)
},
DateTime.UtcNow);
await repository.AddSchemaVersionAsync(schemaVersion);
// act
SchemaVersion retrieved = await repository.GetSchemaVersionByExternalIdAsync(
schemaVersion.ExternalId);
// assert
Assert.NotNull(retrieved);
Assert.Equal(schemaVersion.Id, retrieved.Id);
Assert.Equal(schemaVersion.Published, retrieved.Published, TimeSpan.FromSeconds(1));
Assert.Equal(schemaVersion.SchemaId, retrieved.SchemaId);
Assert.Equal(schemaVersion.ExternalId, retrieved.ExternalId);
Assert.Equal(schemaVersion.Tags.Count, retrieved.Tags.Count);
}
/// <inheritdoc />
public async Task <TryteString> PublishInvoiceHashAsync(byte[] document, CngKey key)
{
var payload = new InvoicePayload(DocumentHash.Create(document),
Encryption.CreateSignatureScheme(key).SignData(document));
var bundle = new Bundle();
bundle.AddTransfer(new Transfer
{
Address = new Address(Seed.Random().Value),
Message = payload.ToTryteString(),
Timestamp = Timestamp.UnixSecondsTimestamp,
Tag = new Tag("CHECKCHEQUE")
});
bundle.Finalize();
bundle.Sign();
await this.IotaRepository.SendTrytesAsync(bundle.Transactions, 2);
return(bundle.Hash);
}
public async Task TestSignatureMatchShouldReturnTrue()
{
var invoice = new Invoice
{
Hash = Hash.Empty, KvkNumber = "123456789", Payload = Encoding.UTF8.GetBytes("Somebody once told me")
};
var signatureScheme = Encryption.CreateSignatureScheme(Encryption.Create());
var dltPayload = new InvoicePayload(DocumentHash.Create(invoice.Payload),
signatureScheme.SignData(invoice.Payload));
var invoiceRepository = new Mock <IInvoiceRepository>();
invoiceRepository.Setup(i => i.LoadInvoiceInformationAsync(It.IsAny <Hash>())).ReturnsAsync(dltPayload);
var kvkRepository = new Mock <IKvkRepository>();
kvkRepository.Setup(k => k.GetCompanyPublicKeyAsync(It.IsAny <string>()))
.ReturnsAsync(signatureScheme.Key.Export(CngKeyBlobFormat.EccFullPublicBlob));
var verificator = new InvoiceVerificator(invoiceRepository.Object, kvkRepository.Object);
Assert.IsTrue(await verificator.IsValid(invoice));
}
public async Task GetSchemaVersionsById_Invalid_Id_Type()
{
// arrange
var serializer = new IdSerializer();
var schema = new Schema(Guid.NewGuid(), "abc", "def");
await SchemaRepository.AddSchemaAsync(schema);
var schemaVersion = new SchemaVersion(
Guid.NewGuid(), schema.Id, "abc", DocumentHash.FromSourceText("def"),
Array.Empty <Tag>(), DateTime.UnixEpoch);
await SchemaRepository.AddSchemaVersionAsync(schemaVersion);
string id = serializer.Serialize("Foo", schemaVersion.Id);
IFileContainer container = await Storage.CreateContainerAsync(
schemaVersion.Id.ToString("N", CultureInfo.InvariantCulture));
byte[] buffer = Encoding.UTF8.GetBytes("SourceTextAbc");
await container.CreateFileAsync("schema.graphql", buffer, 0, buffer.Length);
// act
IExecutionResult result = await Executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"query($ids: [ID!]!) {
schemaVersionsById(ids: $ids) {
id
sourceText
}
}")
.SetVariableValue("ids", new[] { id })
.Create());
// assert
result.MatchSnapshot();
}