Test, work in progress, TOFU with encMode.PEP

test/java/foundation/pEp/jniadapter/test/templateAliceBob/Makefile

@@ -6,6 +6,8 @@ TEST_UNIT_NAME=templateAliceBob
 JAVA_CLASSES = \
  	TestAlice.class \
  	TestBob.class \
+ 	MultiPeerCTX.class \
+ 	pEpMessage.class \
  	../utils/AdapterBaseTestContext.class \
  	../utils/AdapterTestUtils.class \
  	../utils/TestCallbacks.class

test/java/foundation/pEp/jniadapter/test/templateAliceBob/MultiPeerCTX.java

@@ -0,0 +1,91 @@
+package foundation.pEp.jniadapter.test.templateAliceBob;
+
+
+import foundation.pEp.jniadapter.Engine;
+import foundation.pEp.jniadapter.Identity;
+import foundation.pEp.jniadapter.Message;
+import foundation.pEp.jniadapter.test.utils.AdapterTestUtils;
+import foundation.pEp.jniadapter.test.utils.TestCallbacks;
+import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.test.ctx.FsMQManagerTestContext;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Vector;
+
+
+class MultiPeerCTX extends FsMQManagerTestContext {
+    // Basic
+    public Engine engine;
+    public TestCallbacks callbacks;
+
+    // Identities
+    public Identity alice;
+    public Identity bob;
+    public Identity carol;
+
+    // Keys
+    public byte[] keyBobSec;
+    private String filenameBobSec = "../resources/test_keys/bob-sec.asc";
+
+    public byte[] keyBobPub;
+    private String filenameBobPub = "../resources/test_keys/bob-pub.asc";
+
+    public byte[] keyAlicePub;
+    private String filenameAlicePub = "../resources/test_keys/alice-pub.asc";
+
+    public byte[] keyAliceSec;
+    private String filenameAliceSec = "../resources/test_keys/alice-sec.asc";
+
+    // Messages
+    public Message msgToSelf;
+    public Message msgToBob;
+
+    // Misc
+    public Vector<Identity> vID;
+    public Vector<String> vStr;
+
+    public MultiPeerCTX(String selfAddress) {
+        super(selfAddress);
+    }
+
+    public void init() throws Throwable {
+        super.init();
+        vID = new Vector<Identity>();
+        vStr = new Vector<String>();
+
+        callbacks = new TestCallbacks();
+        engine = new Engine();
+        engine.setMessageToSendCallback(callbacks);
+        engine.setNotifyHandshakeCallback(callbacks);
+
+        alice = new Identity();
+        alice.address = "alice@peptest.org";
+        alice.username = "alice";
+        alice.user_id = "23";
+
+        bob = new Identity();
+        bob.address = "bob@peptest.org";
+        bob.username = "bob";
+        bob.user_id = "42";
+
+        msgToSelf = AdapterTestUtils.makeNewTestMessage(alice, alice, Message.Direction.Outgoing);
+        msgToBob = AdapterTestUtils.makeNewTestMessage(alice, bob, Message.Direction.Outgoing);
+
+        vID.add(bob);
+        vStr.add("StringItem");
+
+        Path path;
+        path = Paths.get(filenameBobPub);
+        keyBobPub = Files.readAllBytes(path);
+
+        path = Paths.get(filenameBobSec);
+        keyBobSec = Files.readAllBytes(path);
+
+        path = Paths.get(filenameAlicePub);
+        keyAlicePub = Files.readAllBytes(path);
+
+        path = Paths.get(filenameAliceSec);
+        keyAliceSec = Files.readAllBytes(path);
+    }
+}

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

@@ -2,35 +2,113 @@ package foundation.pEp.jniadapter.test.templateAliceBob;
 
 import static foundation.pEp.pitytest.TestLogger.*;
 
+import foundation.pEp.jniadapter.Blob;
+import foundation.pEp.jniadapter.test.templateAliceBob.MultiPeerCTX;
+
+import foundation.pEp.jniadapter.Engine;
+import foundation.pEp.jniadapter.Identity;
+import foundation.pEp.jniadapter.Message;
+import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.FsMQMessage;
+import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.test.ctx.FsMQManagerTestContext;
 import foundation.pEp.pitytest.*;
 import foundation.pEp.pitytest.utils.TestUtils;
 import foundation.pEp.jniadapter.test.utils.*;
 
