mirror of
https://codeberg.org/Mercury-IM/Smack
synced 2025-09-10 10:49:41 +02:00
Rework support for XEP-0384: OMEMO Encryption
Changes:
Rework integration tests
New structure of base integration test classes
bump dependency on signal-protocol-java from 2.4.0 to 2.6.2
Introduced CachingOmemoStore implementations
Use CachingOmemoStore classes in integration tests
Removed OmemoSession classes (replaced with more logical OmemoRatchet classes)
Consequently also removed load/storeOmemoSession methods from OmemoStore
Removed some clutter from KeyUtil classes
Moved trust decision related code from OmemoStore to TrustCallback
Require authenticated connection for many functions
Add async initialization function in OmemoStore
Refactor omemo test package (/java/org/jivesoftware/smack/omemo -> /java/org/jivesoftware/smackx)
Remove OmemoStore method isFreshInstallation() as well as defaultDeviceId related stuff
FileBasedOmemoStore: Add cleaner methods to store/load base data types (Using tryWithResource, only for future releases, once Android API gets bumped)
Attempt to make OmemoManager thread safe
new logic for getInstanceFor() deviceId determination
OmemoManagers encrypt methods now don't throw exceptions when encryption for some devices fails. Instead message gets encrypted when possible and more information about failures gets returned alongside the message itself
Added OmemoMessage class for that purpose
Reworked entire OmemoService class
Use safer logic for creating trust-ignoring messages (like ratchet-update messages)
Restructure elements/provider in order to prepare for OMEMO namespace bumps
Remove OmemoManager.regenerate() methods in favor of getInstanceFor(connection, randomDeviceId)
Removed some unnecessary configuration options
Prepare for support of more AES message key types
Simplify session creation
Where possible, avoid side effects in methods
Add UntrustedOmemoIdentityException
Add TrustState enum
More improved tests
This commit is contained in:
parent
f290197f6a
commit
1f731f6318
GPG key ID:
62BEE9264BF17311
96 changed files with 6915 additions and 5488 deletions
|
|
@ -0,0 +1,78 @@
|
|||
/**
|
||||
*
|
||||
* Copyright the original author or authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo;
|
||||
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
import org.jivesoftware.smackx.omemo.internal.OmemoCachedDeviceList;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
|
||||
/**
|
||||
* Test behavior of device lists.
|
||||
*
|
||||
* @author Paul Schaub
|
||||
*/
|
||||
public class DeviceListTest {
|
||||
|
||||
|
||||
/**
|
||||
* Test, whether deviceList updates are correctly merged into the cached device list.
|
||||
* IDs in the update become active devices, active IDs that were not in the update become inactive.
|
||||
* Inactive IDs that were not in the update stay inactive.
|
||||
*/
|
||||
@Test
|
||||
public void mergeDeviceListsTest() {
|
||||
OmemoCachedDeviceList cached = new OmemoCachedDeviceList();
|
||||
assertNotNull(cached.getActiveDevices());
|
||||
assertNotNull(cached.getInactiveDevices());
|
||||
|
||||
cached.getInactiveDevices().add(1);
|
||||
cached.getInactiveDevices().add(2);
|
||||
cached.getActiveDevices().add(3);
|
||||
|
||||
Set<Integer> update = new HashSet<>();
|
||||
update.add(4);
|
||||
update.add(1);
|
||||
|
||||
cached.merge(update);
|
||||
|
||||
assertTrue(cached.getActiveDevices().contains(1) &&
|
||||
!cached.getActiveDevices().contains(2) &&
|
||||
!cached.getActiveDevices().contains(3) &&
|
||||
cached.getActiveDevices().contains(4));
|
||||
|
||||
assertTrue(!cached.getInactiveDevices().contains(1) &&
|
||||
cached.getInactiveDevices().contains(2) &&
|
||||
cached.getInactiveDevices().contains(3) &&
|
||||
!cached.getInactiveDevices().contains(4));
|
||||
|
||||
assertTrue(cached.getAllDevices().size() == 4);
|
||||
|
||||
assertFalse(cached.contains(17));
|
||||
cached.addDevice(17);
|
||||
assertTrue(cached.getActiveDevices().contains(17));
|
||||
|
||||
assertNotNull(cached.toString());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
/**
|
||||
*
|
||||
* Copyright the original author or authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo;
|
||||
|
||||
import static junit.framework.TestCase.assertEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
|
||||
import org.jivesoftware.smack.test.util.SmackTestSuite;
|
||||
import org.jivesoftware.smack.test.util.TestUtils;
|
||||
import org.jivesoftware.smack.util.StringUtils;
|
||||
import org.jivesoftware.smack.util.stringencoder.Base64;
|
||||
|
||||
import org.jivesoftware.smackx.omemo.element.OmemoBundleElement_VAxolotl;
|
||||
import org.jivesoftware.smackx.omemo.provider.OmemoBundleVAxolotlProvider;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
/**
|
||||
* Test serialization and parsing of the OmemoBundleVAxolotlElement.
|
||||
*/
|
||||
public class OmemoBundleVAxolotlElementTest extends SmackTestSuite {
|
||||
|
||||
@Test
|
||||
public void serializationTest() throws Exception {
|
||||
int signedPreKeyId = 420;
|
||||
String signedPreKeyB64 = Base64.encodeToString("SignedPreKey".getBytes(StringUtils.UTF8));
|
||||
String signedPreKeySigB64 = Base64.encodeToString("SignedPreKeySignature".getBytes(StringUtils.UTF8));
|
||||
String identityKeyB64 = Base64.encodeToString("IdentityKey".getBytes(StringUtils.UTF8));
|
||||
int preKeyId1 = 220, preKeyId2 = 284;
|
||||
String preKey1B64 = Base64.encodeToString("FirstPreKey".getBytes(StringUtils.UTF8)),
|
||||
preKey2B64 = Base64.encodeToString("SecondPreKey".getBytes(StringUtils.UTF8));
|
||||
HashMap<Integer, String> preKeysB64 = new HashMap<>();
|
||||
preKeysB64.put(preKeyId1, preKey1B64);
|
||||
preKeysB64.put(preKeyId2, preKey2B64);
|
||||
|
||||
OmemoBundleElement_VAxolotl bundle = new OmemoBundleElement_VAxolotl(signedPreKeyId,
|
||||
signedPreKeyB64, signedPreKeySigB64, identityKeyB64, preKeysB64);
|
||||
|
||||
assertEquals("ElementName must match.", "bundle", bundle.getElementName());
|
||||
assertEquals("Namespace must match.", "eu.siacs.conversations.axolotl", bundle.getNamespace());
|
||||
|
||||
String expected =
|
||||
"<bundle xmlns='eu.siacs.conversations.axolotl'>" +
|
||||
"<signedPreKeyPublic signedPreKeyId='420'>" +
|
||||
signedPreKeyB64 +
|
||||
"</signedPreKeyPublic>" +
|
||||
"<signedPreKeySignature>" +
|
||||
signedPreKeySigB64 +
|
||||
"</signedPreKeySignature>" +
|
||||
"<identityKey>" +
|
||||
identityKeyB64 +
|
||||
"</identityKey>" +
|
||||
"<prekeys>" +
|
||||
"<preKeyPublic preKeyId='220'>" +
|
||||
preKey1B64 +
|
||||
"</preKeyPublic>" +
|
||||
"<preKeyPublic preKeyId='284'>" +
|
||||
preKey2B64 +
|
||||
"</preKeyPublic>" +
|
||||
"</prekeys>" +
|
||||
"</bundle>";
|
||||
String actual = bundle.toXML(null).toString();
|
||||
assertEquals("Bundles XML must match.", expected, actual);
|
||||
|
||||
byte[] signedPreKey = "SignedPreKey".getBytes(StringUtils.UTF8);
|
||||
byte[] signedPreKeySig = "SignedPreKeySignature".getBytes(StringUtils.UTF8);
|
||||
byte[] identityKey = "IdentityKey".getBytes(StringUtils.UTF8);
|
||||
byte[] firstPreKey = "FirstPreKey".getBytes(StringUtils.UTF8);
|
||||
byte[] secondPreKey = "SecondPreKey".getBytes(StringUtils.UTF8);
|
||||
|
||||
OmemoBundleElement_VAxolotl parsed = new OmemoBundleVAxolotlProvider().parse(TestUtils.getParser(actual));
|
||||
|
||||
assertTrue("B64-decoded signedPreKey must match.", Arrays.equals(signedPreKey, parsed.getSignedPreKey()));
|
||||
assertEquals("SignedPreKeyId must match", signedPreKeyId, parsed.getSignedPreKeyId());
|
||||
assertTrue("B64-decoded signedPreKey signature must match.", Arrays.equals(signedPreKeySig, parsed.getSignedPreKeySignature()));
|
||||
assertTrue("B64-decoded identityKey must match.", Arrays.equals(identityKey, parsed.getIdentityKey()));
|
||||
assertTrue("B64-decoded first preKey must match.", Arrays.equals(firstPreKey, parsed.getPreKey(220)));
|
||||
assertTrue("B64-decoded second preKey must match.", Arrays.equals(secondPreKey, parsed.getPreKey(284)));
|
||||
assertEquals("toString outputs must match.", bundle.toString(), parsed.toString());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
/**
|
||||
*
|
||||
* Copyright the original author or authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
import org.junit.Test;
|
||||
|
||||
/**
|
||||
* Test the OmemoConfiguration class.
|
||||
*/
|
||||
public class OmemoConfigurationTest {
|
||||
|
||||
@Test
|
||||
public void omemoConfigurationTest() {
|
||||
@SuppressWarnings("unused") OmemoConfiguration configuration = new OmemoConfiguration();
|
||||
|
||||
// Body hint
|
||||
OmemoConfiguration.setAddOmemoHintBody(false);
|
||||
assertEquals(false, OmemoConfiguration.getAddOmemoHintBody());
|
||||
OmemoConfiguration.setAddOmemoHintBody(true);
|
||||
assertEquals(true, OmemoConfiguration.getAddOmemoHintBody());
|
||||
|
||||
// Delete stale devices
|
||||
OmemoConfiguration.setDeleteStaleDevices(false);
|
||||
assertEquals(false, OmemoConfiguration.getDeleteStaleDevices());
|
||||
OmemoConfiguration.setDeleteStaleDevices(true);
|
||||
assertEquals(true, OmemoConfiguration.getDeleteStaleDevices());
|
||||
OmemoConfiguration.setDeleteStaleDevicesAfterHours(25);
|
||||
assertEquals(25, OmemoConfiguration.getDeleteStaleDevicesAfterHours());
|
||||
try {
|
||||
OmemoConfiguration.setDeleteStaleDevicesAfterHours(-3);
|
||||
TestCase.fail("OmemoConfiguration.setDeleteStaleDevicesAfterHours should not accept values <= 0.");
|
||||
} catch (IllegalArgumentException e) {
|
||||
// Expected.
|
||||
}
|
||||
|
||||
// Ignore stale device
|
||||
OmemoConfiguration.setIgnoreStaleDevices(false);
|
||||
assertEquals(false, OmemoConfiguration.getIgnoreStaleDevices());
|
||||
OmemoConfiguration.setIgnoreStaleDevices(true);
|
||||
assertEquals(true, OmemoConfiguration.getIgnoreStaleDevices());
|
||||
OmemoConfiguration.setIgnoreStaleDevicesAfterHours(44);
|
||||
assertEquals(44, OmemoConfiguration.getIgnoreStaleDevicesAfterHours());
|
||||
try {
|
||||
OmemoConfiguration.setIgnoreStaleDevicesAfterHours(-5);
|
||||
TestCase.fail("OmemoConfiguration.setIgnoreStaleDevicesAfterHours should not accept values <= 0.");
|
||||
} catch (IllegalArgumentException e) {
|
||||
// Expected
|
||||
}
|
||||
|
||||
// Renew signedPreKeys
|
||||
OmemoConfiguration.setRenewOldSignedPreKeys(false);
|
||||
assertEquals(false, OmemoConfiguration.getRenewOldSignedPreKeys());
|
||||
OmemoConfiguration.setRenewOldSignedPreKeys(true);
|
||||
assertEquals(true, OmemoConfiguration.getRenewOldSignedPreKeys());
|
||||
OmemoConfiguration.setRenewOldSignedPreKeysAfterHours(77);
|
||||
assertEquals(77, OmemoConfiguration.getRenewOldSignedPreKeysAfterHours());
|
||||
try {
|
||||
OmemoConfiguration.setRenewOldSignedPreKeysAfterHours(0);
|
||||
TestCase.fail("OmemoConfiguration.setRenewOldSignedPreKeysAfterHours should not accept values <= 0");
|
||||
} catch (IllegalArgumentException e) {
|
||||
// Expected
|
||||
}
|
||||
OmemoConfiguration.setMaxNumberOfStoredSignedPreKeys(6);
|
||||
assertEquals(6, OmemoConfiguration.getMaxNumberOfStoredSignedPreKeys());
|
||||
try {
|
||||
OmemoConfiguration.setMaxNumberOfStoredSignedPreKeys(0);
|
||||
TestCase.fail("OmemoConfiguration.setMaxNumberOfStoredSignedPreKeys should not accept values <= 0");
|
||||
} catch (IllegalArgumentException e) {
|
||||
// Expected
|
||||
}
|
||||
|
||||
// Repair broken sessions
|
||||
OmemoConfiguration.setRepairBrokenSessionsWithPrekeyMessages(false);
|
||||
assertFalse(OmemoConfiguration.getRepairBrokenSessionsWithPreKeyMessages());
|
||||
OmemoConfiguration.setRepairBrokenSessionsWithPrekeyMessages(true);
|
||||
assertTrue(OmemoConfiguration.getRepairBrokenSessionsWithPreKeyMessages());
|
||||
|
||||
// Complete fresh sessions
|
||||
OmemoConfiguration.setCompleteSessionWithEmptyMessage(false);
|
||||
assertFalse(OmemoConfiguration.getCompleteSessionWithEmptyMessage());
|
||||
OmemoConfiguration.setCompleteSessionWithEmptyMessage(true);
|
||||
assertTrue(OmemoConfiguration.getCompleteSessionWithEmptyMessage());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
/**
|
||||
*
|
||||
* Copyright the original author or authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.HashSet;
|
||||
|
||||
import org.jivesoftware.smack.test.util.SmackTestSuite;
|
||||
import org.jivesoftware.smack.test.util.TestUtils;
|
||||
|
||||
import org.jivesoftware.smackx.omemo.element.OmemoDeviceListElement_VAxolotl;
|
||||
import org.jivesoftware.smackx.omemo.provider.OmemoDeviceListVAxolotlProvider;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.xmlpull.v1.XmlPullParser;
|
||||
|
||||
/**
|
||||
* Test serialization and parsing of DeviceListElement.
|
||||
*/
|
||||
public class OmemoDeviceListVAxolotlElementTest extends SmackTestSuite {
|
||||
|
||||
@Test
|
||||
public void serializationTest() throws Exception {
|
||||
HashSet<Integer> ids = new HashSet<>();
|
||||
ids.add(1234);
|
||||
ids.add(9876);
|
||||
|
||||
OmemoDeviceListElement_VAxolotl element = new OmemoDeviceListElement_VAxolotl(ids);
|
||||
String xml = element.toXML(null).toString();
|
||||
|
||||
XmlPullParser parser = TestUtils.getParser(xml);
|
||||
OmemoDeviceListElement_VAxolotl parsed = new OmemoDeviceListVAxolotlProvider().parse(parser);
|
||||
|
||||
assertTrue("Parsed element must equal the original.", parsed.getDeviceIds().equals(element.getDeviceIds()));
|
||||
assertEquals("Generated XML must match.",
|
||||
"<list xmlns='eu.siacs.conversations.axolotl'>" +
|
||||
"<device id='1234'/>" +
|
||||
"<device id='9876'/>" +
|
||||
"</list>",
|
||||
xml);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,63 @@
|
|||
/**
|
||||
*
|
||||
* Copyright the original author or authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo;
|
||||
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import org.jivesoftware.smackx.omemo.internal.OmemoDevice;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
import org.jxmpp.jid.BareJid;
|
||||
import org.jxmpp.jid.impl.JidCreate;
|
||||
import org.jxmpp.stringprep.XmppStringprepException;
|
||||
|
||||
/**
|
||||
* Test the OmemoDevice class.
|
||||
*
|
||||
* @author Paul Schaub
|
||||
*/
|
||||
public class OmemoDeviceTest {
|
||||
|
||||
/**
|
||||
* Test, if the equals() method works as intended.
|
||||
*/
|
||||
@Test
|
||||
public void testEquals() {
|
||||
BareJid romeo, juliet, guyUnderTheBalcony;
|
||||
try {
|
||||
romeo = JidCreate.bareFrom("romeo@shakespeare.lit");
|
||||
guyUnderTheBalcony = JidCreate.bareFrom("romeo@shakespeare.lit/underTheBalcony");
|
||||
juliet = JidCreate.bareFrom("juliet@shakespeare.lit");
|
||||
} catch (XmppStringprepException e) {
|
||||
Assert.fail(e.getMessage());
|
||||
return;
|
||||
}
|
||||
|
||||
OmemoDevice r = new OmemoDevice(romeo, 1);
|
||||
OmemoDevice g = new OmemoDevice(guyUnderTheBalcony, 1);
|
||||
OmemoDevice r2 = new OmemoDevice(romeo, 2);
|
||||
OmemoDevice j = new OmemoDevice(juliet, 3);
|
||||
OmemoDevice j2 = new OmemoDevice(juliet, 1);
|
||||
|
||||
assertTrue(r.equals(g));
|
||||
assertFalse(r.equals(r2));
|
||||
assertFalse(j.equals(j2));
|
||||
assertFalse(j2.equals(r2));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,105 @@
|
|||
/**
|
||||
*
|
||||
* Copyright the original author or authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo;
|
||||
|
||||
import static junit.framework.TestCase.fail;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
import org.jivesoftware.smackx.omemo.exceptions.CannotEstablishOmemoSessionException;
|
||||
import org.jivesoftware.smackx.omemo.exceptions.CryptoFailedException;
|
||||
import org.jivesoftware.smackx.omemo.exceptions.MultipleCryptoFailedException;
|
||||
import org.jivesoftware.smackx.omemo.exceptions.UndecidedOmemoIdentityException;
|
||||
import org.jivesoftware.smackx.omemo.internal.OmemoDevice;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.jxmpp.jid.impl.JidCreate;
|
||||
import org.jxmpp.stringprep.XmppStringprepException;
|
||||
|
||||
/**
|
||||
* Test Omemo related Exceptions.
|
||||
*/
|
||||
public class OmemoExceptionsTest {
|
||||
|
||||
@Test
|
||||
public void undecidedOmemoIdentityExceptionTest() throws XmppStringprepException {
|
||||
OmemoDevice alice = new OmemoDevice(JidCreate.bareFrom("alice@server.tld"), 1234);
|
||||
OmemoDevice bob = new OmemoDevice(JidCreate.bareFrom("bob@server.tld"), 5678);
|
||||
OmemoDevice mallory = new OmemoDevice(JidCreate.bareFrom("mallory@server.tld"), 9876);
|
||||
|
||||
UndecidedOmemoIdentityException u = new UndecidedOmemoIdentityException(alice);
|
||||
assertTrue(u.getUndecidedDevices().contains(alice));
|
||||
assertTrue(u.getUndecidedDevices().size() == 1);
|
||||
|
||||
UndecidedOmemoIdentityException v = new UndecidedOmemoIdentityException(bob);
|
||||
v.getUndecidedDevices().add(mallory);
|
||||
assertTrue(v.getUndecidedDevices().size() == 2);
|
||||
assertTrue(v.getUndecidedDevices().contains(bob));
|
||||
assertTrue(v.getUndecidedDevices().contains(mallory));
|
||||
|
||||
u.getUndecidedDevices().add(bob);
|
||||
u.join(v);
|
||||
assertTrue(u.getUndecidedDevices().size() == 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void cannotEstablishOmemoSessionExceptionTest() throws XmppStringprepException {
|
||||
OmemoDevice alice1 = new OmemoDevice(JidCreate.bareFrom("alice@server.tld"), 1234);
|
||||
OmemoDevice alice2 = new OmemoDevice(JidCreate.bareFrom("alice@server.tld"), 2345);
|
||||
OmemoDevice bob = new OmemoDevice(JidCreate.bareFrom("bob@server.tld"), 5678);
|
||||
|
||||
CannotEstablishOmemoSessionException c = new CannotEstablishOmemoSessionException(alice1, null);
|
||||
assertEquals(1, c.getFailures().size());
|
||||
assertTrue(c.getFailures().containsKey(alice1.getJid()));
|
||||
|
||||
c.addSuccess(alice2);
|
||||
assertFalse(c.requiresThrowing());
|
||||
|
||||
c.addFailures(new CannotEstablishOmemoSessionException(bob, null));
|
||||
assertTrue(c.requiresThrowing());
|
||||
assertEquals(1, c.getSuccesses().size());
|
||||
assertEquals(2, c.getFailures().size());
|
||||
|
||||
c.getSuccesses().remove(alice2.getJid());
|
||||
c.addFailures(new CannotEstablishOmemoSessionException(alice2, null));
|
||||
assertEquals(2, c.getFailures().size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void multipleCryptoFailedExceptionTest() {
|
||||
CryptoFailedException e1 = new CryptoFailedException("Fail");
|
||||
CryptoFailedException e2 = new CryptoFailedException("EpicFail");
|
||||
ArrayList<CryptoFailedException> l = new ArrayList<>();
|
||||
l.add(e1); l.add(e2);
|
||||
MultipleCryptoFailedException m = MultipleCryptoFailedException.from(l);
|
||||
|
||||
assertEquals(2, m.getCryptoFailedExceptions().size());
|
||||
assertTrue(m.getCryptoFailedExceptions().contains(e1));
|
||||
assertTrue(m.getCryptoFailedExceptions().contains(e2));
|
||||
|
||||
ArrayList<CryptoFailedException> el = new ArrayList<>();
|
||||
try {
|
||||
MultipleCryptoFailedException m2 = MultipleCryptoFailedException.from(el);
|
||||
fail("MultipleCryptoFailedException must not allow empty list.");
|
||||
} catch (IllegalArgumentException e) {
|
||||
// Expected
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2017 Paul Schaub
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo;
|
||||
|
||||
import static junit.framework.TestCase.assertEquals;
|
||||
import static junit.framework.TestCase.assertNotSame;
|
||||
|
||||
import org.jivesoftware.smackx.omemo.trust.OmemoFingerprint;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
/**
|
||||
* Test the OmemoFingerprint class.
|
||||
*/
|
||||
public class OmemoFingerprintTest {
|
||||
|
||||
@Test
|
||||
public void fingerprintTest() {
|
||||
OmemoFingerprint first = new OmemoFingerprint("FINGER");
|
||||
OmemoFingerprint second = new OmemoFingerprint("TOE");
|
||||
|
||||
assertNotSame(first, second);
|
||||
assertEquals(first, new OmemoFingerprint("FINGER"));
|
||||
}
|
||||
}
|
||||
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,91 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2017 Paul Schaub
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo;
|
||||
|
||||
import static junit.framework.TestCase.assertFalse;
|
||||
import static junit.framework.TestCase.assertTrue;
|
||||
|
||||
import java.util.Date;
|
||||
import java.util.HashSet;
|
||||
|
||||
import org.jivesoftware.smack.test.util.SmackTestSuite;
|
||||
import org.jivesoftware.smackx.omemo.internal.OmemoDevice;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.jxmpp.jid.impl.JidCreate;
|
||||
import org.jxmpp.stringprep.XmppStringprepException;
|
||||
|
||||
public class OmemoServiceTest extends SmackTestSuite {
|
||||
|
||||
private static final long ONE_HOUR = 1000L * 60 * 60;
|
||||
private static final int IGNORE_STALE = OmemoConfiguration.getIgnoreStaleDevicesAfterHours();
|
||||
private static final int DELETE_STALE = OmemoConfiguration.getDeleteStaleDevicesAfterHours();
|
||||
|
||||
@Test(expected = IllegalStateException.class)
|
||||
public void getInstanceFailsWhenNullTest() {
|
||||
OmemoService.getInstance();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isServiceRegisteredTest() {
|
||||
assertFalse(OmemoService.isServiceRegistered());
|
||||
}
|
||||
|
||||
/**
|
||||
* Test correct functionality of isStale method.
|
||||
* @throws XmppStringprepException
|
||||
*/
|
||||
@Test
|
||||
public void isStaleDeviceTest() throws XmppStringprepException {
|
||||
OmemoDevice user = new OmemoDevice(JidCreate.bareFrom("alice@wonderland.lit"), 123);
|
||||
OmemoDevice other = new OmemoDevice(JidCreate.bareFrom("bob@builder.tv"), 444);
|
||||
|
||||
Date now = new Date();
|
||||
Date ignoreMe = new Date(now.getTime() - ((IGNORE_STALE + 1) * ONE_HOUR));
|
||||
Date deleteMe = new Date(now.getTime() - ((DELETE_STALE + 1) * ONE_HOUR));
|
||||
Date imFine = new Date(now.getTime() - ONE_HOUR);
|
||||
|
||||
// One hour "old" devices are (probably) not not stale
|
||||
assertFalse(OmemoService.isStale(user, other, imFine, IGNORE_STALE));
|
||||
|
||||
// Devices one hour "older" than max ages are stale
|
||||
assertTrue(OmemoService.isStale(user, other, ignoreMe, IGNORE_STALE));
|
||||
assertTrue(OmemoService.isStale(user, other, deleteMe, DELETE_STALE));
|
||||
|
||||
// Own device is never stale, no matter how old
|
||||
assertFalse(OmemoService.isStale(user, user, deleteMe, DELETE_STALE));
|
||||
|
||||
// Always return false if date is null.
|
||||
assertFalse(OmemoService.isStale(user, other, null, DELETE_STALE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void removeOurDeviceTest() throws XmppStringprepException {
|
||||
OmemoDevice a = new OmemoDevice(JidCreate.bareFrom("a@b.c"), 123);
|
||||
OmemoDevice b = new OmemoDevice(JidCreate.bareFrom("a@b.c"), 124);
|
||||
|
||||
HashSet<OmemoDevice> devices = new HashSet<>();
|
||||
devices.add(a); devices.add(b);
|
||||
|
||||
assertTrue(devices.contains(a));
|
||||
assertTrue(devices.contains(b));
|
||||
OmemoService.removeOurDevice(a, devices);
|
||||
|
||||
assertFalse(devices.contains(a));
|
||||
assertTrue(devices.contains(b));
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,345 @@
|
|||
/**
|
||||
*
|
||||
* Copyright Paul Schaub
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo;
|
||||
|
||||
import static junit.framework.TestCase.assertEquals;
|
||||
import static junit.framework.TestCase.assertFalse;
|
||||
import static junit.framework.TestCase.assertNotNull;
|
||||
import static junit.framework.TestCase.assertNotSame;
|
||||
import static junit.framework.TestCase.assertNull;
|
||||
import static junit.framework.TestCase.assertSame;
|
||||
import static junit.framework.TestCase.assertTrue;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Arrays;
|
||||
import java.util.Date;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.TreeMap;
|
||||
|
||||
import org.jivesoftware.smackx.omemo.exceptions.CorruptedOmemoKeyException;
|
||||
import org.jivesoftware.smackx.omemo.internal.OmemoCachedDeviceList;
|
||||
import org.jivesoftware.smackx.omemo.internal.OmemoDevice;
|
||||
import org.jivesoftware.smackx.omemo.trust.OmemoFingerprint;
|
||||
|
||||
import org.junit.AfterClass;
|
||||
import org.junit.Test;
|
||||
import org.junit.rules.TemporaryFolder;
|
||||
import org.jxmpp.jid.impl.JidCreate;
|
||||
import org.jxmpp.stringprep.XmppStringprepException;
|
||||
|
||||
|
||||
public abstract class OmemoStoreTest<T_IdKeyPair, T_IdKey, T_PreKey, T_SigPreKey, T_Sess, T_Addr, T_ECPub, T_Bundle, T_Ciph> {
|
||||
|
||||
protected final OmemoStore<T_IdKeyPair, T_IdKey, T_PreKey, T_SigPreKey, T_Sess, T_Addr, T_ECPub, T_Bundle, T_Ciph> store;
|
||||
private final OmemoDevice alice, bob;
|
||||
|
||||
private static final TemporaryFolder tmp = initStaticTemp();
|
||||
|
||||
OmemoStoreTest(OmemoStore<T_IdKeyPair, T_IdKey, T_PreKey, T_SigPreKey, T_Sess, T_Addr, T_ECPub, T_Bundle, T_Ciph> store)
|
||||
throws XmppStringprepException {
|
||||
this.store = store;
|
||||
alice = new OmemoDevice(JidCreate.bareFrom("alice@wonderland.lit"), 123);
|
||||
bob = new OmemoDevice(JidCreate.bareFrom("bob@builder.tv"), 987);
|
||||
}
|
||||
|
||||
// Tests
|
||||
|
||||
@Test
|
||||
public void keyUtilNotNull() {
|
||||
assertNotNull(store.keyUtil());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void generateOmemoIdentityKeyPairDoesNotReturnNull() {
|
||||
assertNotNull(store.generateOmemoIdentityKeyPair());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void identityKeyFromIdentityKeyPairIsNotNull() {
|
||||
T_IdKeyPair pair = store.generateOmemoIdentityKeyPair();
|
||||
assertNotNull(store.keyUtil().identityKeyFromPair(pair));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void storeLoadRemoveOmemoIdentityKeyPair()
|
||||
throws IOException, CorruptedOmemoKeyException {
|
||||
|
||||
T_IdKeyPair before = store.generateOmemoIdentityKeyPair();
|
||||
|
||||
assertNull(store.loadOmemoIdentityKeyPair(alice));
|
||||
store.storeOmemoIdentityKeyPair(alice, before);
|
||||
|
||||
T_IdKeyPair after = store.loadOmemoIdentityKeyPair(alice);
|
||||
assertNotNull(after);
|
||||
|
||||
// Fingerprints equal
|
||||
assertEquals(store.keyUtil().getFingerprintOfIdentityKeyPair(before),
|
||||
store.keyUtil().getFingerprintOfIdentityKeyPair(after));
|
||||
|
||||
// Byte-representation equals
|
||||
assertTrue(Arrays.equals(
|
||||
store.keyUtil().identityKeyPairToBytes(before),
|
||||
store.keyUtil().identityKeyPairToBytes(after)));
|
||||
|
||||
// Non-existing keypair
|
||||
assertNull("Must return null for non-existing key pairs.", store.loadOmemoIdentityKeyPair(bob));
|
||||
|
||||
// Deleting works
|
||||
store.removeOmemoIdentityKeyPair(alice);
|
||||
assertNull(store.loadOmemoIdentityKeyPair(alice));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void storeLoadRemoveOmemoIdentityKey()
|
||||
throws IOException, CorruptedOmemoKeyException {
|
||||
|
||||
// Create IdentityKeys and get bytes
|
||||
T_IdKey keyA1 = store.keyUtil().identityKeyFromPair(store.generateOmemoIdentityKeyPair());
|
||||
T_IdKey keyB1 = store.keyUtil().identityKeyFromPair(store.generateOmemoIdentityKeyPair());
|
||||
byte[] bytesA1 = store.keyUtil().identityKeyToBytes(keyA1);
|
||||
byte[] bytesB = store.keyUtil().identityKeyToBytes(keyB1);
|
||||
|
||||
// Not null and not of length 0
|
||||
assertNotNull("Serialized identityKey cannot be null.", bytesA1);
|
||||
assertNotNull("Serialized identityKey cannot be null.", bytesB);
|
||||
assertNotSame("Serialized identityKey must be of length > 0.", 0, bytesA1.length);
|
||||
assertNotSame("Serialized identityKey must be of length > 0.", 0, bytesB.length);
|
||||
|
||||
// Keys do not equal
|
||||
assertFalse("Generated IdentityKeys must not be equal (ULTRA unlikely).",
|
||||
Arrays.equals(bytesA1, bytesB));
|
||||
|
||||
// Loading must return null before and not null after saving
|
||||
assertNull("Must return null, the store could not have this key by now.",
|
||||
store.loadOmemoIdentityKey(alice, bob));
|
||||
store.storeOmemoIdentityKey(alice, bob, keyA1);
|
||||
T_IdKey keyA2 = store.loadOmemoIdentityKey(alice, bob);
|
||||
assertNotNull(keyA2);
|
||||
|
||||
// Loaded key must equal stored one
|
||||
byte[] bytesA2 = store.keyUtil().identityKeyToBytes(keyA2);
|
||||
assertTrue("Serialized loaded key must equal serialized stored one.",
|
||||
Arrays.equals(bytesA1, bytesA2));
|
||||
|
||||
// Non-existing keys must return null
|
||||
assertNull("Non-existing keys must be returned as null.", store.loadOmemoIdentityKey(bob, alice));
|
||||
|
||||
// Key must vanish when deleted.
|
||||
store.removeOmemoIdentityKey(alice, bob);
|
||||
assertNull(store.loadOmemoIdentityKey(alice, bob));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void generateOmemoPreKeys() {
|
||||
TreeMap<Integer, T_PreKey> keys = store.generateOmemoPreKeys(31, 49);
|
||||
assertNotNull("Generated data structure must not be null.", keys);
|
||||
|
||||
byte[] lastKey = null;
|
||||
|
||||
for (int i = 31; i <= 79; i++) {
|
||||
assertEquals("Key ids must be ascending order, starting at 31.", Integer.valueOf(i), keys.firstKey());
|
||||
assertNotNull("Every id must match to a key.", keys.get(keys.firstKey()));
|
||||
byte[] bytes = store.keyUtil().preKeyToBytes(keys.get(keys.firstKey()));
|
||||
assertNotNull("Serialized preKey must not be null.", bytes);
|
||||
assertNotSame("Serialized preKey must not be of length 0.", 0, bytes.length);
|
||||
|
||||
if (lastKey != null) {
|
||||
assertFalse("PreKeys MUST NOT be equal.", Arrays.equals(lastKey, bytes));
|
||||
}
|
||||
lastKey = bytes;
|
||||
|
||||
keys.remove(keys.firstKey());
|
||||
|
||||
}
|
||||
|
||||
assertEquals("After deleting 49 keys, there must be no keys left.", 0, keys.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void storeLoadRemoveOmemoPreKeys()
|
||||
throws IOException, InterruptedException {
|
||||
|
||||
TreeMap<Integer, T_PreKey> before = store.generateOmemoPreKeys(1, 10);
|
||||
assertEquals("The store must have no prekeys before this test.", 0, store.loadOmemoPreKeys(alice).size());
|
||||
|
||||
store.storeOmemoPreKeys(alice, before);
|
||||
TreeMap<Integer, T_PreKey> after = store.loadOmemoPreKeys(alice);
|
||||
assertNotNull("Loaded preKeys must not be null.", after);
|
||||
assertEquals("Loaded preKey count must equal stored count.", before.size(), after.size());
|
||||
|
||||
// Non-existing key must be returned as null
|
||||
assertNull("Non-existing preKey must be returned as null.", store.loadOmemoPreKey(alice, 10000));
|
||||
|
||||
int last = after.size();
|
||||
for (int i = 1; i <= last; i++) {
|
||||
T_PreKey bKey = before.get(i);
|
||||
T_PreKey aKey = after.get(i);
|
||||
|
||||
assertTrue("Loaded keys must equal stored ones.", Arrays.equals(
|
||||
store.keyUtil().preKeyToBytes(bKey),
|
||||
store.keyUtil().preKeyToBytes(aKey)));
|
||||
|
||||
T_PreKey rKey = store.loadOmemoPreKey(alice, i);
|
||||
assertNotNull("Randomly accessed preKeys must not be null.", rKey);
|
||||
assertTrue("Randomly accessed preKeys must equal the stored ones.", Arrays.equals(
|
||||
store.keyUtil().preKeyToBytes(aKey),
|
||||
store.keyUtil().preKeyToBytes(rKey)));
|
||||
|
||||
store.removeOmemoPreKey(alice, i);
|
||||
assertNull("PreKey must be null after deletion.", store.loadOmemoPreKey(alice, i));
|
||||
}
|
||||
|
||||
TreeMap<Integer, T_PreKey> postDeletion = store.loadOmemoPreKeys(alice);
|
||||
assertSame("PreKey count must equal 0 after deletion of all keys.", 0, postDeletion.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void storeLoadRemoveOmemoSignedPreKeys()
|
||||
throws IOException, CorruptedOmemoKeyException {
|
||||
|
||||
TreeMap<Integer, T_SigPreKey> before = store.loadOmemoSignedPreKeys(alice);
|
||||
assertEquals("At this stage, there must be no signed prekeys in the store.", 0, before.size());
|
||||
|
||||
T_IdKeyPair idp = store.generateOmemoIdentityKeyPair();
|
||||
T_SigPreKey spk = store.generateOmemoSignedPreKey(idp, 125);
|
||||
|
||||
assertNotNull("SignedPreKey must not be null.", spk);
|
||||
assertEquals("ID of signedPreKey must match.", 125, store.keyUtil().signedPreKeyIdFromKey(spk));
|
||||
byte[] bytes = store.keyUtil().signedPreKeyToBytes(spk);
|
||||
assertNotNull("Serialized signedPreKey must not be null", bytes);
|
||||
assertNotSame("Serialized signedPreKey must not be of length 0.", 0, bytes.length);
|
||||
|
||||
// Stored key must equal loaded key
|
||||
store.storeOmemoSignedPreKey(alice, 125, spk);
|
||||
TreeMap<Integer, T_SigPreKey> after = store.loadOmemoSignedPreKeys(alice);
|
||||
assertEquals("We must have exactly 1 signedPreKey now.", 1, after.size());
|
||||
T_SigPreKey spk2 = after.get(after.firstKey());
|
||||
assertEquals("Id of the stored signedPreKey must match the one we stored.",
|
||||
125, store.keyUtil().signedPreKeyIdFromKey(spk2));
|
||||
assertTrue("Serialization of stored and loaded signed preKey must equal.", Arrays.equals(
|
||||
store.keyUtil().signedPreKeyToBytes(spk), store.keyUtil().signedPreKeyToBytes(spk2)));
|
||||
|
||||
// Random access
|
||||
T_SigPreKey rspk = store.loadOmemoSignedPreKey(alice, 125);
|
||||
assertTrue("Serialization of stored and randomly accessed signed preKey must equal.", Arrays.equals(
|
||||
store.keyUtil().signedPreKeyToBytes(spk), store.keyUtil().signedPreKeyToBytes(rspk)));
|
||||
assertNull("Non-existing signedPreKey must be returned as null.",
|
||||
store.loadOmemoSignedPreKey(alice, 10000));
|
||||
|
||||
// Deleting
|
||||
store.removeOmemoSignedPreKey(alice, 125);
|
||||
assertNull("Deleted key must be returned as null.", store.loadOmemoSignedPreKey(alice, 125));
|
||||
assertEquals(0, store.loadOmemoSignedPreKeys(alice).size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void loadStoreDateOfLastSignedPreKeyRenewal() throws IOException {
|
||||
assertNull("The date of last signed preKey renewal must be null at this stage.",
|
||||
store.getDateOfLastSignedPreKeyRenewal(alice));
|
||||
Date before = new Date();
|
||||
store.setDateOfLastSignedPreKeyRenewal(alice, before);
|
||||
Date after = store.getDateOfLastSignedPreKeyRenewal(alice);
|
||||
assertEquals("Dates must equal.", after, before);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void loadStoreDateOfLastMessageReceived() throws IOException {
|
||||
assertNull("The date of last message received must be null at this stage.",
|
||||
store.getDateOfLastReceivedMessage(alice, bob));
|
||||
Date before = new Date();
|
||||
store.setDateOfLastReceivedMessage(alice, bob, before);
|
||||
Date after = store.getDateOfLastReceivedMessage(alice, bob);
|
||||
assertEquals("Dates must equal.", after, before);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void loadStoreCachedDeviceList() throws IOException {
|
||||
Integer[] active = new Integer[] {1,5,999,10};
|
||||
Integer[] inactive = new Integer[] {6,7,8};
|
||||
OmemoCachedDeviceList before = new OmemoCachedDeviceList(
|
||||
new HashSet<>(Arrays.asList(active)),
|
||||
new HashSet<>(Arrays.asList(inactive)));
|
||||
|
||||
assertNotNull("Loading a non-existent cached deviceList must return an empty list.",
|
||||
store.loadCachedDeviceList(alice, bob.getJid()));
|
||||
|
||||
store.storeCachedDeviceList(alice, bob.getJid(), before);
|
||||
OmemoCachedDeviceList after = store.loadCachedDeviceList(alice, bob.getJid());
|
||||
assertTrue("Loaded deviceList must not be empty", after.getAllDevices().size() != 0);
|
||||
|
||||
assertEquals("Number of entries in active devices must match.", active.length, after.getActiveDevices().size());
|
||||
assertEquals("Number of entries in inactive devices must match.", inactive.length, after.getInactiveDevices().size());
|
||||
assertEquals("Number of total entries must match.", active.length + inactive.length, after.getAllDevices().size());
|
||||
|
||||
for (Integer a : active) {
|
||||
assertTrue(after.getActiveDevices().contains(a));
|
||||
assertTrue(after.getAllDevices().contains(a));
|
||||
}
|
||||
|
||||
for (Integer i : inactive) {
|
||||
assertTrue(after.getInactiveDevices().contains(i));
|
||||
assertTrue(after.getAllDevices().contains(i));
|
||||
}
|
||||
|
||||
store.storeCachedDeviceList(alice, bob.getJid(), new OmemoCachedDeviceList());
|
||||
assertEquals("DeviceList must be empty after overwriting it with empty list.", 0,
|
||||
store.loadCachedDeviceList(alice, bob.getJid()).getAllDevices().size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void loadAllRawSessionsReturnsEmptyMapTest() {
|
||||
HashMap<Integer, T_Sess> sessions = store.loadAllRawSessionsOf(alice, bob.getJid());
|
||||
assertNotNull(sessions);
|
||||
assertEquals(0, sessions.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void loadNonExistentRawSessionReturnsNullTest() {
|
||||
T_Sess session = store.loadRawSession(alice, bob);
|
||||
assertNull(session);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getFingerprint() throws IOException, CorruptedOmemoKeyException {
|
||||
assertNull("Method must return null for a non-existent fingerprint.", store.getFingerprint(alice));
|
||||
store.storeOmemoIdentityKeyPair(alice, store.generateOmemoIdentityKeyPair());
|
||||
OmemoFingerprint fingerprint = store.getFingerprint(alice);
|
||||
assertNotNull("fingerprint must not be null", fingerprint);
|
||||
assertEquals("Fingerprint must be of length 64", 64, fingerprint.length());
|
||||
|
||||
store.removeOmemoIdentityKeyPair(alice); //clean up
|
||||
}
|
||||
|
||||
// ##############################################################
|
||||
// Workaround for https://github.com/junit-team/junit4/issues/671
|
||||
|
||||
static TemporaryFolder initStaticTemp() {
|
||||
try {
|
||||
return new TemporaryFolder() { { before(); } };
|
||||
} catch (Throwable t) {
|
||||
throw new RuntimeException(t);
|
||||
}
|
||||
}
|
||||
|
||||
@AfterClass
|
||||
public static void cleanup() throws Exception {
|
||||
FileBasedOmemoStore.deleteDirectory(tmp.getRoot());
|
||||
}
|
||||
|
||||
// ##############################################################
|
||||
}
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
/**
|
||||
*
|
||||
* Copyright the original author or authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
import org.jivesoftware.smack.test.util.SmackTestSuite;
|
||||
import org.jivesoftware.smack.test.util.TestUtils;
|
||||
import org.jivesoftware.smack.util.StringUtils;
|
||||
import org.jivesoftware.smack.util.stringencoder.Base64;
|
||||
import org.jivesoftware.smackx.omemo.element.OmemoElement_VAxolotl;
|
||||
import org.jivesoftware.smackx.omemo.element.OmemoHeaderElement_VAxolotl;
|
||||
import org.jivesoftware.smackx.omemo.element.OmemoKeyElement;
|
||||
import org.jivesoftware.smackx.omemo.provider.OmemoVAxolotlProvider;
|
||||
import org.jivesoftware.smackx.omemo.util.OmemoMessageBuilder;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
/**
|
||||
* Test serialization and parsing of OmemoVAxolotlElements.
|
||||
*/
|
||||
public class OmemoVAxolotlElementTest extends SmackTestSuite {
|
||||
|
||||
@Test
|
||||
public void serializationTest() throws Exception {
|
||||
byte[] payload = "This is payload.".getBytes(StringUtils.UTF8);
|
||||
int keyId1 = 8;
|
||||
int keyId2 = 33333;
|
||||
byte[] keyData1 = "KEYDATA".getBytes(StringUtils.UTF8);
|
||||
byte[] keyData2 = "DATAKEY".getBytes(StringUtils.UTF8);
|
||||
int sid = 12131415;
|
||||
byte[] iv = OmemoMessageBuilder.generateIv();
|
||||
|
||||
ArrayList<OmemoKeyElement> keys = new ArrayList<>();
|
||||
keys.add(new OmemoKeyElement(keyData1, keyId1));
|
||||
keys.add(new OmemoKeyElement(keyData2, keyId2, true));
|
||||
|
||||
OmemoHeaderElement_VAxolotl header = new OmemoHeaderElement_VAxolotl(sid, keys, iv);
|
||||
OmemoElement_VAxolotl element = new OmemoElement_VAxolotl(header, payload);
|
||||
|
||||
String expected =
|
||||
"<encrypted xmlns='eu.siacs.conversations.axolotl'>" +
|
||||
"<header sid='12131415'>" +
|
||||
"<key rid='8'>" + Base64.encodeToString(keyData1) + "</key>" +
|
||||
"<key prekey='true' rid='33333'>" + Base64.encodeToString(keyData2) + "</key>" +
|
||||
"<iv>" + Base64.encodeToString(iv) + "</iv>" +
|
||||
"</header>" +
|
||||
"<payload>" +
|
||||
Base64.encodeToString(payload) +
|
||||
"</payload>" +
|
||||
"</encrypted>";
|
||||
|
||||
String actual = element.toXML(null).toString();
|
||||
assertEquals("Serialized xml of OmemoElement must match.", expected, actual);
|
||||
|
||||
OmemoElement_VAxolotl parsed = new OmemoVAxolotlProvider().parse(TestUtils.getParser(actual));
|
||||
assertEquals("Parsed OmemoElement must equal the original.",
|
||||
element.toXML(null).toString(),
|
||||
parsed.toXML(null).toString());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
/**
|
||||
*
|
||||
* Copyright the original author or authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo;
|
||||
|
||||
import static junit.framework.TestCase.assertEquals;
|
||||
import static junit.framework.TestCase.assertTrue;
|
||||
import static org.jivesoftware.smackx.omemo.util.OmemoConstants.Crypto.KEYLENGTH;
|
||||
import static org.jivesoftware.smackx.omemo.util.OmemoConstants.Crypto.KEYTYPE;
|
||||
import static org.junit.Assert.assertArrayEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
|
||||
import java.security.NoSuchAlgorithmException;
|
||||
import java.security.Security;
|
||||
|
||||
import org.jivesoftware.smackx.omemo.element.OmemoElement;
|
||||
import org.jivesoftware.smackx.omemo.exceptions.CryptoFailedException;
|
||||
import org.jivesoftware.smackx.omemo.internal.CipherAndAuthTag;
|
||||
import org.jivesoftware.smackx.omemo.internal.CiphertextTuple;
|
||||
import org.jivesoftware.smackx.omemo.util.OmemoMessageBuilder;
|
||||
|
||||
import org.bouncycastle.jce.provider.BouncyCastleProvider;
|
||||
import org.junit.Test;
|
||||
|
||||
/**
|
||||
* Test the identityKeyWrapper.
|
||||
*/
|
||||
public class WrapperObjectsTest {
|
||||
|
||||
@Test
|
||||
public void ciphertextTupleTest() {
|
||||
byte[] c = OmemoMessageBuilder.generateIv();
|
||||
CiphertextTuple c1 = new CiphertextTuple(c, OmemoElement.TYPE_OMEMO_PREKEY_MESSAGE);
|
||||
assertTrue(c1.isPreKeyMessage());
|
||||
assertArrayEquals(c, c1.getCiphertext());
|
||||
assertEquals(OmemoElement.TYPE_OMEMO_PREKEY_MESSAGE, c1.getMessageType());
|
||||
|
||||
CiphertextTuple c2 = new CiphertextTuple(c, OmemoElement.TYPE_OMEMO_MESSAGE);
|
||||
assertFalse(c2.isPreKeyMessage());
|
||||
assertEquals(OmemoElement.TYPE_OMEMO_MESSAGE, c2.getMessageType());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void cipherAndAuthTagTest() throws NoSuchAlgorithmException, CryptoFailedException {
|
||||
Security.addProvider(new BouncyCastleProvider());
|
||||
byte[] key = OmemoMessageBuilder.generateKey(KEYTYPE, KEYLENGTH);
|
||||
byte[] iv = OmemoMessageBuilder.generateIv();
|
||||
byte[] authTag = OmemoMessageBuilder.generateIv();
|
||||
|
||||
CipherAndAuthTag cat = new CipherAndAuthTag(key, iv, authTag, true);
|
||||
|
||||
assertNotNull(cat.getCipher());
|
||||
assertArrayEquals(key, cat.getKey());
|
||||
assertArrayEquals(iv, cat.getIv());
|
||||
assertArrayEquals(authTag, cat.getAuthTag());
|
||||
assertTrue(cat.wasPreKeyEncrypted());
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,59 @@
|
|||
/**
|
||||
*
|
||||
* Copyright the original author or authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo.util;
|
||||
|
||||
import java.util.HashMap;
|
||||
|
||||
import org.jivesoftware.smackx.omemo.internal.OmemoDevice;
|
||||
import org.jivesoftware.smackx.omemo.trust.OmemoFingerprint;
|
||||
import org.jivesoftware.smackx.omemo.trust.OmemoTrustCallback;
|
||||
import org.jivesoftware.smackx.omemo.trust.TrustState;
|
||||
|
||||
/**
|
||||
* Ephemera Trust Callback used to make trust decisions in tests.
|
||||
*/
|
||||
public class EphemeralTrustCallback implements OmemoTrustCallback {
|
||||
|
||||
private final HashMap<OmemoDevice, HashMap<OmemoFingerprint, TrustState>> trustStates = new HashMap<>();
|
||||
|
||||
@Override
|
||||
public TrustState getTrust(OmemoDevice device, OmemoFingerprint fingerprint) {
|
||||
HashMap<OmemoFingerprint, TrustState> states = trustStates.get(device);
|
||||
|
||||
if (states != null) {
|
||||
TrustState state = states.get(fingerprint);
|
||||
|
||||
if (state != null) {
|
||||
return state;
|
||||
}
|
||||
}
|
||||
|
||||
return TrustState.undecided;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTrust(OmemoDevice device, OmemoFingerprint fingerprint, TrustState state) {
|
||||
HashMap<OmemoFingerprint, TrustState> states = trustStates.get(device);
|
||||
|
||||
if (states == null) {
|
||||
states = new HashMap<>();
|
||||
trustStates.put(device, states);
|
||||
}
|
||||
|
||||
states.put(fingerprint, state);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
/**
|
||||
*
|
||||
* Copyright the original author or authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.omemo.util;
|
||||
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Random;
|
||||
|
||||
import org.jivesoftware.smack.test.util.SmackTestSuite;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
public class OmemoMessageBuilderTest extends SmackTestSuite {
|
||||
|
||||
private static final byte[] messageKey = new byte[16];
|
||||
private static final byte[] cipherTextWithAuthTag = new byte[35 + 16];
|
||||
|
||||
public OmemoMessageBuilderTest() {
|
||||
Random random = new Random();
|
||||
random.nextBytes(messageKey);
|
||||
random.nextBytes(cipherTextWithAuthTag);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMoveAuthTag() {
|
||||
// Extract authTag for testing purposes
|
||||
byte[] authTag = new byte[16];
|
||||
System.arraycopy(cipherTextWithAuthTag, 35, authTag, 0, 16);
|
||||
|
||||
byte[] messageKeyWithAuthTag = new byte[16 + 16];
|
||||
byte[] cipherTextWithoutAuthTag = new byte[35];
|
||||
|
||||
OmemoMessageBuilder.moveAuthTag(messageKey, cipherTextWithAuthTag, messageKeyWithAuthTag, cipherTextWithoutAuthTag);
|
||||
|
||||
// Check if first n - 16 bytes of cipherText got copied over to cipherTextWithoutAuthTag correctly
|
||||
byte[] checkCipherText = new byte[35];
|
||||
System.arraycopy(cipherTextWithAuthTag, 0, checkCipherText, 0, 35);
|
||||
assertTrue(Arrays.equals(checkCipherText, cipherTextWithoutAuthTag));
|
||||
|
||||
byte[] checkMessageKey = new byte[16];
|
||||
System.arraycopy(messageKeyWithAuthTag, 0, checkMessageKey, 0, 16);
|
||||
assertTrue(Arrays.equals(checkMessageKey, messageKey));
|
||||
|
||||
byte[] checkAuthTag = new byte[16];
|
||||
System.arraycopy(messageKeyWithAuthTag, 16, checkAuthTag, 0, 16);
|
||||
assertTrue(Arrays.equals(checkAuthTag, authTag));
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void testCheckIllegalMessageKeyWithAuthTagLength() {
|
||||
byte[] illegalMessageKey = new byte[16 + 15]; // too short
|
||||
byte[] cipherTextWithoutAuthTag = new byte[35]; // ok
|
||||
|
||||
OmemoMessageBuilder.moveAuthTag(messageKey, cipherTextWithAuthTag, illegalMessageKey, cipherTextWithoutAuthTag);
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void testCheckIllegalCipherTextWithoutAuthTagLength() {
|
||||
byte[] messageKeyWithAuthTag = new byte[16 + 16]; // ok
|
||||
byte[] illegalCipherTextWithoutAuthTag = new byte[39]; // too long
|
||||
|
||||
OmemoMessageBuilder.moveAuthTag(messageKey, cipherTextWithAuthTag, messageKeyWithAuthTag, illegalCipherTextWithoutAuthTag);
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue