Decrypt and verify pgp data in C# and VB.NET

using System;
using DidiSoft.Pgp;
 
public class DecryptAndVerify
{
 public void Demo()
 {
    // create an instance of the library
    PGPLib pgp = new PGPLib();
 
    SignatureCheckResult signatureCheck = 
         pgp.DecryptAndVerifyFile(@"C:\Test\OUTPUT.pgp",
                                  @"C:\Test\my_private_key.asc",
                                  "private key password",
                                  @"C:\Test\sender_public_key.asc",
                                  @"C:\Test\INPUT.txt");
   if (signatureCheck == SignatureCheckResult.SignatureVerified)
   {
	   Console.WriteLine("Signare OK");
   }
   else if (signatureCheck == SignatureCheckResult.SignatureBroken)
   {
	   Console.WriteLine("Signare of the message is either broken or forged");
   }
   else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
   {
	   Console.WriteLine("The provided public key doesn't match the signature");
   }
   else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
   {
	   Console.WriteLine("This message is not digitally signed");
   }
 }
}

Imports System
Imports DidiSoft.Pgp
 
Public Class DecryptAndVerify
 Public Sub Demo()
   ' create an instance of the library   
   Dim pgp As New PGPLib()
 
   Dim signatureCheck As SignatureCheckResult = _
       pgp.DecryptAndVerifyFile("C:\Test\OUTPUT.pgp", _
				"C:\Test\my_private_key.asc", _
				"private key password", _
				"C:\Test\sender_public_key.asc", _
				"C:\Test\INPUT.txt")
   If signatureCheck = SignatureCheckResult.SignatureVerified Then
	Console.WriteLine("Signare OK")
   ElseIf signatureCheck = SignatureCheckResult.SignatureBroken Then
	Console.WriteLine("Signare of the message is either broken or forged")
   ElseIf signatureCheck = SignatureCheckResult.PublicKeyNotMatching Then
	Console.WriteLine("The provided public key(s) doesn't match the signature")
   ElseIf signatureCheck = SignatureCheckResult.NoSignatureFound Then
	Console.WriteLine("This message is not digitally signed")
   End If
 End Sub
End Class

using System;
using System.Threading;
using System.Threading.Tasks;
using DidiSoft.Pgp;
 
public class DecryptAndVerify
{
 public async void Demo()
 {
  // create an instance of the library
  PGPLibAsync pgp = new PGPLibAsync();
 
  // private key to be used for decryption
  String privateKeyFile = @"DataFiles\private.key";
  String privateKeyPassword = "changeit";
 
  // public key of the sender, to be used for signature verficitaion
  String senderPublicKeyFile = @"DataFiles\public.key";
 
  // optional parameter
  CancellationToken token = default(CancellationToken);
 
  SignatureCheckResult signatureCheck = SignatureCheckResult.NoSignatureFound;
  try
  {
	signatureCheck =
	 await pgp.DecryptAndVerifyFileAsync(@"DataFiles\OUTPUTse.pgp",
						 privateKeyFile,
						 privateKeyPassword,
						 senderPublicKeyFile,
						 @"DataFiles\OUTPUT.txt");
  }
  catch (PGPException e)
  {
	if (e is NonPGPDataException)
	{
		Console.WriteLine("The input file is not an OpenPGP archive or is corrupted");
	}
	else if (e is WrongPublicKeyException)
	{
		Console.WriteLine("The supplied public key is not an OpenPGP public key or is corrupted");
	}
	else if (e is WrongPrivateKeyException)
	{
		// The message cannot be decrypted with this private key 
		// or the supplied private key is not an OpenPGP private key or is corrupted
		Console.WriteLine(e.Message);
	}
	else if (e is WrongPasswordException)
	{
		Console.WriteLine("The password for the private key is incorrect");
	}
	else if (e is FileIsPBEEncryptedException)
	{
		Console.WriteLine("The input file is password encrypted.");
		Console.WriteLine("You have to use DecryptAndVeifyFilePBE or DecryptAndVerifyStreamPBE");
	}
	else if (e is IntegrityCheckException)
	{
		Console.WriteLine("The encrypted data is corrupted");
	}
	else
	{
		Console.WriteLine(e.Message);
	}
  }
 
  if (signatureCheck == SignatureCheckResult.SignatureVerified)
  {
	Console.WriteLine("Signature OK");
  }
  else if (signatureCheck == SignatureCheckResult.SignatureBroken)
  {
	Console.WriteLine("Signature of the message is either broken or forged");
  }
  else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
  {
	Console.WriteLine("The provided public key doesn't match the signature");
  }
  else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
  {
	Console.WriteLine("This message is not digitally signed");
  }
 }
}

