private static void EncryptFile(string filePath, string encryptedFilePath, byte[] salt, byte[] encryptionKey, byte[] macKey)
{
try
{
using (var ciphertext = new FileStream(encryptedFilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read, Constants.FileBufferSize, FileOptions.SequentialScan))
using (var plaintext = new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read, Constants.FileBufferSize, FileOptions.SequentialScan))
{
WriteFileHeaders.WriteHeaders(ciphertext, salt);
byte[] fileBytes = FileHandling.GetBufferSize(plaintext.Length);
// Generate a counter starting at 0
byte[] counter = Generate.Counter();
int bytesRead;
MemoryEncryption.DecryptByteArray(ref encryptionKey);
while ((bytesRead = plaintext.Read(fileBytes, 0, fileBytes.Length)) > 0)
{
byte[] encryptedBytes = StreamEncryption.EncryptXChaCha20(fileBytes, counter, encryptionKey);
ciphertext.Write(encryptedBytes, 0, bytesRead);
counter = Sodium.Utilities.Increment(counter);
}
}
Utilities.ZeroArray(encryptionKey);
CompleteEncryption(filePath, encryptedFilePath, macKey);
}
catch (Exception ex) when(ExceptionFilters.FileEncryptionExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.High);
DisplayMessage.Error(filePath, ex.GetType().Name, "Unable to encrypt the file.");
FileHandling.DeleteFile(encryptedFilePath);
Utilities.ZeroArray(encryptionKey);
Utilities.ZeroArray(macKey);
}
}
private static void RestoreDirectoryName(string obfuscatedDirectoryPath)
{
try
{
string obfuscatedDirectoryName = Path.GetFileName(obfuscatedDirectoryPath);
// Get the path where the original directory name is stored
string storageFileName = $"{obfuscatedDirectoryName}.txt";
string storageFilePath = Path.Combine(obfuscatedDirectoryPath, storageFileName);
if (!File.Exists(storageFilePath))
{
return;
}
string directoryName = File.ReadAllText(storageFilePath);
string directoryPath = obfuscatedDirectoryPath.Replace(obfuscatedDirectoryName, directoryName);
directoryPath = FileHandling.GetUniqueDirectoryPath(directoryPath);
Directory.Move(obfuscatedDirectoryPath, directoryPath);
DisplayMessage.FileEncryptionResult(obfuscatedDirectoryName, directoryName);
storageFilePath = Path.Combine(directoryPath, storageFileName);
FileHandling.DeleteFile(storageFilePath);
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Error);
DisplayMessage.FilePathException(obfuscatedDirectoryPath, ex.GetType().Name, "Unable to restore the directory name.");
}
}
private static void Finalize(string directoryPath, string saltFilePath)
{
if (Globals.SuccessfulCount != 0 && Globals.SuccessfulCount == Globals.TotalCount)
{
FileHandling.DeleteFile(saltFilePath);
}
Finalize(directoryPath);
}
private static void CompleteDecryption(string filePath, string decryptedFilePath)
{
// Deanonymise file name
OriginalFileName.RestoreOriginalFileName(decryptedFilePath);
FileHandling.DeleteFile(filePath);
Console.WriteLine($"{Path.GetFileName(filePath)}: File decryption successful.");
Globals.SuccessfulCount += 1;
}
private static void Finalize(string directoryPath, string saltFilePath)
{
string[] kryptorFiles = Directory.GetFiles(directoryPath, $"*{Constants.EncryptedExtension}", SearchOption.AllDirectories);
if (kryptorFiles.Length == 0)
{
FileHandling.DeleteFile(saltFilePath);
}
Finalize(directoryPath);
}
public static void RenameFile(string outputFilePath, int fileNameLength)
{
try
{
if (fileNameLength == 0)
{
return;
}
string originalFileName = ReadFileName(outputFilePath, fileNameLength);
string obfuscatedFileName = Path.GetFileName(outputFilePath);
string restoredFilePath = outputFilePath.Replace(obfuscatedFileName, originalFileName);
// Replace the file if it already exists
FileHandling.DeleteFile(restoredFilePath);
File.Move(outputFilePath, restoredFilePath);
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Error);
DisplayMessage.FilePathException(outputFilePath, ex.GetType().Name, "Unable to restore the original file name.");
}
}
public static void Initialize(FileStream inputFile, string outputFilePath, byte[] ephemeralPublicKey, byte[] keyEncryptionKey)
{
var dataEncryptionKey = new byte[Constants.EncryptionKeyLength];
try
{
byte[] encryptedHeader = FileHeaders.ReadEncryptedHeader(inputFile);
byte[] nonce = FileHeaders.ReadNonce(inputFile);
byte[] header = DecryptFileHeader(inputFile, ephemeralPublicKey, encryptedHeader, nonce, keyEncryptionKey);
if (header == null)
{
throw new ArgumentException("Incorrect password/key or this file has been tampered with.");
}
int lastChunkLength = FileHeaders.GetLastChunkLength(header);
int fileNameLength = FileHeaders.GetFileNameLength(header);
dataEncryptionKey = FileHeaders.GetDataEncryptionKey(header);
CryptographicOperations.ZeroMemory(header);
using (var outputFile = new FileStream(outputFilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read, Constants.FileStreamBufferSize, FileOptions.SequentialScan))
{
nonce = Utilities.Increment(nonce);
byte[] additionalData = ChunkHandling.GetPreviousTag(encryptedHeader);
Decrypt(inputFile, outputFile, nonce, dataEncryptionKey, additionalData, lastChunkLength);
}
string inputFilePath = inputFile.Name;
inputFile.Dispose();
Finalize(inputFilePath, outputFilePath, fileNameLength);
}
catch (Exception ex) when(ExceptionFilters.Cryptography(ex))
{
CryptographicOperations.ZeroMemory(dataEncryptionKey);
if (!(ex is ArgumentException))
{
FileHandling.DeleteFile(outputFilePath);
}
throw;
}
}
public static void Initialize(string inputFilePath, string outputFilePath, byte[] ephemeralPublicKey, byte[] salt, byte[] keyEncryptionKey)
{
byte[] dataEncryptionKey = Generate.DataEncryptionKey();
try
{
using (var inputFile = new FileStream(inputFilePath, FileMode.Open, FileAccess.Read, FileShare.Read, Constants.FileStreamBufferSize, FileOptions.SequentialScan))
using (var outputFile = new FileStream(outputFilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read, Constants.FileStreamBufferSize, FileOptions.SequentialScan))
{
byte[] nonce = Generate.Nonce();
byte[] encryptedHeader = EncryptFileHeader(inputFilePath, dataEncryptionKey, nonce, keyEncryptionKey);
FileHeaders.WriteHeaders(outputFile, ephemeralPublicKey, salt, nonce, encryptedHeader);
nonce = Sodium.Utilities.Increment(nonce);
byte[] additionalData = ChunkHandling.GetPreviousPoly1305Tag(encryptedHeader);
Encrypt(inputFile, outputFile, nonce, dataEncryptionKey, additionalData);
}
Finalize(inputFilePath, outputFilePath);
}
catch (Exception ex) when(ExceptionFilters.Cryptography(ex))
{
FileHandling.DeleteFile(outputFilePath);
Utilities.ZeroArray(dataEncryptionKey);
throw;
}
}
private static void Finalize(string inputFilePath, string outputFilePath, int fileNameLength)
{
RestoreFileName.RenameFile(outputFilePath, fileNameLength);
FileHandling.DeleteFile(inputFilePath);
}
