BgcyCastle C#

Question

का उपयोग करके पीजीपी एन्क्रिप्शन और डिक्रिप्शन मैंने कई पोस्ट देखी हैं, कई ट्यूटोरियल्स का पालन किया है लेकिन कोई भी काम नहीं कर रहा है। कभी-कभी, वे कुछ कक्षाओं का संदर्भ देते हैं जो नहीं मिलते हैं। क्या मुझे ऐसी जगह पर इशारा किया जा सकता है जहां मुझे एक सरल ट्यूटोरियल मिल सकता है जिसमें फ़ाइल को एन्क्रिप्ट और डिक्रिप्ट करना है।

मैं पीजीपी के लिए बहुत नया हूं और किसी भी सहायता का स्वागत है।

Answer 1

यह कैसे है:

PartialInputStream during Bouncycastle PGP decryption

इसके अलावा, ज़िप यहाँ उदाहरण दिए गए हैं:

http://www.bouncycastle.org/csharp/

आशा इस मदद करता है। यदि आप अभी भी अटक गए हैं, तो कुछ और विवरण पोस्ट करें कि कंपाइलर किस वर्ग की शिकायत कर रहा है और समुदाय एक नज़र डालेगा।

Answer 2

मुझे पता है कि यह प्रश्न साल पुराना है लेकिन यह अभी भी बाउंसी कैसल का उपयोग करके पीजीपी डिक्रिप्शन से संबंधित खोजों के लिए Google में # 1 या # 2 है। चूंकि यह एक पूर्ण, संक्षिप्त उदाहरण खोजने में मुश्किल लगता है, इसलिए मैं एक पीजीपी फाइल को डिक्रिप्ट करने के लिए यहां अपना कामकाजी समाधान साझा करना चाहता था। यह बस बोउन्सी कैसल उदाहरण का एक संशोधित संस्करण है जो उनकी स्रोत फ़ाइलों के साथ शामिल है।

using System; 
using System.IO; 
using Org.BouncyCastle.Bcpg.OpenPgp; 
using Org.BouncyCastle.Utilities.IO; 

namespace PGPDecrypt 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      DecryptFile(
       @"path_to_encrypted_file.pgp", 
       @"path_to_secret_key.asc", 
       "your_password_here".ToCharArray(), 
       "output.txt" 
      ); 
     } 

     private static void DecryptFile(
      string inputFileName, 
      string keyFileName, 
      char[] passwd, 
      string defaultFileName) 
     { 
      using (Stream input = File.OpenRead(inputFileName), 
        keyIn = File.OpenRead(keyFileName)) 
      { 
       DecryptFile(input, keyIn, passwd, defaultFileName); 
      } 
     } 

     private static void DecryptFile(
      Stream inputStream, 
      Stream keyIn, 
      char[] passwd, 
      string defaultFileName) 
     { 
      inputStream = PgpUtilities.GetDecoderStream(inputStream); 

      try 
      { 
       PgpObjectFactory pgpF = new PgpObjectFactory(inputStream); 
       PgpEncryptedDataList enc; 

       PgpObject o = pgpF.NextPgpObject(); 
       // 
       // the first object might be a PGP marker packet. 
       // 
       if (o is PgpEncryptedDataList) 
       { 
        enc = (PgpEncryptedDataList)o; 
       } 
       else 
       { 
        enc = (PgpEncryptedDataList)pgpF.NextPgpObject(); 
       } 

       // 
       // find the secret key 
       // 
       PgpPrivateKey sKey = null; 
       PgpPublicKeyEncryptedData pbe = null; 
       PgpSecretKeyRingBundle pgpSec = new PgpSecretKeyRingBundle(
        PgpUtilities.GetDecoderStream(keyIn)); 

       foreach (PgpPublicKeyEncryptedData pked in enc.GetEncryptedDataObjects()) 
       { 
        sKey = FindSecretKey(pgpSec, pked.KeyId, passwd); 

        if (sKey != null) 
        { 
         pbe = pked; 
         break; 
        } 
       } 

       if (sKey == null) 
       { 
        throw new ArgumentException("secret key for message not found."); 
       } 

       Stream clear = pbe.GetDataStream(sKey); 

       PgpObjectFactory plainFact = new PgpObjectFactory(clear); 

       PgpObject message = plainFact.NextPgpObject(); 

       if (message is PgpCompressedData) 
       { 
        PgpCompressedData cData = (PgpCompressedData)message; 
        PgpObjectFactory pgpFact = new PgpObjectFactory(cData.GetDataStream()); 

        message = pgpFact.NextPgpObject(); 
       } 

       if (message is PgpLiteralData) 
       { 
        PgpLiteralData ld = (PgpLiteralData)message; 

        string outFileName = ld.FileName; 
        if (outFileName.Length == 0) 
        { 
         outFileName = defaultFileName; 
        } 

        Stream fOut = File.Create(outFileName); 
        Stream unc = ld.GetInputStream(); 
        Streams.PipeAll(unc, fOut); 
        fOut.Close(); 
       } 
       else if (message 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 (pbe.IsIntegrityProtected()) 
       { 
        if (!pbe.Verify()) 
        { 
         Console.Error.WriteLine("message failed integrity check"); 
        } 
        else 
        { 
         Console.Error.WriteLine("message integrity check passed"); 
        } 
       } 
       else 
       { 
        Console.Error.WriteLine("no message integrity check"); 
       } 
      } 
      catch (PgpException e) 
      { 
       Console.Error.WriteLine(e); 

       Exception underlyingException = e.InnerException; 
       if (underlyingException != null) 
       { 
        Console.Error.WriteLine(underlyingException.Message); 
        Console.Error.WriteLine(underlyingException.StackTrace); 
       } 
      } 
     } 

     private static PgpPrivateKey FindSecretKey(PgpSecretKeyRingBundle pgpSec, long keyID, char[] pass) 
     { 
      PgpSecretKey pgpSecKey = pgpSec.GetSecretKey(keyID); 

      if (pgpSecKey == null) 
      { 
       return null; 
      } 

      return pgpSecKey.ExtractPrivateKey(pass); 
     } 
    } 
}