cthrace/open-keychain
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

drop broken secure wifi transfer feature

Browse Source 
This feature depended on the unsupported TLS-PSK implementation shipped
with Android's conscrypt implementation. It abused a duck typing
mechanism that allowed using TLS-PSK despite its unsupported status, but
this silently broke somewhere along the way.
This commit is contained in:
Vincent Breitmoser
2021-01-29 12:09:37 +01:00
parent 2cc35ce970
commit 5eaa7518e8
17 changed files with 2 additions and 2324 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
OpenKeychain/src/test/java/org/sufficientlysecure/keychain/network/KeyTransferInteractorTest.java
View File

@@ -1,122 +0,0 @@
package org.sufficientlysecure.keychain.network;
import java.net.URISyntaxException;
import android.os.Build.VERSION_CODES;
import androidx.annotation.RequiresApi;
import junit.framework.Assert;
import org.robolectric.shadows.ShadowLog;
import org.robolectric.shadows.ShadowLooper;
import org.sufficientlysecure.keychain.network.KeyTransferInteractor.KeyTransferCallback;
import static junit.framework.Assert.assertTrue;
import static junit.framework.Assert.fail;
@SuppressWarnings("WeakerAccess")
// disabled, because we can't easily mock the tls-psk ciphersuite (it's removed in bouncycastle) :(
//@RunWith(KeychainTestRunner.class)
@RequiresApi(api = VERSION_CODES.LOLLIPOP)
public class KeyTransferInteractorTest {
private static final String DELIM_START = "--";
private static final String DELIM_END = "--";
private String receivedQrCodeData;
private boolean clientConnectionEstablished;
private boolean serverConnectionEstablished;
// @Before
public void setUp() throws Exception {
ShadowLog.stream = System.out;
}
// @Test
public void testServerShouldGiveSuccessCallback() throws URISyntaxException {
KeyTransferInteractor serverKeyTransferInteractor = new KeyTransferInteractor(DELIM_START, DELIM_END);
serverKeyTransferInteractor.startServer(new SimpleKeyTransferCallback() {
@Override
public void onServerStarted(String qrCodeData) {
receivedQrCodeData = qrCodeData;
}
@Override
public void onConnectionEstablished(String otherName) {
serverConnectionEstablished = true;
}
}, null);
waitForLooperCallback();
Assert.assertNotNull(receivedQrCodeData);
final KeyTransferInteractor clientKeyTransferInteractor = new KeyTransferInteractor(DELIM_START, DELIM_END);
clientKeyTransferInteractor.connectToServer(receivedQrCodeData, new SimpleKeyTransferCallback() {
@Override
public void onConnectionEstablished(String otherName) {
clientConnectionEstablished = true;
}
});
waitForLooperCallback();
waitForLooperCallback();
assertTrue(clientConnectionEstablished);
assertTrue(serverConnectionEstablished);
serverKeyTransferInteractor.sendData(new byte[] { (byte) 1, (byte) 2 }, "passthrough");
waitForLooperCallback();
}
private void waitForLooperCallback() {
while (!ShadowLooper.getShadowMainLooper().getScheduler().runOneTask());
}
static class SimpleKeyTransferCallback implements KeyTransferCallback {
@Override
public void onServerStarted(String qrCodeData) {
fail("unexpected callback: onServerStarted");
}
@Override
public void onConnectionEstablished(String otherName) {
fail("unexpected callback: onConnectionEstablished");
}
@Override
public void onConnectionLost() {
fail("unexpected callback: onConnectionLost");
}
@Override
public void onDataReceivedOk(String receivedData) {
fail("unexpected callback: onDataReceivedOk");
}
@Override
public void onDataSentOk(String passthrough) {
fail("unexpected callback: onDataSentOk");
}
@Override
public void onConnectionErrorNoRouteToHost(String wifiSsid) {
fail("unexpected callback: onConnectionErrorNoRouteToHost");
}
@Override
public void onConnectionErrorConnect() {
fail("unexpected callback: onConnectionErrorConnect");
}
@Override
public void onConnectionErrorListen() {
fail("unexpected callback: onConnectionErrorListen");
}
@Override
public void onConnectionError(String arg) {
fail("unexpected callback: onConnectionError");
}
}
}

