Ejemplo n.º 1
0
 public static void CallEncryption(bool encryption, char[] password, string keyfilePath, string[] filePaths)
 {
     byte[] passwordBytes = FileEncryption.GetPasswordBytes(password);
     Utilities.ZeroArray(password);
     FileEncryption.StartEncryption(encryption, filePaths, passwordBytes, keyfilePath);
     EncryptionCompleted(encryption);
 }
Ejemplo n.º 2
0
 private static void EncryptInputFile(string inputFilePath, string outputFilePath, byte[] ephemeralPublicKey, byte[] salt, byte[] keyEncryptionKey)
 {
     try
     {
         EncryptFile.Initialize(inputFilePath, outputFilePath, ephemeralPublicKey, salt, keyEncryptionKey);
         FileEncryption.EncryptionSuccessful(inputFilePath, outputFilePath);
     }
     catch (Exception ex) when(ExceptionFilters.Cryptography(ex))
     {
         DisplayMessage.FilePathException(inputFilePath, ex.GetType().Name, "Unable to encrypt the file.");
     }
 }
Ejemplo n.º 3
0
        private static void FileEncryptionWithPrivateKey(string privateKeyPath, string[] filePaths)
        {
            bool validUserInput = FileEncryptionValidation.FileEncryptionWithPrivateKey(privateKeyPath, filePaths);

            if (!validUserInput)
            {
                return;
            }
            byte[] privateKey = AsymmetricKeyValidation.EncryptionPrivateKeyFile(privateKeyPath);
            if (privateKey == null)
            {
                return;
            }
            FileEncryption.EncryptEachFileWithPrivateKey(filePaths, privateKey);
        }
Ejemplo n.º 4
0
        private static void FileEncryptionWithPassword(char[] password, string keyfilePath, string[] filePaths)
        {
            bool validUserInput = FileEncryptionValidation.FileEncryptionWithPassword(password, keyfilePath, filePaths);

            if (!validUserInput)
            {
                return;
            }
            if (!File.Exists(keyfilePath))
            {
                keyfilePath = FilePathValidation.KeyfilePath(keyfilePath);
            }
            byte[] passwordBytes = Password.Hash(password, keyfilePath);
            FileEncryption.EncryptEachFileWithPassword(filePaths, passwordBytes);
        }
Ejemplo n.º 5
0
 private static void EncryptEachFileWithPassword(string[] filePaths, byte[] salt, byte[] keyEncryptionKey)
 {
     foreach (string inputFilePath in filePaths)
     {
         bool validFilePath = FilePathValidation.FileEncryption(inputFilePath);
         if (!validFilePath)
         {
             --Globals.TotalCount;
             continue;
         }
         // Fill unused header with random public key
         byte[] ephemeralPublicKey = Generate.EphemeralPublicKeyHeader();
         string outputFilePath     = FileEncryption.GetOutputFilePath(inputFilePath);
         EncryptInputFile(inputFilePath, outputFilePath, ephemeralPublicKey, salt, keyEncryptionKey);
     }
     CryptographicOperations.ZeroMemory(keyEncryptionKey);
 }
Ejemplo n.º 6
0
 private static void EncryptEachFileWithPassword(string[] filePaths, byte[] salt, byte[] keyEncryptionKey)
 {
     foreach (string inputFilePath in filePaths)
     {
         bool validFilePath = FilePathValidation.FileEncryption(inputFilePath);
         if (!validFilePath)
         {
             --Globals.TotalCount;
             continue;
         }
         // Fill the ephemeral public key header with random bytes (since not in use)
         byte[] randomEphemeralPublicKeyHeader = Generate.EphemeralPublicKeyHeader();
         string outputFilePath = FileEncryption.GetOutputFilePath(inputFilePath);
         EncryptInputFile(inputFilePath, outputFilePath, randomEphemeralPublicKeyHeader, salt, keyEncryptionKey);
     }
     Utilities.ZeroArray(keyEncryptionKey);
 }
Ejemplo n.º 7
0
 private static void EncryptEachFileWithPrivateKey(string[] filePaths, byte[] privateKey)
 {
     foreach (string inputFilePath in filePaths)
     {
         bool validFilePath = FilePathValidation.FileEncryption(inputFilePath);
         if (!validFilePath)
         {
             --Globals.TotalCount;
             continue;
         }
         // Derive a unique KEK per file
         byte[] ephemeralSharedSecret = KeyExchange.GetPrivateKeySharedSecret(privateKey, out byte[] ephemeralPublicKey);
         byte[] salt             = Generate.Salt();
         byte[] keyEncryptionKey = Generate.KeyEncryptionKey(ephemeralSharedSecret, salt);
         string outputFilePath   = FileEncryption.GetOutputFilePath(inputFilePath);
         EncryptInputFile(inputFilePath, outputFilePath, ephemeralPublicKey, salt, keyEncryptionKey);
         CryptographicOperations.ZeroMemory(keyEncryptionKey);
     }
 }
Ejemplo n.º 8
0
 private static void EncryptEachFileWithPublicKey(string[] filePaths, byte[] sharedSecret, byte[] recipientPublicKey)
 {
     foreach (string inputFilePath in filePaths)
     {
         bool validFilePath = FilePathValidation.FileEncryption(inputFilePath);
         if (!validFilePath)
         {
             --Globals.TotalCount;
             continue;
         }
         // Derive a unique KEK per file
         (byte[] ephemeralSharedSecret, byte[] ephemeralPublicKey) = KeyExchange.GetEphemeralSharedSecret(recipientPublicKey);
         byte[] salt             = Generate.Salt();
         byte[] keyEncryptionKey = Generate.KeyEncryptionKey(sharedSecret, ephemeralSharedSecret, salt);
         string outputFilePath   = FileEncryption.GetOutputFilePath(inputFilePath);
         EncryptInputFile(inputFilePath, outputFilePath, ephemeralPublicKey, salt, keyEncryptionKey);
         Utilities.ZeroArray(keyEncryptionKey);
     }
 }
Ejemplo n.º 9
0
        private static void FileEncryptionWithPublicKey(string senderPrivateKeyPath, char[] recipientPublicKeyString, string[] filePaths)
        {
            bool validUserInput = FileEncryptionValidation.FileEncryptionWithPublicKey(senderPrivateKeyPath, recipientPublicKeyString, filePaths);

            if (!validUserInput)
            {
                return;
            }
            byte[] senderPrivateKey = AsymmetricKeyValidation.EncryptionPrivateKeyFile(senderPrivateKeyPath);
            if (senderPrivateKey == null)
            {
                return;
            }
            byte[] recipientPublicKey = AsymmetricKeyValidation.EncryptionPublicKeyString(recipientPublicKeyString);
            if (recipientPublicKey == null)
            {
                return;
            }
            FileEncryption.EncryptEachFileWithPublicKey(filePaths, senderPrivateKey, recipientPublicKey);
        }
Ejemplo n.º 10
0
 private static void GetBenchmarkInputs(out byte[] passwordBytes, out byte[] salt)
 {
     char[] password = "******".ToCharArray();
     passwordBytes = FileEncryption.GetPasswordBytes(password);
     salt          = Generate.Salt();
 }