public void EncryptData_MultiplePublicKeysWithDifferentTypesGiven_ShouldCipherDataBeDecrypted()
{
var crypto = new VirgilCrypto();
var keyPairs = new List <KeyPair>
{
crypto.GenerateKeys(KeyPairType.EC_SECP256R1),
crypto.GenerateKeys(KeyPairType.EC_SECP384R1),
crypto.GenerateKeys(KeyPairType.EC_SECP521R1),
crypto.GenerateKeys(KeyPairType.EC_BP256R1),
crypto.GenerateKeys(KeyPairType.EC_BP384R1),
crypto.GenerateKeys(KeyPairType.EC_BP512R1),
crypto.GenerateKeys(KeyPairType.EC_SECP256K1),
crypto.GenerateKeys(KeyPairType.EC_CURVE25519),
crypto.GenerateKeys(KeyPairType.FAST_EC_ED25519),
crypto.GenerateKeys(KeyPairType.FAST_EC_X25519)
};
var data = Encoding.UTF8.GetBytes("Encrypt me!!!");
var encryptedData = crypto.Encrypt(data, keyPairs.Select(it => it.PublicKey).ToArray());
foreach (var keyPair in keyPairs)
{
var decryptedData = crypto.Decrypt(encryptedData, keyPair.PrivateKey);
data.ShouldAllBeEquivalentTo(decryptedData);
}
}
public void EncryptStream_SmallStreamBufferGiven_ShouldCipherStreamBeDecrypted()
{
var crypto = new VirgilCrypto();
var keyPair = crypto.GenerateKeys();
var originalData = Encoding.UTF8.GetBytes("Hello There :)");
byte[] cipherData;
byte[] resultData;
using (var inputStream = new MemoryStream(originalData))
using (var cipherStream = new MemoryStream())
{
crypto.Encrypt(inputStream, cipherStream, keyPair.PublicKey);
cipherData = cipherStream.ToArray();
}
using (var cipherStream = new MemoryStream(cipherData))
using (var resultStream = new MemoryStream())
{
crypto.Decrypt(cipherStream, resultStream, keyPair.PrivateKey);
resultData = resultStream.ToArray();
}
originalData.ShouldAllBeEquivalentTo(resultData);
}
public static byte[] EncryptMessage(byte[] senderPrivateKey, byte[] receiverPublicKey, byte[] plainText)
{
var crypto = new VirgilCrypto(KeyPairType.EC_SECP256K1);
var ecdhKey = Ecdh(senderPrivateKey, receiverPublicKey);
var newKeyPair = crypto.GenerateKeys(KeyPairType.EC_SECP256K1, ecdhKey);
return(crypto.Encrypt(plainText, newKeyPair.PublicKey));
}
public void DecryptEncryptedMessage_Should_ReturnEquivalentMessage()
{
var crypto = new VirgilCrypto();
var keyPair = crypto.GenerateKeys();
var messageBytes = Encoding.UTF8.GetBytes("hi");
var encryptedData = crypto.Encrypt(messageBytes, keyPair.PublicKey);
Assert.AreEqual(messageBytes, crypto.Decrypt(encryptedData, keyPair.PrivateKey));
}
public void DecryptEncryptedMessageByGeneratedFromKeyMateria_Should_ReturnEquivalentMessage()
{
var crypto = new VirgilCrypto();
var keyMateria = Encoding.UTF8.GetBytes("26dfhvnslvdsfkdfvnndsb234q2xrFOuY5EDSAFGCCXHCJSHJAD");
var keyPair = crypto.GenerateKeys(keyMateria);
var messageBytes = Encoding.UTF8.GetBytes("hi");
var encryptedData = crypto.Encrypt(messageBytes, keyPair.PublicKey);
Assert.AreEqual(messageBytes, crypto.Decrypt(encryptedData, keyPair.PrivateKey));
}
public void DecryptEncryptedMessageWithWrongPassword_Should_RaiseException()
{
var crypto = new VirgilCrypto();
var aliceKeyPair = crypto.GenerateKeys();
var bobKeyPair = crypto.GenerateKeys();
var messageBytes = Encoding.UTF8.GetBytes("hi");
var encryptedDataForAlice = crypto.Encrypt(messageBytes, aliceKeyPair.PublicKey);
Assert.Throws <VirgilCryptoException>(() => crypto.Decrypt(encryptedDataForAlice, bobKeyPair.PrivateKey));
}
public void EncryptData_SinglePublicKeyGiven_ShouldCipherDataBeDecrypted()
{
var crypto = new VirgilCrypto();
var keyPair = crypto.GenerateKeys();
var data = Encoding.UTF8.GetBytes("Encrypt me!!!");
var encryptedData = crypto.Encrypt(data, keyPair.PublicKey);
var decryptedData = crypto.Decrypt(encryptedData, keyPair.PrivateKey);
data.ShouldAllBeEquivalentTo(decryptedData);
}
public void EncryptData_MultiplePublicKeysGiven_ShouldCipherDataBeDecrypted()
{
var crypto = new VirgilCrypto();
var keyPairs = new List <KeyPair>();
for (var index = 0; index < 10; index++)
{
keyPairs.Add(crypto.GenerateKeys());
}
var data = Encoding.UTF8.GetBytes("Encrypt me!!!");
var encryptedData = crypto.Encrypt(data, keyPairs.Select(it => it.PublicKey).ToArray());
foreach (var keyPair in keyPairs)
{
var decryptedData = crypto.Decrypt(encryptedData, keyPair.PrivateKey);
data.ShouldAllBeEquivalentTo(decryptedData);
}
}
public void EncryptStream_SinglePublicKeyGiven_ShouldCipherStreamBeDecrypted()
{
var crypto = new VirgilCrypto();
var keyPair = crypto.GenerateKeys();
var originalData = Encoding.UTF8.GetBytes(IntegrationHelper.RandomText);
using (var inputStream = new MemoryStream(originalData))
using (var cipherStream = new MemoryStream())
using (var resultStream = new MemoryStream())
{
crypto.Encrypt(inputStream, cipherStream, keyPair.PublicKey);
using (var cipherStream1 = new MemoryStream(cipherStream.ToArray()))
{
crypto.Decrypt(cipherStream1, resultStream, keyPair.PrivateKey);
resultStream.ToArray().ShouldAllBeEquivalentTo(originalData);
}
}
}
public void EncryptStream_MultiplePublicKeysGiven_ShouldCipherStreamBeDecrypted()
{
var crypto = new VirgilCrypto();
var keyPairs = new List <KeyPair>
{
crypto.GenerateKeys(KeyPairType.EC_SECP256R1),
crypto.GenerateKeys(KeyPairType.EC_SECP384R1),
crypto.GenerateKeys(KeyPairType.EC_SECP521R1),
crypto.GenerateKeys(KeyPairType.EC_BP256R1),
crypto.GenerateKeys(KeyPairType.EC_BP384R1),
crypto.GenerateKeys(KeyPairType.EC_BP512R1),
crypto.GenerateKeys(KeyPairType.EC_SECP256K1),
crypto.GenerateKeys(KeyPairType.EC_CURVE25519),
crypto.GenerateKeys(KeyPairType.FAST_EC_ED25519),
crypto.GenerateKeys(KeyPairType.FAST_EC_X25519)
};
var originalData = Encoding.UTF8.GetBytes(IntegrationHelper.RandomText);
foreach (var keyPair in keyPairs)
{
using (var inputStream = new MemoryStream(originalData))
using (var cipherStream = new MemoryStream())
using (var resultStream = new MemoryStream())
{
crypto.Encrypt(inputStream, cipherStream, keyPairs.Select(it => it.PublicKey).ToArray());
using (var cipherStream1 = new MemoryStream(cipherStream.ToArray()))
{
crypto.Decrypt(cipherStream1, resultStream, keyPair.PrivateKey);
resultStream.ToArray().ShouldAllBeEquivalentTo(originalData);
}
}
}
}
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);
}