101
OpenKeychain/src/test/java/org/sufficientlysecure/keychain/network/SktUriTest.java
View File

@@ -1,101 +0,0 @@
package org.sufficientlysecure.keychain.network;
import java.net.URISyntaxException;
import android.annotation.SuppressLint;
import org.bouncycastle.util.encoders.Hex;
import org.junit.Test;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
@SuppressWarnings("WeakerAccess")
@SuppressLint("DefaultLocale")
public class SktUriTest {
static final String HOST = "127.0.0.1";
static final int PORT = 1234;
static final byte[] PRESHARED_KEY = { 1, 2 };
static final String SSID = "ssid";
static final String ENCODED_SKT = String.format("OPGPSKT:%s/%d/%s/SSID:%s",
HOST, PORT, Hex.toHexString(PRESHARED_KEY), Hex.toHexString(SSID.getBytes()));
@Test
public void testCreate() {
SktUri sktUri = SktUri.create(HOST, PORT, PRESHARED_KEY, null);
assertEquals(HOST, sktUri.getHost());
assertEquals(PORT, sktUri.getPort());
assertArrayEquals(PRESHARED_KEY, sktUri.getPresharedKey());
assertEquals(null, sktUri.getWifiSsid());
}
@Test
public void testCreateWithSsid() {
SktUri sktUri = SktUri.create(HOST, PORT, PRESHARED_KEY, SSID);
assertEquals(HOST, sktUri.getHost());
assertEquals(PORT, sktUri.getPort());
assertArrayEquals(PRESHARED_KEY, sktUri.getPresharedKey());
assertEquals(SSID, sktUri.getWifiSsid());
}
@Test
public void testCreate_isAllUppercase() {
SktUri sktUri = SktUri.create(HOST, PORT, PRESHARED_KEY, SSID);
String encodedSktUri = sktUri.toUriString();
assertEquals(encodedSktUri.toUpperCase(), encodedSktUri);
}
@Test
public void testParse() throws URISyntaxException {
SktUri sktUri = SktUri.parse(ENCODED_SKT);
assertNotNull(sktUri);
assertEquals(HOST, sktUri.getHost());
assertEquals(PORT, sktUri.getPort());
assertArrayEquals(PRESHARED_KEY, sktUri.getPresharedKey());
assertEquals(SSID, sktUri.getWifiSsid());
}
@Test
public void testBackAndForth() throws URISyntaxException {
SktUri sktUri = SktUri.create(HOST, PORT, PRESHARED_KEY, null);
String encodedSktUri = sktUri.toUriString();
SktUri decodedSktUri = SktUri.parse(encodedSktUri);
assertEquals(sktUri, decodedSktUri);
}
@Test
public void testBackAndForthWithSsid() throws URISyntaxException {
SktUri sktUri = SktUri.create(HOST, PORT, PRESHARED_KEY, SSID);
String encodedSktUri = sktUri.toUriString();
SktUri decodedSktUri = SktUri.parse(encodedSktUri);
assertEquals(sktUri, decodedSktUri);
}
@Test(expected = URISyntaxException.class)
public void testParse_withBadScheme_shouldFail() throws URISyntaxException {
SktUri.parse(String.format("XXXGPSKT:%s/%d/%s/SSID:%s",
HOST, PORT, Hex.toHexString(PRESHARED_KEY), Hex.toHexString(SSID.getBytes())));
}
@Test(expected = URISyntaxException.class)
public void testParse_withBadPsk_shouldFail() throws URISyntaxException {
SktUri.parse(String.format("OPGPSKT:%s/%d/xx%s/SSID:%s",
HOST, PORT, Hex.toHexString(PRESHARED_KEY), Hex.toHexString(SSID.getBytes())));
}
@Test(expected = URISyntaxException.class)
public void testParse_withBadPort_shouldFail() throws URISyntaxException {
SktUri.parse(String.format("OPGPSKT:%s/x%d/%s/SSID:%s",
HOST, PORT, Hex.toHexString(PRESHARED_KEY), Hex.toHexString(SSID.getBytes())));
}
}