private static void Finalize(string directoryPath)
{
try
{
RestoreDirectoryNames.AllDirectories(directoryPath);
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Error);
DisplayMessage.FilePathException(directoryPath, ex.GetType().Name, "Unable to restore the directory names.");
}
}
public static void MakeFileReadOnly(string filePath)
{
try
{
File.SetAttributes(filePath, FileAttributes.ReadOnly);
}
catch (Exception ex) when(ExceptionFilters.FileAccessExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Medium);
DisplayMessage.Error(filePath, ex.GetType().Name, "Unable to make the file read-only.");
}
}
public static bool?IsKryptorFile(string filePath)
{
try
{
byte[] magicBytes = FileHeaders.ReadMagicBytes(filePath);
return(Utilities.Compare(magicBytes, Constants.KryptorMagicBytes));
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
return(null);
}
}
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.");
}
}
public static bool?IsSignatureFile(string filePath)
{
try
{
byte[] magicBytes = ReadFileHeader(filePath, offset: 0, Constants.SignatureMagicBytes.Length);
return(Utilities.Compare(magicBytes, Constants.SignatureMagicBytes));
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
return(null);
}
}
public static void UsingPrivateKey(string directoryPath, byte[] privateKey)
{
try
{
string[] filePaths = GetFiles(ref directoryPath);
EncryptEachFileWithPrivateKey(filePaths, privateKey);
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Error);
DisplayMessage.FilePathException(directoryPath, ex.GetType().Name, "Unable to encrypt the directory.");
}
}
public static void UsingPublicKey(string directoryPath, byte[] sharedSecret, byte[] recipientPrivateKey)
{
try
{
string[] filePaths = GetFiles(directoryPath);
DecryptEachFileWithPublicKey(filePaths, sharedSecret, recipientPrivateKey);
Finalize(directoryPath);
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
DisplayMessage.FilePathException(directoryPath, ex.GetType().Name, "Unable to decrypt the directory.");
}
}
public static void OverwriteFile(string fileToDelete, string fileToCopy)
{
try
{
File.Copy(fileToCopy, fileToDelete, true);
File.Delete(fileToDelete);
}
catch (Exception ex) when(ExceptionFilters.FileAccessExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Medium);
DisplayMessage.Error(fileToDelete, ex.GetType().Name, "Unable to overwrite and/or delete.");
}
}
public static void OverwriteFile(string fileToDelete, string fileToCopy)
{
try
{
File.SetAttributes(fileToDelete, FileAttributes.Normal);
File.Copy(fileToCopy, fileToDelete, overwrite: true);
File.Delete(fileToDelete);
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
DisplayMessage.FilePathException(fileToDelete, ex.GetType().Name, "Unable to overwrite the file.");
}
}
private static string[] GetAllDirectories(string folderPath)
{
try
{
return(Directory.GetDirectories(folderPath, "*", SearchOption.AllDirectories));
}
catch (Exception ex) when(ExceptionFilters.FileAccessExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.High);
DisplayMessage.Error(folderPath, ex.GetType().Name, "Unable to get subdirectories in selected folder.");
return(null);
}
}
private static byte[] UseKeyfile(byte[] passwordBytes, string keyfilePath)
{
try
{
byte[] keyfileBytes = Keyfiles.ReadKeyfile(keyfilePath);
return(passwordBytes == null ? keyfileBytes : CombineKeyfileAndPassword(passwordBytes, keyfileBytes));
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
DisplayMessage.Exception(ex.GetType().Name, "Unable to read keyfile. The keyfile has not been used.");
return(passwordBytes);
}
}
public static void OverwriteFile(string fileToDelete, string fileToCopy)
{
try
{
File.Copy(fileToCopy, fileToDelete, overwrite: true);
DeleteFile(fileToDelete);
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Warning);
DisplayMessage.FilePathException(fileToDelete, ex.GetType().Name, "Unable to overwrite the file.");
}
}
private static bool?LoadBooleanSetting(string setting)
{
try
{
return(Invariant.ToBoolean(setting));
}
catch (Exception ex) when(ExceptionFilters.SettingsExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Low);
DisplayMessage.Error(ex.GetType().Name, $"Unable to convert {setting} setting to boolean.");
return(null);
}
}
public static void LogException(string exceptionMessage, Severity severity)
{
try
{
const string logFileName = "error log.txt";
string logFilePath = Path.Combine(Constants.KryptorDirectory, logFileName);
string logMessage = $"[Error] Severity = {severity}" + Environment.NewLine + exceptionMessage + Environment.NewLine;
File.AppendAllText(logFilePath, logMessage);
}
catch (Exception ex) when(ExceptionFilters.FileAccessExceptions(ex))
{
DisplayMessage.Error(ex.GetType().Name, "Unable to log exception.");
}
}
private static char[] EncryptPassword(byte[] plaintext, byte[] publicKey)
{
try
{
byte[] ciphertext = SealedPublicKeyBox.Create(plaintext, publicKey);
return(Convert.ToBase64String(ciphertext).ToCharArray());
}
catch (Exception ex) when(ExceptionFilters.PasswordSharingExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Low);
GetErrorMessage(ex);
return(Array.Empty <char>());
}
}
private static int GetFileNameLength(string filePath, string originalFileName)
{
try
{
EncodeFileName(filePath, originalFileName, out byte[] newLineBytes, out byte[] fileNameBytes);
return(newLineBytes.Length + fileNameBytes.Length);
}
catch (Exception ex) when(ExceptionFilters.CharacterEncodingExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.High);
DisplayMessage.Error(filePath, ex.GetType().Name, "Unable to remove the original file name stored in the file. The length of the stored file name could not be calculated.");
return(0);
}
}
public static bool?IsDirectory(string filePath)
{
try
{
var fileAttributes = File.GetAttributes(filePath);
return(fileAttributes.HasFlag(FileAttributes.Directory));
}
catch (Exception ex) when(ExceptionFilters.FileAccessExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.High);
DisplayMessage.Error(filePath, ex.GetType().Name, "Unable to check if file path is a directory.");
return(null);
}
}
public static void RemoveAppendedFileName(string inputFilePath)
{
try
{
File.SetAttributes(inputFilePath, FileAttributes.Normal);
string fileName = Path.GetFileName(inputFilePath);
byte[] fileNameBytes = Encoding.UTF8.GetBytes(fileName);
using var inputFile = new FileStream(inputFilePath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read, Constants.FileStreamBufferSize, FileOptions.RandomAccess);
inputFile.SetLength(inputFile.Length - fileNameBytes.Length);
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
DisplayMessage.FilePathException(inputFilePath, ex.GetType().Name, "Unable to remove appended file name.");
}
}
private static char[] DecryptPassword(byte[] ciphertext, byte[] privateKey)
{
try
{
using var keyPair = PublicKeyBox.GenerateKeyPair(privateKey);
byte[] plaintext = SealedPublicKeyBox.Open(ciphertext, keyPair);
return(Encoding.UTF8.GetChars(plaintext));
}
catch (Exception ex) when(ExceptionFilters.PasswordSharingExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Low);
GetErrorMessage(ex);
return(Array.Empty <char>());
}
}
public static void DeleteFile(string filePath)
{
try
{
if (File.Exists(filePath))
{
File.SetAttributes(filePath, FileAttributes.Normal);
File.Delete(filePath);
}
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
DisplayMessage.FilePathException(filePath, ex.GetType().Name, "Unable to delete the file.");
}
}
public static void DeleteFile(string filePath)
{
try
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
catch (Exception ex) when(ExceptionFilters.FileAccessExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Medium);
DisplayMessage.Error(filePath, ex.GetType().Name, "Unable to delete the file.");
}
}
public static void DecryptByteArray(ref byte[] byteArray)
{
try
{
if (Globals.MemoryEncryption == true && byteArray != null)
{
byteArray = SealedPublicKeyBox.Open(byteArray, _keyPair);
}
}
catch (Exception ex) when(ExceptionFilters.MemoryEncryptionExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Bug);
DisplayMessage.Error(ex.GetType().Name, "Memory decryption failed. This is a bug - please report it.");
}
}
public static void LogException(string exceptionMessage, Severity severity)
{
try
{
string logMessage = $"Exception Severity = {severity}" + Environment.NewLine + exceptionMessage + Environment.NewLine;
if (!Directory.Exists(_logdirectoryPath))
{
Directory.CreateDirectory(_logdirectoryPath);
}
File.AppendAllText(_logFilePath, logMessage);
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
DisplayMessage.Exception(ex.GetType().Name, "Unable to log exception.");
}
}
private static string ObfuscateDirectoryName(string directoryPath)
{
try
{
string directoryName = Path.GetFileName(directoryPath);
string obfuscatedPath = ObfuscateFileName.ReplaceFilePath(directoryPath);
Directory.Move(directoryPath, obfuscatedPath);
StoreDirectoryName(directoryName, obfuscatedPath);
return(obfuscatedPath);
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex))
{
DisplayMessage.FilePathException(directoryPath, ex.GetType().Name, "Unable to obfuscate directory name.");
return(directoryPath);
}
}
public static void GenerateKeyfile(string filePath)
{
try
{
byte[] keyfileBytes = SodiumCore.GetRandomBytes(Constants.MACKeySize);
File.WriteAllBytes(filePath, keyfileBytes);
File.SetAttributes(filePath, FileAttributes.ReadOnly);
Utilities.ZeroArray(keyfileBytes);
Console.WriteLine("Keyfile successfully generated.");
}
catch (Exception ex) when(ExceptionFilters.FileAccessExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.Low);
DisplayMessage.Error(ex.GetType().Name, "Keyfile generation failed.");
}
}
public static string ReadOriginalFileName(string filePath)
{
try
{
// Read the last line of the decrypted file
string originalFileName = File.ReadLines(filePath).Last().Trim('\0');
RemoveStoredFileName(filePath, originalFileName);
return(originalFileName);
}
catch (Exception ex) when(ExceptionFilters.FileAccessExceptions(ex) || ex is InvalidOperationException)
{
Logging.LogException(ex.ToString(), Logging.Severity.High);
DisplayMessage.Error(filePath, ex.GetType().Name, "Unable to read original file name.");
return(string.Empty);
}
}
public static void CheckForUpdates()
{
try
{
bool updateAvailable = Updates.CheckForUpdates();
if (updateAvailable)
{
Console.WriteLine("An update is available for Kryptor. Visit <https://github.com/samuel-lucas6/Kryptor/releases> to update.");
return;
}
Console.WriteLine("Kryptor is up-to-date.");
}
catch (Exception ex) when(ExceptionFilters.CheckForUpdates(ex))
{
DisplayMessage.Exception(ex.GetType().Name, "Unable to check for updates.");
}
}
public static string GetOutputFilePath(string inputFilePath)
{
try
{
if (Globals.ObfuscateFileNames)
{
ObfuscateFileName.AppendFileName(inputFilePath);
inputFilePath = ObfuscateFileName.ReplaceFilePath(inputFilePath);
}
}
catch (Exception ex) when(ExceptionFilters.FileAccess(ex) || ex is EncoderFallbackException)
{
Logging.LogException(ex.ToString(), Logging.Severity.Error);
DisplayMessage.FilePathException(inputFilePath, ex.GetType().Name, "Unable to store file name.");
}
return(inputFilePath + Constants.EncryptedExtension);
}
private static (byte[], byte[], byte[]) GetParametersBytes(string memorySize, string iterations)
{
try
{
Encoding encoding = Encoding.UTF8;
byte[] memorySizeBytes = encoding.GetBytes(memorySize);
byte[] iterationsBytes = encoding.GetBytes(iterations);
byte[] endFlagBytes = encoding.GetBytes(Constants.EndFlag);
return(memorySizeBytes, iterationsBytes, endFlagBytes);
}
catch (Exception ex) when(ExceptionFilters.CharacterEncodingExceptions(ex))
{
Logging.LogException(ex.ToString(), Logging.Severity.High);
DisplayMessage.Error(ex.GetType().Name, "Unable to convert Argon2 parameters to bytes.");
return(null, null, null);
}
}
public static void EncryptByteArray(ref byte[] byteArray)
{
try
{
if (Globals.MemoryEncryption == true && byteArray != null)
{
byteArray = SealedPublicKeyBox.Create(byteArray, _keyPair.PublicKey);
}
}
catch (Exception ex) when(ExceptionFilters.MemoryEncryptionExceptions(ex))
{
Globals.MemoryEncryption = false;
KryptorSettings.SaveSettings();
Logging.LogException(ex.ToString(), Logging.Severity.Bug);
DisplayMessage.Error(ex.GetType().Name, "Memory encryption has been disabled due to an exception. This is a bug - please report it.");
}
}
