public async Task CreateNewVirgilCard_SignatureValidation_ShouldPassValidation()
{
var crypto = new VirgilCrypto();
var client = IntegrationHelper.GetVirgilClient();
// CREATING A VIRGIL CARD
var appKey = crypto.ImportPrivateKey(IntegrationHelper.AppKey, IntegrationHelper.AppKeyPassword);
var aliceKeys = crypto.GenerateKeys();
var exportedPublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var aliceIdentity = "alice-" + Guid.NewGuid();
var request = new PublishCardRequest(aliceIdentity, "member", exportedPublicKey);
var requestSigner = new RequestSigner(crypto);
requestSigner.SelfSign(request, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(request, IntegrationHelper.AppID, appKey);
var aliceCard = await client.PublishCardAsync(request);
// VALIDATING A VIRGIL CARD
var appPublicKey = crypto.ExtractPublicKey(appKey);
var exportedAppPublicKey = crypto.ExportPublicKey(appPublicKey);
var validator = new CardValidator(crypto);
validator.AddVerifier(IntegrationHelper.AppID, exportedAppPublicKey);
validator.Validate(aliceCard).Should().BeTrue();
await IntegrationHelper.RevokeCard(aliceCard.Id);
}
public async Task SearchForVirgilCards_ValidationWithServiceKey_ShouldPassValidation()
{
var crypto = new VirgilCrypto();
var client = IntegrationHelper.GetVirgilClient();
client.SetCardValidator(new CardValidator(crypto));
// CREATING A VIRGIL CARD
var appKey = crypto.ImportPrivateKey(IntegrationHelper.AppKey, IntegrationHelper.AppKeyPassword);
var aliceKeys = crypto.GenerateKeys();
var exportedPublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var aliceIdentity = "alice-" + Guid.NewGuid();
var request = new PublishCardRequest(aliceIdentity, "member", exportedPublicKey);
var requestSigner = new RequestSigner(crypto);
requestSigner.SelfSign(request, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(request, IntegrationHelper.AppID, appKey);
var aliceCard = await client.PublishCardAsync(request);
// VALIDATING A VIRGIL CARD
var cards = await client.SearchCardsAsync(SearchCriteria.ByIdentity(aliceIdentity));
aliceCard.ShouldBeEquivalentTo(cards.Single());
await IntegrationHelper.RevokeCard(aliceCard.Id);
}
public async Task CreateNewVirgilCard_IdentityAndPublicKeyGiven_ShouldBeFoundByIdentity()
{
var crypto = new VirgilCrypto();
var client = IntegrationHelper.GetVirgilClient();
var appKey = crypto.ImportPrivateKey(IntegrationHelper.AppKey, IntegrationHelper.AppKeyPassword);
var aliceKeys = crypto.GenerateKeys();
var exportedPublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var aliceIdentity = "alice-" + Guid.NewGuid();
var request = new PublishCardRequest(aliceIdentity, "member", exportedPublicKey);
var requestSigner = new RequestSigner(crypto);
requestSigner.SelfSign(request, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(request, IntegrationHelper.AppID, appKey);
var newCard = await client.PublishCardAsync(request);
var cards = await client.SearchCardsAsync(new SearchCriteria { Identities = new[] { aliceIdentity } });
cards.Should().HaveCount(1);
var foundCard = cards.Single();
newCard.ShouldBeEquivalentTo(foundCard);
}
public void Export_WithoutParameters_ShouldBeEquivalentToImportedRequest()
{
var crypto = new VirgilCrypto();
var aliceKeys = crypto.GenerateKeys();
var exportedPublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
const string identity = "alice";
const string identityType = "member";
var request = new PublishCardRequest(
identity: identity,
identityType: identityType,
publicKeyData: exportedPublicKey,
customFields: new Dictionary <string, string>
{
["key1"] = "value1",
["key2"] = "value2"
},
info: new CardInfoModel
{
Device = "Device",
DeviceName = "DeviceName"
});
var requestSigner = new RequestSigner(crypto);
requestSigner.SelfSign(request, aliceKeys.PrivateKey);
var exportedRequest = request.Export();
var importedRequest = new PublishCardRequest(exportedRequest);
request.ShouldBeEquivalentTo(importedRequest);
}
public async Task GetSignleVirgilCard_ByGivenId_ShouldReturnVirgilCard()
{
var crypto = new VirgilCrypto();
var client = IntegrationHelper.GetVirgilClient();
var requestSigner = new RequestSigner(crypto);
var appKey = crypto.ImportPrivateKey(IntegrationHelper.AppKey, IntegrationHelper.AppKeyPassword);
// Prepare Requests
var aliceIdentity = "alice-" + Guid.NewGuid();
var aliceKeys = crypto.GenerateKeys();
var alicePublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var aliceRequest = new PublishCardRequest(aliceIdentity, "member", alicePublicKey);
requestSigner.SelfSign(aliceRequest, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(aliceRequest, IntegrationHelper.AppID, appKey);
var aliceCard = await client.PublishCardAsync(aliceRequest);
var foundAliceCard = await client.GetCardAsync(aliceCard.Id);
aliceCard.ShouldBeEquivalentTo(foundAliceCard);
await IntegrationHelper.RevokeCard(aliceCard.Id);
}
public async Task AddOrDeleteRelationWithoutAuthoritySign_ExceptionShouldOccur()
{
const string identityType = "member";
var crypto = new VirgilCrypto();
var client = PredefinedClient(crypto);
var requestSigner = new RequestSigner(crypto);
var aliceKeys = crypto.GenerateKeys();
var aliceExportedPublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var aliceRequest = new PublishCardRequest("alice", identityType, aliceExportedPublicKey);
var bobKeys = crypto.GenerateKeys();
var bobExportedPublicKey = crypto.ExportPublicKey(bobKeys.PublicKey);
var bobRequest = new PublishCardRequest("bob", identityType, bobExportedPublicKey);
var appId = ConfigurationManager.AppSettings["virgil:AppID"];
var appKey = crypto.ImportPrivateKey(
VirgilBuffer.FromFile(ConfigurationManager.AppSettings["virgil:AppKeyPath"]).GetBytes(),
ConfigurationManager.AppSettings["virgil:AppKeyPassword"]);
// publish cards
requestSigner.SelfSign(aliceRequest, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(aliceRequest, appId, appKey);
var aliceCardModel = await client
.PublishCardAsync(aliceRequest).ConfigureAwait(false);
requestSigner.SelfSign(bobRequest, bobKeys.PrivateKey);
requestSigner.AuthoritySign(bobRequest, appId, appKey);
var bobCardModel = await client
.PublishCardAsync(bobRequest).ConfigureAwait(false);
aliceCardModel.Meta.Relations.Count.ShouldBeEquivalentTo(0);
// add Bob's card to Alice's relations
var addRelationRequest = new AddRelationRequest(bobCardModel.SnapshotModel);
Assert.ThrowsAsync <Exceptions.RelationException>(() => client.AddRelationAsync(addRelationRequest));
// Delete Bob's card from Alice's relations
var deleteRelationRequest = new DeleteRelationRequest(bobCardModel.Id, RevocationReason.Unspecified);
Assert.ThrowsAsync <Exceptions.RelationException>(() => client.DeleteRelationAsync(deleteRelationRequest));
// delete cards
var revokeBobRequest = new RevokeCardRequest(bobCardModel.Id, RevocationReason.Unspecified);
requestSigner.AuthoritySign(revokeBobRequest, appId, appKey);
await client.RevokeCardAsync(revokeBobRequest);
var revokeAliceRequest = new RevokeCardRequest(aliceCardModel.Id, RevocationReason.Unspecified);
requestSigner.AuthoritySign(revokeAliceRequest, appId, appKey);
await client.RevokeCardAsync(revokeAliceRequest);
}
public async Task SearchForTheVirgilCards_MultipleIdentitiesGiven_ShouldReturnVirgilCards()
{
// Initialization
var crypto = new VirgilCrypto();
var client = IntegrationHelper.GetVirgilClient();
var requestSigner = new RequestSigner(crypto);
var appKey = crypto.ImportPrivateKey(IntegrationHelper.AppKey, IntegrationHelper.AppKeyPassword);
// Prepare Requests
var aliceIdentity = "alice-" + Guid.NewGuid();
var aliceKeys = crypto.GenerateKeys();
var alicePublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var bobIdentity = "bob-" + Guid.NewGuid();
var bobKeys = crypto.GenerateKeys();
var bobPublicKey = crypto.ExportPublicKey(bobKeys.PublicKey);
var aliceRequest = new PublishCardRequest(aliceIdentity, "member", alicePublicKey);
var bobRequest = new PublishCardRequest(bobIdentity, "member", bobPublicKey);
requestSigner.SelfSign(aliceRequest, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(aliceRequest, IntegrationHelper.AppID, appKey);
requestSigner.SelfSign(bobRequest, bobKeys.PrivateKey);
requestSigner.AuthoritySign(bobRequest, IntegrationHelper.AppID, appKey);
// Publish Virgil Cards
var aliceCard = await client.PublishCardAsync(aliceRequest);
var bobCard = await client.PublishCardAsync(bobRequest);
// Search for the Virgil Cards
var foundCards = await client.SearchCardsAsync(new SearchCriteria
{
Identities = new[] { bobIdentity, aliceIdentity }
});
// Assertions
foundCards.Should().HaveCount(2);
foundCards.Single(it => it.Id == aliceCard.Id).ShouldBeEquivalentTo(aliceCard);
foundCards.Single(it => it.Id == bobCard.Id).ShouldBeEquivalentTo(bobCard);
await IntegrationHelper.RevokeCard(aliceCard.Id);
await IntegrationHelper.RevokeCard(bobCard.Id);
}
/// <summary>
/// Publishes a current <see cref="VirgilCard"/> to the Virgil Security services.
/// </summary>
internal async Task PublishAsync()
{
var publishCardRequest = new PublishCardRequest(this.card.Snapshot, this.card.Meta.Signatures);
var appId = this.context.Credentials.GetAppId();
var appKey = this.context.Credentials.GetAppKey(this.context.Crypto);
var requestSigner = new RequestSigner(this.context.Crypto);
requestSigner.AuthoritySign(publishCardRequest, appId, appKey);
var updatedModel = await this.context.Client
.PublishCardAsync(publishCardRequest).ConfigureAwait(false);
this.card.Meta = updatedModel.Meta;
}
public void Ctor_NullAsParameterGiven_ShouldSnapshotBeEquivalentToSerializedDetails()
{
var crypto = new VirgilCrypto();
var keyPair = crypto.GenerateKeys();
var exportedPublicKey = crypto.ExportPublicKey(keyPair.PublicKey);
const string identity = "alice";
const string identityType = "member";
var request = new PublishCardRequest(identity, identityType, exportedPublicKey);
var requestJson = Encoding.UTF8.GetString(request.Snapshot);
var requestModel = JsonConvert.DeserializeObject <PublishCardSnapshotModel>(requestJson);
requestModel.Identity.ShouldBeEquivalentTo(identity);
requestModel.IdentityType.ShouldBeEquivalentTo(identityType);
requestModel.PublicKeyData.ShouldBeEquivalentTo(exportedPublicKey);
}
public async Task CreateNewVirgilCard_DuplicateCardCreation_ShouldThrowException()
{
var crypto = new VirgilCrypto();
var client = IntegrationHelper.GetVirgilClient();
var appKey = crypto.ImportPrivateKey(IntegrationHelper.AppKey, IntegrationHelper.AppKeyPassword);
var aliceKeys = crypto.GenerateKeys();
var exportedPublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
var aliceIdentity = "alice-" + Guid.NewGuid();
var request = new PublishCardRequest(aliceIdentity, "member", exportedPublicKey);
var requestSigner = new RequestSigner(crypto);
requestSigner.SelfSign(request, aliceKeys.PrivateKey);
requestSigner.AuthoritySign(request, IntegrationHelper.AppID, appKey);
var virgilCard = await client.PublishCardAsync(request);
Assert.ThrowsAsync <VirgilClientException>(async() => await client.PublishCardAsync(request));
}
public void Export_WithoutParameters_ShouldReturnStringRepresentationOfRequest()
{
var crypto = new VirgilCrypto();
var requestSigner = new RequestSigner(crypto);
var aliceKeys = crypto.GenerateKeys();
var exportedPublicKey = crypto.ExportPublicKey(aliceKeys.PublicKey);
const string identity = "alice";
const string identityType = "member";
var request = new PublishCardRequest(identity, identityType, exportedPublicKey);
requestSigner.SelfSign(request, aliceKeys.PrivateKey);
var exportedRequest = request.Export();
var jsonData = Convert.FromBase64String(exportedRequest);
var json = Encoding.UTF8.GetString(jsonData);
var model = JsonConvert.DeserializeObject <SignableRequestModel>(json);
model.ContentSnapshot.ShouldBeEquivalentTo(request.Snapshot);
model.Meta.Signatures.ShouldAllBeEquivalentTo(request.Signatures);
}
public void Crossplatform_Compatibility_Test()
{
var crypto = new VirgilCrypto();
dynamic testData = new ExpandoObject();
// Encrypt for single recipient
{
var kp = crypto.GenerateKeys();
var prkey = crypto.ExportPrivateKey(kp.PrivateKey);
var data = System.Text.Encoding.UTF8.GetBytes("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
testData.encrypt_single_recipient = new
{
private_key = prkey,
original_data = data,
cipher_data = crypto.Encrypt(data, kp.PublicKey)
};
}
// Encrypt for multiple recipients
{
var kps = new int[new Random().Next(5, 10)].Select(it => crypto.GenerateKeys()).ToList();
var prkeys = kps.Select(kp => crypto.ExportPrivateKey(kp.PrivateKey)).ToArray();
var data = System.Text.Encoding.UTF8.GetBytes("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
testData.encrypt_multiple_recipients = new
{
private_keys = prkeys,
original_data = data,
cipher_data = crypto.Encrypt(data, kps.Select(kp => kp.PublicKey).ToArray())
};
}
// Sign and Encrypt for single recipient
{
var kp = crypto.GenerateKeys();
var prkey = crypto.ExportPrivateKey(kp.PrivateKey);
var data = System.Text.Encoding.UTF8.GetBytes("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
testData.sign_then_encrypt_single_recipient = new
{
private_key = prkey,
original_data = data,
cipher_data = crypto.SignThenEncrypt(data, kp.PrivateKey, kp.PublicKey)
};
}
// Sign and encrypt for multiple recipients
{
var kps = new int[new Random().Next(5, 10)].Select(it => crypto.GenerateKeys()).ToList();
var prkeys = kps.Select(kp => crypto.ExportPrivateKey(kp.PrivateKey)).ToArray();
var data = System.Text.Encoding.UTF8.GetBytes("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
testData.sign_then_encrypt_multiple_recipients = new
{
private_keys = prkeys,
original_data = data,
cipher_data =
crypto.SignThenEncrypt(data, kps[0].PrivateKey, kps.Select(kp => kp.PublicKey).ToArray())
};
}
// Generate Signature
{
var kp = crypto.GenerateKeys();
var prkey = crypto.ExportPrivateKey(kp.PrivateKey);
var data = System.Text.Encoding.UTF8.GetBytes("Suspendisse elit purus, laoreet ut nibh nec.");
testData.generate_signature = new
{
private_key = prkey,
original_data = data,
signature = crypto.Sign(data, kp.PrivateKey)
};
}
// Export and Import SignableRequest
{
var kp = crypto.GenerateKeys();
var prkey = crypto.ExportPrivateKey(kp.PrivateKey);
var req = new PublishCardRequest(
identity: "alice",
identityType: "member",
publicKeyData: crypto.ExportPublicKey(kp.PublicKey),
customFields: new Dictionary<string, string>
{
["Key1"] = "Value1",
["Key2"] = "Value2"
},
info: new CardInfoModel
{
Device = "iPhone 7",
DeviceName = "My precious"
}
);
var reqSigner = new RequestSigner(crypto);
reqSigner.SelfSign(req, kp.PrivateKey);
testData.export_signable_request = new
{
private_key = prkey,
exported_request = req.Export()
};
}
var testJson = JsonConvert.SerializeObject(testData, Formatting.Indented);
}