using System;
using DidiSoft.Pgp;
 
public class KeyStoreDecryptAndVerifyFile
{
 public static void Demo()
 {
   // initialize the KeyStore
   KeyStore keyStore = new KeyStore(@"c:\key.store", "key store pass");
 
   // create an instance of the library
   PGPLib pgp = new PGPLib();
 
   // we should provide the private decryption key password too
   String decryptionKeyPassword = "private key password";
   SignatureCheckResult signatureCheck = 
                       pgp.DecryptAndVerifyFile(@"c:\INPUT.pgp",
						keyStore,
						decryptionKeyPassword,
						@"c:\OUTPUT.txt");
   if (signatureCheck == SignatureCheckResult.SignatureVerified)
   {
	   Console.WriteLine("Signare OK");
   }
   else if (signatureCheck == SignatureCheckResult.SignatureBroken)
   {
	   Console.WriteLine("Signare of the message is either broken or forged");
   }
   else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
   {
	   Console.WriteLine("The provided public key doesn't match the signature");
   }
   else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
   {
	   Console.WriteLine("This message is not digitally signed");
   }
 }
}

Imports System
Imports DidiSoft.Pgp
 
Public Class KeyStoreDecryptAndVerifyFile
 Public Shared Sub Demo()
    ' initialize the KeyStore
    Dim keyStore As New KeyStore("c:\key.store", "key store pass")
 
    ' create an instance of the library
    Dim pgp As New PGPLib()
 
    ' we should provide the private decryption key password too
    Dim decryptionKeyPassword As String = "private key password"
    Dim signatureCheck As SignatureCheckResult = _
                pgp.DecryptAndVerifyFile("c:\OUTPUT.pgp", _
					  keyStore, _
					  decryptionKeyPassword, _
					  "c:\OUTPUT.txt")
    If signatureCheck = SignatureCheckResult.SignatureVerified Then
		Console.WriteLine("Signare OK")
    ElseIf signatureCheck = SignatureCheckResult.SignatureBroken Then
		Console.WriteLine("Signare of the message is either broken or forged")
    ElseIf signatureCheck = SignatureCheckResult.PublicKeyNotMatching Then
		Console.WriteLine("The provided public key(s) doesn't match the signature")
    ElseIf signatureCheck = SignatureCheckResult.NoSignatureFound Then
		Console.WriteLine("This message is not digitally signed")
    End If
 
 End Sub
End Class

using System;
using System.Threading;
using System.Threading.Tasks;
using DidiSoft.Pgp;
 
public class KeyStoreDecryptAndVerifyFile
{
  public async Task Demo()
  {
	// initialize the key store
	KeyStore keyStore = new KeyStore(@"DataFiles\key.store", "changeit");
 
	// initialize the library
	PGPLibAsync pgp = new PGPLibAsync();
 
	String decryptionKeyPassword = "private key password";
 
        // optional parameter
        CancellationToken token = default(CancellationToken);
 
	SignatureCheckResult signatureCheck =
		await pgp.DecryptAndVerifyFileAsync(@"DataFiles\OUTPUT.pgp",
						keyStore,
						decryptionKeyPassword,
						@"DataFiles\OUTPUT.txt",
                                                token);
 
	if (signatureCheck == SignatureCheckResult.SignatureVerified)
	{
		Console.WriteLine("Signature OK");
	}
	else if (signatureCheck == SignatureCheckResult.SignatureBroken)
	{
		Console.WriteLine("Signature of the message is either broken or forged");
	}
	else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
	{
		Console.WriteLine("The provided public key doesn't match the signature");
	}
	else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
	{
		Console.WriteLine("This message is not digitally signed");
	}
  }
}

using System;
using DidiSoft.Pgp;
 
public class DecryptAndVerifyMulti
{
 public void Demo()
 {
	// create an instance of the library
	PGPLib pgp = new PGPLib();
 
	// private key to be used for decryption
	String privateKeyFile = @"DataFiles\private.key";
	String privateKeyPassword = "changeit";
 
	// public key of the sender, to be used for signature verficitaion
	String senderPublicKeyFile = @"DataFiles\public.key";
 
	string outputFolder = @"DataFiles";
 
	SignatureCheckResult signatureCheck = 
			pgp.VerifyFileWithoutExtracting(@"DataFiles\OUTPUTse.pgp",
							 privateKeyFile,
							 privateKeyPassword,
							 senderPublicKeyFile);
 
        if (signatureCheck == SignatureCheckResult.SignatureVerified)
        {
	   Console.WriteLine("Signare OK");
        }
	else if (signatureCheck == SignatureCheckResult.SignatureBroken)
	{
	   Console.WriteLine("Signare of the message is either broken or forged");
	}
	else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
	{
	   Console.WriteLine("The provided public key doesn't match the signature");
	}
	else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
	{
	   Console.WriteLine("This message is not digitally signed");
	}
 
	// decrypts the content of the PGP archive
	// and returns array with full file paths of the 
	// exytracted file(s)
	string[] decryptedFileNames =
		pgp.DecryptTo(@"DataFiles\OUTPUTse.pgp",
					privateKeyFile,
					privateKeyPassword,
					outputFolder);
 }
}

