private IAlgorithm getSessionKeyAlg(bool encryption, string password)
{
var SKkey = Serpent.generateKeyFromBytes(computeHash(password));
var SKiv = Serpent.generateIV(true);
IAlgorithm sessionKeyAlg = new Serpent(SKkey, SKiv, encryption);
sessionKeyAlg.init(null, null, "ECB", 128);
return(sessionKeyAlg);
}
public IAlgorithm encryptFile(String src, String dst, String cipher_mode, int segment, int session_key_size, String password, KeyParameter key, byte[] iv) // dodac uzytnikow
{
IAlgorithm alg;
//var key2 = Serpent.generateKey(session_key_size);
//var iv2 = Serpent.generateIV();
// szyfrowanie
alg = new Serpent(key, iv, true);
alg.init(src, dst, cipher_mode, segment, 0);
return(alg);
}
private IAlgorithm decryptKey(String src, String password)
{
IAlgorithm alg = null;
String key;
var SHA = SHA256.Create();
byte[] hashed_password = SHA.ComputeHash(GetBytes(password)); //iv
KeyParameter session_key = new KeyParameter(hashed_password); //skey
String password_to_use = Convert.ToBase64String(hashed_password); //password
alg = new Serpent(session_key, hashed_password, false);
alg.init(src, src + "tmp", "ECB", 128, 0, 0);
return(alg);
}
private IAlgorithm encryptFile(String src, String dst, String cipher_mode, int segment, int session_key_size, String password) // dodac uzytnikow
{
// wykonanie algorytmu
// utworzenie obiektu klasy algorithm (IAlgorithm)
// wywołanie metody encrypt z odpowiednimi parametrami
// w tym obsługa paska postepu i przerwania operacji
IAlgorithm alg;
//Dodaje tutaj naglowek userow, pomysl nad rozbiciem tego na funkcje############################################################
var session_key = Serpent.generateKey(session_key_size);
var iv = Serpent.generateIV();
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
// zaszyfrowanie klucza sesyjnego algorytmem Serpent/ECB hasłem `password` // usun to, nie mozna haslem szyfrowac tylko kluczem!
//sessionKeyAlg = getSessionKeyAlg(true, password); // <--- podajesz password // i cisniesz dla usera
//encryptedKey = sessionKeyAlg.encryptInMemory(key.GetKey()); //
foreach (var user in users_to_encode)
{
using (StreamReader sr = new StreamReader(public_keys_path.ToString() + user))
{
var public_key = sr.ReadToEnd();
rsa.FromXmlString(public_key);
var encrypted_key = rsa.Encrypt(session_key.GetKey(), false);
encrypted_keys.Add(Convert.ToBase64String(encrypted_key));
//MessageBox.Show(Convert.ToBase64String(encrypted_key)); //tutaj messagebox
}
}
XElement usersXML = new XElement("Users");
for (int i = 0; i < users_to_encode.Count(); i++)
{
usersXML.Add(new XElement("User",
new XElement("Name", users_to_encode[i]),
new XElement("EncryptedKey", encrypted_keys[i])));
}
//#################################################################################################################################
// utworzenie nagłówka
XDocument miXML = new XDocument(
new XDeclaration("1.0", "utf-8", "yes"),
new XElement("EncryptedFileHeader",
new XElement("Algorithm", "SERPENT"),
new XElement("CipherMode", cipher_mode),
new XElement("SegmentSize", segment),
new XElement("KeySize", session_key_size),
new XElement("IV", Convert.ToBase64String(iv)),
usersXML
)
);
using (StreamWriter sw = new StreamWriter(dst, false, Encoding.ASCII))
{
miXML.Save(sw);
sw.WriteLine();
}
long xmlSize = new FileInfo(dst).Length;
// zapisanie nagłówka
var headerOffset = xmlSize;
// szyfrowanie
alg = new Serpent(session_key, iv, true);
alg.init(src, dst, cipher_mode, segment, 0, headerOffset);
return(alg);
}
private IAlgorithm decryptFile(String src, String dst, String password, String private_key, String selected_user)
{
// wykonanie algorytmu
// utworzenie obiektu klasy algorithm (IAlgorithm)
// wywołanie metody encrypt lub decrypt z odpowiednimi parametrami
// w tym obsługa paska postepu i przerwania operacji
IAlgorithm alg;
// wczytanie nagłówka
String xmlHeader = "";
using (StreamReader sr = new StreamReader(src))
{
String line;
while (sr.Peek() >= 0)
{
line = sr.ReadLine();
xmlHeader += line + "\r\n";
if (line.Equals("</EncryptedFileHeader>"))
{
break;
}
}
}
XmlDocument doc = new XmlDocument();
doc.LoadXml(xmlHeader);
int headerOffset = xmlHeader.Length;
// wyświetlenie nagłówka w GUI
//fileHeader.Text = xmlHeader;
// odczytanie parametrów z nagłówka
XmlNode node = doc.DocumentElement.SelectSingleNode("/EncryptedFileHeader/KeySize");
var keySize = Convert.ToInt32(node.InnerText);
keySize = keySize >> 3;
XmlNodeList xnList = doc.SelectNodes("/EncryptedFileHeader/Users/User");
byte[] encryptedKey = null;
bool znaleziony = false;
foreach (XmlNode user in xnList)
{
if (user["Name"].InnerText == selected_user)
{
encryptedKey = Convert.FromBase64String(user["EncryptedKey"].InnerText);
znaleziony = true;
break;
}
else
{
znaleziony = false;
}
}
if (znaleziony == false)
{
MessageBox.Show("Wybrany uzytkownik nie jest na liscie odbiorcow tego pliku");
Application.Restart();
}
//node = doc.DocumentElement.SelectSingleNode("/EncryptedFileHeader/Users/User/"+ selected_user + "/EncryptedKey");
//byte[] encryptedKey = Convert.FromBase64String(node.InnerText);
byte[] sessionKey = null;
// odszyfrowanie klucza sesyjnego kluczem prywatnym uzytnika
if (private_key.Length > 5)
{
if (private_key.Substring(1, 3) == "RSA")
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(private_key);
sessionKey = rsa.Decrypt(encryptedKey, false);
}
}
KeyParameter session_key_kp;
if (sessionKey == null)
{
session_key_kp = new KeyParameter(Serpent.generateIV());
}
else
{
session_key_kp = new KeyParameter(sessionKey);
}
//*************************************************************************
node = doc.DocumentElement.SelectSingleNode("/EncryptedFileHeader/IV");
byte[] iv = Convert.FromBase64String(node.InnerText);
node = doc.DocumentElement.SelectSingleNode("/EncryptedFileHeader/SegmentSize");
var segment = Convert.ToInt32(node.InnerText);
node = doc.DocumentElement.SelectSingleNode("/EncryptedFileHeader/CipherMode");
var cipherMode = node.InnerText;
// odszyfrowywanie
alg = new Serpent(session_key_kp, iv, false);
alg.init(src, dst, cipherMode, segment, headerOffset, 0);
return(alg);
}
