예제 #1
0
        private static void DisplaySubKeys(PgpKey bob)
        {
            Console.WriteLine("Bob has now the following sub keys:");
            int subkeycount = 0;

            foreach (Subkey subkey in bob.Subkeys)
            {
                subkeycount++;
                Console.WriteLine("{0}\n\tAlgorithm: {1}\n\t"
                                  + "Length: {2}\n\t"
                                  + "Expires: {3}\n",
                                  subkey.Fingerprint,
                                  Gpgme.GetPubkeyAlgoName(subkey.PubkeyAlgorithm),
                                  subkey.Length.ToString(CultureInfo.InvariantCulture),
                                  subkey.Expires.ToString(CultureInfo.InvariantCulture));
            }
            Console.WriteLine("Found {0} sub keys.", subkeycount.ToString(CultureInfo.InvariantCulture));
        }
        internal static string CheckVersion(string ReqVersion)
        {
            // we are doing this check only once

            if (gpgme_version_str == null)
            {
                IntPtr verPtr    = IntPtr.Zero;
                IntPtr reqverPtr = IntPtr.Zero;

                if (ReqVersion != null && ReqVersion.Length != 0)
                {
                    // minimun required version
                    reqverPtr = Gpgme.StringToCoTaskMemUTF8(ReqVersion);
                }

                // retrieve GPGME's version
                verPtr = libgpgme.gpgme_check_version(reqverPtr);

                if (!reqverPtr.Equals(IntPtr.Zero))
                {
                    Marshal.FreeCoTaskMem(reqverPtr);
                    reqverPtr = IntPtr.Zero;
                }

                if (!verPtr.Equals(IntPtr.Zero))
                {
                    gpgme_version_str = Gpgme.PtrToStringUTF8(verPtr);
                }
                else
                {
                    throw new GeneralErrorException("Could not retrieve a valid GPGME version.\nGot: "
                                                    + gpgme_version_str
                                                    + " Minimum required: " + ReqVersion
                                                    );
                }
            }
            return(gpgme_version_str);
        }
        static void Main(string[] args)
        {
            Context ctx = new Context();

            if (ctx.Protocol != Protocol.OpenPGP)
            {
                ctx.SetEngineInfo(Protocol.OpenPGP, null, null);
            }

            Console.WriteLine("Search Bob's PGP key in the default keyring..");

            String    searchstr = "*****@*****.**";
            IKeyStore keyring   = ctx.KeyStore;

            // retrieve all keys that have Bob's email address
            Key[] keys = keyring.GetKeyList(searchstr, false);
            if (keys == null || keys.Length == 0)
            {
                Console.WriteLine("Cannot find Bob's PGP key {0} in your keyring.", searchstr);
                Console.WriteLine("You may want to create the PGP key by using the appropriate\n"
                                  + "sample in the Samples/ directory.");
                return;
            }

            // print a list of all returned keys
            foreach (Key key in keys)
            {
                if (key.Uid != null &&
                    key.Fingerprint != null)
                {
                    Console.WriteLine("Found key {0} with fingerprint {1}",
                                      key.Uid.Name,
                                      key.Fingerprint);
                }
            }

            // we are going to use the first key in the list
            PgpKey bob = (PgpKey)keys[0];

            if (bob.Uid == null || bob.Fingerprint == null)
            {
                throw new InvalidKeyException();
            }

            // Create a sample string
            StringBuilder randomtext = new StringBuilder();

            for (int i = 0; i < 80 * 6; i++)
            {
                randomtext.Append((char)(34 + i % 221));
            }
            string secrettext = new string('+', 508)
                                + " Die Gedanken sind frei "
                                + new string('+', 508)
                                + randomtext.ToString();

            Console.WriteLine("Text to be encrypted:\n\n{0}", secrettext);

            // we want our string UTF8 encoded.
            UTF8Encoding utf8 = new UTF8Encoding();

            // create a (dynamic) memory based data buffer to place the unencrypted (plain) text
            GpgmeData plain = new GpgmeMemoryData();

            // set a filename for this data buffer
            plain.FileName = "my_document.txt";

            BinaryWriter binwriter = new BinaryWriter(plain, utf8);

            // write our secret text to the memory buffer
            binwriter.Write(secrettext.ToCharArray());
            binwriter.Flush();
            // go to the beginning(!)
            binwriter.Seek(0, SeekOrigin.Begin);

            /////// ENCRYPT DATA ///////

            // we want or PGP encrypted data RADIX/BASE64 encoded.
            ctx.Armor = true;

            // create another (dynamic) memory based data buffer as destination
            GpgmeData cipher = new GpgmeMemoryData();

            cipher.FileName = "my_document.txt";

            Console.Write("Encrypt data for {0} ({1}).. ",
                          bob.Uid.Name, bob.KeyId);

            EncryptionResult encrst = ctx.Encrypt(
                new Key[] { bob },        // encrypt data to Bob's key only
                EncryptFlags.AlwaysTrust, // trust our sample PGP key
                plain,                    // source buffer
                cipher);                  // destination buffer

            Console.WriteLine("done.");
            Console.WriteLine("Cipher text:");

            // move cursor to the beginning
            cipher.Seek(0, SeekOrigin.Begin);

            /* Read cipher text from libgpgme's memory based buffer and print
             * it to the console screen.
             */
            char[] buf;
            // the cipher text is UTF8 encoded
            BinaryReader binreader = new BinaryReader(cipher, utf8);

            while (true)
            {
                try
                {
                    buf = binreader.ReadChars(255);
                    if (buf.Length == 0)
                    {
                        break;
                    }
                    Console.Write(buf);
                }
                catch (EndOfStreamException)
                {
                    break;
                }
            }

            /////// DECRYPT DATA ///////

            /* Set the password callback - needed if the user doesn't run
             * gpg-agent or any other password / pin-entry software.
             */
            ctx.SetPassphraseFunction(new PassphraseDelegate(MyPassphraseCallback));

            // go to the beginning(!)
            cipher.Seek(0, SeekOrigin.Begin);

            Console.Write("Decrypt data.. ");
            GpgmeData decryptedText = new GpgmeMemoryData();

            DecryptionResult decrst = ctx.Decrypt(
                cipher,         // source buffer
                decryptedText); // destination buffer

            Console.WriteLine("Done. Filename: \"{0}\" Recipients:",
                              decrst.FileName);

            /* print out all recipients key ids (a PGP package can be
             * encrypted to various recipients).
             */
            if (decrst.Recipients != null)
            {
                foreach (Recipient recp in decrst.Recipients)
                {
                    Console.WriteLine("\tKey id {0} with {1} algorithm",
                                      recp.KeyId,
                                      Gpgme.GetPubkeyAlgoName(recp.KeyAlgorithm));
                }
            }
            else
            {
                Console.WriteLine("\tNone");
            }

            // TEST: Compare original data and decrypted data
            byte[] orig = new byte[255], cmp = new byte[255];

            plain.Seek(0, SeekOrigin.Begin);
            decryptedText.Seek(0, SeekOrigin.Begin);

            while (true)
            {
                try
                {
                    int a, b;
                    a = plain.Read(orig, orig.Length);
                    b = decryptedText.Read(cmp, cmp.Length);

                    if (a != b)
                    {
                        throw new DecryptionFailedException("The two data buffers have different sizes.");
                    }

                    if (a == 0)
                    {
                        break; // everything okay - end of stream reached.
                    }
                    for (int i = 0; i < a; i++)
                    {
                        if (orig[i] != cmp[i])
                        {
                            throw new DecryptionFailedException("The two data buffers differ at position "
                                                                + i.ToString() + ".");
                        }
                    }
                }
                catch (EndOfStreamException)
                {
                    throw new DecryptionFailedException("The two data buffers have different sizes.");
                }
            }

            // we do not want our GpgmeData buffers destroyed
            GC.KeepAlive(binwriter);
            GC.KeepAlive(binreader);

            /////// FILE BASED DATA BUFFERS ///////

            /////// ENCRYPT FILE ///////

            // Now let's use a file based data buffers

            // create the "source" file first and fill it with our sample text.
            Console.WriteLine("Create new file plainfile.txt.");
            File.WriteAllText("plainfile.txt", secrettext, utf8);

            GpgmeData plainfile = new GpgmeFileData(
                "plainfile.txt",
                FileMode.Open,
                FileAccess.Read);

            GpgmeData cipherfile = new GpgmeFileData(
                "cipherfile.asc",
                FileMode.Create,
                FileAccess.ReadWrite);

            Console.Write("Encrypt file plainfile.txt to cipherfile.asc.. ");

            encrst = ctx.Encrypt(
                new Key[] { bob },
                EncryptFlags.AlwaysTrust,
                plainfile,
                cipherfile);

            Console.WriteLine("done.");

            plainfile.Close();
            cipherfile.Close();

            /////// DECRYPT FILE ///////

            //cipherfile = new GpgmeFileData("cipherfile.asc");
            // load the file content into the system memory
            cipherfile = new GpgmeMemoryData("cipherfile.asc");

            plainfile = new GpgmeFileData(
                "decrypted.txt",
                FileMode.Create,
                FileAccess.Write);

            Console.WriteLine("Decrypt file cipherfile.asc to decrypted.txt.. ");

            decrst = ctx.Decrypt(
                cipherfile,     // source buffer
                plainfile);     // destination buffer

            Console.WriteLine("Done. Filename: \"{0}\" Recipients:",
                              decrst.FileName);

            /* print out all recipients key ids (a PGP package can be
             * encrypted to various recipients).
             */
            if (decrst.Recipients != null)
            {
                foreach (Recipient recp in decrst.Recipients)
                {
                    Console.WriteLine("\tKey id {0} with {1} algorithm",
                                      recp.KeyId,
                                      Gpgme.GetPubkeyAlgoName(recp.KeyAlgorithm));
                }
            }
            else
            {
                Console.WriteLine("\tNone");
            }

            cipherfile.Close();
            plainfile.Close();

            return;
        }
