public string CreateVCN(RequestSigner signer, string url = "https://iaas.ap-sydney-1.oraclecloud.com/20160918/vcns")
{
try
{
// POST with body (creates a VCN)
var uri = new Uri($"https://iaas.ap-sydney-1.oraclecloud.com/20160918/vcns");
var body = string.Format(@"{{""cidrBlock"" : ""10.0.0.0/16"",""compartmentId"" : ""{0}"",""displayName"" : ""mytest""}}", compartmentId);
var bytes = Encoding.UTF8.GetBytes(body);
var request = (HttpWebRequest)WebRequest.Create(uri);
request.Method = "POST";
request.Accept = "application/json";
request.ContentType = "application/json";
request.Headers["x-content-sha256"] = Convert.ToBase64String(SHA256.Create().ComputeHash(bytes));
using (var stream = request.GetRequestStream())
{
stream.Write(bytes, 0, bytes.Length);
}
signer.SignRequest(request);
var response = ExecuteRequest(request);
return(response);
}
catch (Exception ex)
{
return(ex.ToString());
}
}
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 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_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 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 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 TestIsNotMatch() {
var requestSigner = new RequestSigner(GetBytes("secret"));
const string expectedSignature = "";
var request = new Request("1544544948", "abc=foo&def=bar", GetBytes("{\"a key\":\"some value\"}"));
Assert.IsFalse(requestSigner.IsMatch(expectedSignature, request));
}
public void TestIsMatchWithDataAndQueryParams() {
var requestSigner = new RequestSigner(GetBytes("other-secret"));
const string expectedSignature = "orb0adPhRCYND1WCAvPBr+qjm4STGtyvNDIDNBZ4Ir4=";
var request = new Request("1544544948", "abc=foo&def=bar", GetBytes("{\"a key\":\"some value\"}"));
Assert.IsTrue(requestSigner.IsMatch(expectedSignature, request));
}
public void TestIsMatchWithShuffledQueryParams() {
var requestSigner = new RequestSigner(GetBytes("secret"));
const string expectedSignature = "Tfn+nRUBsn6lQgf6IpxBMS1j9lm7XsGjt5xh47M3jCk=";
var request = new Request("1544544948", "def=bar&abc=foo", GetBytes(""));
Assert.IsTrue(requestSigner.IsMatch(expectedSignature, request));
}
public void TestIsMatchWithData() {
var requestSigner = new RequestSigner(GetBytes("secret"));
const string expectedSignature = "p2e20OtAg39DEmz1ORHpjQ556U4o1ZaH4NWbM9Q8Qjk=";
var request = new Request("1544544948", "", GetBytes("{\"a key\":\"some value\"}"));
Assert.IsTrue(requestSigner.IsMatch(expectedSignature, request));
}
public void TestIsMatchEmptyQueryParamsAndEmptyData() {
var requestSigner = new RequestSigner(GetBytes("secret"));
const string expectedSignature = "LISw4Je7n0/MkYDgVSzTJm8dW6BkytKTXMZZk1IElMs=";
var request = new Request("1544544948", "", GetBytes(""));
Assert.IsTrue(requestSigner.IsMatch(expectedSignature, request));
}
//public string GetInstances()
//{
// //GET /20160918/instances/?availabilityDomain=MsFN%3AAP-SYDNEY-1-AD-1&compartmentId=ocid1.compartment.oc1..aaaaaaaaa2sevxdnsfngp5jxzl7ej5oqdnq77yad3maramyp3xz2vnyrxsya&sortBy=timeCreated&sortOrder=DESC HTTP/1.1
// //var uri = new Uri($"https://identity.us-ashburn-1.oraclecloud.com/20160918/users/{userId}");
// //url=https://iaas.ap-sydney-1.oraclecloud.com/20160918/instances/?availabilityDomain=MsFN%3AAP-SYDNEY-1-AD-1&compartmentId=ocid1.compartment.oc1..aaaaaaaaa2sevxdnsfngp5jxzl7ej5oqdnq77yad3maramyp3xz2vnyrxsya&sortBy=timeCreated&sortOrder=DESC
// //var uri = new Uri(string.Format(@"https://identity.us-ashburn-1.oraclecloud.com/20160918/users/" + this.userId));
// var uri = new Uri("https://iaas.ap-sydney-1.oraclecloud.com/20160918/instances?compartmentId="+this.compartmentId);
// // var uri = new Uri(url);
// var request = (HttpWebRequest)WebRequest.Create(uri);
// request.Method = "GET";
// request.Accept = "application/json";
// var signer = new RequestSigner(tenancyId, userId, fingerPrint, privateKeyPath, privateKeyPassphrase);
// signer.SignRequest(request);
// Console.WriteLine($"Authorization header: {request.Headers["authorization"]}");
// Console.WriteLine("=========================================================");
// Console.WriteLine("REQUEST");
// Console.WriteLine(request.Address.ToString());
// Console.WriteLine(request.Headers.ToString());
// Console.WriteLine("=========================================================");
// Console.WriteLine("RESPONSE");
// var response = ExecuteRequest(request);
// Console.WriteLine(request);
// return response;
//}
public string StartInstancePool(string instanceid, string mode)//mode=start/stop
{
// POST / 20160918 / instancePools /{ instancePoolId}/ actions / start
var uri = new Uri("https://iaas." + this.region + ".oraclecloud.com/20160918/instances/" + instanceid + "/actions/" + mode);
var body = "";// string.Format(@"{{""cidrblock"" : ""10.0.0.0/16"",""compartmentid"" : ""{0}"",""displayname"" : ""myvcn""}}", this.compartmentId);
var bytes = Encoding.UTF8.GetBytes(body);
var request = (HttpWebRequest)WebRequest.Create(uri);
request.Method = "POST";
request.Accept = "application/json";
request.ContentType = "application/json";
//request = (HttpWebRequest)WebRequest.Create(uri);
request.Headers["x-content-sha256"] = Convert.ToBase64String(SHA256.Create().ComputeHash(bytes));
using (var stream = request.GetRequestStream())
{
stream.Write(bytes, 0, bytes.Length);
}
var signer = new RequestSigner(tenancyId, userId, fingerPrint, privateKeyPath, privateKeyPassphrase);
signer.SignRequest(request);
//Console.WriteLine($"authorization header: {request.Headers["authorization"]}");
//Console.WriteLine("=========================================================");
//Console.WriteLine("REQUEST");
//Console.WriteLine(request.Address.ToString());
//Console.WriteLine(request.Headers.ToString());
//Console.WriteLine("=========================================================");
//Console.WriteLine("RESPONSE");
var response = ExecuteRequest(request);
Console.WriteLine(response);
return(response);
}
public bool Verify(string _messageBirdSignature, string _signingKey, string _timeStampt, string _requestBody)
{
byte[] _requestBodyByte = Encoding.ASCII.GetBytes(_requestBody);
var requestSigner = new RequestSigner(Encoding.ASCII.GetBytes(_signingKey));
var request = new Request(_timeStampt, "", _requestBodyByte);
return(requestSigner.IsMatch(_messageBirdSignature, request));
}
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);
}
/// <summary> Constructor of a service client.</summary>
/// <param name="authProvider">The authentication details provider.</param>
/// <param name="clientConfiguration">A client configuration to customize client.</param>
/// <param name="requestSigner">A request signer that will be used to sign requests.</param>
public ClientBase(IBasicAuthenticationDetailsProvider authProvider, ClientConfiguration clientConfiguration, RequestSigner requestSigner)
{
ClientConfiguration clientConfigurationToUse = clientConfiguration ?? new ClientConfiguration();
this.clientHandler = new RestClientHandler(RequestReceptor);
this.restClient = new RestClient(clientHandler, clientConfigurationToUse);
this.requestSigner = requestSigner;
this.availableRequestSigners = GetAvailableRequestSigners(authProvider);
this.restClient.SetDefaultUserAgent(GetUserAgent(clientConfigurationToUse.ClientUserAgent));
}
internal void RequestReceptor(HttpRequestMessage requestMessage)
{
RequestSigner requestSignerToUse = requestSigner;
if (requestMessage.Properties.TryGetValue(SigningStrategy.SIGNING_STRATEGY_PROPERTY_NAME_KEY, out var signingStrategy))
{
requestSignerToUse = availableRequestSigners.TryGetValue((SigningStrategy)signingStrategy, out var desiredSigner) ?
desiredSigner : requestSignerToUse;
}
requestSignerToUse.SignRequest(requestMessage);
}
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);
}
public static async Task RevokeCard(string cardId)
{
var client = GetVirgilClient();
var crypto = new VirgilCrypto();
var requestSigner = new RequestSigner(crypto);
var appKey = crypto.ImportPrivateKey(AppKey, AppKeyPassword);
var revokeRequest = new RevokeCardRequest(cardId, RevocationReason.Unspecified);
requestSigner.AuthoritySign(revokeRequest, AppID, appKey);
await client.RevokeCardAsync(revokeRequest);
}
/// <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;
}
private void HttpClientSendPutRecordsRequest(PutRecordsRequest prr)
{
StdErrorOut.Instance.StdOut(LogLevel.debug, "Pipeline.send_put_records_request");
AwsHttpRequest kinesisRequest = AwsHttp.create_kinesis_request(this.region_, "PutRecords", prr.serialize());
try
{
RequestSigner.sign_v4(kinesisRequest, this.sig_v4_ctx_);
StdErrorOut.Instance.StdOut(LogLevel.debug, "after RequestSigner.sign_v4(request, sig_v4_ctx_)");
this.http_client_.put(kinesisRequest, (Action <AwsHttpResult>)(result => this.retrier_put(result)), (object)prr, prr.Deadline(), prr.Expiration());
StdErrorOut.Instance.StdOut(LogLevel.debug, "http_client_.put");
}
catch (Exception ex)
{
this.retrier_.put(new AwsHttpResult(ex.ToString(), (object)prr, DateTime.Now, DateTime.Now));
}
}
void upload_with_path(string path)
{
AwsHttpRequest req = new AwsHttpRequest("POST", path);
req.add_header("Host", endpoint);
req.add_header("Content-Length", "0");
SigV4Context ctx = new SigV4Context(region, "monitoring", creds);
try
{
RequestSigner.sign_v4(req, ctx);
http_client.put(req, (r) => { handle_result(r); }, path, DateTime.Now, DateTime.Now);
}
catch (Exception e)
{
handle_result(new AwsHttpResult(e.ToString(), path, DateTime.Now, DateTime.Now));
}
}
public string GetUsers()
{
var uri = new Uri("https://identity." + this.region + ".oraclecloud.com/20160918/users/" + this.userId);
// var uri = new Uri(url);
var request = (HttpWebRequest)WebRequest.Create(uri);
request.Method = "GET";
request.Accept = "application/json";
var signer = new RequestSigner(tenancyId, userId, fingerPrint, privateKeyPath, privateKeyPassphrase);
signer.SignRequest(request);
var response = ExecuteRequest(request);
Console.WriteLine(response);
return(response);
}
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 TestWithRealSignature()
{
/*
* Here we use real signature from MessageBird webhook call
*/
var requestSigner = new RequestSigner(GetBytes("Wb3N9gKeFf8ZoCzlOb5lJSic7bHLUcSu"));
const string requestSignature = "5Jha9Yyhwgc1nTsgJ9WyzeHilsuUumydICdf4LuIZE8=";
const string requestTimestamp = "1547036603";
const string requestParams = "id=57db52e04e2f4001b555f79813a0f503&mccmnc=20409&ported=0&recipient=31667788880&reference=curl&status=delivered&statusDatetime=2019-01-09T12%3A23%3A23%2B00%3A00";
var requestBody = new byte[] {};
const string spoiledSignature = "5Jha9Yyhwgc1nTsgJ9WyzeHilsuUumydICdf4LUIZE8=";
const string spoiledTimestamp = "1547036605";
const string spoiledParams = "id=57db52e04e2f4001b555f79813a0f503&mccmnc=20409&ported=0&recipient=31667788880&reference=curvy&status=delivered&statusDatetime=2019-01-09T12%3A23%3A23%2B00%3A00";
var spoiledBody = GetBytes("get shit spoiled");
Assert.IsTrue(
requestSigner.IsMatch(requestSignature, new Request(requestTimestamp, requestParams, requestBody)),
"Definitely valid signature is threaten as invalid"
);
Assert.IsFalse(
requestSigner.IsMatch(spoiledSignature, new Request(requestTimestamp, requestParams, requestBody)),
"Invalid signature is threaten as invalid"
);
Assert.IsFalse(
requestSigner.IsMatch(requestSignature, new Request(spoiledTimestamp, requestParams, requestBody)),
"Signature is still valid with replaced timestamp"
);
Assert.IsFalse(
requestSigner.IsMatch(requestSignature, new Request(requestTimestamp, spoiledParams, requestBody)),
"Signature is still valid with replaced params"
);
Assert.IsFalse(
requestSigner.IsMatch(requestSignature, new Request(requestTimestamp, requestParams, spoiledBody)),
"Signature is still valid with replaced body"
);
}
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 CreateCardRequest
(
identity,
identityType,
exportedPublicKey,
new Dictionary <string, string>
{
["key1"] = "value1",
["key2"] = "value2"
},
new DeviceInfo
{
Device = "Device",
DeviceName = "DeviceName"
}
);
var requestSigner = new RequestSigner(crypto);
requestSigner.SelfSign(request, aliceKeys.PrivateKey);
var exportedRequest = request.Export();
var importedRequest = SignableRequest.Import <CreateCardRequest>(exportedRequest);
request.ShouldBeEquivalentTo(importedRequest);
}
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 CreateCardRequest(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 <SignedRequestModel>(json);
model.ContentSnapshot.ShouldBeEquivalentTo(request.Snapshot);
model.Meta.Signatures.ShouldAllBeEquivalentTo(request.Signatures);
}
private void HttpClientUpdate(string start_shard_id)
{
StringBuilder sb = new StringBuilder();
sb.Append("{\"StreamName\":\"").Append(stream).Append("\"");
if (!string.IsNullOrEmpty(start_shard_id))
{
sb.Append(",\"ExclusiveStartShardId\":\"").Append(start_shard_id).Append("\"");
}
sb.Append("}");
var req = AwsHttp.create_kinesis_request(region, "DescribeStream", sb.ToString());
var ctx = new SigV4Context(region, "kinesis", creds_provider);
try
{
RequestSigner.sign_v4(req, ctx);
http_client.put(req, (r) => { update_callback(r); }, null, DateTime.Now, DateTime.Now);
}
catch (Exception e)
{
update_callback(new AwsKinesisResult(e.ToString(), null, DateTime.Now, DateTime.Now));
}
}
public RegionalClientBase(IBasicAuthenticationDetailsProvider authProvider, ClientConfiguration clientConfiguration, RequestSigner requestSigner) : base(authProvider, clientConfiguration, requestSigner)
{
}
public RegionalClientBase(IBasicAuthenticationDetailsProvider authProvider, RequestSigner requestSigner) : base(authProvider, requestSigner)
{
}
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 = 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 = 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 = 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 = 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 = 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 CreateCardRequest
(
"alice",
"member",
crypto.ExportPublicKey(kp.PublicKey),
new Dictionary <string, string>
{
["Key1"] = "Value1",
["Key2"] = "Value2"
},
new DeviceInfo
{
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);
}
public AmazonUtilities(String awsAccessKeyId, String awsSecretKey, String associateTag)
{
_associateTag = associateTag;
_requestSigner = new RequestSigner(awsAccessKeyId, awsSecretKey, "ecs.amazonaws.com");
}
public void Hash(string date, string key, string hash)
{
var signer = new RequestSigner(Helper.GetCredentials(key));
Assert.AreEqual(hash, signer.GenerateSignature(date));
}
