public void MigrateTestPositive()
{
var server = new FakeHttpServer(Port,
new[] { new FakeHttpServerResponse(200, FindResponse),
new FakeHttpServerResponse(201, FindResponse),
new FakeHttpServerResponse(200, BadFindResponse) });
server.Start();
var config = new StorageConfig(endPoint: "http://*****:*****@ssworD!"));
using var storage = Storage.NewStorage(config);
const int limit = 50;
var migrateResult = storage.MigrateAsync("country", limit).Result;
Assert.NotNull(migrateResult);
Assert.AreEqual(1, migrateResult.Migrated);
Assert.AreEqual(0, migrateResult.TotalLeft);
Assert.AreEqual(0, migrateResult.Errors.Count);
migrateResult = storage.MigrateAsync("country", limit).Result;
Assert.NotNull(migrateResult);
Assert.AreEqual(0, migrateResult.Migrated);
Assert.AreEqual(1, migrateResult.TotalLeft);
Assert.AreEqual(1, migrateResult.Errors.Count);
server.Stop();
}
private static IStorage InitStorageWithEncryptionSecret()
{
var config = CredentialsHelper.GetConfigWithOauth();
var secretData = SecretsDataGenerator.FromPassword("<Str0ng_p@ssworD!");
config.SecretKeyAccessor = () => secretData;
return(Storage.NewStorage(config));
}
public void GetKeyTest()
{
var secretData = SecretsDataGenerator.FromPassword("secret");
var salt = Encoding.UTF8.GetBytes(Guid.NewGuid().ToString());
var key = SecretKeyFactory.GetKey(salt, secretData.CurrentSecret, 1000);
Assert.IsNotNull(key);
Assert.IsNotEmpty(key);
}
private static IStorage InitStorageWithoutHashing()
{
var config = CredentialsHelper.GetConfigWithOauth();
var secretData = SecretsDataGenerator.FromPassword("<vEry-Str0ng_p@ssworD!_StorageWithoutHashing");
config.SecretKeyAccessor = () => secretData;
config.HashSearchKeys = false;
return(Storage.NewStorage(config));
}
public void DecryptAesGcm10KHexTest()
{
const string CipherMessageV1 =
"1:8b02d29be1521e992b49a9408f2777084e9d8195e4a3392c68c70545eb559670b70ec928c8eeb2e34f118d32a23d77abdcde38446241efacb71922579d1dcbc23fca62c1f9ec5d97fbc3a9862c0a9e1bb630aaa3585eac160a65b24a96af5becef3cdc2b29";
using var cryptoManager = new CryptoProvider();
var decryptedMessage =
cryptoManager.Decrypt(CipherMessageV1, SecretsDataGenerator.FromPassword("password"), 0);
Assert.AreEqual("InCountry", decryptedMessage);
}
public void FromPasswordTest()
{
const string secret = "password";
var secretData = SecretsDataGenerator.FromPassword(secret);
Assert.AreEqual(0, secretData.CurrentSecret.Version);
Assert.AreEqual(1, secretData.Secrets.Count);
Assert.AreEqual(0, secretData.Secrets[0].Version);
Assert.AreEqual(Encoding.UTF8.GetBytes(secret), secretData.Secrets[0].GetSecretBytes());
Assert.AreEqual(typeof(EncryptionSecret), secretData.Secrets[0].GetType());
}
public void TestDecryptionFromOtherSdk(Record record, string jsonResponse)
{
var secretData = SecretsDataGenerator.FromPassword(Password);
using var cryptoManager = new CryptoProvider();
var decodedRecord =
new DtoTransformer(cryptoManager,
new HashUtils(EnvironmentId, false, Encoding.UTF8), true, () => secretData)
.GetRecord(JsonConvert.DeserializeObject <TransferRecord>(jsonResponse, _jsonSettings));
Assert.NotNull(decodedRecord);
#pragma warning disable CA1062
Assert.IsTrue(RecordEquals(record, decodedRecord));
#pragma warning restore CA1062
}
public void MigrateTestNegative()
{
var config = new StorageConfig(endPoint: "http://*****:*****@ssworD!");
using var storage2 = Storage.NewStorage(config);
const int limit = 0;
var exception2 = Assert.ThrowsAsync <StorageClientException>(() => storage2.MigrateAsync("country", limit));
Assert.AreEqual("Limit can't be less then 1", exception2.Message);
}
public void ValidateCipherNegativeTest()
{
var cipher1 = new CipherStub("cipherStub1");
var cipher2 = new WrongCipher("WrongCipher");
using var provider = new CryptoProvider(cipher1);
provider.RegisterCipher(cipher2);
var customEncryptionKey = new CustomEncryptionKey(1, Encoding.UTF8.GetBytes("CustomEncryptionKey"));
var exception = Assert.Throws <StorageClientException>(() =>
{
provider.ValidateCustomCiphers(new SecretsData(new List <Secret> {
customEncryptionKey
},
customEncryptionKey));
});
Assert.AreEqual("Validation failed for custom cipher with version 'WrongCipher'", exception.Message);
provider.UnregisterCipher(cipher2);
var cipher3 = new CipherWithException("CipherWithException");
provider.RegisterCipher(cipher3);
exception = Assert.Throws <StorageClientException>(() =>
{
provider.ValidateCustomCiphers(new SecretsData(new List <Secret> {
customEncryptionKey
},
customEncryptionKey));
});
Assert.AreEqual("Validation failed for custom cipher with version 'CipherWithException'",
exception.Message);
Assert.NotNull(exception.InnerException);
Assert.IsInstanceOf <NotImplementedException>(exception.InnerException);
var secretData = SecretsDataGenerator.FromPassword("password");
exception = Assert.Throws <StorageClientException>(() => provider.ValidateCustomCiphers(secretData));
Assert.AreEqual("There is no custom encryption key for the custom ciphers", exception.Message);
}
public void TestEncryptionFromOtherSdk(Record record, string jsonResponse)
{
var secretData = SecretsDataGenerator.FromPassword(Password);
using var cryptoManager = new CryptoProvider();
var recordJsonString = JsonConvert.SerializeObject(
new DtoTransformer(cryptoManager,
new HashUtils(EnvironmentId, false, Encoding.UTF8), true, () => secretData)
.GetTransferRecord(record), _jsonSettings);
var jsonObject = JObject.Parse(recordJsonString);
var originalJsonObject = JObject.Parse(jsonResponse);
var excludedList = new List <string> {
"body", "precommit_body", "is_encrypted"
};
var fieldList =
new List <JProperty>(originalJsonObject.Properties()).FindAll(key => !excludedList.Contains(key.Name));
foreach (var jsonKey in fieldList)
{
Assert.AreEqual(jsonObject[jsonKey.Name].Value <string>(),
originalJsonObject[jsonKey.Name].Value <string>());
}
fieldList =
new List <JProperty>(jsonObject.Properties()).FindAll(key => !excludedList.Contains(key.Name));
foreach (var jsonKey in fieldList)
{
Assert.AreEqual(jsonObject[jsonKey.Name].Value <string>(),
originalJsonObject[jsonKey.Name].Value <string>());
}
Assert.AreNotEqual(originalJsonObject["body"], jsonObject["body"]);
if (originalJsonObject["precommit_body"] != null)
{
Assert.AreNotEqual(originalJsonObject["precommit_body"].Value <string>(),
jsonObject["precommit_body"].Value <string>());
}
}
public void DecryptUnknownTest()
{
const string CipherMessageV1 =
"unknown";
using var cryptoManager = new CryptoProvider();
var exception = Assert.Throws <StorageCryptoException>(() =>
cryptoManager.Decrypt(CipherMessageV1, SecretsDataGenerator.FromPassword("password"), 0));
Assert.AreEqual("Unknown cipher format", exception.Message);
}
