/// <summary> /// Initializes a new instance of the <see cref="MimeKit.Cryptography.OpenPgpContext"/> class. /// </summary> /// <param name="pubring">The public keyring file path.</param> /// <param name="secring">The secret keyring file path.</param> /// <exception cref="System.ArgumentNullException"> /// <para><paramref name="pubring"/> is <c>null</c>.</para> /// <para>-or-</para> /// <para><paramref name="secring"/> is <c>null</c>.</para> /// </exception> /// <exception cref="System.IO.IOException"> /// An error occurred while reading one of the keyring files. /// </exception> /// <exception cref="Org.BouncyCastle.Bcpg.OpenPgp.PgpException"> /// An error occurred while parsing one of the keyring files. /// </exception> protected OpenPgpContext(string pubring, string secring) { if (pubring == null) throw new ArgumentNullException ("pubring"); if (secring == null) throw new ArgumentNullException ("secring"); PublicKeyRingPath = pubring; SecretKeyRingPath = secring; if (File.Exists (pubring)) { using (var file = File.OpenRead (pubring)) { PublicKeyRingBundle = new PgpPublicKeyRingBundle (file); } } else { PublicKeyRingBundle = new PgpPublicKeyRingBundle (new byte[0]); } if (File.Exists (secring)) { using (var file = File.OpenRead (secring)) { SecretKeyRingBundle = new PgpSecretKeyRingBundle (file); } } else { SecretKeyRingBundle = new PgpSecretKeyRingBundle (new byte[0]); } }
private PgpPublicKey GetFirstPublicKey(PgpPublicKeyRingBundle publicKeyRingBundle) { foreach (PgpPublicKeyRing kRing in publicKeyRingBundle.GetKeyRings()) { PgpPublicKey key = kRing.GetPublicKeys() .Cast<PgpPublicKey>() .Where(k => k.IsEncryptionKey) .FirstOrDefault(); if (key != null) return key; } return null; }
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 = kRing.GetPublicKeys() .Cast<PgpPublicKey>() .Where(k => k.IsEncryptionKey) .FirstOrDefault(); if (key != null) { return key; } */ IEnumerator ikeys = kRing.GetPublicKeys().GetEnumerator(); if(ikeys.MoveNext()){ PgpPublicKey key=(PgpPublicKey)ikeys.Current; if(key.IsEncryptionKey){ return key; } } } return null; }
public static PgpPublicKeyRingBundle RemovePublicKeyRing(PgpPublicKeyRingBundle bundle, PgpPublicKeyRing publicKeyRing) { //IL_0024: Unknown result type (might be due to invalid IL or missing references) long keyId = publicKeyRing.GetPublicKey().KeyId; if (!bundle.pubRings.Contains((object)keyId)) { throw new ArgumentException("Bundle does not contain a key with a keyId for the passed in ring."); } IDictionary val = Platform.CreateHashtable(bundle.pubRings); global::System.Collections.IList list = Platform.CreateArrayList((global::System.Collections.ICollection)bundle.order); val.Remove((object)keyId); list.Remove((object)keyId); return(new PgpPublicKeyRingBundle(val, list)); }
/** * verify the signature in in against the file fileName. */ private static void VerifySignature( string fileName, Stream inputStream, Stream keyIn) { inputStream = PgpUtilities.GetDecoderStream(inputStream); PgpObjectFactory pgpFact = new PgpObjectFactory(inputStream); PgpSignatureList p3 = null; PgpObject o = pgpFact.NextPgpObject(); if (o is PgpCompressedData) { PgpCompressedData c1 = (PgpCompressedData)o; pgpFact = new PgpObjectFactory(c1.GetDataStream()); p3 = (PgpSignatureList)pgpFact.NextPgpObject(); } else { p3 = (PgpSignatureList)o; } PgpPublicKeyRingBundle pgpPubRingCollection = new PgpPublicKeyRingBundle( PgpUtilities.GetDecoderStream(keyIn)); Stream dIn = File.OpenRead(fileName); PgpSignature sig = p3[0]; PgpPublicKey key = pgpPubRingCollection.GetPublicKey(sig.KeyId); sig.InitVerify(key); int ch; while ((ch = dIn.ReadByte()) >= 0) { sig.Update((byte)ch); } dIn.Close(); if (sig.Verify()) { Console.WriteLine("signature verified."); } else { Console.WriteLine("signature verification failed."); } }
public static void Main( string[] args) { Stream fs = File.OpenRead(args[0]); // // Read the public key rings // PgpPublicKeyRingBundle pubRings = new PgpPublicKeyRingBundle( PgpUtilities.GetDecoderStream(fs)); fs.Close(); foreach (PgpPublicKeyRing pgpPub in pubRings.GetKeyRings()) { try { //PgpPublicKey pubKey = pgpPub.GetPublicKey(); } catch (Exception e) { Console.Error.WriteLine(e.Message); Console.Error.WriteLine(e.StackTrace); continue; } bool first = true; foreach (PgpPublicKey pgpKey in pgpPub.GetPublicKeys()) { if (first) { Console.WriteLine("Key ID: " + pgpKey.KeyId.ToString("X")); first = false; } else { Console.WriteLine("Key ID: " + pgpKey.KeyId.ToString("X") + " (subkey)"); } Console.WriteLine(" Algorithm: " + GetAlgorithm(pgpKey.Algorithm)); Console.WriteLine(" Fingerprint: " + Hex.ToHexString(pgpKey.GetFingerprint())); } } }
public static PgpPublicKey ReadPublicKey(Stream inputStream) { inputStream = PgpUtilities.GetDecoderStream(inputStream); PgpPublicKeyRingBundle pgpPub = new PgpPublicKeyRingBundle(inputStream); foreach (PgpPublicKeyRing keyRing in pgpPub.GetKeyRings()) { foreach (PgpPublicKey key in keyRing.GetPublicKeys()) { if (key.IsEncryptionKey) { return key; } } } throw new ArgumentException("Can't find encryption key in key ring."); }
/// <summary> /// Return a new bundle containing the contents of the passed in bundle with /// the passed in public key ring removed. /// </summary> /// <param name="bundle">The <c>PgpPublicKeyRingBundle</c> the key ring is to be removed from.</param> /// <param name="publicKeyRing">The key ring to be removed.</param> /// <returns>A new <c>PgpPublicKeyRingBundle</c> not containing the passed in key ring.</returns> /// <exception cref="ArgumentException">If the keyId for the passed in key ring is not present.</exception> public static PgpPublicKeyRingBundle RemovePublicKeyRing( PgpPublicKeyRingBundle bundle, PgpPublicKeyRing publicKeyRing) { long key = publicKeyRing.GetPublicKey().KeyId; if (!bundle.pubRings.Contains(key)) { throw new ArgumentException("Bundle does not contain a key with a keyId for the passed in ring."); } IDictionary newPubRings = Platform.CreateHashtable(bundle.pubRings); IList newOrder = Platform.CreateArrayList(bundle.order); newPubRings.Remove(key); newOrder.Remove(key); return(new PgpPublicKeyRingBundle(newPubRings, newOrder)); }
/// <summary> /// Return a new bundle containing the contents of the passed in bundle and /// the passed in public key ring. /// </summary> /// <param name="bundle">The <c>PgpPublicKeyRingBundle</c> the key ring is to be added to.</param> /// <param name="publicKeyRing">The key ring to be added.</param> /// <returns>A new <c>PgpPublicKeyRingBundle</c> merging the current one with the passed in key ring.</returns> /// <exception cref="ArgumentException">If the keyId for the passed in key ring is already present.</exception> public static PgpPublicKeyRingBundle AddPublicKeyRing( PgpPublicKeyRingBundle bundle, PgpPublicKeyRing publicKeyRing) { long key = publicKeyRing.GetPublicKey().KeyId; if (bundle.pubRings.Contains(key)) { throw new ArgumentException("Bundle already contains a key with a keyId for the passed in ring."); } IDictionary newPubRings = new Hashtable(bundle.pubRings); ArrayList newOrder = new ArrayList(bundle.order); newPubRings[key] = publicKeyRing; newOrder.Add(key); return(new PgpPublicKeyRingBundle(newPubRings, newOrder)); }
/** * verify the passed in file as being correctly signed. */ private static void VerifyFile( Stream inputStream, Stream keyIn) { inputStream = PgpUtilities.GetDecoderStream(inputStream); PgpObjectFactory pgpFact = new PgpObjectFactory(inputStream); PgpCompressedData c1 = (PgpCompressedData) pgpFact.NextPgpObject(); pgpFact = new PgpObjectFactory(c1.GetDataStream()); PgpOnePassSignatureList p1 = (PgpOnePassSignatureList) pgpFact.NextPgpObject(); PgpOnePassSignature ops = p1[0]; PgpLiteralData p2 = (PgpLiteralData) pgpFact.NextPgpObject(); Stream dIn = p2.GetInputStream(); PgpPublicKeyRingBundle pgpRing = new PgpPublicKeyRingBundle(PgpUtilities.GetDecoderStream(keyIn)); PgpPublicKey key = pgpRing.GetPublicKey(ops.KeyId); Stream fos = File.Create(p2.FileName); ops.InitVerify(key); int ch; while ((ch = dIn.ReadByte()) >= 0) { ops.Update((byte)ch); fos.WriteByte((byte) ch); } fos.Close(); PgpSignatureList p3 = (PgpSignatureList)pgpFact.NextPgpObject(); PgpSignature firstSig = p3[0]; if (ops.Verify(firstSig)) { Console.Out.WriteLine("signature verified."); } else { Console.Out.WriteLine("signature verification failed."); } }
static void Main(string[] args) { //password = args[0].ToCharArray(); //var context = new CryptoContext(PasswordCallback, "AES-128", "SHA-1"); //var crypto = new PgpCrypto(context); try { using (var inputStream = File.OpenRead(@"C:\projects\OutlookPrivacyPlugin\Deja.Crypto.Test\private\andrew-pubring.gpg")) using (var decodeStream = PgpUtilities.GetDecoderStream(inputStream)) { var pgpPub = new PgpPublicKeyRingBundle(decodeStream); foreach (PgpPublicKeyRing kRing in pgpPub.GetKeyRings()) { // The master key is normally the first key returned. var masterKey = kRing.GetPublicKey(); if (!masterKey.IsMasterKey) { foreach (PgpPublicKey k in kRing.GetPublicKeys()) if (k.IsMasterKey) Console.WriteLine("{0:X}", k.KeyId); } foreach (PgpPublicKey k in kRing.GetPublicKeys()) { Console.WriteLine("{0:X}", k.KeyId); } } } } catch (Exception) { throw; } }
/// <summary> /// Encrypt string using a PGP public key /// </summary> /// <param name="plain">plain text to encrypt</param> /// <param name="armoredPublicKey">public key in ASCII "-----BEGIN PGP PUBLIC KEY BLOCK----- .. -----END PGP PUBLIC KEY BLOCK-----" format</param> /// <returns>PGP message string</returns> public static string PGPEncrypt(string plain, string armoredPublicKey) { // encode data byte[] data = Encoding.UTF8.GetBytes(plain); // create the WinAuth public key PgpPublicKey publicKey = null; using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(armoredPublicKey))) { using (Stream dis = PgpUtilities.GetDecoderStream(ms)) { PgpPublicKeyRingBundle bundle = new PgpPublicKeyRingBundle(dis); foreach (PgpPublicKeyRing keyring in bundle.GetKeyRings()) { foreach (PgpPublicKey key in keyring.GetPublicKeys()) { if (key.IsEncryptionKey == true && key.IsRevoked() == false) { publicKey = key; break; } } } } } // encrypt the data using PGP using (MemoryStream encryptedStream = new MemoryStream()) { using (ArmoredOutputStream armored = new ArmoredOutputStream(encryptedStream)) { PgpEncryptedDataGenerator pedg = new PgpEncryptedDataGenerator(Org.BouncyCastle.Bcpg.SymmetricKeyAlgorithmTag.Cast5, true, new Org.BouncyCastle.Security.SecureRandom()); pedg.AddMethod(publicKey); using (Stream pedgStream = pedg.Open(armored, new byte[4096])) { PgpCompressedDataGenerator pcdg = new PgpCompressedDataGenerator(Org.BouncyCastle.Bcpg.CompressionAlgorithmTag.Zip); using (Stream pcdgStream = pcdg.Open(pedgStream)) { PgpLiteralDataGenerator pldg = new PgpLiteralDataGenerator(); using (Stream encrypter = pldg.Open(pcdgStream, PgpLiteralData.Binary, "", (long)data.Length, DateTime.Now)) { encrypter.Write(data, 0, data.Length); } } } } return Encoding.ASCII.GetString(encryptedStream.ToArray()); } }
/// <summary> /// Return a new bundle containing the contents of the passed in bundle and /// the passed in public key ring. /// </summary> /// <param name="bundle">The <c>PgpPublicKeyRingBundle</c> the key ring is to be added to.</param> /// <param name="publicKeyRing">The key ring to be added.</param> /// <returns>A new <c>PgpPublicKeyRingBundle</c> merging the current one with the passed in key ring.</returns> /// <exception cref="ArgumentException">If the keyId for the passed in key ring is already present.</exception> public static PgpPublicKeyRingBundle AddPublicKeyRing( PgpPublicKeyRingBundle bundle, PgpPublicKeyRing publicKeyRing) { long key = publicKeyRing.GetPublicKey().KeyId; if (bundle.pubRings.Contains(key)) { throw new ArgumentException("Bundle already contains a key with a keyId for the passed in ring."); } IDictionary newPubRings = Platform.CreateHashtable(bundle.pubRings); IList newOrder = Platform.CreateArrayList(bundle.order); newPubRings[key] = publicKeyRing; newOrder.Add(key); return new PgpPublicKeyRingBundle(newPubRings, newOrder); }
private static PgpPublicKey GetFirstPublicKey(PgpPublicKeyRingBundle publicKeyRingBundle) { foreach (PgpPublicKeyRing kRing in publicKeyRingBundle.GetKeyRings()) { var keys = kRing.GetPublicKeys(); foreach (var key in keys) { PgpPublicKey foundKey = (PgpPublicKey)key; //PgpPublicKey key = kRing.GetPublicKeys() //.Cast<PgpPublicKey>() // .Where(k => k.IsEncryptionKey) // .FirstOrDefault(); if (foundKey != null && foundKey.IsEncryptionKey) return foundKey; } } return null; }
public static string GetFingerprint(string key) { string hexString = string.Empty; byte[] byteArray = Encoding.ASCII.GetBytes(key); using (MemoryStream stream = new MemoryStream(byteArray)) { using (Stream decoderStream = PgpUtilities.GetDecoderStream(stream)) { PgpPublicKeyRingBundle publicKeyBundle = new PgpPublicKeyRingBundle(decoderStream); PgpPublicKey foundKey = GetFirstPublicKey(publicKeyBundle); if (foundKey != null) { byte[] fing = foundKey.GetFingerprint(); hexString = Hex.ToHexString(fing); } } } return hexString; }
public static bool IsPublicKey(string key) { bool isValid = false; try { byte[] byteArray = Encoding.ASCII.GetBytes(key); using (MemoryStream stream = new MemoryStream(byteArray)) { using (Stream decoderStream = PgpUtilities.GetDecoderStream(stream)) { PgpPublicKeyRingBundle publicKeyBundle = new PgpPublicKeyRingBundle(decoderStream); PgpPublicKey foundKey = GetFirstPublicKey(publicKeyBundle); if (foundKey != null) { isValid = true; } } } } catch (Exception ex) { isValid = false; } return isValid; }
/// <summary> /// Exports the specified public keys. /// </summary> /// <remarks> /// Exports the specified public keys. /// </remarks> /// <returns>A new <see cref="MimeKit.MimePart"/> instance containing the exported public keys.</returns> /// <param name="keys">The keys.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="keys"/> is <c>null</c>. /// </exception> public MimePart Export (PgpPublicKeyRingBundle keys) { if (keys == null) throw new ArgumentNullException ("keys"); var content = new MemoryBlockStream (); using (var armored = new ArmoredOutputStream (content)) { keys.Encode (armored); armored.Flush (); } content.Position = 0; return new MimePart ("application", "pgp-keys") { ContentDisposition = new ContentDisposition ("attachment"), ContentObject = new ContentObject (content) }; }
/* * verify a clear text signed file */ private static void VerifyFile( Stream inputStream, Stream keyIn, string resultName) { ArmoredInputStream aIn = new ArmoredInputStream(inputStream); Stream outStr = File.Create(resultName); // // write out signed section using the local line separator. // note: trailing white space needs to be removed from the end of // each line RFC 4880 Section 7.1 // MemoryStream lineOut = new MemoryStream(); int lookAhead = ReadInputLine(lineOut, aIn); byte[] lineSep = LineSeparator; if (lookAhead != -1 && aIn.IsClearText()) { byte[] line = lineOut.ToArray(); outStr.Write(line, 0, GetLengthWithoutSeparatorOrTrailingWhitespace(line)); outStr.Write(lineSep, 0, lineSep.Length); while (lookAhead != -1 && aIn.IsClearText()) { lookAhead = ReadInputLine(lineOut, lookAhead, aIn); line = lineOut.ToArray(); outStr.Write(line, 0, GetLengthWithoutSeparatorOrTrailingWhitespace(line)); outStr.Write(lineSep, 0, lineSep.Length); } } else { // a single line file if (lookAhead != -1) { byte[] line = lineOut.ToArray(); outStr.Write(line, 0, GetLengthWithoutSeparatorOrTrailingWhitespace(line)); outStr.Write(lineSep, 0, lineSep.Length); } } outStr.Close(); PgpPublicKeyRingBundle pgpRings = new PgpPublicKeyRingBundle(keyIn); PgpObjectFactory pgpFact = new PgpObjectFactory(aIn); PgpSignatureList p3 = (PgpSignatureList) pgpFact.NextPgpObject(); PgpSignature sig = p3[0]; sig.InitVerify(pgpRings.GetPublicKey(sig.KeyId)); // // read the input, making sure we ignore the last newline. // Stream sigIn = File.OpenRead(resultName); lookAhead = ReadInputLine(lineOut, sigIn); ProcessLine(sig, lineOut.ToArray()); if (lookAhead != -1) { do { lookAhead = ReadInputLine(lineOut, lookAhead, sigIn); sig.Update((byte) '\r'); sig.Update((byte) '\n'); ProcessLine(sig, lineOut.ToArray()); } while (lookAhead != -1); } sigIn.Close(); if (sig.Verify()) { Console.WriteLine("signature verified."); } else { Console.WriteLine("signature verification failed."); } }
public static bool ReadAndVerifyFile(Stream inputStream, Stream keyIn, out Stream cleartextOut) { // Count any exception as BouncyCastle failing to parse something, because of corruption maybe? try { // Disposing this will close the underlying stream, which we don't want to do var armouredInputStream = new ArmoredInputStream(inputStream); // This stream is returned, so is not disposed var cleartextStream = new MemoryStream(); int chr; while ((chr = armouredInputStream.ReadByte()) >= 0 && armouredInputStream.IsClearText()) { cleartextStream.WriteByte((byte)chr); } // Strip the trailing newline if set... cleartextStream.Position = Math.Max(0, cleartextStream.Position - 2); int count = 0; if (cleartextStream.ReadByte() == '\r') count++; if (cleartextStream.ReadByte() == '\n') count++; cleartextStream.SetLength(cleartextStream.Length - count); cleartextStream.Position = 0; // This will either return inputStream, or a new ArmouredStream(inputStream) // Either way, disposing it will close the underlying stream, which we don't want to do var decoderStream = PgpUtilities.GetDecoderStream(inputStream); var pgpObjectFactory = new PgpObjectFactory(decoderStream); var signatureList = (PgpSignatureList)pgpObjectFactory.NextPgpObject(); var signature = signatureList[0]; var publicKeyRing = new PgpPublicKeyRingBundle(PgpUtilities.GetDecoderStream(keyIn)); var publicKey = publicKeyRing.GetPublicKey(signature.KeyId); signature.InitVerify(publicKey); while ((chr = cleartextStream.ReadByte()) > 0) { signature.Update((byte)chr); } cleartextStream.Position = 0; cleartextOut = cleartextStream; return signature.Verify(); } catch { cleartextOut = null; return false; } }
public PgpPublicKey LoadPubKey(string path) { using (FileStream keyStream = File.OpenRead(path)) { Stream decStream = PgpUtilities.GetDecoderStream (keyStream); PgpPublicKeyRingBundle pgpPub = new PgpPublicKeyRingBundle (decStream); foreach (PgpPublicKeyRing keyRing in pgpPub.GetKeyRings()) { foreach (PgpPublicKey key in keyRing.GetPublicKeys()) { if (key.IsEncryptionKey) { return key; } } } throw new ArgumentException ("Key not found"); } }
public PgpPublicKey GetPublicKey(long KeyId) { using (var inputStream = File.OpenRead(Context.PublicKeyRingFile)) { using (var decodeStream = PgpUtilities.GetDecoderStream(inputStream)) { var pgpPub = new PgpPublicKeyRingBundle(decodeStream); foreach (PgpPublicKeyRing kRing in pgpPub.GetKeyRings()) { foreach (PgpPublicKey k in kRing.GetPublicKeys()) { if (k.KeyId == KeyId) return k; } } return null; } } }
public PgpPublicKey GetPublicKeyForEncryption(string email) { using (var inputStream = File.OpenRead(Context.PublicKeyRingFile)) { using (var decoderStream = PgpUtilities.GetDecoderStream(inputStream)) { var pgpPub = new PgpPublicKeyRingBundle(decoderStream); var emailSearch = "<" + email.ToLower().Trim() + ">"; foreach (PgpPublicKeyRing kRing in pgpPub.GetKeyRings()) { foreach (PgpPublicKey k in kRing.GetPublicKeys()) { if (!IsEncryptionKey(k)) continue; if (!k.IsMasterKey) { foreach (PgpSignature sig in k.GetSignaturesOfType(24)) { var pubKey = this.GetPublicKey(sig.KeyId); if (!pubKey.IsMasterKey) continue; foreach (string id in pubKey.GetUserIds()) { if (id.ToLower().IndexOf(emailSearch) > -1) return k; } } } foreach (string id in k.GetUserIds()) { if (id.ToLower().IndexOf(emailSearch) > -1) return k; } } } return null; } } }
/// <summary> /// Imports a public pgp keyring bundle. /// </summary> /// <remarks> /// Imports a public pgp keyring bundle. /// </remarks> /// <param name="bundle">The pgp keyring bundle.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="bundle"/> is <c>null</c>. /// </exception> public void Import (PgpPublicKeyRingBundle bundle) { if (bundle == null) throw new ArgumentNullException (nameof (bundle)); int publicKeysAdded = 0; foreach (PgpPublicKeyRing pubring in bundle.GetKeyRings ()) { if (!PublicKeyRingBundle.Contains (pubring.GetPublicKey ().KeyId)) { PublicKeyRingBundle = PgpPublicKeyRingBundle.AddPublicKeyRing (PublicKeyRingBundle, pubring); publicKeysAdded++; } } if (publicKeysAdded > 0) SavePublicKeyRingBundle (); }
/// <summary> /// Initializes a new instance of the <see cref="MimeKit.Cryptography.OpenPgpContext"/> class. /// </summary> /// <remarks> /// Creates a new <see cref="OpenPgpContext"/> using the specified public and private keyring paths. /// </remarks> /// <param name="pubring">The public keyring file path.</param> /// <param name="secring">The secret keyring file path.</param> /// <exception cref="System.ArgumentNullException"> /// <para><paramref name="pubring"/> is <c>null</c>.</para> /// <para>-or-</para> /// <para><paramref name="secring"/> is <c>null</c>.</para> /// </exception> /// <exception cref="System.IO.IOException"> /// An error occurred while reading one of the keyring files. /// </exception> /// <exception cref="Org.BouncyCastle.Bcpg.OpenPgp.PgpException"> /// An error occurred while parsing one of the keyring files. /// </exception> protected OpenPgpContext (string pubring, string secring) : this () { if (pubring == null) throw new ArgumentNullException (nameof (pubring)); if (secring == null) throw new ArgumentNullException (nameof (secring)); PublicKeyRingPath = pubring; SecretKeyRingPath = secring; if (File.Exists (pubring)) { using (var file = File.Open (pubring, FileMode.Open, FileAccess.Read)) { PublicKeyRingBundle = new PgpPublicKeyRingBundle (file); } } else { PublicKeyRingBundle = new PgpPublicKeyRingBundle (new byte[0]); } if (File.Exists (secring)) { using (var file = File.Open (secring, FileMode.Open, FileAccess.Read)) { SecretKeyRingBundle = new PgpSecretKeyRingBundle (file); } } else { SecretKeyRingBundle = new PgpSecretKeyRingBundle (new byte[0]); } }
public string[] GetPublicKeyUserIdsForEncryption() { using (var inputStream = File.OpenRead(Context.PublicKeyRingFile)) { using (var decoderStream = PgpUtilities.GetDecoderStream(inputStream)) { var pgpPub = new PgpPublicKeyRingBundle(decoderStream); var keyUserIds = new List<string>(); foreach (PgpPublicKeyRing kRing in pgpPub.GetKeyRings()) { foreach (PgpPublicKey k in kRing.GetPublicKeys()) { if (!IsEncryptionKey(k)) continue; if (!k.IsMasterKey) { foreach(PgpSignature sig in k.GetSignaturesOfType(24)) { var pubKey = this.GetPublicKey(sig.KeyId); if (!pubKey.IsMasterKey) continue; foreach (string id in pubKey.GetUserIds()) { if(!keyUserIds.Contains(id)) keyUserIds.Add(id); } } } foreach (string id in k.GetUserIds()) { keyUserIds.Add(id); } } } return keyUserIds.ToArray(); } } }
/// <summary> /// A simple routine that opens a key ring file and loads the first available key suitable for encryption. /// </summary> /// <param name="inputStream">The input stream.</param> /// <returns></returns> /// <exception cref="System.ArgumentException">Can't find encryption key in key ring.</exception> private static PgpPublicKey ReadPublicKey(Stream inputStream) { inputStream = PgpUtilities.GetDecoderStream(inputStream); PgpPublicKeyRingBundle pgpPub = new PgpPublicKeyRingBundle(inputStream); // we just loop through the collection till we find a key suitable for encryption, in the real // world you would probably want to be a bit smarter about this. // iterate through the key rings. foreach (PgpPublicKeyRing kRing in pgpPub.GetKeyRings()) { foreach (PgpPublicKey k in kRing.GetPublicKeys()) { if (k.IsEncryptionKey) return k; } } throw new ArgumentException("Can't find encryption key in key ring."); }
/// <summary> /// Return a new bundle containing the contents of the passed in bundle with /// the passed in public key ring removed. /// </summary> /// <param name="bundle">The <c>PgpPublicKeyRingBundle</c> the key ring is to be removed from.</param> /// <param name="publicKeyRing">The key ring to be removed.</param> /// <returns>A new <c>PgpPublicKeyRingBundle</c> not containing the passed in key ring.</returns> /// <exception cref="ArgumentException">If the keyId for the passed in key ring is not present.</exception> public static PgpPublicKeyRingBundle RemovePublicKeyRing( PgpPublicKeyRingBundle bundle, PgpPublicKeyRing publicKeyRing) { long key = publicKeyRing.GetPublicKey().KeyId; if (!bundle.pubRings.Contains(key)) { throw new ArgumentException("Bundle does not contain a key with a keyId for the passed in ring."); } IDictionary newPubRings = new Hashtable(bundle.pubRings); ArrayList newOrder = new ArrayList(bundle.order); newPubRings.Remove(key); newOrder.Remove(key); return new PgpPublicKeyRingBundle(newPubRings, newOrder); }
public void VerifySignature(Stream input, string outputpath) { input = PgpUtilities.GetDecoderStream(input); PgpObjectFactory pgpObjF = new PgpObjectFactory(input); //IList collection = pgpObjF.AllPgpObjects(); PgpEncryptedDataList enc = (PgpEncryptedDataList) pgpObjF.NextPgpObject(); PgpPrivateKey sKey = null; PgpPublicKeyEncryptedData pbe = null; PgpSecretKeyRingBundle pgpSec = new PgpSecretKeyRingBundle(PgpUtilities. GetDecoderStream(File.OpenRead(m_encryptionKeys.PrivateKeyPathd))); foreach (PgpPublicKeyEncryptedData pked in enc.GetEncryptedDataObjects()) { sKey = FindSecretKey(pgpSec, pked.KeyId, m_encryptionKeys.PassPhrase.ToCharArray()); 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); PgpCompressedData cData = (PgpCompressedData)plainFact.NextPgpObject(); PgpObjectFactory pgpFact = new PgpObjectFactory(cData.GetDataStream()); PgpObject message = pgpFact.NextPgpObject(); if (message is PgpOnePassSignatureList) { PgpOnePassSignatureList p1 = (PgpOnePassSignatureList)message; PgpOnePassSignature ops = p1[0]; PgpLiteralData p2 = (PgpLiteralData)pgpFact.NextPgpObject(); Stream dIn = p2.GetInputStream(); PgpPublicKeyRingBundle pgpRing = new PgpPublicKeyRingBundle(PgpUtilities. GetDecoderStream(File.OpenRead(m_encryptionKeys.PublicKeyPathd))); PgpPublicKey key = pgpRing.GetPublicKey(ops.KeyId); Stream fos = File.Create(p2.FileName); ops.InitVerify(key); int ch; while ((ch = dIn.ReadByte()) >= 0) { ops.Update((byte)ch); fos.WriteByte((byte)ch); } fos.Close(); PgpSignatureList p3 = (PgpSignatureList)pgpFact.NextPgpObject(); PgpSignature firstSig = p3[0]; if (ops.Verify(firstSig)) { throw new PgpException("signature verified."); } else { throw new PgpException("signature verification failed."); } } }
/// <summary> /// Imports public pgp keys from the specified stream. /// </summary> /// <remarks> /// Imports public pgp keys from the specified stream. /// </remarks> /// <param name="stream">The raw key data.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="stream"/> is <c>null</c>. /// </exception> /// <exception cref="System.IO.IOException"> /// <para>An error occurred while parsing the raw key-ring data</para> /// <para>-or-</para> /// <para>An error occured while saving the public key-ring bundle.</para> /// </exception> public override void Import (Stream stream) { if (stream == null) throw new ArgumentNullException ("stream"); using (var armored = new ArmoredInputStream (stream)) { var imported = new PgpPublicKeyRingBundle (armored); if (imported.Count == 0) return; int publicKeysAdded = 0; foreach (PgpPublicKeyRing pubring in imported.GetKeyRings ()) { if (!PublicKeyRingBundle.Contains (pubring.GetPublicKey ().KeyId)) { PublicKeyRingBundle = PgpPublicKeyRingBundle.AddPublicKeyRing (PublicKeyRingBundle, pubring); publicKeysAdded++; } } if (publicKeysAdded > 0) SavePublicKeyRingBundle (); } }
/// <summary> /// Exports the specified public keys. /// </summary> /// <remarks> /// Exports the specified public keys. /// </remarks> /// <returns>A new <see cref="MimeKit.MimePart"/> instance containing the exported public keys.</returns> /// <param name="keys">The keys.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="keys"/> is <c>null</c>. /// </exception> public MimePart Export (IEnumerable<PgpPublicKey> keys) { if (keys == null) throw new ArgumentNullException ("keys"); var keyrings = keys.Select (key => new PgpPublicKeyRing (key.GetEncoded ())); var bundle = new PgpPublicKeyRingBundle (keyrings); return Export (bundle); }
/// <summary> /// Initializes a new instance of the <see cref="MimeKit.Cryptography.OpenPgpContext"/> class. /// </summary> /// <remarks> /// Creates a new <see cref="OpenPgpContext"/> using the specified public and private keyrings. /// </remarks> /// <param name="pubring">The public keyring.</param> /// <param name="secring">The secret keyring.</param> /// <exception cref="System.ArgumentNullException"> /// <para><paramref name="pubring"/> is <c>null</c>.</para> /// <para>-or-</para> /// <para><paramref name="secring"/> is <c>null</c>.</para> /// </exception> /// <exception cref="System.IO.IOException"> /// An error occurred while reading one of the keyring files. /// </exception> /// <exception cref="Org.BouncyCastle.Bcpg.OpenPgp.PgpException"> /// An error occurred while parsing one of the keyring files. /// </exception> protected OpenPgpContext (Stream pubring, Stream secring) : this () { if (pubring == null) throw new ArgumentNullException ("pubring"); if (secring == null) throw new ArgumentNullException ("secring"); PublicKeyRing = pubring; SecretKeyRing = secring; PublicKeyRingBundle = new PgpPublicKeyRingBundle (pubring); SecretKeyRingBundle = new PgpSecretKeyRingBundle (secring); if (pubring.CanSeek) pubring.Seek (0, SeekOrigin.Begin); if (secring.CanSeek) secring.Seek (0, SeekOrigin.Begin); }
public string[] GetPublicKeyUserIdsForSign() { using (var inputStream = File.OpenRead(Context.PublicKeyRingFile)) { using (var decoderStream = PgpUtilities.GetDecoderStream(inputStream)) { var pgpPub = new PgpPublicKeyRingBundle(decoderStream); var keyUserIds = new List<string>(); foreach (PgpPublicKeyRing kRing in pgpPub.GetKeyRings()) { foreach (PgpPublicKey k in kRing.GetPublicKeys()) { if (!IsSigningKey(k)) continue; foreach (string id in k.GetUserIds()) { keyUserIds.Add(id); } } } return keyUserIds.ToArray(); } } }