From 5a349a105239c83d4ef63a5c1586eb8c9149e655 Mon Sep 17 00:00:00 2001 From: mattosaurus Date: Wed, 28 Aug 2019 12:15:58 +0100 Subject: [PATCH 1/5] Update CreateRandomFile to be properly random. --- PgpCore.Tests/UnitTests.cs | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/PgpCore.Tests/UnitTests.cs b/PgpCore.Tests/UnitTests.cs index 4a74aec..e7964b5 100644 --- a/PgpCore.Tests/UnitTests.cs +++ b/PgpCore.Tests/UnitTests.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.IO; +using System.Security.Cryptography; using Org.BouncyCastle.Bcpg.OpenPgp; using Xunit; @@ -924,14 +925,16 @@ private void CreateRandomFile(string filePath, int sizeInMb) const int blocksPerMb = (1024 * 1024) / blockSize; byte[] data = new byte[blockSize]; - Random rng = new Random(); - using (FileStream stream = File.OpenWrite(filePath)) + + using (RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider()) { - // There - for (int i = 0; i < sizeInMb * blocksPerMb; i++) + using (FileStream stream = File.OpenWrite(filePath)) { - rng.NextBytes(data); - stream.Write(data, 0, data.Length); + for (int i = 0; i < sizeInMb * blocksPerMb; i++) + { + crypto.GetBytes(data); + stream.Write(data, 0, data.Length); + } } } } From 817cd44b5c817af63aa5d83aa11315882692f60a Mon Sep 17 00:00:00 2001 From: mattosaurus Date: Wed, 28 Aug 2019 12:51:10 +0100 Subject: [PATCH 2/5] Update packages --- PgpCore.Tests/PgpCore.Tests.csproj | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/PgpCore.Tests/PgpCore.Tests.csproj b/PgpCore.Tests/PgpCore.Tests.csproj index 8e3bb5f..68c1a2c 100644 --- a/PgpCore.Tests/PgpCore.Tests.csproj +++ b/PgpCore.Tests/PgpCore.Tests.csproj @@ -1,4 +1,4 @@ - + netcoreapp2.2 @@ -7,9 +7,12 @@ - - - + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + From 8a93211a8681ce7664474e6dfd880a5895618130 Mon Sep 17 00:00:00 2001 From: mattosaurus Date: Wed, 28 Aug 2019 16:56:37 +0100 Subject: [PATCH 3/5] Add copy of BouncyCastle streams object with Async methods --- PgpCore/Streams.cs | 169 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 169 insertions(+) create mode 100644 PgpCore/Streams.cs diff --git a/PgpCore/Streams.cs b/PgpCore/Streams.cs new file mode 100644 index 0000000..24cf807 --- /dev/null +++ b/PgpCore/Streams.cs @@ -0,0 +1,169 @@ +using Org.BouncyCastle.Utilities.IO; +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using System.Threading.Tasks; + +namespace PgpCore +{ + public sealed class Streams + { + private const int BufferSize = 512; + + private Streams() + { + } + + public static void Drain(Stream inStr) + { + byte[] bs = new byte[BufferSize]; + while (inStr.Read(bs, 0, bs.Length) > 0) + { + } + } + + public static byte[] ReadAll(Stream inStr) + { + MemoryStream buf = new MemoryStream(); + PipeAll(inStr, buf); + return buf.ToArray(); + } + + public static byte[] ReadAllLimited(Stream inStr, int limit) + { + MemoryStream buf = new MemoryStream(); + PipeAllLimited(inStr, limit, buf); + return buf.ToArray(); + } + + public static int ReadFully(Stream inStr, byte[] buf) + { + return ReadFully(inStr, buf, 0, buf.Length); + } + + public static int ReadFully(Stream inStr, byte[] buf, int off, int len) + { + int totalRead = 0; + while (totalRead < len) + { + int numRead = inStr.Read(buf, off + totalRead, len - totalRead); + if (numRead < 1) + break; + totalRead += numRead; + } + return totalRead; + } + + public static void PipeAll(Stream inStr, Stream outStr) + { + byte[] bs = new byte[BufferSize]; + int numRead; + while ((numRead = inStr.Read(bs, 0, bs.Length)) > 0) + { + outStr.Write(bs, 0, numRead); + } + } + + /// + /// Pipe all bytes from inStr to outStr, throwing StreamFlowException if greater + /// than limit bytes in inStr. + /// + /// + /// A + /// + /// + /// A + /// + /// + /// A + /// + /// The number of bytes actually transferred, if not greater than limit + /// + public static long PipeAllLimited(Stream inStr, long limit, Stream outStr) + { + byte[] bs = new byte[BufferSize]; + long total = 0; + int numRead; + while ((numRead = inStr.Read(bs, 0, bs.Length)) > 0) + { + if ((limit - total) < numRead) + throw new StreamOverflowException("Data Overflow"); + total += numRead; + outStr.Write(bs, 0, numRead); + } + return total; + } + + /// + public static void WriteBufTo(MemoryStream buf, Stream output) + { + buf.WriteTo(output); + } + + public static async Task DrainAsync(Stream inStr) + { + byte[] bs = new byte[BufferSize]; + while (await inStr.ReadAsync(bs, 0, bs.Length) > 0) + { + } + } + + public static async Task ReadAllAsync(Stream inStr) + { + MemoryStream buf = new MemoryStream(); + await PipeAllAsync(inStr, buf); + return buf.ToArray(); + } + + public static async Task ReadAllLimitedAsync(Stream inStr, int limit) + { + MemoryStream buf = new MemoryStream(); + await PipeAllLimitedAsync(inStr, limit, buf); + return buf.ToArray(); + } + + public static async Task ReadFullyAsync(Stream inStr, byte[] buf) + { + return await ReadFullyAsync(inStr, buf, 0, buf.Length); + } + + public static async Task ReadFullyAsync(Stream inStr, byte[] buf, int off, int len) + { + int totalRead = 0; + while (totalRead < len) + { + int numRead = await inStr.ReadAsync(buf, off + totalRead, len - totalRead); + if (numRead < 1) + break; + totalRead += numRead; + } + return totalRead; + } + + public static async Task PipeAllAsync(Stream inStr, Stream outStr) + { + byte[] bs = new byte[BufferSize]; + int numRead; + while ((numRead = await inStr.ReadAsync(bs, 0, bs.Length)) > 0) + { + await outStr.WriteAsync(bs, 0, numRead); + } + } + + public static async Task PipeAllLimitedAsync(Stream inStr, long limit, Stream outStr) + { + byte[] bs = new byte[BufferSize]; + long total = 0; + int numRead; + while ((numRead = await inStr.ReadAsync(bs, 0, bs.Length)) > 0) + { + if ((limit - total) < numRead) + throw new StreamOverflowException("Data Overflow"); + total += numRead; + await outStr.WriteAsync(bs, 0, numRead); + } + return total; + } + } +} From cb702227da3f72df2f8d4f0260e5615e9393ad7c Mon Sep 17 00:00:00 2001 From: mattosaurus Date: Wed, 28 Aug 2019 16:57:46 +0100 Subject: [PATCH 4/5] Make properly async --- PgpCore/PGP.cs | 207 ++++++++++++++++++++++++------------------- PgpCore/Utilities.cs | 30 +++---- 2 files changed, 131 insertions(+), 106 deletions(-) diff --git a/PgpCore/PGP.cs b/PgpCore/PGP.cs index bb7ecc1..27bb381 100644 --- a/PgpCore/PGP.cs +++ b/PgpCore/PGP.cs @@ -8,7 +8,6 @@ using Org.BouncyCastle.Math; using Org.BouncyCastle.Pkcs; using Org.BouncyCastle.Security; -using Org.BouncyCastle.Utilities.IO; using Org.BouncyCastle.X509; using System; using System.Collections.Generic; @@ -72,28 +71,28 @@ public PGP() #region Encrypt - public async Task EncryptFileAsync(string inputFilePath, string outputFilePath, string publicKeyFilePath, + public void EncryptFile(string inputFilePath, string outputFilePath, string publicKeyFilePath, bool armor = true, bool withIntegrityCheck = true) { - await Task.Run(() => EncryptFile(inputFilePath, outputFilePath, publicKeyFilePath, armor, withIntegrityCheck)); + EncryptFileAsync(inputFilePath, outputFilePath, publicKeyFilePath, armor, withIntegrityCheck).Wait(); } - public async Task EncryptFileAsync(string inputFilePath, string outputFilePath, IEnumerable publicKeyFilePaths, + public void EncryptFile(string inputFilePath, string outputFilePath, IEnumerable publicKeyFilePaths, bool armor = true, bool withIntegrityCheck = true) { - await Task.Run(() => EncryptFile(inputFilePath, outputFilePath, publicKeyFilePaths, armor, withIntegrityCheck)); + EncryptFileAsync(inputFilePath, outputFilePath, publicKeyFilePaths, armor, withIntegrityCheck).Wait(); } - public async Task EncryptStreamAsync(Stream inputStream, Stream outputStream, Stream publicKeyStream, + public void EncryptStream(Stream inputStream, Stream outputStream, Stream publicKeyStream, bool armor = true, bool withIntegrityCheck = true) { - await Task.Run(() => EncryptStream(inputStream, outputStream, publicKeyStream, armor, withIntegrityCheck)); + EncryptStreamAsync(inputStream, outputStream, publicKeyStream, armor, withIntegrityCheck).Wait(); } - public async Task EncryptStreamAsync(Stream inputStream, Stream outputStream, IEnumerable publicKeyStreams, + public void EncryptStream(Stream inputStream, Stream outputStream, IEnumerable publicKeyStreams, bool armor = true, bool withIntegrityCheck = true) { - await Task.Run(() => EncryptStream(inputStream, outputStream, publicKeyStreams, armor, withIntegrityCheck)); + EncryptStreamAsync(inputStream, outputStream, publicKeyStreams, armor, withIntegrityCheck).Wait(); } /// @@ -104,14 +103,14 @@ public async Task EncryptStreamAsync(Stream inputStream, Stream outputStream, IE /// /// /// - public void EncryptFile( + public async Task EncryptFileAsync( string inputFilePath, string outputFilePath, string publicKeyFilePath, bool armor = true, bool withIntegrityCheck = true) { - EncryptFile(inputFilePath, outputFilePath, new [] {publicKeyFilePath}, armor, withIntegrityCheck); + await EncryptFileAsync(inputFilePath, outputFilePath, new[] { publicKeyFilePath }, armor, withIntegrityCheck); } /// @@ -122,7 +121,7 @@ public void EncryptFile( /// /// /// - public void EncryptFile( + public async Task EncryptFileAsync( string inputFilePath, string outputFilePath, IEnumerable publicKeyFilePaths, @@ -140,7 +139,7 @@ public void EncryptFile( throw new FileNotFoundException(String.Format("Input file [{0}] does not exist.", inputFilePath)); foreach (string publicKeyFilePath in publicKeys) { - if(String.IsNullOrEmpty(publicKeyFilePath)) + if (String.IsNullOrEmpty(publicKeyFilePath)) throw new ArgumentException(nameof(publicKeyFilePath)); if (!File.Exists(publicKeyFilePath)) throw new FileNotFoundException(String.Format("Input file [{0}] does not exist.", publicKeyFilePath)); @@ -153,7 +152,7 @@ public void EncryptFile( MemoryStream memoryStream = new MemoryStream(); using (Stream publicKeyStream = new FileStream(publicKeyFilePath, FileMode.Open)) { - publicKeyStream.CopyTo(memoryStream); + await publicKeyStream.CopyToAsync(memoryStream); memoryStream.Position = 0; publicKeyStreams.Add(memoryStream); } @@ -161,7 +160,7 @@ public void EncryptFile( using (FileStream inputStream = new FileStream(inputFilePath, FileMode.Open)) using (Stream outputStream = File.Create(outputFilePath)) - EncryptStream(inputStream, outputStream, publicKeyStreams, armor, withIntegrityCheck); + await EncryptStreamAsync(inputStream, outputStream, publicKeyStreams, armor, withIntegrityCheck); } /// @@ -172,14 +171,14 @@ public void EncryptFile( /// /// /// - public void EncryptStream( + public async Task EncryptStreamAsync( Stream inputStream, Stream outputStream, Stream publicKeyStream, bool armor = true, bool withIntegrityCheck = true) { - EncryptStream(inputStream, outputStream, new[] { publicKeyStream }, armor, withIntegrityCheck); + await EncryptStreamAsync(inputStream, outputStream, new[] { publicKeyStream }, armor, withIntegrityCheck); } /// @@ -187,10 +186,10 @@ public void EncryptStream( /// /// /// - /// + /// /// /// - public void EncryptStream(Stream inputStream, Stream outputStream, IEnumerable publicKeyStreams, bool armor = true, bool withIntegrityCheck = true) + public async Task EncryptStreamAsync(Stream inputStream, Stream outputStream, IEnumerable publicKeyStreams, bool armor = true, bool withIntegrityCheck = true) { //Avoid multiple enumerations of 'publicKeyFilePaths' Stream[] publicKeys = publicKeyStreams.ToArray(); @@ -222,11 +221,11 @@ public void EncryptStream(Stream inputStream, Stream outputStream, IEnumerable EncryptFileAndSign(inputFilePath, outputFilePath, publicKeyFilePath, privateKeyFilePath, passPhrase, armor, withIntegrityCheck)); + EncryptFileAndSignAsync(inputFilePath, outputFilePath, publicKeyFilePath, privateKeyFilePath, passPhrase, armor, withIntegrityCheck).Wait(); } - public async Task EncryptFileAndSignAsync(string inputFilePath, string outputFilePath, IEnumerable publicKeyFilePaths, string privateKeyFilePath, + public void EncryptFileAndSign(string inputFilePath, string outputFilePath, IEnumerable publicKeyFilePaths, string privateKeyFilePath, string passPhrase, bool armor = true, bool withIntegrityCheck = true) { - await Task.Run(() => EncryptFileAndSign(inputFilePath, outputFilePath, publicKeyFilePaths, privateKeyFilePath, passPhrase, armor, withIntegrityCheck)); + EncryptFileAndSignAsync(inputFilePath, outputFilePath, publicKeyFilePaths, privateKeyFilePath, passPhrase, armor, withIntegrityCheck).Wait(); } - public async Task EncryptStreamAndSignAsync(Stream inputStream, Stream outputStream, Stream publicKeyStream, Stream privateKeyStream, string passPhrase, bool armor = true, bool withIntegrityCheck = true) + public void EncryptStreamAndSign(Stream inputStream, Stream outputStream, Stream publicKeyStream, Stream privateKeyStream, string passPhrase, bool armor = true, bool withIntegrityCheck = true) { - await Task.Run(() => EncryptStreamAndSign(inputStream, outputStream, publicKeyStream, privateKeyStream, passPhrase, armor, withIntegrityCheck)); + EncryptStreamAndSignAsync(inputStream, outputStream, publicKeyStream, privateKeyStream, passPhrase, armor, withIntegrityCheck).Wait(); } - public async Task EncryptStreamAndSignAsync(Stream inputStream, Stream outputStream, IEnumerable publicKeyStreams, Stream privateKeyStream, string passPhrase, bool armor = true, bool withIntegrityCheck = true) + public void EncryptStreamAndSign(Stream inputStream, Stream outputStream, IEnumerable publicKeyStreams, Stream privateKeyStream, string passPhrase, bool armor = true, bool withIntegrityCheck = true) { - await Task.Run(() => EncryptStreamAndSign(inputStream, outputStream, publicKeyStreams, privateKeyStream, passPhrase, armor, withIntegrityCheck)); + EncryptStreamAndSignAsync(inputStream, outputStream, publicKeyStreams, privateKeyStream, passPhrase, armor, withIntegrityCheck).Wait(); } /// @@ -271,10 +270,10 @@ public async Task EncryptStreamAndSignAsync(Stream inputStream, Stream outputStr /// /// /// - public void EncryptFileAndSign(string inputFilePath, string outputFilePath, string publicKeyFilePath, + public async Task EncryptFileAndSignAsync(string inputFilePath, string outputFilePath, string publicKeyFilePath, string privateKeyFilePath, string passPhrase, bool armor = true, bool withIntegrityCheck = true) { - EncryptFileAndSign(inputFilePath, outputFilePath, new[] { publicKeyFilePath }, privateKeyFilePath, passPhrase, armor, withIntegrityCheck); + await EncryptFileAndSignAsync(inputFilePath, outputFilePath, new[] { publicKeyFilePath }, privateKeyFilePath, passPhrase, armor, withIntegrityCheck); } /// @@ -286,7 +285,7 @@ public void EncryptFileAndSign(string inputFilePath, string outputFilePath, stri /// /// /// - public void EncryptFileAndSign(string inputFilePath, string outputFilePath, IEnumerable publicKeyFilePaths, + public async Task EncryptFileAndSignAsync(string inputFilePath, string outputFilePath, IEnumerable publicKeyFilePaths, string privateKeyFilePath, string passPhrase, bool armor = true, bool withIntegrityCheck = true) { //Avoid multiple enumerations of 'publicKeyFilePaths' @@ -325,11 +324,11 @@ public void EncryptFileAndSign(string inputFilePath, string outputFilePath, IEnu { using (ArmoredOutputStream armoredOutputStream = new ArmoredOutputStream(outputStream)) { - OutputEncrypted(inputFilePath, armoredOutputStream, encryptionKeys, withIntegrityCheck); + await OutputEncryptedAsync(inputFilePath, armoredOutputStream, encryptionKeys, withIntegrityCheck); } } else - OutputEncrypted(inputFilePath, outputStream, encryptionKeys, withIntegrityCheck); + await OutputEncryptedAsync(inputFilePath, outputStream, encryptionKeys, withIntegrityCheck); } } @@ -342,10 +341,10 @@ public void EncryptFileAndSign(string inputFilePath, string outputFilePath, IEnu /// /// /// - public void EncryptStreamAndSign(Stream inputStream, Stream outputStream, Stream publicKeyStream, + public async Task EncryptStreamAndSignAsync(Stream inputStream, Stream outputStream, Stream publicKeyStream, Stream privateKeyStream, string passPhrase, bool armor = true, bool withIntegrityCheck = true) { - EncryptStreamAndSign(inputStream, outputStream, new[] { publicKeyStream }, privateKeyStream, passPhrase, armor, withIntegrityCheck); + await EncryptStreamAndSignAsync(inputStream, outputStream, new[] { publicKeyStream }, privateKeyStream, passPhrase, armor, withIntegrityCheck); } /// @@ -357,7 +356,7 @@ public void EncryptStreamAndSign(Stream inputStream, Stream outputStream, Stream /// /// /// - public void EncryptStreamAndSign(Stream inputStream, Stream outputStream, IEnumerable publicKeyStreams, + public async Task EncryptStreamAndSignAsync(Stream inputStream, Stream outputStream, IEnumerable publicKeyStreams, Stream privateKeyStream, string passPhrase, bool armor = true, bool withIntegrityCheck = true) { if (inputStream == null) @@ -384,14 +383,14 @@ public void EncryptStreamAndSign(Stream inputStream, Stream outputStream, IEnume { using (ArmoredOutputStream armoredOutputStream = new ArmoredOutputStream(outputStream)) { - OutputEncrypted(inputStream, armoredOutputStream, encryptionKeys, withIntegrityCheck, "name"); + await OutputEncryptedAsync(inputStream, armoredOutputStream, encryptionKeys, withIntegrityCheck, "name"); } } else - OutputEncrypted(inputStream, outputStream, encryptionKeys, withIntegrityCheck, "name"); + await OutputEncryptedAsync(inputStream, outputStream, encryptionKeys, withIntegrityCheck, "name"); } - private void OutputEncrypted(string inputFilePath, Stream outputStream, EncryptionKeys encryptionKeys, bool withIntegrityCheck) + private async Task OutputEncryptedAsync(string inputFilePath, Stream outputStream, EncryptionKeys encryptionKeys, bool withIntegrityCheck) { using (Stream encryptedOut = ChainEncryptedOut(outputStream, encryptionKeys, withIntegrityCheck)) { @@ -403,7 +402,7 @@ private void OutputEncrypted(string inputFilePath, Stream outputStream, Encrypti { using (FileStream inputFileStream = unencryptedFileInfo.OpenRead()) { - WriteOutputAndSign(compressedOut, literalOut, inputFileStream, signatureGenerator); + await WriteOutputAndSignAsync(compressedOut, literalOut, inputFileStream, signatureGenerator); inputFileStream.Dispose(); } } @@ -411,7 +410,7 @@ private void OutputEncrypted(string inputFilePath, Stream outputStream, Encrypti } } - private void OutputSigned(string inputFilePath, Stream outputStream, EncryptionKeys encryptionKeys, bool withIntegrityCheck) + private async Task OutputSignedAsync(string inputFilePath, Stream outputStream, EncryptionKeys encryptionKeys, bool withIntegrityCheck) { FileInfo unencryptedFileInfo = new FileInfo(inputFilePath); using (Stream compressedOut = ChainCompressedOut(outputStream)) @@ -421,14 +420,14 @@ private void OutputSigned(string inputFilePath, Stream outputStream, EncryptionK { using (FileStream inputFileStream = unencryptedFileInfo.OpenRead()) { - WriteOutputAndSign(compressedOut, literalOut, inputFileStream, signatureGenerator); + await WriteOutputAndSignAsync(compressedOut, literalOut, inputFileStream, signatureGenerator); inputFileStream.Dispose(); } } } } - private void OutputEncrypted(Stream inputStream, Stream outputStream, EncryptionKeys encryptionKeys, bool withIntegrityCheck, string name) + private async Task OutputEncryptedAsync(Stream inputStream, Stream outputStream, EncryptionKeys encryptionKeys, bool withIntegrityCheck, string name) { using (Stream encryptedOut = ChainEncryptedOut(outputStream, encryptionKeys, withIntegrityCheck)) { @@ -437,45 +436,45 @@ private void OutputEncrypted(Stream inputStream, Stream outputStream, Encryption PgpSignatureGenerator signatureGenerator = InitSignatureGenerator(compressedOut, encryptionKeys); using (Stream literalOut = ChainLiteralStreamOut(compressedOut, inputStream, name)) { - WriteOutputAndSign(compressedOut, literalOut, inputStream, signatureGenerator); + await WriteOutputAndSignAsync(compressedOut, literalOut, inputStream, signatureGenerator); inputStream.Dispose(); } } } } - private void OutputSigned(Stream inputStream, Stream outputStream, EncryptionKeys encryptionKeys, bool withIntegrityCheck, string name) + private async Task OutputSignedAsync(Stream inputStream, Stream outputStream, EncryptionKeys encryptionKeys, bool withIntegrityCheck, string name) { using (Stream compressedOut = ChainCompressedOut(outputStream)) { PgpSignatureGenerator signatureGenerator = InitSignatureGenerator(compressedOut, encryptionKeys); using (Stream literalOut = ChainLiteralStreamOut(compressedOut, inputStream, name)) { - WriteOutputAndSign(compressedOut, literalOut, inputStream, signatureGenerator); + await WriteOutputAndSignAsync(compressedOut, literalOut, inputStream, signatureGenerator); inputStream.Dispose(); } } } - private void WriteOutputAndSign(Stream compressedOut, Stream literalOut, FileStream inputFilePath, PgpSignatureGenerator signatureGenerator) + private async Task WriteOutputAndSignAsync(Stream compressedOut, Stream literalOut, FileStream inputFilePath, PgpSignatureGenerator signatureGenerator) { int length = 0; byte[] buf = new byte[BufferSize]; - while ((length = inputFilePath.Read(buf, 0, buf.Length)) > 0) + while ((length = await inputFilePath.ReadAsync(buf, 0, buf.Length)) > 0) { - literalOut.Write(buf, 0, length); + await literalOut.WriteAsync(buf, 0, length); signatureGenerator.Update(buf, 0, length); } signatureGenerator.Generate().Encode(compressedOut); } - private void WriteOutputAndSign(Stream compressedOut, Stream literalOut, Stream inputStream, PgpSignatureGenerator signatureGenerator) + private async Task WriteOutputAndSignAsync(Stream compressedOut, Stream literalOut, Stream inputStream, PgpSignatureGenerator signatureGenerator) { int length = 0; byte[] buf = new byte[BufferSize]; - while ((length = inputStream.Read(buf, 0, buf.Length)) > 0) + while ((length = await inputStream.ReadAsync(buf, 0, buf.Length)) > 0) { - literalOut.Write(buf, 0, length); + await literalOut.WriteAsync(buf, 0, length); signatureGenerator.Update(buf, 0, length); } signatureGenerator.Generate().Encode(compressedOut); @@ -545,6 +544,12 @@ private PgpSignatureGenerator InitSignatureGenerator(Stream compressedOut, Encry #region Sign + public void SignFile(string inputFilePath, string outputFilePath, + string privateKeyFilePath, string passPhrase, bool armor = true, bool withIntegrityCheck = true) + { + SignFileAsync(inputFilePath, outputFilePath, privateKeyFilePath, passPhrase, armor, withIntegrityCheck).Wait(); + } + /// /// Sign the file pointed to by unencryptedFileInfo and /// @@ -553,7 +558,7 @@ private PgpSignatureGenerator InitSignatureGenerator(Stream compressedOut, Encry /// /// /// - public void SignFile(string inputFilePath, string outputFilePath, + public async Task SignFileAsync(string inputFilePath, string outputFilePath, string privateKeyFilePath, string passPhrase, bool armor = true, bool withIntegrityCheck = true) { if (String.IsNullOrEmpty(inputFilePath)) @@ -581,14 +586,20 @@ public void SignFile(string inputFilePath, string outputFilePath, { using (ArmoredOutputStream armoredOutputStream = new ArmoredOutputStream(outputStream)) { - OutputSigned(inputFilePath, armoredOutputStream, encryptionKeys, withIntegrityCheck); + await OutputSignedAsync(inputFilePath, armoredOutputStream, encryptionKeys, withIntegrityCheck); } } else - OutputSigned(inputFilePath, outputStream, encryptionKeys, withIntegrityCheck); + await OutputSignedAsync(inputFilePath, outputStream, encryptionKeys, withIntegrityCheck); } } + public void SignStream(Stream inputStream, Stream outputStream, + Stream privateKeyStream, string passPhrase, bool armor = true, bool withIntegrityCheck = true) + { + SignStreamAsync(inputStream, outputStream, privateKeyStream, passPhrase, armor, withIntegrityCheck).Wait(); + } + /// /// Sign the stream pointed to by unencryptedFileInfo and /// @@ -598,7 +609,7 @@ public void SignFile(string inputFilePath, string outputFilePath, /// /// /// - public void SignStream(Stream inputStream, Stream outputStream, + public async Task SignStreamAsync(Stream inputStream, Stream outputStream, Stream privateKeyStream, string passPhrase, bool armor = true, bool withIntegrityCheck = true) { if (inputStream == null) @@ -619,25 +630,25 @@ public void SignStream(Stream inputStream, Stream outputStream, { using (ArmoredOutputStream armoredOutputStream = new ArmoredOutputStream(outputStream)) { - OutputSigned(inputStream, armoredOutputStream, encryptionKeys, withIntegrityCheck, "name"); + await OutputSignedAsync(inputStream, armoredOutputStream, encryptionKeys, withIntegrityCheck, "name"); } } else - OutputSigned(inputStream, outputStream, encryptionKeys, withIntegrityCheck, "name"); + await OutputSignedAsync(inputStream, outputStream, encryptionKeys, withIntegrityCheck, "name"); } #endregion Sign #region Decrypt - public async Task DecryptFileAsync(string inputFilePath, string outputFilePath, string privateKeyFilePath, string passPhrase) + public void DecryptFile(string inputFilePath, string outputFilePath, string privateKeyFilePath, string passPhrase) { - await Task.Run(() => DecryptFile(inputFilePath, outputFilePath, privateKeyFilePath, passPhrase)); + DecryptFileAsync(inputFilePath, outputFilePath, privateKeyFilePath, passPhrase).Wait(); } - public async Task DecryptStreamAsync(Stream inputStream, Stream outputStream, Stream privateKeyStream, string passPhrase) + public void DecryptStream(Stream inputStream, Stream outputStream, Stream privateKeyStream, string passPhrase) { - await Task.Run(() => DecryptStream(inputStream, outputStream, privateKeyStream, passPhrase)); + DecryptStreamAsync(inputStream, outputStream, privateKeyStream, passPhrase).Wait(); } /// @@ -647,7 +658,7 @@ public async Task DecryptStreamAsync(Stream inputStream, Stream outputStream, St /// /// /// - public void DecryptFile(string inputFilePath, string outputFilePath, string privateKeyFilePath, string passPhrase) + public async Task DecryptFileAsync(string inputFilePath, string outputFilePath, string privateKeyFilePath, string passPhrase) { if (String.IsNullOrEmpty(inputFilePath)) throw new ArgumentException("InputFilePath"); @@ -668,7 +679,7 @@ public void DecryptFile(string inputFilePath, string outputFilePath, string priv using (Stream keyStream = File.OpenRead(privateKeyFilePath)) { using (Stream outStream = File.Create(outputFilePath)) - Decrypt(inputStream, outStream, keyStream, passPhrase); + await DecryptAsync(inputStream, outStream, keyStream, passPhrase); } } } @@ -680,7 +691,7 @@ public void DecryptFile(string inputFilePath, string outputFilePath, string priv /// /// /// - public Stream DecryptStream(Stream inputStream, Stream outputStream, Stream privateKeyStream, string passPhrase) + public async Task DecryptStreamAsync(Stream inputStream, Stream outputStream, Stream privateKeyStream, string passPhrase) { if (inputStream == null) throw new ArgumentException("InputStream"); @@ -691,14 +702,14 @@ public Stream DecryptStream(Stream inputStream, Stream outputStream, Stream priv if (passPhrase == null) passPhrase = String.Empty; - Decrypt(inputStream, outputStream, privateKeyStream, passPhrase); + await DecryptAsync(inputStream, outputStream, privateKeyStream, passPhrase); return outputStream; } /* * PGP decrypt a given stream. */ - private void Decrypt(Stream inputStream, Stream outputStream, Stream privateKeyStream, string passPhrase) + private async Task DecryptAsync(Stream inputStream, Stream outputStream, Stream privateKeyStream, string passPhrase) { if (inputStream == null) throw new ArgumentException("InputStream"); @@ -772,14 +783,14 @@ private void Decrypt(Stream inputStream, Stream outputStream, Stream privateKeyS PgpLiteralData Ld = null; Ld = (PgpLiteralData)message; Stream unc = Ld.GetInputStream(); - Streams.PipeAll(unc, outputStream); + await Streams.PipeAllAsync(unc, outputStream); } else { PgpLiteralData Ld = null; Ld = (PgpLiteralData)message; Stream unc = Ld.GetInputStream(); - Streams.PipeAll(unc, outputStream); + await Streams.PipeAllAsync(unc, outputStream); } } else if (message is PgpLiteralData) @@ -788,7 +799,7 @@ private void Decrypt(Stream inputStream, Stream outputStream, Stream privateKeyS string outFileName = ld.FileName; Stream unc = ld.GetInputStream(); - Streams.PipeAll(unc, outputStream); + await Streams.PipeAllAsync(unc, outputStream); if (pbe.IsIntegrityProtected()) { @@ -808,24 +819,38 @@ private void Decrypt(Stream inputStream, Stream outputStream, Stream privateKeyS #region DecryptAndVerify - public async Task DecryptFileAndVerifyAsync(string inputFilePath, string outputFilePath, string publicKeyFilePath, string privateKeyFilePath, string passPhrase) + public void DecryptFileAndVerify(string inputFilePath, string outputFilePath, string publicKeyFilePath, string privateKeyFilePath, string passPhrase) { - await Task.Run(() => DecryptFileAndVerify(inputFilePath, outputFilePath, publicKeyFilePath, privateKeyFilePath, passPhrase)); + try + { + DecryptFileAndVerifyAsync(inputFilePath, outputFilePath, publicKeyFilePath, privateKeyFilePath, passPhrase).Wait(); + } + catch (Exception ex) + { + throw ex.InnerException; + } } - public async Task DecryptStreamAndAndVerifyAsync(Stream inputStream, Stream outputStream, Stream publicKeyStream, Stream privateKeyStream, string passPhrase) + public void DecryptStreamAndAndVerify(Stream inputStream, Stream outputStream, Stream publicKeyStream, Stream privateKeyStream, string passPhrase) { - await Task.Run(() => DecryptStreamAndVerify(inputStream, outputStream, publicKeyStream, privateKeyStream, passPhrase)); + try + { + DecryptStreamAndVerifyAsync(inputStream, outputStream, publicKeyStream, privateKeyStream, passPhrase).Wait(); + } + catch (Exception ex) + { + throw ex.InnerException; + } } - public async Task VerifyFileAsync(string inputFilePath, string publicKeyFilePath) + public bool VerifyFile(string inputFilePath, string publicKeyFilePath) { - await Task.Run(() => VerifyFile(inputFilePath, publicKeyFilePath)); + return VerifyFileAsync(inputFilePath, publicKeyFilePath).Result; } - public async Task VerifyStreamAsync(Stream inputStream, Stream publicKeyStream) + public bool VerifyStream(Stream inputStream, Stream publicKeyStream) { - await Task.Run(() => VerifyStream(inputStream, publicKeyStream)); + return VerifyStreamAsync(inputStream, publicKeyStream).Result; } /// @@ -836,7 +861,7 @@ public async Task VerifyStreamAsync(Stream inputStream, Stream publicKeyStream) /// /// /// - public void DecryptFileAndVerify(string inputFilePath, string outputFilePath, string publicKeyFilePath, string privateKeyFilePath, string passPhrase) + public async Task DecryptFileAndVerifyAsync(string inputFilePath, string outputFilePath, string publicKeyFilePath, string privateKeyFilePath, string passPhrase) { if (String.IsNullOrEmpty(inputFilePath)) throw new ArgumentException("InputFilePath"); @@ -861,7 +886,7 @@ public void DecryptFileAndVerify(string inputFilePath, string outputFilePath, st using (Stream publicKeyStream = File.OpenRead(publicKeyFilePath)) using (Stream privateKeyStream = File.OpenRead(privateKeyFilePath)) using (Stream outStream = File.Create(outputFilePath)) - DecryptAndVerify(inputStream, outStream, publicKeyStream, privateKeyStream, passPhrase); + await DecryptAndVerifyAsync(inputStream, outStream, publicKeyStream, privateKeyStream, passPhrase); } } @@ -872,7 +897,7 @@ public void DecryptFileAndVerify(string inputFilePath, string outputFilePath, st /// /// /// - public Stream DecryptStreamAndVerify(Stream inputStream, Stream outputStream, Stream publicKeyStream, Stream privateKeyStream, string passPhrase) + public async Task DecryptStreamAndVerifyAsync(Stream inputStream, Stream outputStream, Stream publicKeyStream, Stream privateKeyStream, string passPhrase) { if (inputStream == null) throw new ArgumentException("InputStream"); @@ -885,14 +910,14 @@ public Stream DecryptStreamAndVerify(Stream inputStream, Stream outputStream, St if (passPhrase == null) passPhrase = String.Empty; - DecryptAndVerify(inputStream, outputStream, publicKeyStream, privateKeyStream, passPhrase); + await DecryptAndVerifyAsync(inputStream, outputStream, publicKeyStream, privateKeyStream, passPhrase); return outputStream; } /* * PGP decrypt and verify a given stream. */ - private void DecryptAndVerify(Stream inputStream, Stream outputStream, Stream publicKeyStream, Stream privateKeyStream, string passPhrase) + private async Task DecryptAndVerifyAsync(Stream inputStream, Stream outputStream, Stream publicKeyStream, Stream privateKeyStream, string passPhrase) { // find secret key PgpSecretKeyRingBundle pgpSec = new PgpSecretKeyRingBundle(PgpUtilities.GetDecoderStream(privateKeyStream)); @@ -922,7 +947,7 @@ private void DecryptAndVerify(Stream inputStream, Stream outputStream, Stream pu { plainFact = new PgpObjectFactory(clear); } - + PgpObject message = plainFact.NextPgpObject(); if (message is PgpCompressedData cData) @@ -951,7 +976,7 @@ private void DecryptAndVerify(Stream inputStream, Stream outputStream, Stream pu if (message is PgpLiteralData ld) { Stream unc = ld.GetInputStream(); - Streams.PipeAll(unc, outputStream); + await Streams.PipeAllAsync(unc, outputStream); if (pbe.IsIntegrityProtected()) { @@ -970,7 +995,7 @@ private void DecryptAndVerify(Stream inputStream, Stream outputStream, Stream pu /// /// /// - public bool VerifyFile(string inputFilePath, string publicKeyFilePath) + public async Task VerifyFileAsync(string inputFilePath, string publicKeyFilePath) { if (String.IsNullOrEmpty(inputFilePath)) throw new ArgumentException("InputFilePath"); @@ -984,7 +1009,7 @@ public bool VerifyFile(string inputFilePath, string publicKeyFilePath) using (Stream inputStream = File.OpenRead(inputFilePath)) using (Stream publicKeyStream = File.OpenRead(publicKeyFilePath)) - return Verify(inputStream, publicKeyStream); + return await VerifyAsync(inputStream, publicKeyStream); } /// @@ -992,17 +1017,17 @@ public bool VerifyFile(string inputFilePath, string publicKeyFilePath) /// /// /// - public bool VerifyStream(Stream inputStream, Stream publicKeyStream) + public async Task VerifyStreamAsync(Stream inputStream, Stream publicKeyStream) { if (inputStream == null) throw new ArgumentException("InputStream"); if (publicKeyStream == null) throw new ArgumentException("PublicKeyStream"); - return Verify(inputStream, publicKeyStream); + return await VerifyAsync(inputStream, publicKeyStream); } - private bool Verify(Stream inputStream, Stream publicKeyStream) + private async Task VerifyAsync(Stream inputStream, Stream publicKeyStream) { PgpPublicKey publicKey = Utilities.ReadPublicKey(publicKeyStream); bool verified = false; diff --git a/PgpCore/Utilities.cs b/PgpCore/Utilities.cs index 70ed541..21ff438 100644 --- a/PgpCore/Utilities.cs +++ b/PgpCore/Utilities.cs @@ -12,6 +12,7 @@ using System.IO; using System.Linq; using System.Text; +using System.Threading.Tasks; namespace PgpCore { @@ -301,18 +302,18 @@ public static KeyParameter MakeKeyFromPassPhrase( } /// Write out the passed in file as a literal data packet. - public static void WriteFileToLiteralData( + public static async Task WriteFileToLiteralDataAsync( Stream output, char fileType, FileInfo file) { PgpLiteralDataGenerator lData = new PgpLiteralDataGenerator(); Stream pOut = lData.Open(output, fileType, file.Name, file.Length, file.LastWriteTime); - PipeFileContents(file, pOut, 4096); + await PipeFileContentsAsync(file, pOut, 4096); } /// Write out the passed in file as a literal data packet in partial packet format. - public static void WriteFileToLiteralData( + public static async Task WriteFileToLiteralDataAsync( Stream output, char fileType, FileInfo file, @@ -320,10 +321,10 @@ public static void WriteFileToLiteralData( { PgpLiteralDataGenerator lData = new PgpLiteralDataGenerator(); Stream pOut = lData.Open(output, fileType, file.Name, file.LastWriteTime, buffer); - PipeFileContents(file, pOut, buffer.Length); + await PipeFileContentsAsync(file, pOut, buffer.Length); } - public static void WriteStreamToLiteralData( + public static async Task WriteStreamToLiteralDataAsync( Stream output, char fileType, Stream input, @@ -331,10 +332,10 @@ public static void WriteStreamToLiteralData( { PgpLiteralDataGenerator lData = new PgpLiteralDataGenerator(); Stream pOut = lData.Open(output, fileType, name, input.Length, DateTime.Now); - PipeStreamContents(input, pOut, 4096); + await PipeStreamContentsAsync(input, pOut, 4096); } - public static void WriteStreamToLiteralData( + public static async Task WriteStreamToLiteralDataAsync( Stream output, char fileType, Stream input, @@ -343,10 +344,9 @@ public static void WriteStreamToLiteralData( { PgpLiteralDataGenerator lData = new PgpLiteralDataGenerator(); Stream pOut = lData.Open(output, fileType, name, DateTime.Now, buffer); - PipeStreamContents(input, pOut, buffer.Length); + await PipeStreamContentsAsync(input, pOut, buffer.Length); } - /// /// Opens a key ring file and returns first available sub-key suitable for encryption. /// If such sub-key is not found, return master key that can encrypt. @@ -394,28 +394,28 @@ public static PgpPublicKey ReadPublicKey(string publicKeyFilePath) return ReadPublicKey(fs); } - private static void PipeFileContents(FileInfo file, Stream pOut, int bufSize) + private static async Task PipeFileContentsAsync(FileInfo file, Stream pOut, int bufSize) { using (FileStream inputStream = file.OpenRead()) { byte[] buf = new byte[bufSize]; int len; - while ((len = inputStream.Read(buf, 0, buf.Length)) > 0) + while ((len = await inputStream.ReadAsync(buf, 0, buf.Length)) > 0) { - pOut.Write(buf, 0, len); + await pOut.WriteAsync(buf, 0, len); } } } - private static void PipeStreamContents(Stream input, Stream pOut, int bufSize) + private static async Task PipeStreamContentsAsync(Stream input, Stream pOut, int bufSize) { byte[] buf = new byte[bufSize]; int len; - while ((len = input.Read(buf, 0, buf.Length)) > 0) + while ((len = await input.ReadAsync(buf, 0, buf.Length)) > 0) { - pOut.Write(buf, 0, len); + await pOut.WriteAsync(buf, 0, len); } } From 5f015c882526b7d709caf5b86e8d3697f5e94803 Mon Sep 17 00:00:00 2001 From: mattosaurus Date: Wed, 28 Aug 2019 17:01:10 +0100 Subject: [PATCH 5/5] Update properties --- PgpCore/PgpCore.csproj | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PgpCore/PgpCore.csproj b/PgpCore/PgpCore.csproj index 1446e02..c9ac28b 100644 --- a/PgpCore/PgpCore.csproj +++ b/PgpCore/PgpCore.csproj @@ -10,10 +10,10 @@ https://github.com/mattosaurus/PgpCore https://github.com/mattosaurus/PgpCore PGP .NET Core - 1.7.2 - 1.7.2.0 - 1.7.2.0 - v1.7.2 - DecryptAndVerify fixes + 2.0.0 + 2.0.0.0 + 2.0.0.0 + v2.0.0 - Updated to be async first and to better handle large files MIT