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;
}
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);
}
}
}
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;
}