Imports System
Imports DidiSoft.Pgp
 
Public Class DecryptAndVerifyMulti
 Public Sub Demo()
	' create an instance of the library
	Dim pgp As New PGPLib()
 
	' private key to be used for decryption
	Dim privateKeyFile As [String] = "DataFiles\private.key"
	Dim privateKeyPassword As [String] = "changeit"
 
	' public key of the sender, to be used for signature verficitaion
	Dim senderPublicKeyFile As [String] = "DataFiles\public.key"
 
	Dim outputFolder As String = "DataFiles"
 
	Dim signatureCheck As SignatureCheckResult = _
		pgp.VerifyFileWithoutExtracting("DataFiles\OUTPUTse.pgp", _
						privateKeyFile, _
						privateKeyPassword, _
						senderPublicKeyFile)
 
	If signatureCheck = SignatureCheckResult.SignatureVerified Then
		Console.WriteLine("Signare OK")
	ElseIf signatureCheck = SignatureCheckResult.SignatureBroken Then
		Console.WriteLine("Signare of the message is either broken or forged")
	ElseIf signatureCheck = SignatureCheckResult.PublicKeyNotMatching Then
		Console.WriteLine("The provided public key(s) doesn't match the signature")
	ElseIf signatureCheck = SignatureCheckResult.NoSignatureFound Then
		Console.WriteLine("This message is not digitally signed")
	End If
 
	' decrypts the content of the PGP archive
	' and returns array with full file paths of the 
	' exytracted file(s)
 
	Dim decryptedFileNames As String() = _
		pgp.DecryptTo("DataFiles\OUTPUTse.pgp", _
					privateKeyFile, _
					privateKeyPassword, _
					outputFolder)
 End Sub
End Class

using System;
using DidiSoft.Pgp;
 
public class KeyStoreDecryptAndVerifyMulti
{
 public void Demo()
 {
	// create an instance of the library
	PGPLib pgp = new PGPLib();
 
	KeyStore keyStore = new KeyStore(@"DataFiles\key.store", "changeit");
 
	String privateKeyPassword = "changeit";
 
	string outputFolder = @"DataFiles";
 
	SignatureCheckResult signatureCheck = 
			pgp.VerifyFileWithoutExtracting(@"DataFiles\OUTPUTse.pgp",
									 keyStore,
									 privateKeyPassword);
 
	if (signatureCheck == SignatureCheckResult.SignatureVerified)
	{
	   Console.WriteLine("Signare OK");
	}
	else if (signatureCheck == SignatureCheckResult.SignatureBroken)
	{
	   Console.WriteLine("Signare of the message is either broken or forged");
	}
	else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
	{
	   Console.WriteLine("The provided public key doesn't match the signature");
	}
	else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
	{
	   Console.WriteLine("This message is not digitally signed");
	}
 
	// decrypts the content of the PGP archive
	// and returns array with full file paths of the 
	// exytracted file(s)
	string[] decryptedFileNames =
		pgp.DecryptTo(@"DataFiles\OUTPUTse.pgp",
					keyStore,
					privateKeyPassword,
					outputFolder);
	}
 }
}

Imports System
Imports DidiSoft.Pgp
 
Public Class KeyStoreDecryptAndVerifyMulti
 Public Sub Demo()
	' create an instance of the library
	Dim pgp As New PGPLib()
 
	Dim keyStore As New KeyStore("DataFiles\key.store", "changeit")
 
	Dim privateKeyPassword As [String] = "changeit"
 
	Dim outputFolder As String = "DataFiles"
 
	Dim signatureCheck As SignatureCheckResult = _
		pgp.VerifyFileWithoutExtracting("DataFiles\OUTPUTse.pgp", _
										keyStore, _
										privateKeyPassword)
 
	If signatureCheck = SignatureCheckResult.SignatureVerified Then
		Console.WriteLine("Signare OK")
	ElseIf signatureCheck = SignatureCheckResult.SignatureBroken Then
		Console.WriteLine("Signare of the message is either broken or forged")
	ElseIf signatureCheck = SignatureCheckResult.PublicKeyNotMatching Then
		Console.WriteLine("The provided public key(s) doesn't match the signature")
	ElseIf signatureCheck = SignatureCheckResult.NoSignatureFound Then
		Console.WriteLine("This message is not digitally signed")
	End If
 
	' decrypts the content of the PGP archive
	' and returns array with full file paths of the 
	' exytracted file(s)
	Dim decryptedFileNames As String() = _
		pgp.DecryptTo("DataFiles\OUTPUTse.pgp", _
					keyStore, _
					privateKeyPassword, _
					outputFolder)
 End Sub
