Bouncy Castle Encryption

Question

У меня есть требование отправить PGP Encrypted CSV Files в SFTP, и я ничего не знаю о PGP. После много исследований я смог найти следующий код в Интернете, используя 'Bouncy Castle' Library. Код кажется гогод, но не работает для меня, учитывая мою неопытность в PGP. Пожалуйста, помогите мне найти правильные значения:

1. publicKeyFileName
2. privateKeyFileName
3. pasPhrase

Ниже мой код:

namespace PgpEncryption 
{ 
    class Program 
    { 
     public static void Main() 
     { 
      EncryptAndSign(); 
     } 

     private static void EncryptAndSign() 
     { 
      string publicKeyFileName = ""; 
      string privateKeyFileName = ""; 
      string pasPhrase = "";  
      PgpEncryptionKeys encryptionKeys 
       = new PgpEncryptionKeys(publicKeyFileName, privateKeyFileName, pasPhrase); 
      PgpEncrypt encrypter = new PgpEncrypt(encryptionKeys); 
      string encryptedFileName = ""; 
      using (Stream outputStream = File.Create(encryptedFileName)) 
      { 
       string fileToEncrypt = "";  
       encrypter.EncryptAndSign(outputStream, new FileInfo(fileToEncrypt)); 
      }  
     } 
    } 
} 

public class PgpEncryptionKeys 
{ 
    public PgpEncryptionKeys(string publicKeyPath, string privateKeyPath, string passPhrase) 
    { 
     if (!File.Exists(publicKeyPath)) 
      throw new ArgumentException("Public key file not found", "publicKeyPath"); 
     if (!File.Exists(privateKeyPath)) 
      throw new ArgumentException("Private key file not found", "privateKeyPath"); 
     if (String.IsNullOrEmpty(passPhrase)) 
      throw new ArgumentException("passPhrase is null or empty.", "passPhrase"); 
     PublicKey = ReadPublicKey(publicKeyPath); 
     SecretKey = ReadSecretKey(privateKeyPath); 
     PrivateKey = ReadPrivateKey(passPhrase); 
    } 

    #region Secret Key 
    private PgpSecretKey ReadSecretKey(string privateKeyPath) 
    { 
     using (Stream keyIn = File.OpenRead(privateKeyPath)) 
     using (Stream inputStream = PgpUtilities.GetDecoderStream(keyIn)) 
     { 
      PgpSecretKeyRingBundle secretKeyRingBundle = new PgpSecretKeyRingBundle(inputStream); 
      PgpSecretKey foundKey = GetFirstSecretKey(secretKeyRingBundle); 
      if (foundKey != null) 
       return foundKey;    
     } 
     throw new ArgumentException("Can't find signing key in key ring."); 
    } 

    private PgpSecretKey GetFirstSecretKey(PgpSecretKeyRingBundle secretKeyRingBundle) 
    { 
     foreach (PgpSecretKeyRing kRing in secretKeyRingBundle.GetKeyRings()) 
     { 
      PgpSecretKey key = (PgpSecretKey)kRing.GetSecretKeys(); 
      if (key != null) 
       return key; 
     } 
     return null; 
    } 
    #endregion 

    #region Public Key 
    private PgpPublicKey ReadPublicKey(string publicKeyPath) 
    { 
     using (Stream keyIn = File.OpenRead(publicKeyPath)) 
     using (Stream inputStream = PgpUtilities.GetDecoderStream(keyIn)) 
     { 
      PgpPublicKeyRingBundle publicKeyRingBundle = new PgpPublicKeyRingBundle(inputStream); 
      PgpPublicKey foundKey = GetFirstPublicKey(publicKeyRingBundle); 
      if (foundKey != null) 
       return foundKey; 
     } 
     throw new ArgumentException("No encryption key found in public key ring."); 
    } 

    private PgpPublicKey GetFirstPublicKey(PgpPublicKeyRingBundle publicKeyRingBundle) 
    { 
     foreach (PgpPublicKeyRing kRing in publicKeyRingBundle.GetKeyRings()) 
     { 
      PgpPublicKey key = (PgpPublicKey)kRing.GetPublicKeys(); 
      //PgpPublicKey key = kRing.GetPublicKeys() 
           //.Cast<PgpPublicKey>() 
           // .Where(k => k.IsEncryptionKey) 
           // .FirstOrDefault(); 
      if (key != null) 
       return key; 
     } 
     return null; 
    } 
    #endregion 

    #region Private Key 
    private PgpPrivateKey ReadPrivateKey(string passPhrase) 
    { 
     PgpPrivateKey privateKey = SecretKey.ExtractPrivateKey(passPhrase.ToCharArray()); 
     if (privateKey != null) 
      return privateKey; 
     throw new ArgumentException("No private key found in secret key."); 
    } 
    #endregion   
} 


public class PgpEncrypt 
{ 

    private PgpEncryptionKeys m_encryptionKeys; 
    private const int BufferSize = 0x10000; // should always be power of 2 

