OXInstantMessagingIntegrationTest.java

  1. /**
  2.  *
  3.  * Copyright 2018 Paul Schaub.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smackx.ox_im;

  19. import static org.junit.jupiter.api.Assertions.assertFalse;
  20. import static org.junit.jupiter.api.Assertions.assertTrue;

  22. import java.io.File;
  23. import java.io.IOException;

  25. import org.jivesoftware.smack.SmackException;
  26. import org.jivesoftware.smack.XMPPException;
  27. import org.jivesoftware.smack.packet.Message;
  28. import org.jivesoftware.smack.util.StringUtils;

  30. import org.jivesoftware.smackx.ox.AbstractOpenPgpIntegrationTest;
  31. import org.jivesoftware.smackx.ox.OpenPgpContact;
  32. import org.jivesoftware.smackx.ox.OpenPgpManager;
  33. import org.jivesoftware.smackx.ox.crypto.PainlessOpenPgpProvider;
  34. import org.jivesoftware.smackx.ox.element.SigncryptElement;
  35. import org.jivesoftware.smackx.ox.store.filebased.FileBasedOpenPgpStore;
  36. import org.jivesoftware.smackx.ox.util.OpenPgpPubSubUtil;

  38. import org.igniterealtime.smack.inttest.SmackIntegrationTestEnvironment;
  39. import org.igniterealtime.smack.inttest.TestNotPossibleException;
  40. import org.igniterealtime.smack.inttest.annotations.AfterClass;
  41. import org.igniterealtime.smack.inttest.annotations.BeforeClass;
  42. import org.igniterealtime.smack.inttest.annotations.SmackIntegrationTest;
  43. import org.igniterealtime.smack.inttest.annotations.SpecificationReference;
  44. import org.igniterealtime.smack.inttest.util.SimpleResultSyncPoint;
  45. import org.pgpainless.decryption_verification.OpenPgpMetadata;
  46. import org.pgpainless.key.OpenPgpV4Fingerprint;
  47. import org.pgpainless.key.protection.UnprotectedKeysProtector;

  49. @SpecificationReference(document = "XEP-0374", version = "0.2.0")
  50. public class OXInstantMessagingIntegrationTest extends AbstractOpenPgpIntegrationTest {

  52.     private static final String sessionId = StringUtils.randomString(10);
  53.     private static final File tempDir = org.apache.commons.io.FileUtils.getTempDirectory();
  54.     private static final File aliceStorePath = new File(tempDir, "basic_ox_messaging_test_alice_" + sessionId);
  55.     private static final File bobStorePath = new File(tempDir, "basic_ox_messaging_test_bob_" + sessionId);

  57.     private OpenPgpV4Fingerprint aliceFingerprint = null;
  58.     private OpenPgpV4Fingerprint bobFingerprint = null;

  60.     private OpenPgpManager aliceOpenPgp;
  61.     private OpenPgpManager bobOpenPgp;

  63.     /**
  64.      * This integration test tests basic OX message exchange.
  65.      * In this scenario, Alice and Bob are strangers, as they do not have subscribed to one another.
  66.      *
  67.      * Alice (conOne) creates keys and publishes them to the server.
  68.      * Bob (conTwo) creates keys and publishes them to the server.
  69.      *
  70.      * Alice then manually fetches Bobs metadata node and all announced keys.
  71.      *
  72.      * Alice trusts Bobs keys and vice versa (even though Bob does not have copies of Alice' keys yet).
  73.      *
  74.      * She proceeds to create an OX encrypted message, which is encrypted to Bob and herself and signed by her.
  75.      *
  76.      * She sends the message.
  77.      *
  78.      * Bob receives the message, which - due to missing keys - triggers him to update Alice' keys.
  79.      *
  80.      * After the update Bob proceeds to decrypt and verify the message.
  81.      *
  82.      * After the test, the keys are deleted from local storage and from PubSub.
  83.      *
  84.      * @param environment test environment
  85.      *
  86.      * @throws XMPPException.XMPPErrorException if there was an XMPP error returned.
  87.      * @throws InterruptedException if the calling thread was interrupted.
  88.      * @throws SmackException.NotConnectedException if the XMPP connection is not connected.
  89.      * @throws TestNotPossibleException if the test is not possible due to lacking server support for PEP.
  90.      * @throws SmackException.NoResponseException if there was no response from the remote entity.
  91.      */
  92.     public OXInstantMessagingIntegrationTest(SmackIntegrationTestEnvironment environment)
  93.             throws XMPPException.XMPPErrorException, InterruptedException, SmackException.NotConnectedException,
  94.             TestNotPossibleException, SmackException.NoResponseException {
  95.         super(environment);
  96.     }

  98.     @BeforeClass
  99.     @AfterClass
  100.     public static void deleteStore() throws IOException {
  101.         org.apache.commons.io.FileUtils.deleteDirectory(aliceStorePath);
  102.         org.apache.commons.io.FileUtils.deleteDirectory(bobStorePath);
  103.     }

  105.     @SmackIntegrationTest
  106.     public void basicInstantMessagingTest()
  107.             throws Exception {

  109.         final SimpleResultSyncPoint bobReceivedMessage = new SimpleResultSyncPoint();
  110.         final String body = "Writing integration tests is an annoying task, but it has to be done, so lets do it!!!";

  112.         FileBasedOpenPgpStore aliceStore = new FileBasedOpenPgpStore(aliceStorePath);
  113.         aliceStore.setKeyRingProtector(new UnprotectedKeysProtector());
  114.         FileBasedOpenPgpStore bobStore = new FileBasedOpenPgpStore(bobStorePath);
  115.         bobStore.setKeyRingProtector(new UnprotectedKeysProtector());

  117.         PainlessOpenPgpProvider aliceProvider = new PainlessOpenPgpProvider(aliceStore);
  118.         PainlessOpenPgpProvider bobProvider = new PainlessOpenPgpProvider(bobStore);

  120.         aliceOpenPgp = OpenPgpManager.getInstanceFor(aliceConnection);
  121.         bobOpenPgp = OpenPgpManager.getInstanceFor(bobConnection);

  123.         OXInstantMessagingManager aliceInstantMessaging = OXInstantMessagingManager.getInstanceFor(aliceConnection);
  124.         OXInstantMessagingManager bobInstantMessaging = OXInstantMessagingManager.getInstanceFor(bobConnection);

  126.         bobInstantMessaging.addOxMessageListener(new OxMessageListener() {
  127.             @Override
  128.             public void newIncomingOxMessage(OpenPgpContact contact, Message originalMessage, SigncryptElement decryptedPayload, OpenPgpMetadata metadata) {
  129.                 if (((Message.Body) decryptedPayload.getExtension(Message.Body.NAMESPACE)).getMessage().equals(body)) {
  130.                     bobReceivedMessage.signal();
  131.                 } else {
  132.                     bobReceivedMessage.signalFailure();
  133.                 }
  134.             }
  135.         });

  137.         aliceOpenPgp.setOpenPgpProvider(aliceProvider);
  138.         bobOpenPgp.setOpenPgpProvider(bobProvider);

  140.         aliceFingerprint = aliceOpenPgp.generateAndImportKeyPair(alice);
  141.         bobFingerprint = bobOpenPgp.generateAndImportKeyPair(bob);

  143.         try {
  144.             aliceOpenPgp.announceSupportAndPublish();
  145.             bobOpenPgp.announceSupportAndPublish();

  147.             OpenPgpContact bobForAlice = aliceOpenPgp.getOpenPgpContact(bob.asEntityBareJidIfPossible());
  148.             OpenPgpContact aliceForBob = bobOpenPgp.getOpenPgpContact(alice.asEntityBareJidIfPossible());

  150.             bobForAlice.updateKeys(aliceConnection);

  152.             assertFalse(bobForAlice.isTrusted(bobFingerprint));
  153.             assertFalse(aliceForBob.isTrusted(aliceFingerprint));

  155.             bobForAlice.trust(bobFingerprint);
  156.             aliceForBob.trust(aliceFingerprint);

  158.             assertTrue(bobForAlice.isTrusted(bobFingerprint));
  159.             assertTrue(aliceForBob.isTrusted(aliceFingerprint));

  161.             aliceInstantMessaging.sendOxMessage(bobForAlice, body);

  163.             bobReceivedMessage.waitForResult(timeout);
  164.         } finally {
  165.             OpenPgpPubSubUtil.deletePublicKeyNode(alicePepManager, aliceFingerprint);
  166.             OpenPgpPubSubUtil.deletePubkeysListNode(alicePepManager);
  167.             OpenPgpPubSubUtil.deletePublicKeyNode(bobPepManager, bobFingerprint);
  168.             OpenPgpPubSubUtil.deletePubkeysListNode(bobPepManager);
  169.         }
  170.     }

  172. }
Created with JaCoCo 0.8.6.202009150832