End Class

using System;
using System.IO;
using DidiSoft.Pgp;
 
class DecryptAndVerifyString
{
 public void Demo()
 {
   // obtain encrypted and signed message
   String signedAndEncryptedMessage = ...
 
   String plainTextExtracted;
 
   // create an instance of the library
   PGPLib pgp = new PGPLib();
 
   // decrypt and verify
   SignatureCheckResult signatureCheck = 
       pgp.DecryptAndVerifyString(signedAndEncryptedMessage,
				@"c:\my_private_key.asc",
				"private key password",
				@"c:\sender_public_key.asc",
				out plainTextExtracted);
   // print the results
   if (signatureCheck == SignatureCheckResult.SignatureVerified)
   {
	   Console.WriteLine("Signare OK");
   }
   else if (signatureCheck == SignatureCheckResult.SignatureBroken)
   {
	   Console.WriteLine("Signare of the message is either broken or forged");
   }
   else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
   {
	   Console.WriteLine("The provided public key doesn't match the signature");
   }
   else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
   {
	   Console.WriteLine("This message is not digitally signed");
   }
 
   Console.WriteLine("Extracted message: " + plainTextExtracted);
 }
}

Imports System
Imports System.IO
Imports DidiSoft.Pgp
 
Class DecryptAndVerifyString
 Public Sub Demo()
   ' obtain encrypted and signed message
   Dim signedAndEncryptedMessage As String = ...
 
   Dim plainTextExtracted As String
 
   ' create an instance of the library
   Dim pgp As New PGPLib()
 
   ' decrypt and verify
   Dim signatureCheck As SignatureCheckResult = _
           pgp.DecryptAndVerifyString(signedAndEncryptedMessage, _
                                     "c:\private.key", _
                                     "private key password", _
                                     "c:\public.key", _
                                     plainTextExtracted)
   ' print the results
   If signatureCheck = SignatureCheckResult.SignatureVerified Then
	Console.WriteLine("Signare OK")
   ElseIf signatureCheck = SignatureCheckResult.SignatureBroken Then
	Console.WriteLine("Signare of the message is either broken or forged")
   ElseIf signatureCheck = SignatureCheckResult.PublicKeyNotMatching Then
	Console.WriteLine("The provided public key(s) doesn't match the signature")
   ElseIf signatureCheck = SignatureCheckResult.NoSignatureFound Then
	Console.WriteLine("This message is not digitally signed")
   End If
 
  Console.WriteLine("Extracted message: " + plainTextExtracted)
 End Sub
End Class

using System;
using System.Threading;
using System.Threading.Tasks;
using DidiSoft.Pgp;
 
class DecryptAndVerifyString
{
  public async Task Demo()
  {
	// obtain encrypted and signed message
	String signedAndEncryptedMessage = SignAndEncryptString.Demo();
 
	// create instance of the library
	PGPLibAsync pgp = new PGPLibAsync();
 
	// optional parameter
	CancellationToken token = default(CancellationToken);
 
	// although we supply here the keys as file locations 
        // they can also be passed as ASCII armor serialzed strings
	Tuple<SignatureCheckResult, string> result = 
                await pgp.DecryptAndVerifyStringAsync(signedAndEncryptedMessage,
							 @"DataFiles\private.key",
							 "private key password",
							 @"DataFiles\public.key",
							 token);
 
	SignatureCheckResult signatureCheck = result.Item1;
	string plainTextExtracted = result.Item2;
 
	// print results
	if (signatureCheck == SignatureCheckResult.SignatureVerified)
	{
		Console.WriteLine("Signature OK");
	}
	else if (signatureCheck == SignatureCheckResult.SignatureBroken)
	{
		Console.WriteLine("Signature of the message is either broken or forged");
	}
	else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
	{
		Console.WriteLine("The provided public key doesn't match the signature");
	}
	else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
	{
		Console.WriteLine("This message is not digitally signed");
	}
 
	Console.WriteLine("Extracted message: " + plainTextExtracted);
  }
}

