コード例 #1
0
 public static char[] ConvertUserInput(bool encryption, char[] base64Key, char[] password)
 {
     try
     {
         NullChecks.CharArray(base64Key);
         NullChecks.CharArray(password);
         char[] message;
         byte[] key = Convert.FromBase64CharArray(base64Key, 0, base64Key.Length);
         if (encryption == true)
         {
             byte[] plaintext = Encoding.UTF8.GetBytes(password);
             message = EncryptPassword(plaintext, key);
             Utilities.ZeroArray(plaintext);
         }
         else
         {
             byte[] ciphertext = Convert.FromBase64CharArray(password, 0, password.Length);
             message = DecryptPassword(ciphertext, key);
             Utilities.ZeroArray(ciphertext);
         }
         Utilities.ZeroArray(key);
         return(message);
     }
     catch (Exception ex) when(ex is FormatException || ex is EncoderFallbackException)
     {
         DisplayMessage.Error(ex.GetType().Name, "Invalid key or password format.");
         return(Array.Empty <char>());
     }
 }
コード例 #2
0
        public static void CreateKeyfile(string filePath)
        {
            NullChecks.Strings(filePath);
            const string keyfileExtension = ".key";

            // Generate a random name if the path is a directory
            if (Directory.Exists(filePath))
            {
                string randomFileName = AnonymousRename.GenerateRandomFileName() + keyfileExtension;
                filePath = Path.Combine(filePath, randomFileName);
            }
            if (!File.Exists(filePath))
            {
                // Append .key extension if missing
                if (!filePath.EndsWith(keyfileExtension, StringComparison.InvariantCulture))
                {
                    filePath += keyfileExtension;
                }
                Keyfiles.GenerateKeyfile(filePath);
            }
            else
            {
                Console.WriteLine("Error: A file with this name already exists.");
            }
        }
コード例 #3
0
 public static void RestoreDirectoryName(string folderPath)
 {
     try
     {
         NullChecks.Strings(folderPath);
         string anonymisedDirectoryName = Path.GetFileName(folderPath);
         // Get the path where the original directory name is stored
         string storageFileName = $"{anonymisedDirectoryName}.txt";
         string storageFilePath = Path.Combine(folderPath, storageFileName);
         if (File.Exists(storageFilePath))
         {
             string originalDirectoryName = File.ReadAllText(storageFilePath);
             string originalDirectoryPath = folderPath.Replace(anonymisedDirectoryName, originalDirectoryName);
             Directory.Move(folderPath, originalDirectoryPath);
             storageFilePath = Path.Combine(originalDirectoryPath, storageFileName);
             if (File.Exists(storageFilePath))
             {
                 File.Delete(storageFilePath);
             }
         }
     }
     catch (Exception ex) when(ExceptionFilters.FileAccessExceptions(ex))
     {
         Logging.LogException(ex.ToString(), Logging.Severity.High);
         DisplayMessage.Error(folderPath, ex.GetType().Name, "Unable to restore original directory name.");
     }
 }
コード例 #4
0
 public static void WriteHeaders(FileStream ciphertext, byte[] salt)
 {
     NullChecks.FileHeaders(ciphertext, salt);
     byte[] memorySizeFlag = Encoding.UTF8.GetBytes(Constants.MemorySizeFlag + Invariant.ToString(Globals.MemorySize));
     byte[] iterationsFlag = Encoding.UTF8.GetBytes(Constants.IterationsFlag + Invariant.ToString(Globals.Iterations));
     byte[] endFlag        = Encoding.UTF8.GetBytes(Constants.EndFlag);
     ciphertext.Write(memorySizeFlag, 0, memorySizeFlag.Length);
     ciphertext.Write(iterationsFlag, 0, iterationsFlag.Length);
     ciphertext.Write(endFlag, 0, endFlag.Length);
     ciphertext.Write(salt, 0, salt.Length);
 }
コード例 #5
0
 public static string GetAnonymousFileName(string filePath)
 {
     try
     {
         NullChecks.Strings(filePath);
         string originalFileName  = Path.GetFileName(filePath);
         string randomFileName    = GenerateRandomFileName();
         string anonymousFilePath = filePath.Replace(originalFileName, randomFileName);
         return(anonymousFilePath);
     }
     catch (ArgumentException ex)
     {
         Logging.LogException(ex.ToString(), Logging.Severity.Bug);
         DisplayMessage.Error(filePath, ex.GetType().Name, "Unable to get anonymous file name. This is a bug - please report it.");
         return(filePath);
     }
 }
コード例 #6
0
 public static bool AppendHash(string filePath, byte[] fileHash)
 {
     try
     {
         NullChecks.ByteArray(fileHash);
         using (var fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.Read, Constants.FileBufferSize, FileOptions.RandomAccess))
         {
             fileStream.Write(fileHash, 0, fileHash.Length);
         }
         return(true);
     }
     catch (Exception ex) when(ExceptionFilters.FileAccessExceptions(ex))
     {
         Logging.LogException(ex.ToString(), Logging.Severity.High);
         DisplayMessage.Error(filePath, ex.GetType().Name, "Unable to append the MAC to the file. This data is required for decryption of the file.");
         return(false);
     }
 }
コード例 #7
0
 public static void GetFilePaths(bool encryption, string[] filePaths, byte[] passwordBytes)
 {
     NullChecks.StringArray(filePaths);
     Globals.SuccessfulCount = 0;
     Globals.TotalCount      = filePaths.Length;
     foreach (string filePath in filePaths)
     {
         bool?fileIsDirectory = FileHandling.IsDirectory(filePath);
         if (fileIsDirectory != null)
         {
             if (fileIsDirectory == false)
             {
                 CallEncryption(encryption, filePath, passwordBytes);
             }
             else
             {
                 DirectoryEncryption(encryption, filePath, passwordBytes);
             }
         }
     }
 }