    /// <summary> 
    /// Instantiate a new PgpEncrypt class with initialized PgpEncryptionKeys. 
    /// </summary> 
    /// <param name="encryptionKeys"></param> 
    /// <exception cref="ArgumentNullException">encryptionKeys is null</exception> 
    public PgpEncrypt(PgpEncryptionKeys encryptionKeys) 
    { 

     if (encryptionKeys == null) 

      throw new ArgumentNullException("encryptionKeys", "encryptionKeys is null."); 
     m_encryptionKeys = encryptionKeys; 
    } 

    /// <summary> 
    /// Encrypt and sign the file pointed to by unencryptedFileInfo and 
    /// write the encrypted content to outputStream. 
    /// </summary> 
    /// <param name="outputStream">The stream that will contain the 
    /// encrypted data when this method returns.</param> 
    /// <param name="fileName">FileInfo of the file to encrypt</param> 
    public void EncryptAndSign(Stream outputStream, FileInfo unencryptedFileInfo) 
    { 
     if (outputStream == null) 
      throw new ArgumentNullException("outputStream", "outputStream is null."); 
     if (unencryptedFileInfo == null) 
      throw new ArgumentNullException("unencryptedFileInfo", "unencryptedFileInfo is null."); 
     if (!File.Exists(unencryptedFileInfo.FullName)) 
      throw new ArgumentException("File to encrypt not found."); 
     using (Stream encryptedOut = ChainEncryptedOut(outputStream)) 
     using (Stream compressedOut = ChainCompressedOut(encryptedOut)) 
     { 
      PgpSignatureGenerator signatureGenerator = InitSignatureGenerator compressedOut); 
      using (Stream literalOut = ChainLiteralOut(compressedOut, unencryptedFileInfo)) 
      using (FileStream inputFile = unencryptedFileInfo.OpenRead()) 
      { 
       WriteOutputAndSign(compressedOut, literalOut, inputFile, signatureGenerator); 
      } 
     } 
    } 

    private static void WriteOutputAndSign(Stream compressedOut,Stream literalOut,FileStream inputFile,PgpSignatureGenerator signatureGenerator) 
    { 
     int length = 0; 
     byte[] buf = new byte[BufferSize]; 
     while ((length = inputFile.Read(buf, 0, buf.Length)) > 0) 
     { 
      literalOut.Write(buf, 0, length); 
      signatureGenerator.Update(buf, 0, length); 
     } 
     signatureGenerator.Generate().Encode(compressedOut); 
    } 

    private Stream ChainEncryptedOut(Stream outputStream) 
    { 
     PgpEncryptedDataGenerator encryptedDataGenerator; 
     encryptedDataGenerator = 
      new PgpEncryptedDataGenerator(SymmetricKeyAlgorithmTag.TripleDes, 
              new SecureRandom()); 
     encryptedDataGenerator.AddMethod(m_encryptionKeys.PublicKey); 
     return encryptedDataGenerator.Open(outputStream, new byte[BufferSize]); 
    } 

    private static Stream ChainCompressedOut(Stream encryptedOut) 
    { 
     PgpCompressedDataGenerator compressedDataGenerator = 
      new PgpCompressedDataGenerator(CompressionAlgorithmTag.Zip); 
     return compressedDataGenerator.Open(encryptedOut); 
    } 

    private static Stream ChainLiteralOut(Stream compressedOut, FileInfo file) 
    { 
     PgpLiteralDataGenerator pgpLiteralDataGenerator = new PgpLiteralDataGenerator(); 
     return pgpLiteralDataGenerator.Open(compressedOut, PgpLiteralData.Binary, file); 
    } 

    private PgpSignatureGenerator InitSignatureGenerator(Stream compressedOut) 
    { 
     const bool IsCritical = false; 
     const bool IsNested = false; 
     PublicKeyAlgorithmTag tag = m_encryptionKeys.SecretKey.PublicKey.Algorithm; 
     PgpSignatureGenerator pgpSignatureGenerator = 
      new PgpSignatureGenerator(tag, HashAlgorithmTag.Sha1); 
     pgpSignatureGenerator.InitSign(PgpSignature.BinaryDocument, m_encryptionKeys.PrivateKey); 

     foreach (string userId in m_encryptionKeys.SecretKey.PublicKey.GetUserIds()) 
     { 
      PgpSignatureSubpacketGenerator subPacketGenerator = 
       new PgpSignatureSubpacketGenerator(); 
      subPacketGenerator.SetSignerUserId(IsCritical, userId); 
      pgpSignatureGenerator.SetHashedSubpackets(subPacketGenerator.Generate()); 
      // Just the first one! 
      break; 
     } 

     pgpSignatureGenerator.GenerateOnePassVersion(IsNested).Encode(compressedOut); 
     return pgpSignatureGenerator; 
    } 
} 

Answer 1

Вы должны получить открытый ключ получателя сообщения и генерировать свой секретный ключ (если вам нужно подписать файлы). Также PGP позволяет шифровать паролем, если это соответствует вашим потребностям. Также я бы рекомендовал взглянуть на коммерческие библиотеки (например, SecureBlackbox). Они дорогие, но содержат гораздо лучшую поддержку, демонстрации, документацию и т. Д.

Answer 2

Я думаю, вы пропустили часть кода?

public class PgpEncryptionKeys { 
    public PgpPublicKey PublicKey { get; private set; } 
    public PgpPrivateKey PrivateKey { get; private set; } 
    public PgpSecretKey SecretKey { get; private set; }