using System;
using DidiSoft.Pgp;
 
class KeyStoreDecryptAndVerifyString
{
 public static void Demo()
 {
    // obtain an OpenPGP signed and enrypted message
    String signedAndEncryptedString = ...
 
    String privateKeyDecryptionPassword = "private key password";
 
    // Extract the message and check the validity of the signature
    String plainText;
 
    // create an instance of the library
    PGPLib pgp = new PGPLib();
 
    // initialize the key store
    KeyStore ks = new KeyStore(@"c:\key.store", "key store password");
 
    SignatureCheckResult signatureCheck = 
           pgp.DecryptAndVerifyString(signedAndEncryptedString,
				     ks,
				     privateKeyDecryptionPassword,
				     out plainText);
 
    // Print the results
    Console.WriteLine("Extracted plain text message is " + plainText);
 
    if (signatureCheck == SignatureCheckResult.SignatureVerified)
    {
	   Console.WriteLine("Signare OK");
    }
    else if (signatureCheck == SignatureCheckResult.SignatureBroken)
    {
	   Console.WriteLine("Signare of the message is either broken or forged");
    }
    else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
    {
	   Console.WriteLine("The provided public key doesn't match the signature");
    }
    else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
    {
	   Console.WriteLine("This message is not digitally signed");
    }
 }
}

Imports System
Imports DidiSoft.Pgp
 
Class KeyStoreDecryptAndVerifyString
 Public Shared Sub Demo()
   ' obtain an OpenPGP signed and enrypted message
   Dim signedAndEncryptedString As String = ...
 
   Dim privateKeyDecryptionPassword As String = "private key password"
 
   ' Extract the message and check the validity of the signature
   Dim plainText As String
 
   ' create an instance of the library
   Dim pgp As New PGPLib()
 
   ' initialize the key store
   Dim ks As New KeyStore("c:\key.store", "key store password")
 
   Dim signatureCheck As SignatureCheckResult = _
           pgp.DecryptAndVerifyString(signedAndEncryptedString, _
                                      ks, _
                                      privateKeyDecryptionPassword, _
                                      plainText)
 
   ' Print the results
   Console.WriteLine("Extracted plain text message is " + plainText)
 
  If signatureCheck = SignatureCheckResult.SignatureVerified Then
	Console.WriteLine("Signare OK")
  ElseIf signatureCheck = SignatureCheckResult.SignatureBroken Then
	Console.WriteLine("Signare of the message is either broken or forged")
  ElseIf signatureCheck = SignatureCheckResult.PublicKeyNotMatching Then
	Console.WriteLine("The provided public key(s) doesn't match the signature")
  ElseIf signatureCheck = SignatureCheckResult.NoSignatureFound Then
	Console.WriteLine("This message is not digitally signed")
  End If
 End Sub
End Class

using System;
using DidiSoft.Pgp;
 
class KeyStoreDecryptAndVerifyString
{
  public async Task Demo()
  {
	// obtain an OpenPGP signed and enrypted message
	String signedAndEncryptedString = SignAndEncryptString.Demo();
 
	String privateKeyPassword = "private key password";
 
	// initialize the library
	PGPLibAsync pgp = new PGPLibAsync();
 
	// initialize the key store
	KeyStore ks = new KeyStore(@"DataFiles\key.store", "changeit");
 
	// optional parameter
	CancellationToken token = default(CancellationToken);
 
	Tuple<SignatureCheckResult, string> result = 
            await pgp.DecryptAndVerifyStringAsync(signedAndEncryptedString,
						ks,
						privateKeyPassword,
						token);
 
	// signature check result
	SignatureCheckResult signatureCheck = result.Item1;
	// Extracted message 
	string plainText = result.Item2;
 
	// Print the results
	Console.WriteLine("Extracted plain text message is " + plainText);
 
	if (signatureCheck == SignatureCheckResult.SignatureVerified)
	{
		Console.WriteLine("Signature OK");
	}
	else if (signatureCheck == SignatureCheckResult.SignatureBroken)
	{
		Console.WriteLine("Signature of the message is either broken or forged");
	}
	else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
	{
		Console.WriteLine("The provided public key doesn't match the signature");
	}
	else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
	{
		Console.WriteLine("This message is not digitally signed");
	}
  }
}

using System;
using System.IO;
using DidiSoft.Pgp;
 