예제 #4
0
        static void Main()
        {
            Context ctx = new Context();

            if (ctx.Protocol != Protocol.OpenPGP)
            {
                ctx.SetEngineInfo(Protocol.OpenPGP, null, null);
            }

            Console.WriteLine("Search Bob's and Alice's PGP keys in the default keyring..");

            String[] searchpattern = new[] {
                "*****@*****.**",
                "*****@*****.**"
            };

            IKeyStore keyring = ctx.KeyStore;

            // We want the key signatures!
            ctx.KeylistMode = KeylistMode.Signatures;

            // retrieve all keys that have Bob's or Alice's email address
            Key[] keys = keyring.GetKeyList(searchpattern, false);

            PgpKey bob = null, alice = null;

            if (keys != null && keys.Length != 0)
            {
                foreach (Key k in keys)
                {
                    if (k.Uid != null)
                    {
                        if (bob == null && k.Uid.Email.ToLower().Equals("*****@*****.**"))
                        {
                            bob = (PgpKey)k;
                        }
                        if (alice == null && k.Uid.Email.ToLower().Equals("*****@*****.**"))
                        {
                            alice = (PgpKey)k;
                        }
                    }
                    else
                    {
                        throw new InvalidKeyException();
                    }
                }
            }

            if (bob == null || alice == null)
            {
                Console.WriteLine("Cannot find Bob's or Alice's PGP key in your keyring.");
                Console.WriteLine("You may want to create the PGP keys by using the appropriate\n"
                                  + "sample in the Samples/ directory.");
                return;
            }

            // Create a sample string
            StringBuilder randomtext = new StringBuilder();

            for (int i = 0; i < 80 * 6; i++)
            {
                randomtext.Append((char)(34 + i % 221));
            }
            string origintxt         = new string('+', 508)
                                       + " Die Gedanken sind frei "
                                       + new string('+', 508)
                                       + randomtext;

            // we want our string UTF8 encoded.
            UTF8Encoding utf8 = new UTF8Encoding();

            // Write sample string to plain.txt
            File.WriteAllText("plain.txt", origintxt, utf8);

            /////// ENCRYPT AND SIGN DATA ///////

            Console.Write("Encrypt data for Bob and sign it with Alice's PGP key.. ");

            GpgmeData plain  = new GpgmeFileData("plain.txt");
            GpgmeData cipher = new GpgmeFileData("cipher.asc");

            // we want or PGP encrypted/signed data RADIX/BASE64 encoded.
            ctx.Armor = true;

            /* Set the password callback - needed if the user doesn't run
             * gpg-agent or any other password / pin-entry software.
             */
            ctx.SetPassphraseFunction(MyPassphraseCallback);

            // Set Alice's PGP key as signer
            ctx.Signers.Clear();
            ctx.Signers.Add(alice);

            EncryptionResult encrst = ctx.EncryptAndSign(
                new Key[] { bob },
                EncryptFlags.AlwaysTrust,
                plain,
                cipher);

            Console.WriteLine("done.");

            // print out invalid signature keys
            if (encrst.InvalidRecipients != null)
            {
                foreach (InvalidKey key in encrst.InvalidRecipients)
                {
                    Console.WriteLine("Invalid key: {0} ({1})",
                                      key.Fingerprint,
                                      key.Reason);
                }
            }

            plain.Close();
            cipher.Close();

            /////// DECRYPT AND VERIFY DATA ///////

            Console.Write("Decrypt and verify data.. ");

            cipher = new GpgmeFileData("cipher.asc");
            plain  = new GpgmeMemoryData();

            CombinedResult comrst = ctx.DecryptAndVerify(
                cipher, // source buffer
                plain); // destination buffer

            Console.WriteLine("Done. Filename: \"{0}\" Recipients:",
                              comrst.DecryptionResult.FileName);

            /* print out all recipients key ids (a PGP package can be
             * encrypted to various recipients).
             */
            DecryptionResult decrst = comrst.DecryptionResult;

            if (decrst.Recipients != null)
            {
                foreach (Recipient recp in decrst.Recipients)
                {
                    Console.WriteLine("\tKey id {0} with {1} algorithm",
                                      recp.KeyId,
                                      Gpgme.GetPubkeyAlgoName(recp.KeyAlgorithm));
                }
            }
            else
            {
                Console.WriteLine("\tNone");
            }

            // print out signature information
            VerificationResult verrst = comrst.VerificationResult;

            if (verrst.Signature != null)
            {
                foreach (Signature sig in verrst.Signature)
                {
                    Console.WriteLine("Verification result (signature): "
                                      + "\n\tFingerprint: {0}"
                                      + "\n\tHash algorithm: {1}"
                                      + "\n\tKey algorithm: {2}"
                                      + "\n\tTimestamp: {3}"
                                      + "\n\tSummary: {4}"
                                      + "\n\tValidity: {5}",
                                      sig.Fingerprint,
                                      Gpgme.GetHashAlgoName(sig.HashAlgorithm),
                                      Gpgme.GetPubkeyAlgoName(sig.PubkeyAlgorithm),
                                      sig.Timestamp,
                                      sig.Summary,
                                      sig.Validity);
                }
            }
        }