+import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+import java.util.Vector;
+
 class TestAlice {
     public static void main(String[] args) throws Exception {
         TestSuite.getDefault().setVerbose(true);
         TestSuite.getDefault().setTestColor(TestUtils.TermColor.GREEN);
 
-        new TestUnit<AdapterBaseTestContext>("Alice tx msg", new AdapterBaseTestContext(), ctx -> {
+        MultiPeerCTX mpctx = new MultiPeerCTX("Alice");
+
+        new TestUnit<MultiPeerCTX>("Alice tx msg", mpctx, ctx -> {
+            try {
+                System.in.read();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            log(AdapterTestUtils.identityToString(ctx.alice, true));
+            log("update_ident");
+            ctx.alice = ctx.engine.updateIdentity(ctx.alice);
+            log(AdapterTestUtils.identityToString(ctx.alice, true));
+
+            log("myself()");
             ctx.alice = ctx.engine.myself(ctx.alice);
+            log(AdapterTestUtils.identityToString(ctx.alice, true));
+
+
+            log(AdapterTestUtils.identityToString(ctx.bob, true));
+            log("update()");
+            ctx.engine.updateIdentity(ctx.bob);
+            log(AdapterTestUtils.identityToString(ctx.bob, true));
+
+            Message pEpMsg = AdapterTestUtils.makeNewTestMessage(ctx.alice, ctx.bob, Message.Direction.Outgoing);
+//            pEpMsg.setEncFormat(Message.EncFormat.None);
+
+            log("Orig IN: " + AdapterTestUtils.msgToString(pEpMsg, false));
 
-            if (ctx.alice.fpr == null) {
+            Message pEpMsgEnc = ctx.engine.encrypt_message(pEpMsg, null, Message.EncFormat.PEP);
-                throw new RuntimeException();
+
+            Message txMsgpEp = null;
+            if (pEpMsgEnc == null) {
+                log("UNENCRYPTED");
+                txMsgpEp = pEpMsg;
+            } else {
+                log("ENCRYPTED");
+                txMsgpEp = pEpMsgEnc;
             }
+            log("Orig OUT: " + AdapterTestUtils.msgToString(txMsgpEp, false));
+
+            pEpMessage pEpMessageOut = new pEpMessage(txMsgpEp);
 
-            //send message
+            log("Serializing");
+            String txMsg = null;
+            try {
+                txMsg = pEpMessageOut.serialize();
+            } catch (IOException e) {
+                log("Exception while serializing: " + e.toString());
+            }
+            log("Serialized Msg: " + txMsg);
+
+            log("deserializing");
+            pEpMessage deserialized = null;
+            try {
+                deserialized = pEpMessage.deserialize(txMsg);
+            } catch (Exception e) {
+                log("Exception while deserializing: " + e.toString());
+            }
+
+            Message reconstr = deserialized.toMessage();
+            log("Reconstr: " + AdapterTestUtils.msgToString(reconstr, false));
+
+            try {
+                ctx.qm.sendMessage("Bob", txMsg);
+            } catch (IOException e) {
+                assert false : e.toString();
+            }
         });
 
-        new TestUnit<AdapterBaseTestContext>("Alice rx msg", new AdapterBaseTestContext(), ctx -> {
+        new TestUnit<MultiPeerCTX>("Alice rx msg", mpctx, ctx -> {
-            for (int i = 0; i < 1000; i++) {
+            FsMQMessage rxMsg = null;
-                log("Alice is waiting for msg...");
+            try {
-                TestUtils.sleep(1000);
+                rxMsg = ctx.qm.receiveMessage(200000);
+            } catch (Exception e) {
+                assert false : e.toString();
             }
 
+            log("Msg rx from [" + rxMsg.getFrom() + "]:" + rxMsg.getMsg());
         });
 
         TestSuite.getDefault().run();
     }
 }
 
-

test/java/foundation/pEp/jniadapter/test/templateAliceBob/TestBob.java

@@ -2,24 +2,67 @@ package foundation.pEp.jniadapter.test.templateAliceBob;
 
 import static foundation.pEp.pitytest.TestLogger.*;
 
+import foundation.pEp.jniadapter.Engine;
+import foundation.pEp.jniadapter.Message;
+import foundation.pEp.jniadapter.test.utils.transport.fsmqmanager.FsMQMessage;
 import foundation.pEp.pitytest.*;
 import foundation.pEp.pitytest.utils.TestUtils;
 import foundation.pEp.jniadapter.test.utils.*;
 
+import java.io.IOException;
+import java.util.Vector;
+
 class TestBob {
     public static void main(String[] args) throws Exception {
         TestSuite.getDefault().setVerbose(true);
         TestSuite.getDefault().setTestColor(TestUtils.TermColor.YELLOW);
 
-        new TestUnit<AdapterBaseTestContext>("Bob rx msg", new AdapterBaseTestContext(), ctx -> {
+        MultiPeerCTX mpctx = new MultiPeerCTX("Bob");
-            for (int i = 0; i < 1000; i++) {
+
-                log("Bob is waiting for msg...");
+        new TestUnit<MultiPeerCTX>("Bob rx msg", mpctx, ctx -> {
-                TestUtils.sleep(1000);
+            log(AdapterTestUtils.identityToString(ctx.bob, true));
-            }
+            log("myself()");
+            ctx.bob = ctx.engine.myself(ctx.bob);
+            log(AdapterTestUtils.identityToString(ctx.bob, true));
+
+            log(AdapterTestUtils.identityToString(ctx.alice, true));
+            log("update()");
+            ctx.engine.updateIdentity(ctx.alice);
+            log(AdapterTestUtils.identityToString(ctx.alice, true));
 
+            FsMQMessage msgRx = null;
+
+            while (true) {
+                try {
+                    msgRx = ctx.qm.receiveMessage(1000000);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    assert false : e.toString();
+                }
+                log("Msg Rx from[" + msgRx.getFrom().getAddress() + "]: " + msgRx.getMsg());
+
+                Message rxMsg = null;
+                if(false) {
+                    rxMsg = ctx.engine.incomingMessageFromPGPText(msgRx.getMsg(), Message.EncFormat.PEP);
+                } else {
+                    pEpMessage rxMsgpEp = null;
+                    try {
+                        rxMsgpEp = pEpMessage.deserialize(msgRx.getMsg());
+                    } catch (Exception e) {
+                        log("Exception while deserializing: " + e.toString());
+                    }
+                    rxMsg = rxMsgpEp.toMessage();
+                }
+                log("Orig IN: " + AdapterTestUtils.msgToString(rxMsg, false));
+
+                // decrypt
+                Engine.decrypt_message_Return result = ctx.engine.decrypt_message(rxMsg, null, 0);
+                log("Msg Rx from[" + msgRx.getFrom().getAddress() + "]: " + AdapterTestUtils.msgToString(result.dst,false));
+
+            }
         });
 
-        new TestUnit<AdapterBaseTestContext>("Bob tx msg", new AdapterBaseTestContext(), ctx -> {
+        new TestUnit<MultiPeerCTX>("Bob tx msg", mpctx, ctx -> {
             ctx.bob = ctx.engine.myself(ctx.bob);
 
             if (ctx.bob.fpr == null) {

test/java/foundation/pEp/jniadapter/test/templateAliceBob/pEpMessage.java

@@ -0,0 +1,81 @@
+package foundation.pEp.jniadapter.test.templateAliceBob;
+
+import foundation.pEp.jniadapter.Blob;
+import foundation.pEp.jniadapter.Identity;
+import foundation.pEp.jniadapter.Message;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+import java.util.Vector;
+
+public class pEpMessage implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    String fromAddress = null;
+    List<String> toAddresses = new ArrayList<String>();
+    List<Blob> attachments = new ArrayList<Blob>();
+    String shortMessage = null;
+    String longMessage = null;
+
+    pEpMessage(Message msg) {
+        fromAddress = msg.getFrom().address;
+        for(Identity i : msg.getTo() ) {
+            toAddresses.add(i.address);
+        }
+        for(Blob b : msg.getAttachments()) {
+            attachments.add(b);
+        }
+        shortMessage = msg.getShortmsg();
+        longMessage = msg.getLongmsg();
+    }
+
+    public Message toMessage() {
+        Message ret = new Message();
+        Identity from = new Identity();
+        from.address = fromAddress;
+        ret.setFrom(from);
+        Vector<Identity> toIdents = new Vector<>();
+        for( String addr : toAddresses) {
+            Identity i = new Identity();
+            i.address = addr;
+            toIdents.add(i);
+        }
+        ret.setTo(toIdents);
+        Vector<Blob> atts = new Vector<>();
+        for(Blob b : attachments) {
+            atts.add(b);
+        }
+        ret.setAttachments(atts);
+        ret.setShortmsg(shortMessage);
+        ret.setLongmsg(longMessage);
+        return ret;
+    }
+
+    public static pEpMessage deserialize(String serializedMsg) throws IOException, ClassNotFoundException {
+        pEpMessage ret = null;
+        byte[] data = Base64.getDecoder().decode(serializedMsg);
+//        byte[] data = serializedMsg.getBytes();
+        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(data));
+        Object obj = ois.readObject();
+        ois.close();
+        if (!(obj instanceof pEpMessage)) {
+            throw new ClassNotFoundException("Invalid serialized string");
+        } else {
+            ret = (pEpMessage) obj;
+        }
+        return ret;
+    }
+
+    public String serialize() throws IOException {
+        String ret = null;
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        ObjectOutputStream oos = new ObjectOutputStream(baos);
+        oos.writeObject(this);
+        oos.close();
+        ret = Base64.getEncoder().encodeToString(baos.toByteArray());
+//        ret = baos.toString();
+        return ret;
+    }
+}