public class DecryptAndVerifyStream
{
public void Demo()
{ 
	// create an instance of the library
	PGPLib pgp = new PGPLib();
 
	// OpenPGP signed and encrypted data
	using (Stream dataStream = File.OpenRead(@"DataFiles\OUTPUTse.pgp"))
	// public key of the sender, to be used for signature verification
	using (Stream senderPublicKeyStream = File.OpenRead(@"DataFiles\public.key"))
	// private key to be used for decryption
	using (Stream privateKeyStream = File.OpenRead(@"DataFiles\private.key"))
	{                
		String privateKeyPassword = "changeit";
 
		// The output can be an arbitrary subclass of System.IO.Stream
		MemoryStream outputStream = new MemoryStream();
		SignatureCheckResult signatureCheck = pgp.DecryptAndVerifyStream(dataStream,
													 privateKeyStream,
													 privateKeyPassword,
													 senderPublicKeyStream,
													 outputStream);
		if (signatureCheck == SignatureCheckResult.SignatureVerified)
		{
			Console.WriteLine("Signature OK");
		}
		else if (signatureCheck == SignatureCheckResult.SignatureBroken)
		{
			Console.WriteLine("Signature of the message is either broken or forged");
		}
		else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
		{
			Console.WriteLine("The provided public key doesn't match the signature");
		}
		else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
		{
			Console.WriteLine("This message is not digitally signed");
		}
 
		// we must reinitialize the output in order to be able to read from it
		outputStream.Position = 0;
	}
}
<a name="DecryptStreamAsync"></a>
<h2>5-A. Async Decrypt and verify a Stream</h2>
We can also asynchronously decrypt and verify an <a href="/net-openpgp/examples/openpgp-sign-and-encrypt-in-net/#SignStreamAsync">OpenPGP signed and encrypted Stream</a> with the method <b>PGPLibAsync.DecryptAndVerifyStreamAsync</b>.
 
The public key of the person or organization that signed the data must be provided for the signature verification and our private key for the data decryption.
 
<pre lang="csharp">using System;
using System.Threading;
using System.Threading.Tasks;
using DidiSoft.Pgp;
 
class DecryptAndVerifyStreamAsync
{
 public async Task Demo()
 {
	// create an instance of the library
	PGPLibAsync pgp = new PGPLibAsync();
 
	using (Stream dataStream = File.OpenRead(@"DataFiles\OUTPUTse.pgp"))
 
	// public key of the sender, to be used for signature verification
	using (Stream senderPublicKeyStream = File.OpenRead(@"DataFiles\public.key"))
 
	// private key to be used for decryption
	using (Stream privateKeyStream = File.OpenRead(@"DataFiles\private.key"))
	{
		String privateKeyPassword = "changeit";
 
		// optional parameter
		CancellationToken token = default(CancellationToken);
 
		// The output can be an arbitrary subclass of System.IO.Stream
		MemoryStream outputStream = new MemoryStream();
		SignatureCheckResult signatureCheck = await pgp.DecryptAndVerifyStreamAsync(dataStream,
													 privateKeyStream,
													 privateKeyPassword,
													 senderPublicKeyStream,
													 outputStream,
													 token);
		if (signatureCheck == SignatureCheckResult.SignatureVerified)
		{
			Console.WriteLine("Signature OK");
		}
		else if (signatureCheck == SignatureCheckResult.SignatureBroken)
		{
			Console.WriteLine("Signature of the message is either broken or forged");
		}
		else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
		{
			Console.WriteLine("The provided public key doesn't match the signature");
		}
		else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
		{
			Console.WriteLine("This message is not digitally signed");
		}
 
		// ... output position is at its end 
		// we must set it to 0 in order to be able to read from it                
	}
 }
}

using System;
using System.IO;
using DidiSoft.Pgp;
 
public class DecryptAndVerifyStream
{
 public static void Demo()
 {
	// initialize the library
	PGPLib pgp = new PGPLib();
 
	// initialize the key store that contains the public key of the sender
	// and the private key (usually our own) that will be used for decryption
	KeyStore keyStore = new KeyStore(@"DataFiles\key.store", "changeit");
 
	// password of the private key that will be used for decryption
	String decryptionKeyPassword = "private key password";
 
	// The output can be an arbitrary subclass of System.IO.Stream
	MemoryStream outputStream = new MemoryStream();
 
	using (Stream encryptedStream = File.OpenRead(@"DataFiles\OUTPUT.pgp")) 
	{
		SignatureCheckResult signatureCheck = 
			pgp.DecryptAndVerifyStream(encryptedStream,
						keyStore,
						decryptionKeyPassword,
						outputStream);
 
		if (signatureCheck == SignatureCheckResult.SignatureVerified)
		{
			Console.WriteLine("Signature OK");
		}
		else if (signatureCheck == SignatureCheckResult.SignatureBroken)
		{
			Console.WriteLine("Signature of the message is either broken or forged");
		}
		else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
		{
			Console.WriteLine("The provided public key doesn't match the signature");
		}
		else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
		{
			Console.WriteLine("This message is not digitally signed");
		}
	}
}

using System;
using System.IO;
using DidiSoft.Pgp;
 
class DecryptAndVerifyStreamAsyncKS
{
public async Task Demo()
{
	// initialize the library
	PGPLibAsync pgp = new PGPLibAsync();
 
	// initialize the key store that contains the public key of the sender
	// and the private key (usually our own) that will be used for decryption
	KeyStore keyStore = new KeyStore(@"DataFiles\key.store", "changeit");
 
	// password of the private key that will be used for decryption
	String decryptionKeyPassword = "private key password";
 
	// The output can be an arbitrary subclass of System.IO.Stream
	MemoryStream outputStream = new MemoryStream();
 
	// optional parameter
	CancellationToken token = default(CancellationToken);
 
	using (Stream encryptedStream = File.OpenRead(@"DataFiles\OUTPUT.pgp"))
	{
		SignatureCheckResult signatureCheck =
			await pgp.DecryptAndVerifyStreamAsync(encryptedStream,
								keyStore,
								decryptionKeyPassword,
								outputStream,
								token);
 
		if (signatureCheck == SignatureCheckResult.SignatureVerified)
		{
			Console.WriteLine("Signature OK");
		}
		else if (signatureCheck == SignatureCheckResult.SignatureBroken)
		{
			Console.WriteLine("Signature of the message is either broken or forged");
		}
		else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
		{
			Console.WriteLine("The provided public key doesn't match the signature");
		}
		else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
		{
			Console.WriteLine("This message is not digitally signed");
		}
 
		// we must reinitialize the output in order to be able to read from it
		outputStream.Position = 0;
	}
}

using System;
using DidiSoft.Pgp;
 
public class DecryptAndVerifyPBE
{
 public void Demo()
 {
    // create an instance of the library
    PGPLib pgp = new PGPLib();
 
    SignatureCheckResult signatureCheck =
         pgp.DecryptAndVerifyFilePBE(@"C:\Test\OUTPUT.pgp",
                                  "encryption password",
                                  @"C:\Test\sender_public_key.asc",
                                  @"C:\Test\INPUT.txt");
 
   if (signatureCheck == SignatureCheckResult.SignatureVerified)
   {
	   Console.WriteLine("Signare OK");
   }
   else if (signatureCheck == SignatureCheckResult.SignatureBroken)
   {
	   Console.WriteLine("Signare of the message is either broken or forged");
   }
   else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
   {
	   Console.WriteLine("The provided public key doesn't match the signature");
   }
   else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
   {
	   Console.WriteLine("This message is not digitally signed");
   }
 }
}

Imports System
Imports DidiSoft.Pgp
 
Public Class DecryptAndVerifyPBE
 Public Sub Demo()
   ' create an instance of the library   
   Dim pgp As New PGPLib()
 
