public void PassRSAParameter_ExportEncryptedParameterWithPrivateKey_Pass()
{
string plainString = "Encrypt me via RSA";
byte[] salt = {
1,2,3,4,5,6,7,8,9
};
string passwd = "SafeP4ssw0rd;,,:;DWAe";
string encryptedKey = "";
string encryptedString;
string decryptedString;
byte[] IV;
using (var cipher = new RSACipher<RSACryptoServiceProvider>(new RSACryptoServiceProvider(2048)))
{
encryptedString = cipher.EncryptToString(plainString);
encryptedKey = cipher.ToEncryptedXmlString<AesManaged>(true, passwd, salt, out IV);
}
using (var cipher = new RSACipher<RSACryptoServiceProvider>(encryptedKey, passwd, salt, IV))
{
decryptedString = cipher.DecryptToString(encryptedString);
}
Assert.AreEqual(plainString, decryptedString);
}
public void TestSendDecryptResponse()
{
String methodName = "methodOne";
String arg0 = "arg0";
String arg1 = "arg1";
TestWebServiceProxy testProxy = new TestWebServiceProxy();
ITransportProxy proxy = testProxy;
FolaighKeyStore keyStore = new FolaighKeyStore(KEYSTORE, "bird8top".ToCharArray());
RSACipher encryptorVerifier = new RSACipher(
keyStore,
"countyKey",
false);
RSACipher signerDecryptor = new RSACipher(
keyStore,
"stateKey",
true);
SecureTransport transport = new SecureTransport(proxy, encryptorVerifier,
signerDecryptor);
String response = transport.send(methodName, new String[] { arg0, arg1 });
Assert.AreEqual(TestWebServiceProxy.THIS_IS_THE_RESPONSE, response);
}
public void TestRSACipher()
{
FolaighKeyStore keyStore = new FolaighKeyStore(KEYSTORE, "bird8top".ToCharArray());
RSACipher cipher = new RSACipher(
keyStore,
"countyKey",
false);
string cleartext = "This is some cleartext to encrypt with RSA.";
byte[] encryptedText = cipher.encrypt(UTF8Encoding.UTF8.GetBytes(cleartext));
Assert.IsNotNull(encryptedText);
Assert.IsTrue(encryptedText.Length >= cleartext.Length);
cipher = new RSACipher(
keyStore,
"countyKey",
true);
byte[] decryptedBytes = cipher.decrypt(encryptedText);
Assert.IsNotNull(decryptedBytes);
Assert.IsTrue(decryptedBytes.Length >= cleartext.Length);
string decryptedText = UTF8Encoding.UTF8.GetString(decryptedBytes);
Assert.AreEqual(cleartext, decryptedText);
}
public void TestKeyPairGeneration()
{
var keys = RSACipher.GenerateKeys();
Assert.IsNotNull(keys);
Assert.IsNotNull(keys.PrivateKey);
Assert.IsNotNull(keys.PublicKey);
Assert.AreNotEqual(keys.PrivateKey, "");
Assert.AreNotEqual(keys.PublicKey, "");
}
public void EncodeDecode_IntArray_OriginalMessageInEnglishAndDecodedMessageShouldMatch(int[] message)
{
RSACipher cipher = new RSACipher(new EnglishAlphabet());
int[] encdodedMessage = cipher.Encode(message);
int[] decodedMessage = cipher.Decode(encdodedMessage);
Assert.Equal(message, decodedMessage);
}
public void EncodeDecode_CharArray_OriginalMessageInUkrainianAndDecodedMessageShouldMatch(string message)
{
RSACipher cipher = new RSACipher(new UkrainianAlphabet());
BigInteger[] encdodedMessage = cipher.Encode(message.ToCharArray());
char[] decodedMessage = cipher.Decode(encdodedMessage);
Assert.Equal(message, new string(decodedMessage));
}
public void TestEncryption()
{
var keys = RSACipher.GenerateKeys();
var text = "test of encryption";
var encryptedText = RSACipher.EncryptString(keys, text);
var decryptedText = RSACipher.DecryptString(keys, encryptedText);
Assert.IsFalse(string.IsNullOrWhiteSpace(encryptedText));
Assert.IsFalse(string.IsNullOrWhiteSpace(decryptedText));
Assert.AreEqual(text, decryptedText);
}
public RSATests()
{
var rsaSettings = new RSASettings()
{
PrimeNumberCountBitsMax = 16,
PrimeNumberCountBitsMin = 0
};
var residueNumberSystem = new ResidueNumberSystem();
_rsaCipher = new RSACipher(residueNumberSystem, Options.Create(rsaSettings));
}
public void TestKeyLoadingAndEncrypting()
{
var privateKey = @"
-----BEGIN RSA PRIVATE KEY-----
MIIEowIBAAKCAQEA3BGLEjYSMZGI9EELAbq9/teH/EPA5aa+XTfOoe6PBRDmPIvl
vCuy+u37DLDqry1zf5spaDSLYVMhiiLDcisLAb0n1TDOHTdSPMTWq7k9ACe0lPOT
d0uPaFwWRBtKXdj/ZmzfEqkwMyUFGTQXeol6c4R3ddnp6fnkZKm1neI+cQ2emvrU
FFbH1NsrC8Kb0F1ysBvePGIvpsf2xc42+pl6tkyhGdnu41Tg78qeYBJWJuxSgcqV
/uq9RB5vwfAKefpQK25eyUXX1cFGOOOJk4ZKepVkKXYwrkjlg6YUczTeOd4ai0Z5
x28d8o3pDv44gd7g1nHmeHiMDePQSzW8kHWbtwIDAQABAoIBAGAS3Jb3uhufwJ15
o9d+ciHGcFyGK7lWgTbq/S+emRuKFCmMnZ/3p+x6ZqZUui/99LVZxMr0XYEArNzE
bnTyK5z3umMNKn6Av0s+V8WiWeoua1y3tcJX32SdBy92hpHQATfzAbQA3sUFPWOS
ZUmeqTGzO//cQY1fBgGYQWyK792kV+ZcgrfPprohuX4vMkZgiq9X8bSQZeyllnFl
Ve5a3lBfehENN5T9oAO5Z79zskKczsuC8ENF8sue8y2hGVWcP1wxynl16N7a/Q7c
7ZBeeaEyzgbwaBD+uOqgRJ95+9aVSp0vv95lO4hevNvHzNjBcjnxZA1yul54qzpF
9s61RGkCgYEA+7zIa1HQv/B3YD1uDhuaUj3kKVr0gvFmUZ38OBWJWuvAO4Fp/Plh
PNBpVdzBF+gxld0xjieEPYD86MYWNUZbXb/EL9tkWs5MRCuNPtHabXXc1KD6lO6h
M/6goD5zIisq9DksfylpUNlVDJttkVDh5veYCOXcET/Z8iIHbJ8ZM4MCgYEA38t7
2bh0RiI2t6+NpOSmxW6fvW4Q5HzNFlM1j83WN933c3ftly7rA/vvTe1zLM/1G4Cs
7qAKJnN5AoSqkmbCnMUmANZ9A0Njr6w83jgqBk49UsEbvmGZhW5/n1Fkg/7ezaVI
vRnmwOykiNu1lUzUnRJGv74pRZ5UXkg8gKEy3L0CgYAPRrh+0rsxOp1z6KZqEsC9
puXWoJ9f5thHsaehm6T3MIE82zCcWmHNN/R8cmYBVmTT7FVahAlhVheC5KpqVzeq
K73zDYQ8gnJcXKw4mLGBnPpmqNIsAYMkzZnfv4prE2WK5oFNwiyS7G1d03zFqbvb
sUC3oYNGRLKsH+aFb+4ukwKBgCj/eBLsrbBjeC6yZHp+wOaOW4kybrnM+y1J1Rgh
F0toyHpI0CfQGpHCR5a5F05wUnDVY9jbTMC6isKhVzY2yRQ7MbkZkhFU+SAnp4b2
NwysrKNKaTC5ZIyDL7IaERX1TQ/TZb3uzs0tDP9dcKiHSLP1syxRQ/JTDRWwmhTe
cxjpAoGBAITD5UmUoKA9Ve/yGhtd7fAlOoXs+zNuRhzEUnaSAORh/mV57hZQhdDA
HsCuVMNxscvownXuSm73Jl3cTO4SpgyDwo9KUGDBvKf+21WaHQ0d+c06TGqi36Yt
1BNpV0hZC1+jws+de01q6iBK9RZ2iQVRMPL+xFpqNHj8PAtPl8A6
-----END RSA PRIVATE KEY-----
";
var publicKey = @"
-----BEGIN PUBLIC KEY-----
MIIBKwIBAAKCAQEA3BGLEjYSMZGI9EELAbq9/teH/EPA5aa+XTfOoe6PBRDmPIvl
vCuy+u37DLDqry1zf5spaDSLYVMhiiLDcisLAb0n1TDOHTdSPMTWq7k9ACe0lPOT
d0uPaFwWRBtKXdj/ZmzfEqkwMyUFGTQXeol6c4R3ddnp6fnkZKm1neI+cQ2emvrU
FFbH1NsrC8Kb0F1ysBvePGIvpsf2xc42+pl6tkyhGdnu41Tg78qeYBJWJuxSgcqV
/uq9RB5vwfAKefpQK25eyUXX1cFGOOOJk4ZKepVkKXYwrkjlg6YUczTeOd4ai0Z5
x28d8o3pDv44gd7g1nHmeHiMDePQSzW8kHWbtwIDAQABAgMBAAECAwEAAQIDAQAB
AgMBAAECAwEAAQIDAQAB
-----END PUBLIC KEY-----
";
var keys = new RSAKeyPair(privateKey, publicKey);
var text = "test of encryption";
var encryptedText = RSACipher.EncryptString(keys, text);
var decryptedText = RSACipher.DecryptString(keys, encryptedText);
Assert.IsFalse(string.IsNullOrWhiteSpace(encryptedText));
Assert.IsFalse(string.IsNullOrWhiteSpace(decryptedText));
Assert.AreEqual(text, decryptedText);
}
public void TestReceiveResponse()
{
TestWebServiceProxy testProxy = new TestWebServiceProxy();
ITransportProxy proxy = testProxy;
FolaighKeyStore keyStore = new FolaighKeyStore(KEYSTORE, "bird8top".ToCharArray());
RSACipher encryptorVerifier = new RSACipher(
keyStore,
"stateKey",
false);
RSACipher signerDecryptor = new RSACipher(
keyStore,
"countyKey",
true);
SecureTransport transport = new SecureTransport(proxy, encryptorVerifier, signerDecryptor);
String sender = "stateKey";
string result = transport.receive(encryptedMessage, signature,
encryptedAesKey, encryptedIV, sender);
// The result should be an XML document with an encrypted AES key
// and
// IV,
// an AES-encrypted response string, and a signed hash of the
// encrypted
// response string.
ResponseInfo objResponseInfo = ResponseInfo.decode(result);
encryptorVerifier = new RSACipher(
keyStore,
"countyKey",
false);
signerDecryptor = new RSACipher(
keyStore,
"stateKey",
true);
byte[] sig = Convert.FromBase64String(objResponseInfo.Signature);
byte[] hash = encryptorVerifier.decrypt(sig);
byte[] encryptedResponse = Convert.FromBase64String(objResponseInfo.Response);
byte[] expectedHash = Hash.getHash(encryptedResponse);
Assert.AreEqual(hash, expectedHash);
byte[] key = signerDecryptor.decrypt(Convert.FromBase64String(objResponseInfo.Key));
byte[] iv = signerDecryptor.decrypt(Convert.FromBase64String(objResponseInfo.IV));
AESCipher cipher = new AESCipher(key, iv);
Assert.AreEqual(TestWebServiceProxy.THIS_IS_THE_RESPONSE, cipher
.decrypt(encryptedResponse));
}
public void RSACipher_EncryptDecrypt_Pass()
{
string plainString = "Encrypt me via RSA";
string encryptedString;
string decryptedString;
using(var cipher = new RSACipher<RSACryptoServiceProvider>())
{
encryptedString = cipher.EncryptToString(plainString);
decryptedString = cipher.DecryptToString(encryptedString);
}
Assert.AreEqual(plainString, decryptedString);
}
static void Main(string[] args)
{
RSACipher rsa = new RSACipher();
(var publicKey, var privateKey) = rsa.GenerateRSAPair();
BigInteger secretText = BigInteger.Parse("13483148314831849481394811231232121");
if (secretText > publicKey.N)
{
throw new Exception("Too big");
}
var crypt = rsa.EncryptRSA(secretText, publicKey);
var decrypt = rsa.DecryptRSA(crypt, privateKey);
Console.WriteLine("text: {0}\n crypted: {1}\n decrypted: {2}", secretText, crypt, decrypt);
}
public void EncryptDecrypt_ShouldRoundTrip()
{
var input = new byte[] { 0, 1, 5, 30, 244, 255, 193 };
var rsa = new RSACipher(new DefaultRandomGenerator());
rsa.Init(new RSAPrivateKeyParameter(Key));
var encryptOutput = new byte[rsa.KeySize];
var decryptOutput = new byte[input.Length];
rsa.Encrypt(input, 0, encryptOutput, 0, input.Length);
rsa.Decrypt(encryptOutput, 0, decryptOutput, 0, encryptOutput.Length);
Assert.Equal(input, decryptOutput);
}
public void PassRSAParameter_ExportParameterWithoutPrivateKey_DecryptionWithPublicKeyFails()
{
string plainString = "Encrypt me via RSA";
string plainkey = "";
string encryptedString;
string decryptedString;
using (var cipher = new RSACipher<RSACryptoServiceProvider>())
{
encryptedString = cipher.EncryptToString(plainString);
plainkey = cipher.ToXmlString(false);
}
using (var cipher = new RSACipher<RSACryptoServiceProvider>(plainkey))
{
decryptedString = cipher.DecryptToString(encryptedString);
}
Assert.AreEqual(plainString, decryptedString);
}
public void TestReceiveCall()
{
TestWebServiceProxy testProxy = new TestWebServiceProxy();
ITransportProxy proxy = testProxy;
// This establishes the signature of the proxy's "receive"
// method. We need to know if the signature was verified
// and whether it came from an authorized sender.
MethodInfo methodInfo = new MethodInfo();
bool validSignature = true;
String sender = "sender";
String reply = proxy.receive(validSignature, methodInfo, sender);
FolaighKeyStore keyStore = new FolaighKeyStore(KEYSTORE, "bird8top".ToCharArray());
RSACipher encryptorVerifier = new RSACipher(
keyStore,
"stateKey",
false);
RSACipher signerDecryptor = new RSACipher(
keyStore,
"countyKey",
true);
SecureTransport transport = new SecureTransport(proxy, encryptorVerifier,
signerDecryptor);
testProxy.m_validSignature = false;
testProxy.m_message = null;
sender = "stateKey";
String result = transport.receive(encryptedMessage, signature,
encryptedAesKey, encryptedIV, sender);
Assert.IsTrue(testProxy.m_validSignature);
Assert.IsNotNull(testProxy.m_methodInfo);
Assert.AreEqual(expectedMethodInfo.MethodName, testProxy.m_methodInfo.MethodName);
Assert.AreEqual(sender, testProxy.m_senderAlias);
}
private byte[] ReadMessage(byte[] body)
{
if (_certificateConfig.Certificate is null)
{
throw new InvalidOperationException("Certificate is not initialized");
}
var length = EndianBitConverter.Big.ToUInt16(body, 0);
SecurityAssert.Assert(body.Length == length + 2);
var key = (RSAPrivateKey)_certificateManager.GetPrivateKey(_certificateConfig.Certificate.SubjectPublicKey);
var rsa = new RSACipher(_random);
rsa.Init(new RSAPrivateKeyParameter(key));
var preMasterSecret = new byte[48];
rsa.Decrypt(body, 2, preMasterSecret, 0, length);
SecurityAssert.Assert(preMasterSecret[0] == _versionConfig.Version.Major);
SecurityAssert.Assert(preMasterSecret[1] == _versionConfig.Version.Minor);
return(preMasterSecret);
}
public void TestSecureTransport()
{
String methodName = "methodOne";
String arg0 = "arg0";
String arg1 = "arg1";
TestWebServiceProxy testProxy = new TestWebServiceProxy();
ITransportProxy proxy = testProxy;
FolaighKeyStore keyStore = new FolaighKeyStore(KEYSTORE, "bird8top".ToCharArray());
RSACipher encryptorVerifier = new RSACipher(
keyStore,
"countyKey",
false);
RSACipher signerDecryptor = new RSACipher(
keyStore,
"stateKey",
true);
SecureTransport transport = new SecureTransport(
proxy,
encryptorVerifier,
signerDecryptor);
// Test for the proxy method
String message = "message";
String signature = "signature";
String aesKey = "key";
String iv = "iv";
String senderAlias = "alias";
String retval = proxy.send(message, signature, aesKey, iv, senderAlias);
String returnVal = transport.send(methodName, new String[] { arg0, arg1 });
// First, just check to see if something got to the proxy.
Assert.IsNotNull(returnVal);
Assert.IsNotNull(testProxy.m_aesKey);
Assert.IsNotNull(testProxy.m_iv);
Assert.IsNotNull(testProxy.m_message);
Assert.IsNotNull(testProxy.m_senderAlias);
Assert.IsNotNull(testProxy.m_signature);
Console.WriteLine("Encrypted AES Key:" + testProxy.m_aesKey);
Console.WriteLine("Encrypted IV:" + testProxy.m_iv);
Console.WriteLine("Encrypted Message:" + testProxy.m_message);
Console.WriteLine("Sender Alias:" + testProxy.m_senderAlias);
Console.WriteLine("Signature:" + testProxy.m_signature);
// Decrypt the AES Key
RSACipher testDecryptor = new RSACipher(
keyStore,
"countyKey",
true);
byte[] testKey = testDecryptor.decrypt(Convert.FromBase64String(testProxy.m_aesKey));
byte[] testIV = testDecryptor.decrypt(Convert.FromBase64String(testProxy.m_iv));
Console.WriteLine("Decrypted Key:" + Convert.ToBase64String(testKey));
Console.WriteLine("Decrypted IV:" + Convert.ToBase64String(testIV));
AESCipher cipher = new AESCipher(testKey, testIV);
// Independently encrypt the message and make sure they're the same
MethodInfo mInfo = new MethodInfo(methodName, new String[] { arg0, arg1 });
String xml = mInfo.encode();
String testEncryptedMessage = Convert.ToBase64String(cipher.encrypt(xml));
Assert.AreEqual(xml, cipher.decrypt(Convert.FromBase64String(testEncryptedMessage)));
Assert.AreEqual(testEncryptedMessage, testProxy.m_message);
string decryptedMessage = cipher.decrypt(Convert.FromBase64String(testProxy.m_message));
string expectedMessage = expectedMethodInfo.encode();
Assert.AreEqual(expectedMessage, decryptedMessage);
}
public void RSAParameterEncryption_ExportEncryptedParameterWithPrivateKey_Pass()
{
string plainKey = "soonAssigned";
byte[] salt = {
1,2,3,4,5,6,7,8,9
};
string passwd = "SafeP4ssw0rd;,,:;DWAe";
string encryptedKey = "";
string decryptedKey = "laterAssigned";
byte[] IV;
using (var cipher = new RSACipher<RSACryptoServiceProvider>())
{
plainKey = cipher.ToXmlString(true);
encryptedKey = cipher.ToEncryptedXmlString<AesManaged>(true, passwd, salt, out IV);
cipher.FromEncryptedXmlString<AesManaged>(encryptedKey, passwd, salt, IV);
decryptedKey = cipher.ToXmlString(true);
}
Assert.AreEqual(plainKey, decryptedKey);
}
public void SignData_CompareSignaturesOfRSACSPAndRSACipher_Pass()
{
int wantedKeySize = 4096;
Random rdm = new Random();
byte[] message = new byte[256];
byte[] signedMessage;
byte[] signedMessageNative;
string nativeXmlString;
rdm.NextBytes(message);
using(var rsacsp = new RSACryptoServiceProvider(wantedKeySize))
{
signedMessageNative = rsacsp.SignData(message, new SHA512Managed());
nativeXmlString = rsacsp.ToXmlString(true);
}
using (var cipher = new RSACipher<RSACryptoServiceProvider>(nativeXmlString))
{
signedMessage = cipher.SignData<SHA512Managed>(message);
}
CollectionAssert.AreEqual(signedMessage, signedMessageNative);
}
public void ChangeRSAKeySize_CreateInstance_Pass()
{
int wantedKeySize = 4096;
int current = 0;
using(var cipher = new RSACipher<RSACryptoServiceProvider>(wantedKeySize))
{
current = cipher.KeySize;
}
Assert.AreEqual(wantedKeySize, current);
}
public void SignHash_CompareSignaturesOfRSACSPAndRSACipher_Pass()
{
int wantedKeySize = 4096;
Random rdm = new Random();
byte[] message = new byte[256];
byte[] signedMessage;
byte[] signedMessageNative;
string nativeXmlString;
rdm.NextBytes(message);
using (var rsacsp = new RSACryptoServiceProvider(wantedKeySize))
{
byte[] native = new SHA1Cng().ComputeHash(message);
signedMessageNative = rsacsp.SignHash(native, "SHA1");
nativeXmlString = rsacsp.ToXmlString(true);
}
using (var cipher = new RSACipher<RSACryptoServiceProvider>(nativeXmlString))
{
//byte[] hash = new SHA1Managed().ComputeHash(message);
signedMessage = cipher.ComputeAndSignHash<SHA1Cng>(message);
}
CollectionAssert.AreEqual(signedMessage, signedMessageNative);
}
public void ComputeAndSignHash_VerifiesComputedSignature_Pass()
{
Random rdm = new Random();
byte[] message = new byte[256];
byte[] signedMessage;
string nativeXmlString;
bool isMessageNotTamperedWith = true;
rdm.NextBytes(message);
using (var rsacsp = new RSACipher<RSACryptoServiceProvider>())
{
signedMessage = rsacsp.ComputeAndSignHash<SHA384Cng>(message);
nativeXmlString = rsacsp.ToXmlString(true);
}
using (var cipher = new RSACipher<RSACryptoServiceProvider>(nativeXmlString))
{
isMessageNotTamperedWith = cipher.ComputeAndVerifyHash<SHA384Cng>(message, signedMessage);
}
Assert.IsTrue(isMessageNotTamperedWith);
}
private void button2_Click(object sender, EventArgs e)
{
byte[] decryptedtex = RSACipher.Decryption(encryptedtext, RSA1.ExportParameters(true), false);
listBox2.Text = ByteConverter.GetString(decryptedtex);
}
private void button1_Click(object sender, EventArgs e)
{
plaintext = ByteConverter.GetBytes(listBox1.Text);
encryptedtext = RSACipher.Encryption(plaintext, RSA1.ExportParameters(false), false);
listBox1.Text = ByteConverter.GetString(encryptedtext);
}
public void SignHash_VerifiesComputedSignature_Pass()
{
Random rdm = new Random();
byte[] message = new byte[256];
byte[] signedMessage;
string nativeXmlString;
bool isMessageNotTamperedWith = true;
rdm.NextBytes(message);
using (var rsacsp = new RSACipher<RSACryptoServiceProvider>())
{
byte[] firstHash = new SHA256Managed().ComputeHash(message);
signedMessage = rsacsp.SignHash(firstHash);
nativeXmlString = rsacsp.ToXmlString(true);
}
using (var cipher = new RSACipher<RSACryptoServiceProvider>(nativeXmlString))
{
byte[] n = new SHA256Managed().ComputeHash(message);
isMessageNotTamperedWith = cipher.VerifyHash(n, signedMessage);
}
Assert.IsTrue(isMessageNotTamperedWith);
}
