diff --git a/src/basic_api.cc b/src/basic_api.cc index ff3be92..469b822 100644 --- a/src/basic_api.cc +++ b/src/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 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 l(global_mutex); + pEpLog("called with lock_guard"); + mutex_local = get_engine_java_object_mutex(env, obj); + } + std::lock_guard 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" diff --git a/src/foundation_pEp_jniadapter_AbstractEngine.cc b/src/foundation_pEp_jniadapter_AbstractEngine.cc index b4e038b..3db137c 100644 --- a/src/foundation_pEp_jniadapter_AbstractEngine.cc +++ b/src/foundation_pEp_jniadapter_AbstractEngine.cc @@ -6,6 +6,7 @@ #include #include #include +#include #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( _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 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 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_startSync( } std::lock_guard l(*mutex_local); - pEpLog("######## starting sync"); try { - Adapter::startup(messageToSend, notifyHandshake, &o, &JNISync::onSyncStartup, &JNISync::onSyncShutdown); - } - catch (RuntimeError& ex) { + CallbackDispatcher::start_sync(); +// Adapter::startup(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_stopSync( } std::lock_guard l(*mutex_local); - Adapter::shutdown(); + CallbackDispatcher::stop_sync(); +// Adapter::shutdown(); } JNIEXPORT jboolean JNICALL Java_foundation_pEp_jniadapter_AbstractEngine_isSyncRunning( diff --git a/src/gen_cpp_Engine.ysl2 b/src/gen_cpp_Engine.ysl2 index 9f50823..669504b 100644 --- a/src/gen_cpp_Engine.ysl2 +++ b/src/gen_cpp_Engine.ysl2 @@ -20,6 +20,7 @@ tstylesheet { #include using pEp::Adapter::session; + using pEp::passphrase_cache; using namespace pEp::JNIAdapter; extern "C" { @@ -68,7 +69,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 { || diff --git a/src/gen_java_Engine.ysl2 b/src/gen_java_Engine.ysl2 index f625efa..b3b07c3 100644 --- a/src/gen_java_Engine.ysl2 +++ b/src/gen_java_Engine.ysl2 @@ -125,7 +125,7 @@ tstylesheet { if "not(position() mod 2)" choose { when "$ptype = 'string'" - | «$pitype» _«$pname» = «$pname».getBytes(); + | «$pitype» _«$pname» = AbstractEngine.toUTF8(«$pname»); when "$ptype = 'bool'" | «$pitype» _«$pname» = «$pname».booleanValue(); when "$ptype = 'bytearray'" diff --git a/src/jniutils.hh b/src/jniutils.hh index 4b620d6..54fcfb2 100644 --- a/src/jniutils.hh +++ b/src/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; diff --git a/src/pEp.yml2 b/src/pEp.yml2 index dfa6cbe..ca00095 100644 --- a/src/pEp.yml2 +++ b/src/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 { diff --git a/test/java/foundation/pEp/jniadapter/test/jni111/TestAlice.java b/test/java/foundation/pEp/jniadapter/test/jni111/TestAlice.java index 74bbf98..429c361 100644 --- a/test/java/foundation/pEp/jniadapter/test/jni111/TestAlice.java +++ b/test/java/foundation/pEp/jniadapter/test/jni111/TestAlice.java @@ -1,29 +1,84 @@ 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.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("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("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("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("config_passphrase() wrong", jni111Ctx, ctx -> { + ctx.engine.config_passphrase("WRONG PASSPHRASE"); + }); + + new TestUnit("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("config_passphrase", jni111Ctx, ctx -> { - ctx.engine.config_passphrase("chocolate"); - ctx.engine.config_passphrase("Bar"); - ctx.engine.config_passphrase("Foo"); + new TestUnit("config_passphrase() correct", jni111Ctx, ctx -> { + ctx.engine.config_passphrase("passphrase_alice"); }); - new TestUnit("config_passphrase_for_new_keys", jni111Ctx, ctx -> { - ctx.engine.config_passphrase_for_new_keys(true, "SUPERCOMPLICATEDPASSPHRASE"); + new TestUnit("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(); diff --git a/test/java/foundation/pEp/jniadapter/test/utils/AdapterBaseTestContext.java b/test/java/foundation/pEp/jniadapter/test/utils/AdapterBaseTestContext.java index aa38878..5c3fa10 100644 --- a/test/java/foundation/pEp/jniadapter/test/utils/AdapterBaseTestContext.java +++ b/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); } } \ No newline at end of file diff --git a/test/java/foundation/pEp/pitytest/utils/TestUtils.java b/test/java/foundation/pEp/pitytest/utils/TestUtils.java index 2f89ed6..f6df12c 100644 --- a/test/java/foundation/pEp/pitytest/utils/TestUtils.java +++ b/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; } diff --git a/test/resources/test_keys/alice-passphrase-pub-BCBAC48800026D6F.asc b/test/resources/test_keys/alice-passphrase-pub-BCBAC48800026D6F.asc new file mode 100644 index 0000000..97ced41 --- /dev/null +++ b/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----- diff --git a/test/resources/test_keys/alice-passphrase-sec-BCBAC48800026D6F.asc b/test/resources/test_keys/alice-passphrase-sec-BCBAC48800026D6F.asc new file mode 100644 index 0000000..1840302 --- /dev/null +++ b/test/resources/test_keys/alice-passphrase-sec-BCBAC48800026D6F.asc @@ -0,0 +1,59 @@ +-----BEGIN PGP PRIVATE KEY BLOCK----- + +lQPFBF8DkRoBCADb8V2JovuiiTzYMw8ma6CYwK+JJt1YQsXh48A+WORe1GZe/jNv +QJUouQNn/pWa1r7nq9XSv3NKukl+ddUIWNPLDHmFZuzoeaGNjuQxKavDiUzE+BNY +buJVnImr6oQpBioNGfvw3JrGq8E51WJok5nDmdpFGfIdnKwhUY8UQ9sJkoLxkkVv +V4e5pKqElXKWABUnypEvt187qsunALOr3JNRoMCp7RZsmqRgAGGbFSla5kDWGY5M +iYkXZdp2+OHDoOwH2U/oyFyBDrrWZzYnIWIjiezoRYHfcfx3OtuGBrwMIMDBxB7k +rd98V7bE8b4NIL04vPkx+s8RvWGrSAzvk2V7ABEBAAH+BwMCd6pqCzmEddTsxzK4 +XxvTrj8yT28I3QLMGDgG9y3NQVH24moRSendoi9x/QeYzrPELZW5Lb/EphZqBc6s +y7kSFgVy0KTXkMPttg1moasbKxM0xolur76t4ha8YH4B22z2d65TKzJLWHCw9LyR +dV9ztgGM4BRococzjL741xx3YgqtLJwy++wtgT1FUP1lQpsjO+m6SBeply7DlKHi +D05ylu1fc8huvSWpEHbE4TzoMcGAkO/OKhBNMQqLvmpwj5jl91tUiCBlR1KA/Ck3 +G5HNGA2ZgMbAZiQPFi7fMbyh2LueFhVjbIhdV2VKnRcF+NTJuydzE2lb0opBymFg +vZcEPxHWDJF+7YDfYc7OP7HMlQnszpCCWc/krC8FcLVKULLDTN4Rl11t0ILp/siI +Cl368w9Lw8InQxuevpUBeTv8zhgNsj1diQOK+2/UDWEJEpCjmQ2rXu2q18XUa4/6 +uVN0mi8o+APJ1DtmmAP+nlVqISChUf2Ibv9EiEiqxXEkCxWlCD0JvpYKVt11M/sr +vJNg4TcJf/0HHWMneuVKt4I9aB96y/hcqUvxy50R75r6RuIpoYKQy9LdCKvYX0JD +RHLMrqPj2qbsmWgsem+TzlWE1ZQB8H91Es4FMqG0MFbnduK5Qazm2+7/QYkJ+NqS +hvYd1hv8lWspvA91H/9fZsE0nQlJuVEOV2yc48Z5KuoWX3QzUkWPHJrob1xcTtEG +oF09FDmySQ6sRLJO7HrcowUW3BYnQxGaKpmlzNiUvwF9KU8pnkyC0SjrJKi2OwCJ +twTA/n+GDnqdeoVhT5uTwYcWGHMtGQIA3KmzVItLpUaxfU1Qr5nVKhyomCUwdtkL +kGUNlErbVUK0Pu2MngjRHTe9PnIY/FMPxUIQ9/xc2N0gn0pulYuAnWekejE1xbfC +oIwdfBdXuIu0GWFsaWNlIDxhbGljZUBwZXB0ZXN0Lm9yZz6JAVQEEwEIAD4WIQT0 +49YCFhGGPZFklCm8usSIAAJtbwUCXwORGgIbAwUJA8JnAAULCQgHAgYVCgkICwIE +FgIDAQIeAQIXgAAKCRC8usSIAAJtb3rRB/sFcXao66WIqhy/9obmUA0SNByHm9V+ +ha7/rUey5htEHBJE3iHZH5zAWthvowcuy+vfprObpQFJSpUg8KtBvEXdA1mYTojW +P3FHhbdwkUMQulKvieVZx+iIr1ld4YYjd7H7z+Ts/euUg73c4auuXk9lMeKU7Fer +FVMUO6FtRyj1unyLi5pLivyrGPj1DE0nSncG1YXQqW+jmUepq5GRETUTPZgdFzu4 +EsXJtM0drY3XCOBsTGxGeGFpzfm1rxorOVKZcvY0JGmvB7fIcDI6Qfmn91gR6Yz6 +y+sNjcVBZR8bVxOHDkAtiugRWbT48JSr721B/W+h6bhxu97DQwSAWGYcnQPGBF8D +kRoBCADFrNmksM6b0OYIQ0kLbkwfctRQNFLE6QPDvXmb634MqXT0qkvVjUEouRPW +bSMbiAQuj0b3G41L4BAzi0DIl43vmpbKXhHlPVelqZzg0yge0e6UmPcBuRP+3Doh +KDBh7GlQQJJuAf0Xd+SqiQd3f5N1hdACpcUoi5zk2xeVh1QKLTpBeSrPp7PtVzNG +Xyu/S1u2FEYjJ9Y6AsjCYTEp1RzsZ2ghlPopDS9l4kQHZTxDC171+5ay5dCDH4an +xBfjF3nXbtjEZwc8SJZ4qvH5WrC0Zgm/Nt8M2FWXTW3AaTYM1rJrGFC+HWIPUDTs +MzeHN4LyVJ+Fftj4vb1EkoiJrCdXABEBAAH+BwMCdzavuxYT0z7s2k55wY2bGSzO +pSfXQUsgwiogzBS8ypIovSPsUhY7fwoGhcsLdNNXSihZaqOu6zgWh9FeGmVTeIKq +SHZbc+SiXr8kf7w0g9r/aZFu2fim02AMbc7atAzRcvfrhckcFH0Fw6l0Km17GJRO +JQ9yJdW+m0rm8MTImKEbZC+aTySbZZZV/65w5LmH354pZfu0LLp2W4wFmi7AaIeo +Da4UTsvmyFT7nsia2WKmOxVtW2hZmcShzwwR+VKn6Mxx33OhwrpEUSfu4/0rOZ+3 +KzUOZfzdks85eowlKE9DqLs+AETcvNqlW3yNN7cVoYwhwUWogd8054DFNqZBrEAe +s2HxuHracxp80e/BSw5rqJVV4xiiWOLZVUVB/9HJcsirYtHM+vJyHDbAYIY9+xeT +wB1PAbbjRFilvTXnTgA7D/LqiSPtBDDRJFC4AvuINbnqz/SaUYh5DMKHFch2FZhV +x6gUV5D0evfmItrL6VDWRy3Y1GqynscCaBipHQ26rVxK/MucghmJ5S/VF1L0NDKm +20nMeV+qXsuXo6r1cmf/98XIYpbOjHuRjSImaUlQFy49AVQ22crHjg6V0740ZMf7 +7vKPkB+I7bR63PmTHZ/H+KJAhIuWddSJbiBfV+Fj0VH2Bt1pxLqec1/uzCfOw+PD ++k/IoJl9goSLuPvFFRyyLVyd1NNhh7lJgwmwbNua0bPsP+msJV8o1Nnwcv3Ffyn5 +tyLqSGpzu2EwCFAUs9arElY6p1fWQ+hctc5Ss/c6xWncjOljoTQMktsS7I1gZ9rL +BOqLZyxvdC7vrxwqfLUiQBCgsw7rFCpijjrKV93+z5WT0kgRojYZjuNHkM9FeuNJ +vgcXskNwsdI1xxEmCbJ4BAf68K6RarvW/F72ApCpCgYKwy/pE5lukzVEXqnTYL8H +oacKiQE8BBgBCAAmFiEE9OPWAhYRhj2RZJQpvLrEiAACbW8FAl8DkRoCGwwFCQPC +ZwAACgkQvLrEiAACbW/A+QgAu6xB7D9s/LPiJdnpuiZbTT/Mhv8GA5HQzyReJBBA +kdHqGKUIwOeSs9TxSGJgZjst6QZ+pEDz3FkpJOyZFeA8J8d01SNZbYQ4d4D8hdsD +P6YZDRLSrUKyxM/wpWVk2w2Y1eJiv/gwgaNYoDglhnXzvLDwuKibPZP+uOuj4Pyw +1Pu/cQtis3B2t8WR/MM0FTH9q4gC3Ietqesh5ZEhxO9QwHonELMLLubR3JBUJ5o4 +hlfYO/mlvkLpLIpHtmYR+0KSluFKf9gbhKGcJXK3Zn4UnILb09LfrdHS+/JY9+7C +8wHgr1Nsz2+cg7TSozZjKs+WBKPBxuc5oFnPkS0UpOH64w== +=cgKm +-----END PGP PRIVATE KEY BLOCK----- diff --git a/test/resources/test_keys/alice-pub-DE5DF92A358DCE5F.asc b/test/resources/test_keys/alice-pub-DE5DF92A358DCE5F.asc new file mode 100644 index 0000000..bf0e12c --- /dev/null +++ b/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----- diff --git a/test/resources/test_keys/alice-sec-DE5DF92A358DCE5F.asc b/test/resources/test_keys/alice-sec-DE5DF92A358DCE5F.asc new file mode 100644 index 0000000..ec58b08 --- /dev/null +++ b/test/resources/test_keys/alice-sec-DE5DF92A358DCE5F.asc @@ -0,0 +1,57 @@ +-----BEGIN PGP PRIVATE KEY BLOCK----- + +lQOXBF8DjmwBCAC5pYaD6DWuLW9gwQ95l9LHPm2i+/cHKvpTuU/I7YCuhDavsuwX +/AQArI9kEwrDsjBxoCUiZcyrxV07GUNmw5i7dQr7v6IMoVdHVmEYEsNZE8VCr2Ln +IGVfT3APFwjS43t/+XhSMyQ/efTItNuRR5DEzJkAeQSA0nOYAvB5Y1NO3OJxX9qV +3HzxgQUnqbsCDzRCXyNz2yjkctWsV4ABL8hqlX5g2H8P63CPN+JEUFOewn4yULiZ +H1pFx5o0a7Gavudbab2H6infHem//Uwo8iu4i1QQcp16MVXDDFXXdKNv8uyp7heo +Y9StBGVs3DvDsjTBw625gdioHeYU+G2UpPj3ABEBAAEAB/dhSzQJmCk0n5s/me6s +9boBseDDtPRB+BmOx2Uzve/dhm0ip81pbyqp2nChLK73i5YtS+t/m4UogMcxBzch +JGFnMnAPKt+YFEvUQfD2LN80T/2Ryq6KyEUDLnQMHzEAqo05r1o1D5hvq/rIiqsy +oyRmqija6+bwR1tNejzitqtyfcGDmV0h3VHiLGJoF87EnF16uTFbnr9E8TQBy/uo +g/N8qPXrHpRwNQzBnbIDQamDmTQa8oTaVUbm5KuwHHmDQDEIk37/lCWXNjtLitnz +y2UZy52FzSs6u0G1CROXIc83Gt8zGZpXxQOzJgVev4KRvpAx2XiqHadbUh6jYMA+ +RW0EANHiv9agVX84dA7/QxIUBbHOI318cd7U3R8n2wYa+od41XU+QKW8yFI6LGHy +oAUZBqy/PgtG0YQFgfLEek5BTW0WG7mbRyMh+wSahOfp8fkdDpZOA0QmhaIdjtWb +dR2FY9eRgsa+aqGEElWBEPw46FKTzLsICW3DcJegkUoEqEylBADib2sj9HSjQIlt +5Vfwv3Hhr4hHXJQFQ2CoTcnFrAPAx+DkGJT9d8wBdnAV23rdbgV/97baOXac4NyS +SybSatJmVGBnUfCpjlcR+Q/N1hioeMdhP0Ewj/cY5DeiBYm7UM3h80Pw+7UZdZf2 +IGN8oYSfMfJ/Ol4NIcizV8lMWtYwawQAkFFKesO/L1r7fFrYJQFRfnzcqDAbkrxO +On80xZMS7RY3RdPlU2DdfTqgU4hat1NUqM6UHoZiZPv3dfvzIlmshB+ydm9LsAWf +3wqkSIR05CdAP+cvKAhUCBe2iwg/VvwB6zReQmVxaUoJ8mIxeVBKypNs/eXwj7Sz +JICsfGvsLf84k7QZYWxpY2UgPGFsaWNlQHBlcHRlc3Qub3JnPokBVAQTAQgAPhYh +BP2QgxZ4EdADQvrqwt5d+So1jc5fBQJfA45sAhsDBQkDwmcABQsJCAcCBhUKCQgL +AgQWAgMBAh4BAheAAAoJEN5d+So1jc5fJb8IAKiidVI8bI2VaD8bVm6GSjvyFvDe +Rkfahc8FooqM67iUkXDAIk+Mzw6vx+Z2gkeoSXCC2hPfRzdYq3DFFgUERr7UetTB +pj8MQcy7bb5/ostRR1MADtxrh2/rKgWOl3EIFJ6U1ahSSGQRbLjj7mLE5PZ7qI32 +Zm2hbJE9tyc3wIISdihRqxI/dOEPPkxKK7jNm1+V4HRfpgcGQ0hiJskbBkK553Yn +Svx385ozN1ccPgTB30StLJw53NqB0ITpJZfe0F37/xKRHdw2uIKy1ITMpCWWW2Ki +02+QgIDDX3CvVbZk0rtWBr082GEEohGQk+HSsvDxxHUB+RUa2CrIPCgJGUudA5gE +XwOObAEIAMCs+sdXaQPI1IT5jwfdpVRRgeFyuJ/rbeuLLx2mVIB6mwt3/c8wta2p +jl961xH7/JRo8LnCQfAnnfU6DYqL03s65yM3ovdy6DiND/jqqcvbJ3UaPE+iFCeT +7EJ5xeEGRyjaliywiPg9nazkvL7X7JdZtOld09WhkzYdwvXlypNH5DZPfFdU/o+0 +0M+4CPjqM/GqaoV4XUuqkcsudq4OlJv380q2UIXk8FTY1d/Lnec6vSo0RcXcJ0Aj +RhROlb2V5fZ4tLR6vbA4IpRCEGuGm1EXg0AYaSq7qB6KqsTAzhI+yvsBpoS4yNa8 +hks/WlpzJTe+RbcytnHAXd7kiF4TuJUAEQEAAQAH/ieR/wj8kzUzRC4xIKZhZ2h7 +Otzl1jQFwnPrCFijBdzDEV+YG5i3LMDHP1WtoUjwww1pxfKoiik7wa2Q6CIJmHvI ++5pYfVArmbSvh9W7v/Z9gkuDAVrrcw8zyoRWhQSzaN7jkY8JDIBLCzxsV7UsHEtz +IXwCCJTp05V8JEOjF2kKsXQkpzlMyK/kr1fgbWZw5cQnPBn80bgE3WwWtAw1z4Bt +SoEgPbvIFMFwdmiP8NeyUGBoloJd2sts1GbdxPbRpws1orrG3e3Q1P5npzX8NouT +zrrv2CS8z2t2RBmdXP15oTGlH7j42rKsDKB8FtBTpjPlxaGkKDWeKh0dRnfJQiEE +AMbc7Vjwry1p3Yg5rS1k9X/40c1yWqOflui5xXtBjQ/owH8+5djJkaH3fXQV8qJZ +rUrAPvpDy5dj+9T1J4jcBAPMFwngS1sCjBFvPepFyh199y+ilI8N2xL4n8rA0DWG +Frkemv6Q20wey32N/QWIxagsK2C5wO9FlqlelSsVosrlBAD4CPSE12hkXnJs5Ode +4CxGjISAjza5IhgtxYb+PY7Fcv/b7PMdiGKgQ7a88QM/NsyZ/YaUufx0aKSijQ51 +7VJvbg0kutbOKDaTC/4ZM59S3znOvwvCD3gS+EtfOTwQuoP7FrhIc4RAYvIkIKJ2 +XMp0lJXEFkdzqO1ZoyNGP6Fr8QQApDKAHb+OM9Y8WAqxCKdbNC88aUhc4Dh9Aeq+ +MBSRmV6tE3d4MgN28PxM3/Yuad8ab46U0Mw76MqvI9VNw5IL0CQrwJxCmFb5A5rz +ZSisKj9xle5i7rYwkDvGv75cqxezmBd4//1lInD9CuCFFuMRwjV1n/vN32ItK3xN +wVOFIg5EhIkBPAQYAQgAJhYhBP2QgxZ4EdADQvrqwt5d+So1jc5fBQJfA45sAhsM +BQkDwmcAAAoJEN5d+So1jc5fCrsH+wWdYSX6Eu7vswrallj+Fl9l8OnacWzzgOSs +3gaAjKegrcQZfwTco1vjDrMqEKHjcoj4vQIcKcyVu82eyCTWodsEKuEO9L4NhMrE +IQmQjgNqfpAcFgVTfylbSVzo3E7DAWTj2JeJ4KtSUdPTusuiqin6myx+yT+kBNWO +dMTDbnJb/3uXwNYLEaW12v7dyiO1FL6sg5Hy89XLP+QzYxqyYW1Fj8sNg7YJdJhv +D9U5Eg3CbLBREAeKO4NB2nzDojjc5NryzcnnX9Mp30W6EKf+EWDCnriLoiupvxjZ +l3AxO2r1KD3/obvucVr6M2Zyh33k8NXiUoQUTMiIUAKl834nQ7A= +=M413 +-----END PGP PRIVATE KEY BLOCK-----