   Dim signatureCheck As SignatureCheckResult = _
    pgp.DecryptAndVerifyFilePBE("C:\Test\OUTPUT.pgp", _
				"encryption password", _
				"C:\Test\sender_public_key.asc", _
				"C:\Test\INPUT.txt")
 
   If signatureCheck = SignatureCheckResult.SignatureVerified Then
	Console.WriteLine("Signare OK")
   ElseIf signatureCheck = SignatureCheckResult.SignatureBroken Then
	Console.WriteLine("Signare of the message is either broken or forged")
   ElseIf signatureCheck = SignatureCheckResult.PublicKeyNotMatching Then
	Console.WriteLine("The provided public key(s) doesn't match the signature")
   ElseIf signatureCheck = SignatureCheckResult.NoSignatureFound Then
	Console.WriteLine("This message is not digitally signed")
   End If
 End Sub
End Class

using System;
using DidiSoft.Pgp;
 
public class KeyStoreDecryptAndVerifyFile
{
 public static void Demo()
 {
   // initialize the KeyStore
   KeyStore keyStore = new KeyStore(@"c:\key.store", "key store pass");
 
   // create an instance of the library
   PGPLib pgp = new PGPLib();
 
   // we should provide the private decryption key password too
   String decryptionPassword = "encryption password";
   SignatureCheckResult signatureCheck = 
                    pgp.DecryptAndVerifyFilePBE(@"c:\INPUT.pgp",
						keyStore,
						decryptionPassword,
						@"c:\OUTPUT.txt");
 
   if (signatureCheck == SignatureCheckResult.SignatureVerified)
   {
	   Console.WriteLine("Signare OK");
   }
   else if (signatureCheck == SignatureCheckResult.SignatureBroken)
   {
	   Console.WriteLine("Signare of the message is either broken or forged");
   }
   else if (signatureCheck == SignatureCheckResult.PublicKeyNotMatching)
   {
	   Console.WriteLine("The provided public key doesn't match the signature");
   }
   else if (signatureCheck == SignatureCheckResult.NoSignatureFound)
   {
	   Console.WriteLine("This message is not digitally signed");
   }
 }
}

Imports System
Imports DidiSoft.Pgp
 
Public Class KeyStoreDecryptAndVerifyFile
 Public Shared Sub Demo()
    ' initialize the KeyStore
    Dim keyStore As New KeyStore("c:\key.store", "key store pass")
 