예제 #5
0
        static void Main()
        {
            Context ctx = new Context();

            if (ctx.Protocol != Protocol.OpenPGP)
            {
                ctx.SetEngineInfo(Protocol.OpenPGP, null, null);
            }

            Console.WriteLine("Search Alice's PGP key in the default keyring..");

            const string SEARCHSTR = "*****@*****.**";
            IKeyStore    keyring   = ctx.KeyStore;

            // retrieve all keys that have Alice's email address
            Key[] keys = keyring.GetKeyList(SEARCHSTR, false);
            if (keys == null || keys.Length == 0)
            {
                Console.WriteLine("Cannot find Alice's PGP key {0} in your keyring.", SEARCHSTR);
                Console.WriteLine("You may want to create the PGP key by using the appropriate\n"
                                  + "sample in the Samples/ directory.");
                return;
            }

            // print a list of all returned keys
            foreach (Key key in keys)
            {
                if (key.Uid != null && key.Fingerprint != null)
                {
                    Console.WriteLine("Found key {0} with fingerprint {1}",
                                      key.Uid.Name,
                                      key.Fingerprint);
                }
            }

            // we are going to use the first key in the list
            PgpKey alice = (PgpKey)keys[0];

            if (alice.Uid == null || alice.Fingerprint == null)
            {
                throw new InvalidKeyException();
            }

            // Create a sample string
            StringBuilder randomtext = new StringBuilder();

            for (int i = 0; i < 80 * 6; i++)
            {
                randomtext.Append((char)(34 + i % 221));
            }
            string origintxt = new string('+', 508)
                               + " Die Gedanken sind frei "
                               + new string('+', 508)
                               + randomtext;

            Console.WriteLine("Text to be signed:\n\n{0}", origintxt);

            // we want our string UTF8 encoded.
            UTF8Encoding utf8 = new UTF8Encoding();

            // Prepare a file for later usage
            File.WriteAllText("original.txt", origintxt, utf8);

            /////// SIGN DATA (detached signature) ///////

            Console.Write("Write a detached signature to file: original.txt.sig.. ");

            GpgmeData origin = new GpgmeFileData("original.txt",
                                                 FileMode.Open,
                                                 FileAccess.Read);

            GpgmeData detachsig = new GpgmeFileData("original.txt.sig",
                                                    FileMode.Create,
                                                    FileAccess.Write);

            // Set Alice as signer
            ctx.Signers.Clear();
            ctx.Signers.Add(alice);

            // we want or PGP encrypted/signed data RADIX/BASE64 encoded.
            ctx.Armor = true;

            /* Set the password callback - needed if the user doesn't run
             * gpg-agent or any other password / pin-entry software.
             */
            ctx.SetPassphraseFunction(MyPassphraseCallback);

            // create a detached signature
            SignatureResult sigrst = ctx.Sign(
                origin,     // plain text (source buffer)
                detachsig,  // signature (destination buffer)
                SignatureMode.Detach);

            Console.WriteLine("done.");

            // print out invalid signature keys
            if (sigrst.InvalidSigners != null)
            {
                foreach (InvalidKey key in sigrst.InvalidSigners)
                {
                    Console.WriteLine("Invalid key: {0} ({1})",
                                      key.Fingerprint,
                                      key.Reason);
                }
            }

            // print out signature information
            if (sigrst.Signatures != null)
            {
                foreach (NewSignature newsig in sigrst.Signatures)
                {
                    Console.WriteLine("New signature: "
                                      + "\n\tFingerprint: {0}"
                                      + "\n\tHash algorithm: {1}"
                                      + "\n\tKey algorithm: {2}"
                                      + "\n\tTimestamp: {3}"
                                      + "\n\tType: {4}",
                                      newsig.Fingerprint,
                                      Gpgme.GetHashAlgoName(newsig.HashAlgorithm),
                                      Gpgme.GetPubkeyAlgoName(newsig.PubkeyAlgorithm),
                                      newsig.Timestamp,
                                      newsig.Type);
                }
            }

            origin.Close();

            detachsig.Close();

            /////// VERIFY DATA (detached signature) ///////
            Console.Write("Verify a detached signature from file: original.txt.sig.. ");

            origin = new GpgmeFileData("original.txt",
                                       FileMode.Open,
                                       FileAccess.Read);

            detachsig = new GpgmeFileData("original.txt.sig",
                                          FileMode.Open,
                                          FileAccess.Read);

            VerificationResult verrst = ctx.Verify(
                detachsig,  // detached signature
                origin,     // original data
                null);      // should be NULL if a detached signature has been provided

            Console.WriteLine("done.");
            Console.WriteLine("Filename: {0}", verrst.FileName);

            // print out signature information
            if (verrst.Signature != null)
            {
                foreach (Signature sig in verrst.Signature)
                {
                    Console.WriteLine("Verification result (signature): "
                                      + "\n\tFingerprint: {0}"
                                      + "\n\tHash algorithm: {1}"
                                      + "\n\tKey algorithm: {2}"
                                      + "\n\tTimestamp: {3}"
                                      + "\n\tSummary: {4}"
                                      + "\n\tValidity: {5}",
                                      sig.Fingerprint,
                                      Gpgme.GetHashAlgoName(sig.HashAlgorithm),
                                      Gpgme.GetPubkeyAlgoName(sig.PubkeyAlgorithm),
                                      sig.Timestamp,
                                      sig.Summary,
                                      sig.Validity);
                }
            }
        }
        static void Main(string[] args)
        {
            Context ctx = new Context();

            if (ctx.Protocol != Protocol.OpenPGP)
            {
                ctx.SetEngineInfo(Protocol.OpenPGP, null, null);
            }

            Console.WriteLine("Search Bob's PGP key in the default keyring..");

            String    searchstr = "*****@*****.**";
            IKeyStore keyring   = ctx.KeyStore;

            // retrieve all keys that have Bob's email address
            Key[] keys = keyring.GetKeyList(searchstr, false);
            if (keys == null || keys.Length == 0)
            {
                Console.WriteLine("Cannot find Bob's PGP key {0} in your keyring.", searchstr);
                Console.WriteLine("You may want to create the PGP key by using the appropriate\n"
                                  + "sample in the Samples/ directory.");
                return;
            }

            // print a list of all returned keys
            foreach (Key key in keys)
            {
                if (key.Uid != null &&
                    key.Fingerprint != null)
                {
                    Console.WriteLine("Found key {0} with fingerprint {1}",
                                      key.Uid.Name,
                                      key.Fingerprint);
                }
            }

            // we are going to use the first key in the list
            PgpKey bob = (PgpKey)keys[0];

            if (bob.Uid == null || bob.Fingerprint == null)
            {
                throw new InvalidKeyException();
            }

            Console.WriteLine("\nUsing key {0}", bob.Fingerprint);

            /////// CHANGE PASSPHRASE ///////

            Console.WriteLine("Change the secret key's password.");

            PgpPassphraseOptions passopts = new PgpPassphraseOptions();

            /* We need to specify our own passphrase callback methods
             * in case the user does not use gpg-agent.
             */
            passopts.OldPassphraseCallback = new PassphraseDelegate(MyPassphraseCallback);
            passopts.NewPassphraseCallback = new PassphraseDelegate(MyNewPassphraseCallback);
            passopts.EmptyOkay             = false; // we do not allow an empty passphrase

            bob.ChangePassphrase(ctx, passopts);

            /////// ADD SUBKEY ///////

            Console.Write("Add a new subkey to Bob's key.. ");

            /* Set the password callback - needed if the user doesn't run
             * gpg-agent or any other password / pin-entry software.
             */
            ctx.SetPassphraseFunction(new PassphraseDelegate(MyPassphraseCallback));

            PgpSubkeyOptions subopts = new PgpSubkeyOptions();

            subopts.Algorithm = PgpSubkeyAlgorithm.RSAEncryptOnly;

            /* Same as:
             * subopts.SetAlgorithm(KeyAlgorithm.RSA);
             * subopts.Capability = AlgorithmCapability.CanEncrypt;
             */
            subopts.KeyLength      = PgpSubkeyOptions.KEY_LENGTH_4096;
            subopts.ExpirationDate = DateTime.Now.AddDays(90);

            bob.AddSubkey(ctx, subopts);

            Console.WriteLine("Done.");

            /////// VIEW SUBKEYS ///////

            // Reload Bobs key
            bob = (PgpKey)keyring.GetKey(bob.Fingerprint, false);

            Console.WriteLine("Bob has now the following sub keys:");
            int subkeycount = 0;

            foreach (Subkey subkey in bob.Subkeys)
            {
                subkeycount++;
                Console.WriteLine("{0}\n\tAlgorithm: {1}\n\t"
                                  + "Length: {2}\n\t"
                                  + "Expires: {3}\n",
                                  subkey.Fingerprint,
                                  Gpgme.GetPubkeyAlgoName(subkey.PubkeyAlgorithm),
                                  subkey.Length.ToString(),
                                  subkey.Expires.ToString());
            }
            Console.WriteLine("Found {0} sub keys.", subkeycount.ToString());

            /////// SET OWNER TRUST ///////
            Console.WriteLine("Set owner trust of Bob's key.");
            Console.Write("\tto never.. ");
            bob.SetOwnerTrust(ctx, PgpOwnerTrust.Never);
            Console.WriteLine("done.");
            Console.Write("\tto ultimate.. ");
            bob.SetOwnerTrust(ctx, PgpOwnerTrust.Ultimate);
            Console.WriteLine("done.");

            /////// ENABLE / DISABLE ///////
            Console.Write("Disable Bob's key.. ");
            bob.Disable(ctx);
            Console.WriteLine("done.");
            Console.Write("Enable Bob's key.. ");
            bob.Enable(ctx);
            Console.WriteLine("done.");

            /////// SET EXPIRE DATE ///////
            DateTime newdate = DateTime.Now.AddYears(5);

            Console.WriteLine("Set new expire date: {0}", newdate);

            PgpExpirationOptions expopts = new PgpExpirationOptions();

            expopts.ExpirationDate  = newdate;
            expopts.SelectedSubkeys = null; // only the primary key
            bob.SetExpirationDate(ctx, expopts);

            return;
        }
        static void Main(string[] args)
        {
            Console.WriteLine("This example will create PGP keys in your default keyring.\n");

            // First step is to create a context
            Context ctx = new Context();

            EngineInfo info = ctx.EngineInfo;

            if (info.Protocol != Protocol.OpenPGP)
            {
                ctx.SetEngineInfo(Protocol.OpenPGP, null, null);
                info = ctx.EngineInfo;
            }

            Console.WriteLine("GnuPG home directory: {0}\n"
                              + "Version: {1}\n"
                              + "Reqversion: {2} \n"
                              + "Program: {3}\n",
                              info.HomeDir,
                              info.Version,
                              info.ReqVersion,
                              info.FileName);

            IKeyGenerator keygen = ctx.KeyStore;

            KeyParameters aliceparam, bobparam, malloryparam;

            aliceparam                = new KeyParameters();
            aliceparam.RealName       = "Alice";
            aliceparam.Comment        = "my comment";
            aliceparam.Email          = "*****@*****.**";
            aliceparam.ExpirationDate = DateTime.Now.AddYears(3);

            // primary key parameters
            aliceparam.KeyLength       = KeyParameters.KEY_LENGTH_2048;
            aliceparam.PubkeyAlgorithm = KeyAlgorithm.RSA;
            // the primary key algorithm MUST have the "Sign" capability
            aliceparam.PubkeyUsage =
                AlgorithmCapability.CanSign
                | AlgorithmCapability.CanAuth
                | AlgorithmCapability.CanCert;

            // subkey parameters (optional)
            aliceparam.SubkeyLength    = KeyParameters.KEY_LENGTH_4096;
            aliceparam.SubkeyAlgorithm = KeyAlgorithm.RSA;
            aliceparam.SubkeyUsage     = AlgorithmCapability.CanEncrypt;

            aliceparam.Passphrase = "topsecret";

            // Generate Alice key
            Console.WriteLine(
                "Create a new PGP key for Alice.\n"
                + "Name: {0}\n"
                + "Comment: {1} \n"
                + "Email: {2} \n"
                + "Secret passphrase: {3} \n"
                + "Expire date: {4} \n"
                + "Primary key algorithm = {5} ({6} bit)\n"
                + "Sub key algorithm = {7} ({8} bit)",
                aliceparam.RealName,
                aliceparam.Comment,
                aliceparam.Email,
                aliceparam.Passphrase,
                aliceparam.ExpirationDate.ToString(),
                Gpgme.GetPubkeyAlgoName(aliceparam.PubkeyAlgorithm),
                aliceparam.PubkeyLength,
                Gpgme.GetPubkeyAlgoName(aliceparam.SubkeyAlgorithm),
                aliceparam.SubkeyLength
                );

            Console.Write("Start key generation.. ");
            GenkeyResult result = keygen.GenerateKey(
                Protocol.OpenPGP,
                aliceparam);

            Console.WriteLine("done.\nFingerprint: {0}\n",
                              result.Fingerprint);

            // okay, create two more keys

            Console.Write("Create PGP key for Bob.. ");
            bobparam                = new KeyParameters();
            bobparam.RealName       = "Bob";
            bobparam.Email          = "*****@*****.**";
            bobparam.ExpirationDate = DateTime.Now.AddYears(2);
            bobparam.Passphrase     = "topsecret";

            result = keygen.GenerateKey(
                Protocol.OpenPGP,
                bobparam);
            Console.WriteLine("done.\nFingerprint: {0}\n",
                              result.Fingerprint);

            Console.Write("Create PGP key for Mallory.. ");
            malloryparam          = new KeyParameters();
            malloryparam.RealName = "Mallory";
            malloryparam.Email    = "*****@*****.**";
            malloryparam.MakeInfinitely(); // PGP key does not expire
            malloryparam.Passphrase = "topsecret";

            result = keygen.GenerateKey(
                Protocol.OpenPGP,
                malloryparam);
            Console.WriteLine("done.\nFingerprint: {0}",
                              result.Fingerprint);

            return;
        }