/// <summary> /// Encrypts an input file given the provided Public Key File. /// </summary> /// <param name="outputFilePath">Path of new encrypted output file.</param> /// <param name="inputFilePath">Path of existing unencrypted input file.</param> /// <param name="publicKeyFilePath">Path of existing Pgp Public Key file.</param> /// <param name="armor">Use ASCII Armor</param> /// <param name="withIntegrityCheck">Include Integrity Check</param> /// <exception cref="ArgumentException"></exception> /// <exception cref="FileNotFoundException"></exception> public static void EncryptFile(string outputFilePath, string inputFilePath, string publicKeyFilePath, bool armor = true, bool withIntegrityCheck = true) { // Parameter Checks if (String.IsNullOrEmpty(outputFilePath)) { throw new ArgumentException("Output File Name Parameter is invalid."); } if (String.IsNullOrEmpty(inputFilePath)) { throw new ArgumentException("Input File Name Parameter is invalid."); } if (String.IsNullOrEmpty(publicKeyFilePath)) { throw new ArgumentException("Public Key File Name Parameter is invalid."); } if (!File.Exists(inputFilePath)) { throw new FileNotFoundException("Input File does not exist."); } if (!File.Exists(publicKeyFilePath)) { throw new FileNotFoundException("Public Key File does not exist"); } PgpPublicKey _publicKey = PgpCustomUtilities.ReadPublicKey(publicKeyFilePath); using (Stream output = File.Create(outputFilePath)) { EncryptFile(output, inputFilePath, _publicKey, armor, withIntegrityCheck); } }
/// <summary> /// Decrypts the Input File stream, given the Private Key File stream, to the specified Decrypted File Path. /// </summary> /// <param name="inputFileStream">File Stream of encrypted file.</param> /// <param name="privateKeyFileStream">File Stream of Private Key file.</param> /// <param name="password">Password that was used to encrypt the file.</param> /// <param name="decryptedFilePath">Path of the new decrypted file.</param> /// <exception cref="ArgumentException"></exception> /// <exception cref="PgpException"></exception> public static void DecryptFile(Stream inputFileStream, Stream privateKeyFileStream, string password, string decryptedFilePath, PgpSecretKeyRingBundle bundle = null) { // Parameter Checks if (String.IsNullOrEmpty(password)) { throw new ArgumentException("Password Parameter is invalid."); } if (String.IsNullOrEmpty(decryptedFilePath)) { throw new ArgumentException("Decrypted File Name Parameter is invalid."); } inputFileStream = PgpUtilities.GetDecoderStream(inputFileStream); PgpObjectFactory _pgpObjectFactory = new PgpObjectFactory(inputFileStream); PgpEncryptedDataList _pgpEncryptedDataList; PgpObject _pgpObject = _pgpObjectFactory.NextPgpObject(); if (_pgpObject is PgpEncryptedDataList) { _pgpEncryptedDataList = (PgpEncryptedDataList)_pgpObject; } else { _pgpEncryptedDataList = (PgpEncryptedDataList)_pgpObjectFactory.NextPgpObject(); } PgpPrivateKey _pgpPrivateKey = null; PgpPublicKeyEncryptedData _pgpPubKeyEncryptedData = null; PgpSecretKeyRingBundle _pgpSecKeyRingBundle = bundle ?? new PgpSecretKeyRingBundle(PgpUtilities.GetDecoderStream(privateKeyFileStream)); foreach (PgpPublicKeyEncryptedData _pgpPubKeyEncData in _pgpEncryptedDataList.GetEncryptedDataObjects()) { _pgpPrivateKey = PgpCustomUtilities.FindSecretKey(_pgpSecKeyRingBundle, _pgpPubKeyEncData.KeyId, password.ToCharArray()); if (_pgpPrivateKey != null) { _pgpPubKeyEncryptedData = _pgpPubKeyEncData; break; } } if (_pgpPrivateKey == null) { throw new ArgumentException("secret key for message not found."); } Stream _privateKeyFileStream = _pgpPubKeyEncryptedData.GetDataStream(_pgpPrivateKey); PgpObjectFactory _pgpObjectFactoryPrivateKey = new PgpObjectFactory(_privateKeyFileStream); PgpObject _pgpObjectMessage = null; var po = _pgpObjectFactoryPrivateKey.NextPgpObject(); if (po is PgpLiteralData) { _pgpObjectMessage = (PgpLiteralData)po; } else if (po is PgpCompressedData) { var _pgpCompressedData = (PgpCompressedData)po; var _pgpObjectFactoryCompressedData = new PgpObjectFactory(_pgpCompressedData.GetDataStream()); _pgpObjectMessage = _pgpObjectFactoryCompressedData.NextPgpObject(); } if (_pgpObjectMessage is PgpLiteralData) { PgpLiteralData _pgpLiteralData = (PgpLiteralData)_pgpObjectMessage; // string _outputFileName = _pgpLiteralData.FileName; using (var st = _pgpLiteralData.GetInputStream()) { using (var dst = File.Create(decryptedFilePath)) { st.CopyTo(dst); } } /* * string _outputFileDirectoryPath; * Stream _outputFileStream; * if (_outputFileName.Length == 0) * { * _outputFileName = decryptedFilePath; * _outputFileStream = File.Create(_outputFileName); * } * else * { * FileInfo _decryptedFileInfo = new FileInfo(decryptedFilePath); * _outputFileDirectoryPath = _decryptedFileInfo.DirectoryName; * _outputFileStream = File.Create(Path.Combine(_outputFileDirectoryPath, _outputFileName)); * } * * Stream _dataInputStream = _pgpLiteralData.GetInputStream(); * _dataInputStream.CopyTo(_outputFileStream); * // Streams.PipeAll(_dataInputStream, _outputFileStream); * _outputFileStream.Close(); */ } else if (_pgpObjectMessage is PgpOnePassSignatureList) { throw new PgpException("Encrypted message contains a signed message - not literal data."); } else { throw new PgpException("Message is not a simple encrypted file - type unknown."); } if (_pgpPubKeyEncryptedData.IsIntegrityProtected()) { if (!_pgpPubKeyEncryptedData.Verify()) { throw new PgpException("Message failed integrity check."); } } }