public void CanSignAndValidateData()
{
var rsa = new RsaManager();
byte[] signature = rsa.SignData(_data);
Assert.IsTrue(rsa.VerifyData(_data, signature));
}
static void Main(string[] args)
{
IPEndPoint point = new IPEndPoint(IPAddress.Parse(ip), port);
Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
TlsServerManager serverManager = new TlsServerManager();
RsaManager rsaManager = new RsaManager();
serverSocket.Bind(point);
try
{
Console.WriteLine("Server is listeting");
serverSocket.Listen(1);
using (var socketHandler = serverSocket.Accept())
{
Console.WriteLine("Connected!");
byte[] buffer = new byte[256];
StringBuilder builder = new StringBuilder();
string serverHello = serverManager.GetConnectMessage();
buffer = Encoding.Unicode.GetBytes(serverHello);
socketHandler.Send(buffer);
do
{
int bytes = socketHandler.Receive(buffer);
builder.Append(Encoding.Unicode.GetString(buffer, 0, bytes));
} while (socketHandler.Available > 0);
string clientHello = builder.ToString();
serverManager.SetClientPublicKey(serverManager.ParseConnectAnswer(clientHello));
string message;
bool isSuccess;
while (true)
{
Console.Write($"{DateTime.Now} You: ");
message = Console.ReadLine();
socketHandler.Send(SerializateMessage(message, serverManager, rsaManager));
while (socketHandler.Available == 0)
{
Thread.Sleep(100);
}
buffer = new byte[socketHandler.Available];
socketHandler.Receive(buffer);
string answer = DeserializateMessage(buffer, serverManager, rsaManager, out isSuccess);
if (isSuccess)
{
Console.WriteLine($"{DateTime.Now} Client: {answer}");
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void CanSignAndValidateData()
{
var rsa = new RsaManager();
byte[] signature = rsa.SignData(_data);
Assert.IsTrue(rsa.VerifyData(_data, signature));
}
public void RsaManager_EqualStrings_ReturnTrue()
{
string message = RandomString((new Random()).Next(10, 100));
RsaManager rsaManager1 = new RsaManager();
RsaManager rsaManager2 = new RsaManager();
var encryptMessage = rsaManager1.EncryptMessage(message, false, rsaManager2.PublicKey);
var result = rsaManager2.DecryptMessage(encryptMessage, false);
Assert.AreEqual(message, result);
}
public static void RsaManagerTests()
{
string data = "HelloWorld!!!";
Console.WriteLine("█ BER");
RsaKeyPair keyPair = RsaManager.CreateKeyPair(4096, RsaKeyEncoding.Ber);
Console.WriteLine("Public:\n" + keyPair.PublicKey);
Console.WriteLine("Private:\n" + keyPair.PrivateKey);
string encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey);
Console.WriteLine("Encrypted: " + encrypted);
Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey));
Console.WriteLine("█ XML");
keyPair = RsaManager.CreateKeyPair(4096, RsaKeyEncoding.Xml, false);
Console.WriteLine("Public:\n" + keyPair.PublicKey);
Console.WriteLine("Private:\n" + keyPair.PrivateKey);
encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey);
Console.WriteLine("Encrypted: " + encrypted);
Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey));
Console.WriteLine("█ XML INDENTED");
keyPair = RsaManager.CreateKeyPair(4096, RsaKeyEncoding.Xml);
Console.WriteLine("Public:\n" + keyPair.PublicKey);
Console.WriteLine("Private:\n" + keyPair.PrivateKey);
encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey);
Console.WriteLine("Encrypted: " + encrypted);
Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey));
Console.WriteLine("█ JSON");
keyPair = RsaManager.CreateKeyPair(4096, RsaKeyEncoding.Json, false);
Console.WriteLine("Public:\n" + keyPair.PublicKey);
Console.WriteLine("Private:\n" + keyPair.PrivateKey);
encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey);
Console.WriteLine("Encrypted: " + encrypted);
Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey));
Console.WriteLine("█ JSON INDENTED");
keyPair = RsaManager.CreateKeyPair(512, RsaKeyEncoding.Json);
Console.WriteLine("Public:\n" + keyPair.PublicKey);
Console.WriteLine("Private:\n" + keyPair.PrivateKey);
encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey);
Console.WriteLine("Encrypted: " + encrypted);
Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey));
Console.WriteLine("█ PEM");
keyPair = RsaManager.CreateKeyPair(4096, RsaKeyEncoding.Pem);
Console.WriteLine("Public:\n" + keyPair.PublicKey);
Console.WriteLine("Private:\n" + keyPair.PrivateKey);
encrypted = RsaManager.EncryptToBase64(data, keyPair.PublicKey);
Console.WriteLine("Encrypted: " + encrypted);
Console.WriteLine("Decrypted: " + RsaManager.DecryptFromBase64(encrypted, keyPair.PrivateKey));
}
/// <summary>
/// Returns a value indicating whether the package is valid or not. If it contains an invalid signature, it will be deleted directly.
/// </summary>
/// <returns>Returns 'true' if the package is valid, otherwise 'false'.</returns>
/// <exception cref="FileNotFoundException">The update package to check could not be found.</exception>
/// <exception cref="ArgumentException">The signature of the update package is null or empty.</exception>
public bool CheckPackageValidity()
{
if (!File.Exists(_updateFilePath))
{
throw new FileNotFoundException(_lp.PackageFileNotFoundExceptionText);
}
if (Signature == null || Signature.Length <= 0)
{
throw new ArgumentException("Signature");
}
byte[] data;
using (var reader =
new BinaryReader(File.Open(_updateFilePath,
FileMode.Open)))
{
data = reader.ReadBytes((int)reader.BaseStream.Length);
}
RsaManager rsa;
try
{
rsa = new RsaManager(PublicKey);
}
catch
{
try
{
DeletePackage();
}
catch (Exception ex)
{
throw new PackageDeleteException(ex.Message);
}
return(false);
}
if (rsa.VerifyData(data, Signature))
{
return(true);
}
try
{
DeletePackage();
}
catch (Exception ex)
{
throw new PackageDeleteException(ex.Message);
}
return(false);
}
public void RsaManager_EqualHash_ReturnTrue()
{
string message = RandomString((new Random()).Next(10, 1000));
SHA1Managed managed = new SHA1Managed();
var hashSum = managed.ComputeHash(Encoding.Unicode.GetBytes(message));
RsaManager manager1 = new RsaManager();
RsaManager manager2 = new RsaManager();
var digitalSignature = manager1.GetDigitalSignature(hashSum);
Assert.IsTrue(manager2.IsValidDigitalSignature(hashSum, digitalSignature, manager1.PublicKey));
}
public void CanSignAndValidateDataWithSaving()
{
var rsa = new RsaManager();
byte[] signature = rsa.SignData(_data);
File.WriteAllBytes(_signatureFile, signature);
File.WriteAllText(_keyFile, rsa.PublicKey);
var givenRsa = new RsaManager(File.ReadAllText(_keyFile));
byte[] givenSignature = File.ReadAllBytes(_signatureFile);
Assert.IsTrue(givenRsa.VerifyData(_data, givenSignature));
}
static void Main(string[] args)
{
IPEndPoint point = new IPEndPoint(IPAddress.Parse(ip), port);
Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
TlsClientManager clientManager = new TlsClientManager();
RsaManager rsaManager = new RsaManager();
try
{
clientSocket.Connect(point);
StringBuilder builder = new StringBuilder();
byte[] buffer = new byte[256];
do
{
int bytes = clientSocket.Receive(buffer);
builder.Append(Encoding.Unicode.GetString(buffer, 0, bytes));
} while (clientSocket.Available > 0);
clientManager.ParseSetConnectMessage(builder.ToString());
builder.Clear();
clientSocket.Send(Encoding.Unicode.GetBytes(clientManager.GetConnectAnswer()));
while (true)
{
while (clientSocket.Available == 0)
{
Thread.Sleep(100);
}
buffer = new byte[clientSocket.Available];
clientSocket.Receive(buffer);
bool isSuccess;
string message = DeserializateMessage(buffer, clientManager, rsaManager, out isSuccess);
if (isSuccess)
{
Console.WriteLine($"{DateTime.Now} Server: {message}");
}
Console.Write($"{DateTime.Now} You: ");
string answer = Console.ReadLine();
clientSocket.Send(SerializateMessage(answer, clientManager, rsaManager));
}
}
catch (Exception e)
{
Console.WriteLine(e);
Console.ReadKey();
}
}
public void CanSignAndValidateDataWithSaving()
{
var rsa = new RsaManager();
byte[] signature = rsa.SignData(_data);
File.WriteAllBytes(_signatureFile, signature);
File.WriteAllText(_keyFile, rsa.PublicKey);
var givenRsa = new RsaManager(File.ReadAllText(_keyFile));
byte[] givenSignature = File.ReadAllBytes(_signatureFile);
Assert.IsTrue(givenRsa.VerifyData(_data, givenSignature));
}
/// <summary>
/// Provides a new thread that generates a new RSA-key pair.
/// </summary>
private void GenerateKeyPair()
{
var rsa = new RsaManager();
PrivateKey = rsa.PrivateKey;
PublicKey = rsa.PublicKey;
Invoke(new Action(() =>
{
controlPanel1.Visible = true;
informationCategoriesTabControl.SelectedTab = generalTabPage;
_sender = generalTabPage;
}));
_allowCancel = true;
}
public void TestSerialization()
{
string message = RandomString((new Random()).Next(10, 1000));
TlsServerManager serverManager = new TlsServerManager();
string connectMessage = serverManager.GetConnectMessage();
TlsClientManager clientManager = new TlsClientManager();
clientManager.ParseSetConnectMessage(connectMessage);
var answer = serverManager.ParseConnectAnswer(clientManager.GetConnectAnswer());
clientManager.ClearData();
serverManager.SetClientPublicKey(answer);
RsaManager rsaManager = new RsaManager();
byte[] resultSerialize = Server.Program.SerializateMessage(message, serverManager, rsaManager);
bool isSuccess;
string resultString = Server.Program.DeserializateMessage(resultSerialize, serverManager, rsaManager, out isSuccess);
Assert.AreEqual(message, resultString);
}
private async void GenerateKeyPair()
{
await Task.Factory.StartNew(() =>
{
var rsa = new RsaManager();
PrivateKey = rsa.PrivateKey;
PublicKey = rsa.PublicKey;
Invoke(new Action(() =>
{
controlPanel1.Visible = true;
informationCategoriesTabControl.SelectedTab = generalTabPage;
_sender = generalTabPage;
}));
_allowCancel = true;
});
}
public void GeneratePublicPrivateKey()
{
rsa = new RsaManager();
}
/// <summary>
/// Returns a value indicating whether the signature of each package is valid, or not. If a package contains an invalid
/// signature, it will be deleted directly.
/// </summary>
/// <returns>Returns <c>true</c> if the package is valid; otherwise <c>false</c>.</returns>
/// <exception cref="FileNotFoundException">The update package to check could not be found.</exception>
/// <exception cref="ArgumentException">The signature of the update package is null or empty.</exception>
public bool ValidatePackages()
{
foreach (var filePathItem in _packageFilePaths)
{
if (!File.Exists(filePathItem.Value))
{
throw new FileNotFoundException(String.Format(_lp.PackageFileNotFoundExceptionText,
filePathItem.Key.FullText));
}
var configuration =
_updateConfigurations.First(config => config.LiteralVersion == filePathItem.Key.ToString());
if (configuration.Signature == null || configuration.Signature.Length <= 0)
{
throw new ArgumentException(String.Format("Signature of version \"{0}\" is null or empty.",
configuration));
}
var stream = FileExtensions.WaitForFile(filePathItem.Value, FileMode.Open, FileAccess.Read,
FileShare.None);
try
{
RsaManager rsa;
try
{
rsa = new RsaManager(_publicKey);
}
catch
{
try
{
DeletePackages();
_packageFilePaths.Clear();
_packageOperations.Clear();
}
catch (Exception ex)
{
throw new PackageDeleteException(ex.Message);
}
return(false);
}
if (rsa.VerifyData(stream, Convert.FromBase64String(configuration.Signature)))
{
continue;
}
try
{
DeletePackages();
}
catch (Exception ex)
{
throw new PackageDeleteException(ex.Message);
}
_packageFilePaths.Clear();
_packageOperations.Clear();
return(false);
}
finally
{
stream.Close();
}
}
return(true);
}
/// <summary>
/// Returns a value indicating whether the signature of each package is valid, or not. If a package contains an invalid
/// signature, it will be deleted directly.
/// </summary>
/// <returns>Returns <c>true</c> if the package is valid; otherwise <c>false</c>.</returns>
/// <exception cref="FileNotFoundException">The update package to check could not be found.</exception>
/// <exception cref="ArgumentException">The signature of the update package is null or empty.</exception>
public bool ValidatePackages()
{
foreach (var filePathItem in _packageFilePaths)
{
if (!File.Exists(filePathItem.Value))
throw new FileNotFoundException(String.Format(_lp.PackageFileNotFoundExceptionText,
filePathItem.Key.FullText));
var configuration =
_updateConfigurations.First(config => config.LiteralVersion == filePathItem.Key.ToString());
if (configuration.Signature == null || configuration.Signature.Length <= 0)
throw new ArgumentException(String.Format("Signature of version \"{0}\" is null or empty.",
configuration));
FileStream stream = File.Open(filePathItem.Value, FileMode.Open);
try
{
RsaManager rsa;
try
{
rsa = new RsaManager(_publicKey);
}
catch
{
try
{
DeletePackages();
_packageFilePaths.Clear();
_packageOperations.Clear();
}
catch (Exception ex)
{
throw new PackageDeleteException(ex.Message);
}
return false;
}
if (rsa.VerifyData(stream, Convert.FromBase64String(configuration.Signature)))
continue;
try
{
DeletePackages();
}
catch (Exception ex)
{
throw new PackageDeleteException(ex.Message);
}
_packageFilePaths.Clear();
_packageOperations.Clear();
return false;
}
finally
{
stream.Close();
}
}
return true;
}
public static string DeserializateMessage(byte[] message, TlsManager tlsManager, RsaManager rsaManager, out bool isAllSuccess)
{
isAllSuccess = false;
byte[] IV = new byte[16],
hashSum,
digitalSignature = new byte[256],
messageBytes;
for (int i = 0; i < IV.Length; i++)
{
IV[i] = message[i];
}
hashSum = new byte[message[16]];
for (int i = IV.Length + 1, j = 0; j < hashSum.Length; i++, j++)
{
hashSum[j] = message[i];
}
for (int i = IV.Length + 1 + hashSum.Length, j = 0; j < digitalSignature.Length; i++, j++)
{
digitalSignature[j] = message[i];
}
messageBytes = new byte[message.Length - IV.Length - 1 - hashSum.Length - digitalSignature.Length];
for (int i = IV.Length + 1 + hashSum.Length + digitalSignature.Length, j = 0;
j < messageBytes.Length;
i++, j++)
{
messageBytes[j] = message[i];
}
bool isSuccess;
string decryptMessage = tlsManager.DecryptMessage(messageBytes, IV, hashSum, out isSuccess);
string rsaNotParsedKey = decryptMessage.Substring(decryptMessage.IndexOf("|rsaKeyStart|"),
decryptMessage.LastIndexOf("|rsaKeyEnd|") + "|rsaKeyEnd|".Length);
string rsaKey = rsaNotParsedKey.Replace("|rsaKeyStart|", "");
rsaKey = rsaKey.Replace("|rsaKeyEnd|", "");
bool isValidDigitalSignature = rsaManager.IsValidDigitalSignature(hashSum, digitalSignature, rsaKey);
decryptMessage = decryptMessage.Replace(rsaNotParsedKey, "");
if ((isSuccess == true) & (isValidDigitalSignature == true))
{
isAllSuccess = true;
}
return(decryptMessage);
}
public static byte[] SerializateMessage(string message, TlsManager tlsManager, RsaManager rsaManager)
{
byte[] IV,
hashSum,
digitalSignature,
hashSumCount,
messageBytes;
string publicRSAKey = rsaManager.PublicKey;
message = $"|rsaKeyStart|{publicRSAKey}|rsaKeyEnd|{message}";
messageBytes = tlsManager.EncryptMessage(message, out IV, out hashSum);
hashSumCount = new byte[] { (byte)hashSum.Length };
digitalSignature = rsaManager.GetDigitalSignature(hashSum);
return(IV.Concat(hashSumCount.Concat(hashSum.Concat(digitalSignature.Concat(messageBytes)))).ToArray());
}
public MasterCommunicator()
{
rsa = new RsaManager();
tdes = new TdesManager();
}
