Merge in default

src/codegen/gen_cpp_Engine.ysl2

@@ -23,6 +23,7 @@ tstylesheet {
         #include <pEp/passphrase_cache.hh>
 
         using pEp::Adapter::session;
+        using pEp::passphrase_cache;
         using namespace pEp::JNIAdapter;
 
         extern "C" {
@@ -71,7 +72,7 @@ tstylesheet {
             when "@cached = 'true'" {
             ||
                 pEpLog("cached passphrase");
-                PEP_STATUS status = cache.api(::«@name»,session()`apply "parm", mode=call`);
+                PEP_STATUS status = passphrase_cache.api(::«@name»,session()`apply "parm", mode=call`);
             ||
             } otherwise {
             ||

src/codegen/gen_java_Engine.ysl2

@@ -141,7 +141,7 @@ tstylesheet {
 
         if "not(position() mod 2)" choose {
             when "$ptype = 'string'"
-            | «$pitype» _«$pname» = «$pname».getBytes();
+            | «$pitype» _«$pname» = Utils.toUTF8(«$pname»);
             when "$ptype = 'bool'"
             | «$pitype» _«$pname» = «$pname».booleanValue();
             when "$ptype = 'bytearray'"

src/codegen/gen_throw_pEp_exception.ysl2

@@ -58,7 +58,7 @@ tstylesheet {
 
     template "*", mode=case {
         | case `call "UCASE" with "text", "name(.)"`:
-        |     ex_name = "foundation/pEp/jniadapter/`call "CamelCase" with "text", "name(.)"`";
+        |     ex_name = "foundation/pEp/jniadapter/exceptions/`call "CamelCase" with "text", "name(.)"`";
         |     break;
     }
 }

src/codegen/pEp.yml2

@@ -241,10 +241,6 @@ namespace pEp {
                 in CipherSuite suite
             );
 
-        method config_passphrase_for_new_keys(
-                in bool enable,
-                in string passphrase
-            );
 
         // "basic" methods are generated on the java side, but
         // on the C++ side, manually implemented in basic_api.cc
@@ -267,6 +263,7 @@ namespace pEp {
         basic string getUserDirectory();
         basic string getMachineDirectory();
         basic void config_passphrase(string passphrase);
+        basic void config_passphrase_for_new_keys(bool enable, string passphrase);
     };
 
     struct message {

src/cxx/basic_api.cc

@@ -13,6 +13,7 @@
 extern "C" {
     using namespace pEp::JNIAdapter;
     using pEp::Adapter::session;
+    using pEp::passphrase_cache;
 
 JNIEXPORT jbyteArray JNICALL Java_foundation_pEp_jniadapter_Engine__1trustwords(
         JNIEnv *env,
@@ -488,14 +489,43 @@ JNIEXPORT void JNICALL Java_foundation_pEp_jniadapter_Engine__1config_1passphras
     }
     std::lock_guard<std::mutex> l(*mutex_local);
 
-    char *_passphrase = to_string(env, passphrase);
+    char* _passphrase = to_string(env, passphrase);
 
-    PEP_STATUS status = ::config_passphrase(session(),cache.add(_passphrase));
+    PEP_STATUS status = ::config_passphrase(session(),passphrase_cache.add(_passphrase));
     if (status != 0) {
         throw_pEp_Exception(env, status);
         return;
     }
 }
 
+
+JNIEXPORT void JNICALL Java_foundation_pEp_jniadapter_Engine__1config_1passphrase_1for_1new_1keys(
+        JNIEnv *env,
+        jobject obj,
+        jboolean enable,
+        jbyteArray passphrase
+    )
+{
+    std::mutex *mutex_local = nullptr;
+    {
+        std::lock_guard<std::mutex> l(global_mutex);
+        pEpLog("called with lock_guard");
+        mutex_local = get_engine_java_object_mutex(env, obj);
+    }
+    std::lock_guard<std::mutex> l(*mutex_local);
+
+    bool _enable = (bool) enable;
+    const char *_passphrase = to_string(env, passphrase);
+
+    PEP_STATUS status = ::config_passphrase_for_new_keys(session(),_enable,passphrase_cache.add_stored(_passphrase));
+    if ((status > PEP_STATUS_OK && status < PEP_UNENCRYPTED) ||
+            status < PEP_STATUS_OK ||
+            status >= PEP_TRUSTWORD_NOT_FOUND) {
+        throw_pEp_Exception(env, status);
+        return ;
+    }
+
+}
+
 } // extern "C"
 

src/cxx/foundation_pEp_jniadapter_AbstractEngine.cc

@@ -6,6 +6,7 @@
 #include <pEp/Adapter.hh>
 #include <pEp/pEpLog.hh>
 #include <pEp/passphrase_cache.hh>
+#include <pEp/callback_dispatcher.hh>
 #include "throw_pEp_exception.hh"
 #include "jniutils.hh"
 
@@ -33,10 +34,8 @@ jclass identityClass = nullptr;;
 jclass signalClass = nullptr;
 jclass engineClass = nullptr;
 
-class JNISync {
-public:
-    JNIEnv * env()
-    {
+namespace JNISync {
+    JNIEnv* env() {
         JNIEnv *thread_env = nullptr;
         int status = jvm->GetEnv((void**)&thread_env, JNI_VERSION_1_6);
         if (status < 0) {
@@ -50,19 +49,20 @@ public:
         return thread_env;
     }
 
-    void onSyncStartup()
-    {
+    void onSyncStartup() {
+        pEpLog("called");
         env();
     }
 
-    void onSyncShutdown()
-    {
+    void onSyncShutdown() {
+        pEpLog("called");
         jvm->DetachCurrentThread();
     }
-} o;
+};
+
 
 void jni_init() {
-    JNIEnv *_env = o.env();
+    JNIEnv *_env = JNISync::env();
 
     messageClass = reinterpret_cast<jclass>(
             _env->NewGlobalRef(findClass(_env, "foundation/pEp/jniadapter/Message")));
@@ -86,35 +86,37 @@ void jni_init() {
         "notifyHandshakeCallFromC",
         "(Lfoundation/pEp/jniadapter/_Identity;Lfoundation/pEp/jniadapter/_Identity;Lfoundation/pEp/jniadapter/SyncHandshakeSignal;)I");
 
-    method_values = o.env()->GetStaticMethodID(signalClass, "values",
+    method_values = JNISync::env()->GetStaticMethodID(signalClass, "values",
                 "()[Lfoundation/pEp/jniadapter/SyncHandshakeSignal;");
-    field_value = o.env()->GetFieldID(signalClass, "value", "I");
+    field_value = JNISync::env()->GetFieldID(signalClass, "value", "I");
 }
 
 PEP_STATUS messageToSend(message *msg)
 {
     std::lock_guard<std::mutex> l(mutex_obj);
-
-    pEpLog("############### messageToSend() called");
+    pEpLog("called");
 
     // Passphrase
     // When a protocol implementation of the p≡p engine using messageToSend() cannot sign or encrypt with an
     // empty passphrase and not with the configured passphrase it is calling messageToSend() with a NULL instead
     // of a struct _message object.
-    if (Adapter::on_sync_thread() && !msg) {
-        return pEp::PassphraseCache::messageToSend(cache, Adapter::session());
-    }
+    if (Adapter::on_sync_thread() && !msg)
+        return pEp::PassphraseCache::config_next_passphrase();
+
+    // reset passphrase iterator
+    if (Adapter::on_sync_thread())
+        pEp::PassphraseCache::config_next_passphrase(true);
 
     jobject msg_ = nullptr;
     assert(messageClass && messageConstructorMethodID && objj && messageToSendMethodID);
 
-    msg_ = o.env()->NewObject(messageClass, messageConstructorMethodID, (jlong) msg);
+    msg_ = JNISync::env()->NewObject(messageClass, messageConstructorMethodID, (jlong) msg);
 
-    PEP_STATUS status = (PEP_STATUS) o.env()->CallIntMethod(objj, messageToSendMethodID, msg_);
-    if (o.env()->ExceptionCheck()) {
-        o.env()->ExceptionDescribe();
+    PEP_STATUS status = (PEP_STATUS) JNISync::env()->CallIntMethod(objj, messageToSendMethodID, msg_);
+    if (JNISync::env()->ExceptionCheck()) {
+        JNISync::env()->ExceptionDescribe();
         status = PEP_UNKNOWN_ERROR;
-        o.env()->ExceptionClear();
+        JNISync::env()->ExceptionClear();
     }
 
 
@@ -124,13 +126,13 @@ PEP_STATUS messageToSend(message *msg)
 PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handshake_signal signal)
 {
     std::lock_guard<std::mutex> l(mutex_obj);
+    pEpLog("called");
 
-    pEpLog("############### notifyHandshake() called");
     jobject me_ = nullptr;
     jobject partner_ = nullptr;
 
-    me_ = from_identity(o.env(), me, identityClass);
-    partner_ = from_identity(o.env(), partner, identityClass);
+    me_ = from_identity(JNISync::env(), me, identityClass);
+    partner_ = from_identity(JNISync::env(), partner, identityClass);
 
     jobject signal_ = nullptr;
     {
@@ -138,31 +140,31 @@ PEP_STATUS notifyHandshake(pEp_identity *me, pEp_identity *partner, sync_handsha
         assert(method_values);
         assert(field_value);
 
-        jobjectArray values = (jobjectArray) o.env()->CallStaticObjectMethod(signalClass,
+        jobjectArray values = (jobjectArray) JNISync::env()->CallStaticObjectMethod(signalClass,
                 method_values);
-        if (o.env()->ExceptionCheck()) {
-            o.env()->ExceptionClear();
+        if (JNISync::env()->ExceptionCheck()) {
+            JNISync::env()->ExceptionClear();
             return PEP_UNKNOWN_ERROR;
         }
 
-        jsize values_size = o.env()->GetArrayLength(values);
+        jsize values_size = JNISync::env()->GetArrayLength(values);
         for (jsize i = 0; i < values_size; i++) {
-            jobject element = o.env()->GetObjectArrayElement(values, i);
+            jobject element = JNISync::env()->GetObjectArrayElement(values, i);
             assert(element);
-            jint value = o.env()->GetIntField(element, field_value);
+            jint value = JNISync::env()->GetIntField(element, field_value);
             if (value == (jint) signal) {
                 signal_ = element;
                 break;
             }
-            o.env() -> DeleteLocalRef(element);
+            JNISync::env() -> DeleteLocalRef(element);
         }
     }
 
     assert(objj && notifyHandShakeMethodID);
 
-    PEP_STATUS status = (PEP_STATUS) o.env()->CallIntMethod(objj, notifyHandShakeMethodID, me_, partner_, signal_);
-    if (o.env()->ExceptionCheck()) {
-        o.env()->ExceptionClear();
+    PEP_STATUS status = (PEP_STATUS) JNISync::env()->CallIntMethod(objj, notifyHandShakeMethodID, me_, partner_, signal_);
+    if (JNISync::env()->ExceptionCheck()) {
+        JNISync::env()->ExceptionClear();
         return PEP_UNKNOWN_ERROR;
     }
 
@@ -187,7 +189,8 @@ JNIEXPORT void JNICALL Java_foundation_pEp_jniadapter_AbstractEngine_init(
         env->GetJavaVM(&jvm);
         jni_init();
         objj = env->NewGlobalRef(obj);
-        Adapter::_messageToSend = messageToSend;
+        callback_dispatcher.add(messageToSend, notifyHandshake, JNISync::onSyncStartup, JNISync::onSyncShutdown);
+        Adapter::_messageToSend = CallbackDispatcher::messageToSend;
     }
 
     create_engine_java_object_mutex(env, obj);  // Create a mutex per java object
@@ -373,11 +376,10 @@ JNIEXPORT void JNICALL Java_foundation_pEp_jniadapter_AbstractEngine__1startSync
     }
     std::lock_guard<std::mutex> l(*mutex_local);
 
-    pEpLog("######## starting sync");
     try {
-        Adapter::startup<JNISync>(messageToSend, notifyHandshake, &o, &JNISync::onSyncStartup, &JNISync::onSyncShutdown);
-    }
-    catch (RuntimeError& ex) {
+        CallbackDispatcher::start_sync();
+//        Adapter::startup<JNISync>(messageToSend, notifyHandshake, &o, &JNISync::onSyncStartup, &JNISync::onSyncShutdown);
+    } catch (RuntimeError& ex) {
         throw_pEp_Exception(env, ex.status);
         return;
     }
@@ -396,7 +398,8 @@ JNIEXPORT void JNICALL Java_foundation_pEp_jniadapter_AbstractEngine__1stopSync(
     }
     std::lock_guard<std::mutex> l(*mutex_local);
 
-    Adapter::shutdown();
+    CallbackDispatcher::stop_sync();
+//    Adapter::shutdown();
 }
 
 JNIEXPORT jboolean JNICALL Java_foundation_pEp_jniadapter_AbstractEngine__1isSyncRunning(

src/cxx/jniutils.hh

@@ -20,8 +20,6 @@
 
 namespace pEp {
     namespace JNIAdapter {
-
-        static pEp::PassphraseCache cache;
         // Global mutex needs to be locked in all constructors which insert their own mutex object
         // into the unordered_map (which is thread safe for read, but not for write)
         extern std::mutex global_mutex;

test/java/foundation/pEp/jniadapter/test/jni111/TestAlice.java

@@ -1,29 +1,85 @@
 package foundation.pEp.jniadapter.test.jni111;
 
 import static foundation.pEp.pitytest.TestLogger.*;
+import static foundation.pEp.pitytest.utils.TestUtils.readKey;
 
+import foundation.pEp.jniadapter.*;
+import foundation.pEp.jniadapter.exceptions.*;
 import foundation.pEp.pitytest.*;
 import foundation.pEp.pitytest.utils.TestUtils;
 import foundation.pEp.jniadapter.test.utils.*;
 
+import java.util.Vector;
+
 
 // https://pep.foundation/jira/browse/JNI-111
 
+class JNI111TestContext extends AdapterBaseTestContext {
+    @Override
+    public void init() throws Throwable {
+        super.init();
+        alice = null;
+        bob = null;
+    }
+}
+
 class TestAlice {
     public static void main(String[] args) throws Exception {
-        TestSuite.getDefault().setVerbose(true);
+//        readKey();
+        TestSuite.getDefault().setVerbose(false);
         TestSuite.getDefault().setTestColor(TestUtils.TermColor.GREEN);
 
-        AdapterBaseTestContext jni111Ctx = new AdapterBaseTestContext();
+        AdapterBaseTestContext jni111Ctx = new JNI111TestContext();
+
+        new TestUnit<AdapterBaseTestContext>("importKey()", jni111Ctx, ctx -> {
+            assert ctx.alice == null: "Alice is not null";
+            ctx.alice = ctx.engine.importKey(ctx.keyAliceSecPassphrase).get(0);
+            log(AdapterTestUtils.identityToString(ctx.alice, true));
+            assert ctx.alice != null: "Keyimport failed";
+        });
+
+        new TestUnit<AdapterBaseTestContext>("setOwnKey()", jni111Ctx, ctx -> {
+            ctx.alice.user_id = "23";
+            ctx.alice = ctx.engine.setOwnKey(ctx.alice, ctx.alice.fpr);
+            log(AdapterTestUtils.identityToString(ctx.alice, true));
+            assert ctx.alice.me == true;
+            assert ctx.alice.comm_type == CommType.PEP_ct_pEp;
+        });
+
+        new TestUnit<AdapterBaseTestContext>("encrypt_message() -> pEpPassphraseRequired ", jni111Ctx, ctx -> {
+            try {
+                Message enc = ctx.engine.encrypt_message(ctx.msgToSelf, new Vector<>(), Message.EncFormat.PEP);
+            } catch (pEpException e) {
+                assert e instanceof pEpPassphraseRequired: "wrong exception type";
+                return;
+            }
+            assert false:"encrypt_message() should have failed";
+        });
+
+        new TestUnit<AdapterBaseTestContext>("config_passphrase() wrong", jni111Ctx, ctx -> {
+            ctx.engine.config_passphrase("WRONG PASSPHRASE");
+        });
+
+        new TestUnit<AdapterBaseTestContext>("encrypt_message() -> pEpWrongPassphrase ", jni111Ctx, ctx -> {
+            try {
+                Message enc = ctx.engine.encrypt_message(ctx.msgToSelf, new Vector<>(), Message.EncFormat.PEP);
+            } catch (pEpException e) {
+                assert e instanceof pEpWrongPassphrase: "wrong exception type";
+                return;
+            }
+            assert false:"encrypt_message() should have failed";
+        });
 
-        new TestUnit<AdapterBaseTestContext>("config_passphrase", jni111Ctx, ctx -> {
-            ctx.engine.config_passphrase("chocolate");
-            ctx.engine.config_passphrase("Bar");
-            ctx.engine.config_passphrase("Foo");
+        new TestUnit<AdapterBaseTestContext>("config_passphrase() correct", jni111Ctx, ctx -> {
+            ctx.engine.config_passphrase("passphrase_alice");
         });
 
-        new TestUnit<AdapterBaseTestContext>("config_passphrase_for_new_keys", jni111Ctx, ctx -> {
-            ctx.engine.config_passphrase_for_new_keys(true, "SUPERCOMPLICATEDPASSPHRASE");
+        new TestUnit<AdapterBaseTestContext>("encrypt_message() -> success", jni111Ctx, ctx -> {
+            assert ctx.msgToSelf.getEncFormat() == Message.EncFormat.None : "Orig msg not plain";
+            Message enc = ctx.engine.encrypt_message(ctx.msgToSelf, new Vector<>(), Message.EncFormat.PEP);
+            assert enc.getEncFormat() == Message.EncFormat.PGPMIME :"Message not encrypted";
+            assert !enc.getLongmsg().contains(ctx.msgToSelf.getLongmsg()): "Message not encrypted";
+            log(AdapterTestUtils.msgToString(enc, false));
         });
 
         TestSuite.getDefault().run();

test/java/foundation/pEp/jniadapter/test/utils/AdapterBaseTestContext.java

@@ -37,17 +37,23 @@ public class AdapterBaseTestContext extends AbstractTestContext {
     public Identity carol;
 
     // Keys
-    public byte[] keyBobSec;
-    private String filenameBobSec = "../resources/test_keys/bob-sec.asc";
+    public byte[] keyAlicePub;
+    private String filenameAlicePub = "../resources/test_keys/alice-pub-DE5DF92A358DCE5F.asc";
+
+    public byte[] keyAliceSec;
+    private String filenameAliceSec = "../resources/test_keys/alice-sec-DE5DF92A358DCE5F.asc";
+
+    public byte[] keyAlicePubPassphrase;
+    private String filenameAlicePubPassphrase = "../resources/test_keys/alice-passphrase-pub-BCBAC48800026D6F.asc";
+
+    public byte[] keyAliceSecPassphrase;
+    private String filenameAliceSecPassphrase = "../resources/test_keys/alice-passphrase-sec-BCBAC48800026D6F.asc";
 
     public byte[] keyBobPub;
     private String filenameBobPub = "../resources/test_keys/bob-pub.asc";
 
-    public byte[] keyAlicePub;
-    private String filenameAlicePub = "../resources/test_keys/alicenew-pub.asc";
-
-    public byte[] keyAliceSec;
-    private String filenameAliceSec = "../resources/test_keys/alicenew-sec.asc";
+    public byte[] keyBobSec;
+    private String filenameBobSec = "../resources/test_keys/bob-sec.asc";
 
     // Messages
     public Message msgToSelf;
@@ -66,6 +72,12 @@ public class AdapterBaseTestContext extends AbstractTestContext {
         engine.setMessageToSendCallback(callbacks);
         engine.setNotifyHandshakeCallback(callbacks);
 
+        TestLogger.logH2("Machine directory: ");
+        TestLogger.log(engine.getMachineDirectory());
+        TestLogger.logH2("User directory:" );
+        TestLogger.log(engine.getUserDirectory());
+
+
         alice = new Identity();
         alice.user_id = "23";
         alice.address = "alice@peptest.org";
@@ -94,6 +106,12 @@ public class AdapterBaseTestContext extends AbstractTestContext {
 
         path = Paths.get(filenameAliceSec);
         keyAliceSec = Files.readAllBytes(path);
+
+        path = Paths.get(filenameAlicePubPassphrase);
+        keyAlicePubPassphrase = Files.readAllBytes(path);
+
+        path = Paths.get(filenameAliceSecPassphrase);
+        keyAliceSecPassphrase = Files.readAllBytes(path);
     }
 
 }

test/java/foundation/pEp/pitytest/utils/TestUtils.java

@@ -18,7 +18,8 @@ import java.util.stream.Collectors;
 
 public class TestUtils {
     // Pure static class
-    private TestUtils() { }
+    private TestUtils() {
+    }
 
     /*
     System
@@ -79,13 +80,18 @@ public class TestUtils {
 
     public static boolean envVarExists(String var) {
         boolean ret = false;
-        if(System.getenv(var) != null) {
+        if (System.getenv(var) != null) {
             ret = true;
         }
         return ret;
     }
 
 
+    public static String readKey() {
+        String ret = null;
+        ret = System.console().readLine();
+        return ret;
+    }
 
     /*
     Time Utils
@@ -157,8 +163,8 @@ public class TestUtils {
     public static int stringLenMinusEscSeq(String str) {
         int ret;
         int escSeqCount = substringOccurencesCount(str, "\u001B[");
-        ret = str.length() -  (escSeqCount * 3);
-        if(ret < 0) ret = 0;
+        ret = str.length() - (escSeqCount * 3);
+        if (ret < 0) ret = 0;
         return ret;
     }
 

test/resources/test_keys/alice-passphrase-pub-BCBAC48800026D6F.asc

@@ -0,0 +1,30 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mQENBF8DkRoBCADb8V2JovuiiTzYMw8ma6CYwK+JJt1YQsXh48A+WORe1GZe/jNv
+QJUouQNn/pWa1r7nq9XSv3NKukl+ddUIWNPLDHmFZuzoeaGNjuQxKavDiUzE+BNY
+buJVnImr6oQpBioNGfvw3JrGq8E51WJok5nDmdpFGfIdnKwhUY8UQ9sJkoLxkkVv
+V4e5pKqElXKWABUnypEvt187qsunALOr3JNRoMCp7RZsmqRgAGGbFSla5kDWGY5M
+iYkXZdp2+OHDoOwH2U/oyFyBDrrWZzYnIWIjiezoRYHfcfx3OtuGBrwMIMDBxB7k
+rd98V7bE8b4NIL04vPkx+s8RvWGrSAzvk2V7ABEBAAG0GWFsaWNlIDxhbGljZUBw
+ZXB0ZXN0Lm9yZz6JAVQEEwEIAD4WIQT049YCFhGGPZFklCm8usSIAAJtbwUCXwOR
+GgIbAwUJA8JnAAULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRC8usSIAAJtb3rR
+B/sFcXao66WIqhy/9obmUA0SNByHm9V+ha7/rUey5htEHBJE3iHZH5zAWthvowcu
+y+vfprObpQFJSpUg8KtBvEXdA1mYTojWP3FHhbdwkUMQulKvieVZx+iIr1ld4YYj
+d7H7z+Ts/euUg73c4auuXk9lMeKU7FerFVMUO6FtRyj1unyLi5pLivyrGPj1DE0n
+SncG1YXQqW+jmUepq5GRETUTPZgdFzu4EsXJtM0drY3XCOBsTGxGeGFpzfm1rxor
+OVKZcvY0JGmvB7fIcDI6Qfmn91gR6Yz6y+sNjcVBZR8bVxOHDkAtiugRWbT48JSr
+721B/W+h6bhxu97DQwSAWGYcuQENBF8DkRoBCADFrNmksM6b0OYIQ0kLbkwfctRQ
+NFLE6QPDvXmb634MqXT0qkvVjUEouRPWbSMbiAQuj0b3G41L4BAzi0DIl43vmpbK
+XhHlPVelqZzg0yge0e6UmPcBuRP+3DohKDBh7GlQQJJuAf0Xd+SqiQd3f5N1hdAC
+pcUoi5zk2xeVh1QKLTpBeSrPp7PtVzNGXyu/S1u2FEYjJ9Y6AsjCYTEp1RzsZ2gh
+lPopDS9l4kQHZTxDC171+5ay5dCDH4anxBfjF3nXbtjEZwc8SJZ4qvH5WrC0Zgm/
+Nt8M2FWXTW3AaTYM1rJrGFC+HWIPUDTsMzeHN4LyVJ+Fftj4vb1EkoiJrCdXABEB
+AAGJATwEGAEIACYWIQT049YCFhGGPZFklCm8usSIAAJtbwUCXwORGgIbDAUJA8Jn
+AAAKCRC8usSIAAJtb8D5CAC7rEHsP2z8s+Il2em6JltNP8yG/wYDkdDPJF4kEECR
+0eoYpQjA55Kz1PFIYmBmOy3pBn6kQPPcWSkk7JkV4Dwnx3TVI1lthDh3gPyF2wM/
+phkNEtKtQrLEz/ClZWTbDZjV4mK/+DCBo1igOCWGdfO8sPC4qJs9k/6466Pg/LDU
++79xC2KzcHa3xZH8wzQVMf2riALch62p6yHlkSHE71DAeicQswsu5tHckFQnmjiG
+V9g7+aW+Quksike2ZhH7QpKW4Up/2BuEoZwlcrdmfhScgtvT0t+t0dL78lj37sLz
+AeCvU2zPb5yDtNKjNmMqz5YEo8HG5zmgWc+RLRSk4frj
+=kc4X
+-----END PGP PUBLIC KEY BLOCK-----

test/resources/test_keys/alice-passphrase-sec-BCBAC48800026D6F.asc

@@ -0,0 +1,59 @@
+-----BEGIN PGP PRIVATE KEY BLOCK-----
+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+=cgKm
+-----END PGP PRIVATE KEY BLOCK-----

test/resources/test_keys/alice-pub-DE5DF92A358DCE5F.asc

@@ -0,0 +1,30 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mQENBF8DjmwBCAC5pYaD6DWuLW9gwQ95l9LHPm2i+/cHKvpTuU/I7YCuhDavsuwX
+/AQArI9kEwrDsjBxoCUiZcyrxV07GUNmw5i7dQr7v6IMoVdHVmEYEsNZE8VCr2Ln
+IGVfT3APFwjS43t/+XhSMyQ/efTItNuRR5DEzJkAeQSA0nOYAvB5Y1NO3OJxX9qV
+3HzxgQUnqbsCDzRCXyNz2yjkctWsV4ABL8hqlX5g2H8P63CPN+JEUFOewn4yULiZ
+H1pFx5o0a7Gavudbab2H6infHem//Uwo8iu4i1QQcp16MVXDDFXXdKNv8uyp7heo
+Y9StBGVs3DvDsjTBw625gdioHeYU+G2UpPj3ABEBAAG0GWFsaWNlIDxhbGljZUBw
+ZXB0ZXN0Lm9yZz6JAVQEEwEIAD4WIQT9kIMWeBHQA0L66sLeXfkqNY3OXwUCXwOO
+bAIbAwUJA8JnAAULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRDeXfkqNY3OXyW/
+CACoonVSPGyNlWg/G1Zuhko78hbw3kZH2oXPBaKKjOu4lJFwwCJPjM8Or8fmdoJH
+qElwgtoT30c3WKtwxRYFBEa+1HrUwaY/DEHMu22+f6LLUUdTAA7ca4dv6yoFjpdx
+CBSelNWoUkhkEWy44+5ixOT2e6iN9mZtoWyRPbcnN8CCEnYoUasSP3ThDz5MSiu4
+zZtfleB0X6YHBkNIYibJGwZCued2J0r8d/OaMzdXHD4Ewd9ErSycOdzagdCE6SWX
+3tBd+/8SkR3cNriCstSEzKQllltiotNvkICAw19wr1W2ZNK7Vga9PNhhBKIRkJPh
+0rLw8cR1AfkVGtgqyDwoCRlLuQENBF8DjmwBCADArPrHV2kDyNSE+Y8H3aVUUYHh
+crif623riy8dplSAepsLd/3PMLWtqY5fetcR+/yUaPC5wkHwJ531Og2Ki9N7Oucj
+N6L3cug4jQ/46qnL2yd1GjxPohQnk+xCecXhBkco2pYssIj4PZ2s5Ly+1+yXWbTp
+XdPVoZM2HcL15cqTR+Q2T3xXVP6PtNDPuAj46jPxqmqFeF1LqpHLLnauDpSb9/NK
+tlCF5PBU2NXfy53nOr0qNEXF3CdAI0YUTpW9leX2eLS0er2wOCKUQhBrhptRF4NA
+GGkqu6geiqrEwM4SPsr7AaaEuMjWvIZLP1pacyU3vkW3MrZxwF3e5IheE7iVABEB
+AAGJATwEGAEIACYWIQT9kIMWeBHQA0L66sLeXfkqNY3OXwUCXwOObAIbDAUJA8Jn
+AAAKCRDeXfkqNY3OXwq7B/sFnWEl+hLu77MK2pZY/hZfZfDp2nFs84DkrN4GgIyn
+oK3EGX8E3KNb4w6zKhCh43KI+L0CHCnMlbvNnsgk1qHbBCrhDvS+DYTKxCEJkI4D
+an6QHBYFU38pW0lc6NxOwwFk49iXieCrUlHT07rLoqop+pssfsk/pATVjnTEw25y
+W/97l8DWCxGltdr+3cojtRS+rIOR8vPVyz/kM2MasmFtRY/LDYO2CXSYbw/VORIN
+wmywURAHijuDQdp8w6I43OTa8s3J51/TKd9FuhCn/hFgwp64i6Irqb8Y2ZdwMTtq
+9Sg9/6G77nFa+jNmcod95PDV4lKEFEzIiFACpfN+J0Ow
+=HEDs
+-----END PGP PUBLIC KEY BLOCK-----

test/resources/test_keys/alice-sec-DE5DF92A358DCE5F.asc

@@ -0,0 +1,57 @@
+-----BEGIN PGP PRIVATE KEY BLOCK-----
+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+=M413
+-----END PGP PRIVATE KEY BLOCK-----