static void p5_crypto_pgp_keys_private_list(ApplicationContext context, ActiveEventArgs e) { // Using common helper to iterate all secret keyrings matching filter. PGPKeyIterator.Find(context, e.Args, delegate(OpenPgpContext ctx, PgpSecretKeyRing keyring) { // Retrieving fingerprint of currently iterated key, and returning to caller. var fingerprint = Fingerprint.FingerprintString(keyring.GetPublicKey().GetFingerprint()); e.Args.Add(fingerprint); }, false); }
public static void p5_crypto_pgp_keys_create(ApplicationContext context, ActiveEventArgs e) { // Making sure we clean up after ourselves. using (new ArgsRemover(e.Args, true)) { // Retrieving identity (normally a name + email address), in addition to password. string identity = e.Args.GetExChildValue <string> ("identity", context); string password = e.Args.GetExChildValue <string> ("password", context); if (string.IsNullOrEmpty(identity) || string.IsNullOrEmpty(password)) { throw new LambdaException( "Minimum [identity] and [password] needs to be supplied to create a PGP keypair", e.Args, context); } // Retrieving other parameters to PGP keypair creation, giving them sane defaults if not supplied. DateTime expires = e.Args.GetExChildValue("expires", context, DateTime.Now.AddYears(3)); int strength = e.Args.GetExChildValue <int> ("strength", context, 4096); long publicExponent = e.Args.GetExChildValue("public-exponent", context, 65537L); int certainty = e.Args.GetExChildValue("certainty", context, 5); // Creating our key generator. PgpKeyRingGenerator generator = GetKeyRingGenerator( context, identity, password, expires, strength, publicExponent, certainty); // Generating public keyrign. PgpPublicKeyRing publicRing = generator.GeneratePublicKeyRing(); // Generating secret keyring. "Secret key" is BC's name for private key. PgpSecretKeyRing secretRing = generator.GenerateSecretKeyRing(); /* * Retrieving PGP context to let MimeKit import keys into PGP storage. * Making sure we retrieve it in "write mode". */ using (var ctx = context.RaiseEvent(".p5.crypto.pgp-keys.context.create", new Node("", true)).Get <OpenPgpContext> (context)) { // Saves public keyring. ctx.Import(publicRing); // Saves secret keyring (private key, BC uses different naming convention). ctx.Import(secretRing); } // Returning fingerprint and key-id to caller. e.Args.Add("fingerprint", Fingerprint.FingerprintString(publicRing.GetPublicKey().GetFingerprint())); e.Args.Add("key-id", ((int)publicRing.GetPublicKey().KeyId).ToString("X")); } }
static void p5_crypto_pgp_keys_sign(ApplicationContext context, ActiveEventArgs e) { // Used as buffer to hold secret signing key. PgpSecretKey secretKey = null; // Retrieving fingerprint of key to use for signing. var fingerprint = e.Args.GetExChildValue <string> ("fingerprint", context, null); if (string.IsNullOrEmpty(fingerprint)) { throw new LambdaException("No [fingerprint] supplied to [p5.crypto.pgp-keys.sign]", e.Args, context); } // Retrieving password for signing key. var password = e.Args ["fingerprint"].GetExChildValue <string> ("password", context, null); if (string.IsNullOrEmpty(password)) { throw new LambdaException("No [fingerprint]/[password] supplied to [p5.crypto.pgp-keys.sign]", e.Args, context); } // Using common helper to iterate all secret keys. PGPKeyIterator.Find(context, e.Args, delegate(OpenPgpContext ctx, PgpPublicKeyRing keyring) { /* * Checking if we have previously found the private signing key. * This little trick allows us to sign multiple public keys while still postpone the lookup of the private * signing key, until we know we actually have a match. */ if (secretKey == null) { // Finding secret key to use for signing the currently iterated public key. foreach (PgpSecretKeyRing idxRing in ctx.SecretKeyRingBundle.GetKeyRings()) { // Checking that this is our key. var cur = idxRing.GetSecretKey(); if (Fingerprint.FingerprintString(cur.PublicKey.GetFingerprint()) == fingerprint) { // This is the signing key. secretKey = cur; break; } } } // Signing key. ctx.SignKey(secretKey, keyring.GetPublicKey()); }, false, false, password, fingerprint); }
static void p5_crypto_pgp_keys_private_delete(ApplicationContext context, ActiveEventArgs e) { // Retrieving server's main PGP key to make sure caller doesn't accidentally delete that key. var serverKey = context.RaiseEvent("p5.auth.pgp.get-fingerprint").Get <string> (context); // Using common helper to iterate all secret keys. PGPKeyIterator.Find(context, e.Args, delegate(OpenPgpContext ctx, PgpSecretKeyRing keyRing) { /* * Notice, since server would effectively become useless if we allowed the caller to * accidentally delete the main server PGP key, we check that the currently iterated key * is not the server's main key. */ if (Fingerprint.FingerprintString(keyRing.GetPublicKey().GetFingerprint()) != serverKey) { // Deleting key. ctx.Delete(keyRing); } }, true, false); }
static void p5_crypto_pgp_keys_get_details(ApplicationContext context, ActiveEventArgs e) { /* * Using common helper to iterate all public keys, assuming that if caller * has supplied a fingerprint or key-id to a private key, the public key * will also exist in PGP context. */ PGPKeyIterator.Find(context, e.Args, delegate(OpenPgpContext ctx, PgpPublicKeyRing keyring) { // This key is matching specified filter criteria. var key = keyring.GetPublicKey(); var fingerprint = Fingerprint.FingerprintString(key.GetFingerprint()); var node = e.Args.Add(fingerprint).LastChild; node.Add("id", ((int)key.KeyId).ToString("X")); node.Add("algorithm", key.Algorithm.ToString()); node.Add("strength", key.BitStrength); node.Add("creation-time", key.CreationTime); node.Add("is-encryption-key", key.IsEncryptionKey); node.Add("is-master-key", key.IsMasterKey); node.Add("is-revoked", key.IsRevoked()); node.Add("version", key.Version); DateTime expires = key.CreationTime.AddSeconds(key.GetValidSeconds()); node.Add("expires", expires); // Returning all user IDs that are strings to caller. foreach (var idxUserId in key.GetUserIds()) { if (idxUserId is string) { node.FindOrInsert("user-ids").Add("", idxUserId); } } // Adding key IDs of all keys that have signed this key. foreach (PgpSignature signature in key.GetSignatures()) { node.FindOrInsert("signed-by").Add(((int)signature.KeyId).ToString("X"), signature.CreationTime); } }, false); }
static void p5_crypto_pgp_keys_public_get(ApplicationContext context, ActiveEventArgs e) { // Using common helper to iterate all public keyrings matching filter. PGPKeyIterator.Find(context, e.Args, delegate(OpenPgpContext ctx, PgpPublicKeyRing keyring) { // Retrieving fingerprint of currently iterated key, and returning to caller. var key = keyring.GetPublicKey(); var fingerprint = Fingerprint.FingerprintString(key.GetFingerprint()); var node = e.Args.Add(fingerprint).LastChild; // Returning public key as armored ASCII. using (var memStream = new MemoryStream()) { using (var armored = new ArmoredOutputStream(memStream)) { key.Encode(armored); armored.Flush(); } memStream.Flush(); memStream.Position = 0; var sr = new StreamReader(memStream); node.Value = sr.ReadToEnd(); } }, false); }
static void p5_crypto_pgp_keys_private_import(ApplicationContext context, ActiveEventArgs e) { // House cleaning. using (new ArgsRemover(e.Args, true)) { // Creating new PGP context. using (var ctx = context.RaiseEvent(".p5.crypto.pgp-keys.context.create", new Node("", true)).Get <OpenPgpContext> (context)) { // Looping through each private key (in ascii armored format) and importing into context. foreach (var idxKey in XUtil.Iterate <string> (context, e.Args)) { // Creating armored input stream to wrap key. using (var memStream = new MemoryStream(Encoding.UTF8.GetBytes(idxKey.Replace("\r\n", "\n")))) { using (var armored = new ArmoredInputStream(memStream)) { var key = new PgpSecretKeyRing(armored); ctx.Import(key); // Returning fingerprint of key that was successfully imported to caller. e.Args.Add(Fingerprint.FingerprintString(key.GetPublicKey().GetFingerprint())); } } } } } }