    ' create an instance of the library
    Dim pgp As New PGPLib()
 
    ' we should provide the decryption password 
    Dim decryptionPassword As String = "encryption password"
    Dim signatureCheck As SignatureCheckResult = _
                pgp.DecryptAndVerifyFile("c:\OUTPUT.pgp", _
					  keyStore, _
					  decryptionPassword, _
					  "c:\OUTPUT.txt")
 
    If signatureCheck = SignatureCheckResult.SignatureVerified Then
	Console.WriteLine("Signare OK")
    ElseIf signatureCheck = SignatureCheckResult.SignatureBroken Then
	Console.WriteLine("Signare of the message is either broken or forged")
    ElseIf signatureCheck = SignatureCheckResult.PublicKeyNotMatching Then
	Console.WriteLine("The provided public key(s) doesn't match the signature")
    ElseIf signatureCheck = SignatureCheckResult.NoSignatureFound Then
	Console.WriteLine("This message is not digitally signed")
    End If
 End Sub
End Class

using System;
using DidiSoft.Pgp;
using DidiSoft.Pgp.Exceptions;
 
public class DecryptAndVerify
{
 public void Demo()
 {
  // create an instance of the library
  PGPLib pgp = new PGPLib();
 
  try
  {	
   SignatureCheckResult signatureCheck = pgp.DecryptAndVerify ...
  }
  catch (PGPException e)
  {
   if (e is NonPGPDataException)
   {
	// The input data is not an OpenPGP archive or is corrupted
   }
   else if (e is WrongPublicKeyException)
   {
	// The supplied public key is not an OpenPGP public key or is corrupted
   }
   else if (e is WrongPrivateKeyException)
   {
	// The message cannot be decrypted with this private key 
	// or the supplied private key is not an OpenPGP private key or is corrupted
	Console.WriteLine(e.Message);
   }
   else if (e is WrongPasswordException)
   {
	// The password for the private key is incorrect
   }
   else if (e is FileIsPBEEncryptedException)
   {
	// The input file is password encrypted
	// We have to use DecryptAndVeifyFilePBE or DecryptAndVerifyStreamPBE
   }
   else if (e is IntegrityCheckException)
   {
	// The encrypted data is corrupted
   }
   else
   { // other OpenPGP error
	Console.WriteLine(e.Message);
   }
  }
 }
}

Imports System
Imports DidiSoft.Pgp
Imports DidiSoft.Pgp.Exceptions
 
Public Class DecryptAndVerify
 Public Sub Demo()
  ' create an instance of the library
  Dim pgp As New PGPLib()
 
  Try
	Dim signatureCheck As SignatureCheckResult = pgp.DecryptAndVerify ...
  Catch e As PGPException
   If TypeOf e Is NonPGPDataException Then
	' The input file is not an OpenPGP archive or is corrupted
   ElseIf TypeOf e Is WrongPublicKeyException Then
	' The supplied public key is not an OpenPGP public key or is corrupted
   ElseIf TypeOf e Is WrongPrivateKeyException Then
	' The message cannot be decrypted with this private key 
	' or the supplied private key is not an OpenPGP private key or is corrupted
	Console.WriteLine(e.Message)
   ElseIf TypeOf e Is WrongPasswordException Then
	' The password for the private key is incorrect
   ElseIf TypeOf e Is FileIsPBEEncryptedException Then
	' The input file is password encrypted.
	' You have to use DecryptAndVeifyFilePBE or DecryptAndVerifyStreamPBE
   ElseIf TypeOf e Is IntegrityCheckException Then
	' The encrypted data is corrupted
   Else
	Console.WriteLine(e.Message)
   End If
  End Try
 End Sub
End Class