コード例 #1
0
        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);
        }
コード例 #2
0
        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);
        }
コード例 #3
0
        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);
        }
コード例 #4
0
        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);
        }
コード例 #5
0
        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);
        }