public void Encrypt_To_File_Using_Main_Using_Manually_Filename()
{
const string encryptedOutputFile = "manually.enc";
var merchantPublicKeyFileName = @"Certificates\merchant.crt";
var mobilePayPublicKeyFileName = @"Certificates\mobilepay.crt";
var merchantSubscriptionKey = Guid.NewGuid().ToString();
string[] args = new[] { merchantSubscriptionKey, merchantPublicKeyFileName, mobilePayPublicKeyFileName, encryptedOutputFile };
Program.Main(args);
var csp = new RSACryptoServiceProvider();
var streamReader = File.OpenText(@"Certificates\mobilepay.pvk");
var pr = new PemReader(streamReader);
var privateKey = (RsaPrivateCrtKeyParameters)pr.ReadObject();
var rsa = DotNetUtilities.ToRSAParameters(privateKey);
csp.ImportParameters(rsa);
var encryptedFile = File.ReadAllBytes(encryptedOutputFile);
var decrypted = Encoding.UTF8.GetString(RSAEncryptionService.Decrypt(csp, encryptedFile));
var decryptedSplits = decrypted.Split(';');
var decryptedMerchantPublicKey = decryptedSplits[0];
var decryptedMerchantSubscriptionKey = decryptedSplits[1];
var merchantPublicKey = File.ReadAllText(merchantPublicKeyFileName);
Assert.Equal(merchantSubscriptionKey, decryptedMerchantSubscriptionKey);
Assert.Equal(Regex.Replace(merchantPublicKey, @"\r\n?|\n", ""), Regex.Replace(decryptedMerchantPublicKey, @"\r\n?|\n", ""));
}
private void Button_Click(object sender, RoutedEventArgs e)
{
try
{
RSAParameters rSAParameters = new RSAParameters
{
Modulus = Convert.FromBase64String(ModulusTextBox.Text),
Exponent = Convert.FromBase64String(ExponentTextBox.Text),
D = Convert.FromBase64String(DTextBox.Text),
DP = Convert.FromBase64String(DPTextBox.Text),
DQ = Convert.FromBase64String(DQTextBox.Text),
InverseQ = Convert.FromBase64String(InverseQTextBox.Text),
P = Convert.FromBase64String(PTextBox.Text),
Q = Convert.FromBase64String(QTextBox.Text)
};
encryptionService = new RSAEncryptionService(rSAParameters);
MessageBox.Show("Your private key have been set.");
}
catch (FormatException)
{
MessageBox.Show("The Values provided did not uphold the Base64 encoding");
}
catch (CryptographicException)
{
MessageBox.Show("The private Key that was provided was not good try again");
}
}
public void TestEncryptDontReturnNull()
{
RSAEncryptionService service = new RSAEncryptionService();
string testString = "Hello world encrypt me";
Assert.NotNull(service.Encrypt(Encoding.UTF8.GetBytes(testString)));
}
public void TestGeneratedKeysAreNotEqual()
{
RSAParameters rSAParameters = RSAEncryptionService.GenerateKeys();
RSAParameters rSAParameters2 = RSAEncryptionService.GenerateKeys();
Assert.AreNotEqual(rSAParameters.Modulus, rSAParameters2.Modulus);
}
public void TestPrivateKeyReturnsFalseWhenPrivateKeyPresent()
{
RSAParameters privateAndPublicKey = RSAEncryptionService.GenerateKeys();
RSAEncryptionService baseLineService = new RSAEncryptionService(privateAndPublicKey);
Assert.True(baseLineService.PrivateKeyPresent());
}
public void TestEncryptedStringCanBeDecrypted()
{
RSAEncryptionService service = new RSAEncryptionService();
string testString = "Hello world encrypt me";
byte[] encrypted = service.Encrypt(Encoding.UTF8.GetBytes(testString));
Assert.AreEqual(testString, Encoding.UTF8.GetString(service.Decrypt(encrypted)));
}
private void InitializeFetcherDependencies(string phoneNumber)
{
MessagingContext fetcherMessagingContext = new DesignTimeDbContextFactory().CreateDbContext(new string[] { });
IMessageRepository fetcherMessageRepository = new EntityFrameworkMessageRepository(fetcherMessagingContext);
IContactRepository fetcherContactRepository = new EntityFrameworkContactRepository(phoneNumber, fetcherMessagingContext);
IKeySetRepository fetcherKeySetRepository = new EntityFrameworkKeySetRepository(phoneNumber, fetcherMessagingContext);
IEncryptionService fetcherEncryptionService = new RSAEncryptionService(fetcherKeySetRepository, Encoding);
FetcherMessageService = new MessageService(fetcherContactRepository, fetcherMessageRepository, fetcherEncryptionService, Encoding, phoneNumber);
}
public void ShouldSuccessfullyEncryptData()
{
// Arrange
const string testData = "This is a test";
var service = new RSAEncryptionService();
// Act
var cipherText = service.EncryptString(testData, _TestData.PublicKey);
// Assert
Assert.True(!string.IsNullOrWhiteSpace(cipherText));
}
public void ShouldReturnBase64EncodedString()
{
// Arrange
const string testData = "This is a test";
var service = new RSAEncryptionService();
var cipherText = service.EncryptString(testData, _TestData.PublicKey);
// Act
var bytes = Convert.FromBase64String(cipherText);
// Assert
Assert.True(bytes.Length > 0);
}
public void ShouldSuccessfullyDecryptData()
{
// Arrange
const string testData = "This is a test";
var service = new RSAEncryptionService();
var cipherText = service.EncryptString(testData, _TestData.PublicKey);
// Act
var plainText = service.DecryptString(cipherText, _TestData.PrivateKey);
// Assert
Assert.Equal(testData, plainText);
}
public void TestPrivateKeyReturnsFalseWhenPrivateKeyNotPresent()
{
RSAParameters privateAndPublicKey = RSAEncryptionService.GenerateKeys();
RSAParameters publicKey = new RSAParameters
{
Modulus = privateAndPublicKey.Modulus,
Exponent = privateAndPublicKey.Exponent
};
RSAEncryptionService baseLineService = new RSAEncryptionService(publicKey);
Assert.False(baseLineService.PrivateKeyPresent());
}
private void GenerateKeyPair_Click(object sender, RoutedEventArgs e)
{
encryptionService = new RSAEncryptionService();
MessageBox.Show("Created a new Encryption Service");
ModulusTextBox.Text = Convert.ToBase64String(encryptionService.PublicKey.Modulus);
ExponentTextBox.Text = Convert.ToBase64String(encryptionService.PublicKey.Exponent);
DTextBox.Text = Convert.ToBase64String(encryptionService.PrivateKey.D);
DPTextBox.Text = Convert.ToBase64String(encryptionService.PrivateKey.DP);
DQTextBox.Text = Convert.ToBase64String(encryptionService.PrivateKey.DQ);
InverseQTextBox.Text = Convert.ToBase64String(encryptionService.PrivateKey.InverseQ);
PTextBox.Text = Convert.ToBase64String(encryptionService.PrivateKey.P);
QTextBox.Text = Convert.ToBase64String(encryptionService.PrivateKey.Q);
}
public static void ToFile(
string merchantSubscriptionKey,
string merchantPublicKeyFileName,
string mobilePayPublicKeyFileName,
string encryptedOutputFile = "merchant.enc")
{
if (string.IsNullOrWhiteSpace(merchantSubscriptionKey))
{
throw new ArgumentException("Argument 1, your merchant subscription key, is not valid");
}
string merchantPublicKeyCrt;
try
{
var x509Certificate2 = new X509Certificate2(merchantPublicKeyFileName);
merchantPublicKeyCrt = ExportToPem(x509Certificate2);
}
catch (Exception e)
{
throw new ArgumentException(
"Argument 2, your merchant public key file path, is not pointing to a valid X509Certificate file", e);
}
X509Certificate2 mobilePayPublicKeyCrt;
try
{
mobilePayPublicKeyCrt = new X509Certificate2(mobilePayPublicKeyFileName);
}
catch (Exception e)
{
throw new ArgumentException(
"Argument 3, MobilePay's public key file path, is not pointing to a valid X509Certificate file", e);
}
var encryptedBytes = RSAEncryptionService.Encrypt(
mobilePayPublicKeyCrt.PublicKey.Key as RSACryptoServiceProvider,
Encoding.UTF8.GetBytes(merchantPublicKeyCrt + ';' + merchantSubscriptionKey));
using (var outputFileStream = new FileStream(encryptedOutputFile, FileMode.Create, FileAccess.ReadWrite))
{
outputFileStream.Write(encryptedBytes, 0, encryptedBytes.Length);
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
try
{
RSAParameters rSAParameters = new RSAParameters
{
Modulus = Convert.FromBase64String(ModulusTextBox.Text),
Exponent = Convert.FromBase64String(ExponentTextBox.Text)
};
encryptionService = new RSAEncryptionService(rSAParameters);
MessageBox.Show("The Public key have been set, you can now encrypt messages");
}
catch (CryptographicException)
{
MessageBox.Show("There is something wrong with the provided values");
}
}
public void TestDecryptingWithOnlyPublicKeyThrowsException()
{
RSAParameters privateAndPublicKey = RSAEncryptionService.GenerateKeys();
RSAEncryptionService baseLineService = new RSAEncryptionService(privateAndPublicKey);
string textToEncrypt = "Testing this encrypts";
byte[] baselineEncrypted = baseLineService.Encrypt(Encoding.UTF8.GetBytes(textToEncrypt));
RSAParameters publicKey = new RSAParameters
{
Modulus = privateAndPublicKey.Modulus,
Exponent = privateAndPublicKey.Exponent
};
RSAEncryptionService encryptionService = new RSAEncryptionService(publicKey);
Assert.Throws <PrivateKeyNotPresentException>(() => encryptionService.Decrypt(baselineEncrypted));
}
public void TestCreatingRSAKeyCanBeSetInConstructor()
{
RSAParameters rSAParameters = RSAEncryptionService.GenerateKeys();
RSAEncryptionService service = new RSAEncryptionService(rSAParameters);
//Check Public key
Assert.AreEqual(rSAParameters.Modulus, service.PublicKey.Modulus);
Assert.AreEqual(rSAParameters.Exponent, service.PublicKey.Exponent);
//Check Private Key
Assert.AreEqual(rSAParameters.Modulus, service.PrivateKey.Modulus);
Assert.AreEqual(rSAParameters.Exponent, service.PrivateKey.Exponent);
Assert.AreEqual(rSAParameters.P, service.PrivateKey.P);
Assert.AreEqual(rSAParameters.Q, service.PrivateKey.Q);
Assert.AreEqual(rSAParameters.DP, service.PrivateKey.DP);
Assert.AreEqual(rSAParameters.DQ, service.PrivateKey.DQ);
Assert.AreEqual(rSAParameters.D, service.PrivateKey.D);
Assert.AreEqual(rSAParameters.InverseQ, service.PrivateKey.InverseQ);
}
public void TestEncryptWorksWhenOnlyPublicKeyIsPresent()
{
RSAParameters privateAndPublicKey = RSAEncryptionService.GenerateKeys();
RSAEncryptionService baseLineService = new RSAEncryptionService(privateAndPublicKey);
string textToEncrypt = "Testing this encrypts";
byte[] baselineEncrypted = baseLineService.Encrypt(Encoding.UTF8.GetBytes(textToEncrypt));
RSAParameters publicKey = new RSAParameters
{
Modulus = privateAndPublicKey.Modulus,
Exponent = privateAndPublicKey.Exponent
};
RSAEncryptionService encryptionService = new RSAEncryptionService(publicKey);
byte[] encryptedTest = encryptionService.Encrypt(Encoding.UTF8.GetBytes(textToEncrypt));
//Assert That the encrypted text comes back as equals
Assert.AreEqual(baseLineService.Decrypt(baselineEncrypted), baseLineService.Decrypt(encryptedTest));
}
public RSAEncryptionServiceTests()
{
this._keySetRepository = A.Fake <IKeySetRepository>();
this._encoding = Encoding.UTF8;
this._rsaEncryptionService = new RSAEncryptionService(this._keySetRepository, this._encoding);
}
public void TestGetPrivateKeyDontReturnNull()
{
RSAEncryptionService service = new RSAEncryptionService();
Assert.NotNull(service.PrivateKey);
}
static HardwareInfoHelper()
{
RSAEncryptionService = new RSAEncryptionService();
}
