public static void RecoverPublicKey(string privateKeyPath) { bool validUserInput = FilePathValidation.RecoverPublicKey(privateKeyPath); if (!validUserInput) { return; } byte[] privateKey = AsymmetricKeyValidation.GetPrivateKeyFromFile(privateKeyPath); if (privateKey == null) { return; } privateKey = PrivateKey.Decrypt(privateKey); if (privateKey == null) { return; } byte[] publicKey = privateKey.Length switch { Constants.EncryptionKeyLength => AsymmetricKeys.GetCurve25519PublicKey(privateKey), _ => AsymmetricKeys.GetEd25519PublicKey(privateKey), }; Console.WriteLine($"Public key: {Convert.ToBase64String(publicKey)}"); }
private static void DecryptEachFileWithPrivateKey(string[] filePaths, byte[] privateKey) { foreach (string inputFilePath in filePaths) { bool validFilePath = FilePathValidation.FileDecryption(inputFilePath); if (!validFilePath) { --Globals.TotalCount; continue; } try { using var inputFile = new FileStream(inputFilePath, FileMode.Open, FileAccess.Read, FileShare.Read, Constants.FileStreamBufferSize, FileOptions.RandomAccess); byte[] ephemeralPublicKey = FileHeaders.ReadEphemeralPublicKey(inputFile); byte[] ephemeralSharedSecret = KeyExchange.GetSharedSecret(privateKey, ephemeralPublicKey); byte[] salt = FileHeaders.ReadSalt(inputFile); byte[] keyEncryptionKey = Generate.KeyEncryptionKey(ephemeralSharedSecret, salt); DecryptInputFile(inputFile, ephemeralPublicKey, keyEncryptionKey); CryptographicOperations.ZeroMemory(keyEncryptionKey); } catch (Exception ex) when(ExceptionFilters.Cryptography(ex)) { FileException(inputFilePath, ex); } } }
public static void GenerateNewKeyPair(string exportDirectoryPath) { try { int keyPairType = GetKeyPairType(); bool validUserInput = FilePathValidation.GenerateKeyPair(exportDirectoryPath, keyPairType); if (!validUserInput) { return; } string publicKey, privateKey, publicKeyPath, privateKeyPath; if (keyPairType == 1) { (publicKey, privateKey) = AsymmetricKeys.GenerateEncryptionKeyPair(); (publicKeyPath, privateKeyPath) = AsymmetricKeys.ExportEncryptionKeyPair(exportDirectoryPath, publicKey, privateKey); } else { (publicKey, privateKey) = AsymmetricKeys.GenerateSigningKeyPair(); (publicKeyPath, privateKeyPath) = AsymmetricKeys.ExportSigningKeyPair(exportDirectoryPath, publicKey, privateKey); } DisplayKeyPair(publicKey, publicKeyPath, privateKeyPath); } catch (Exception ex) when(ExceptionFilters.FileAccess(ex)) { Logging.LogException(ex.ToString(), Logging.Severity.Error); DisplayMessage.FilePathException(exportDirectoryPath, ex.GetType().Name, "Unable to export key pair."); } }
private static void DecryptEachFileWithPassword(string[] filePaths, byte[] keyEncryptionKey) { foreach (string inputFilePath in filePaths) { bool validFilePath = FilePathValidation.FileDecryption(inputFilePath); if (!validFilePath) { --Globals.TotalCount; continue; } DecryptInputFile(inputFilePath, keyEncryptionKey); } Utilities.ZeroArray(keyEncryptionKey); }
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); }
public static void EncryptEachFileWithPassword(string[] filePaths, byte[] passwordBytes) { Globals.TotalCount = filePaths.Length; foreach (string inputFilePath in filePaths) { bool validFilePath = FilePathValidation.FileEncryption(inputFilePath); if (!validFilePath) { --Globals.TotalCount; continue; } UsingPassword(inputFilePath, passwordBytes); } Utilities.ZeroArray(passwordBytes); DisplayMessage.SuccessfullyEncrypted(); }
public static void DecryptEachFileWithPassword(string[] filePaths, byte[] passwordBytes) { Globals.TotalCount = filePaths.Length; foreach (string inputFilePath in filePaths) { bool validFilePath = FilePathValidation.FileDecryption(inputFilePath); if (!validFilePath) { --Globals.TotalCount; continue; } UsingPassword(inputFilePath, passwordBytes); } CryptographicOperations.ZeroMemory(passwordBytes); DisplayMessage.SuccessfullyDecrypted(); }
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); }
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); }
private static void DecryptEachFileWithPrivateKey(string[] filePaths, byte[] privateKey) { foreach (string inputFilePath in filePaths) { bool validFilePath = FilePathValidation.FileDecryption(inputFilePath); if (!validFilePath) { --Globals.TotalCount; continue; } byte[] ephemeralPublicKey = FileHeaders.ReadEphemeralPublicKey(inputFilePath); byte[] ephemeralSharedSecret = KeyExchange.GetSharedSecret(privateKey, ephemeralPublicKey); byte[] salt = FileHeaders.ReadSalt(inputFilePath); byte[] keyEncryptionKey = Generate.KeyEncryptionKey(ephemeralSharedSecret, salt); DecryptInputFile(inputFilePath, keyEncryptionKey); Utilities.ZeroArray(keyEncryptionKey); } }
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); } }
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); } }
public static void EncryptEachFileWithPrivateKey(string[] filePaths, byte[] privateKey) { Globals.TotalCount = filePaths.Length; privateKey = PrivateKey.Decrypt(privateKey); if (privateKey == null) { return; } foreach (string inputFilePath in filePaths) { bool validFilePath = FilePathValidation.FileEncryption(inputFilePath); if (!validFilePath) { --Globals.TotalCount; continue; } UsingPrivateKey(inputFilePath, privateKey); } Utilities.ZeroArray(privateKey); DisplayMessage.SuccessfullyEncrypted(); }
private static void VerifySignature(string publicKeyPath, string signatureFilePath, string[] filePaths) { bool validUserInput = SigningValidation.Verify(publicKeyPath, signatureFilePath, filePaths); if (!validUserInput) { return; } signatureFilePath = FilePathValidation.GetSignatureFilePath(signatureFilePath, filePaths); bool validSignatureFile = SigningValidation.SignatureFile(signatureFilePath); if (!validSignatureFile) { return; } byte[] publicKey = AsymmetricKeyValidation.SigningPublicKeyFile(publicKeyPath); if (publicKey == null) { return; } FileSigning.VerifyFile(signatureFilePath, filePaths[0], publicKey); }
public static void EncryptEachFileWithPublicKey(string[] filePaths, byte[] senderPrivateKey, byte[] recipientPublicKey) { Globals.TotalCount = filePaths.Length; senderPrivateKey = PrivateKey.Decrypt(senderPrivateKey); if (senderPrivateKey == null) { return; } byte[] sharedSecret = KeyExchange.GetSharedSecret(senderPrivateKey, recipientPublicKey); Utilities.ZeroArray(senderPrivateKey); foreach (string inputFilePath in filePaths) { bool validFilePath = FilePathValidation.FileEncryption(inputFilePath); if (!validFilePath) { --Globals.TotalCount; continue; } UsingPublicKey(inputFilePath, sharedSecret, recipientPublicKey); } Utilities.ZeroArray(sharedSecret); DisplayMessage.SuccessfullyEncrypted(); }
public static void DecryptEachFileWithPublicKey(string[] filePaths, byte[] recipientPrivateKey, byte[] senderPublicKey) { Globals.TotalCount = filePaths.Length; recipientPrivateKey = PrivateKey.Decrypt(recipientPrivateKey); if (recipientPrivateKey == null) { return; } byte[] sharedSecret = KeyExchange.GetSharedSecret(recipientPrivateKey, senderPublicKey); foreach (string inputFilePath in filePaths) { bool validFilePath = FilePathValidation.FileDecryption(inputFilePath); if (!validFilePath) { --Globals.TotalCount; continue; } UsingPublicKey(inputFilePath, sharedSecret, recipientPrivateKey); } CryptographicOperations.ZeroMemory(recipientPrivateKey); CryptographicOperations.ZeroMemory(sharedSecret); DisplayMessage.SuccessfullyDecrypted(); }