PeterCxy/open-keychain
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases 1 Wiki Activity

refactor keyserver class structure, use AutoValue for ParcelableHkpKeyserver

Browse source
This commit is contained in:
Vincent Breitmoser 2017-07-24 22:01:02 +02:00
parent 6e18531920
commit b8d01bf9d2
34 changed files with 389 additions and 427 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/CloudSearch.java
View file

@ -37,20 +37,20 @@ public class CloudSearch {
public static ArrayList<ImportKeysListEntry> search(
@NonNull final String query, Preferences.CloudSearchPrefs cloudPrefs, @NonNull final ParcelableProxy proxy)
throws Keyserver.CloudSearchFailureException {
throws KeyserverClient.CloudSearchFailureException {
final ArrayList<Keyserver> servers = new ArrayList<>();
final ArrayList<KeyserverClient> servers = new ArrayList<>();
// it's a Vector for sync, multiple threads might report problems
final Vector<Keyserver.CloudSearchFailureException> problems = new Vector<>();
final Vector<KeyserverClient.CloudSearchFailureException> problems = new Vector<>();
if (cloudPrefs.searchKeyserver) {
servers.add(cloudPrefs.keyserver);
servers.add(HkpKeyserverClient.fromHkpKeyserverAddress(cloudPrefs.keyserver));
}
if (cloudPrefs.searchKeybase) {
servers.add(KeybaseKeyserver.getInstance());
servers.add(KeybaseKeyserverClient.getInstance());
}
if (cloudPrefs.searchFacebook) {
servers.add(FacebookKeyserver.getInstance());
servers.add(FacebookKeyserverClient.getInstance());
}
int numberOfServers = servers.size();
@ -58,13 +58,13 @@ public class CloudSearch {
if (numberOfServers > 0) {
ArrayList<Thread> searchThreads = new ArrayList<>();
for (final Keyserver keyserver : servers) {
for (final KeyserverClient keyserverClient : servers) {
Runnable r = new Runnable() {
@Override
public void run() {
try {
results.addAll(keyserver.search(query, proxy));
} catch (Keyserver.CloudSearchFailureException e) {
results.addAll(keyserverClient.search(query, proxy));
} catch (KeyserverClient.CloudSearchFailureException e) {
problems.add(e);
}
results.finishedAdding(); // notifies if all searchers done
@ -90,14 +90,14 @@ public class CloudSearch {
if (results.outstandingSuppliers() > 0) {
String message = "Launched " + servers.size() + " cloud searchers, but " +
results.outstandingSuppliers() + "failed to complete.";
problems.add(new Keyserver.QueryFailedException(message));
problems.add(new KeyserverClient.QueryFailedException(message));
}
} else {
problems.add(new Keyserver.QueryNoEnabledSourceException());
problems.add(new KeyserverClient.QueryNoEnabledSourceException());
}
if (!problems.isEmpty()) {
for (Keyserver.CloudSearchFailureException e : problems) {
for (KeyserverClient.CloudSearchFailureException e : problems) {
Log.d(Constants.TAG, "Cloud search exception: " + e.getLocalizedMessage());
}

8
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/FacebookKeyserver.java → OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/FacebookKeyserverClient.java
View file

@ -44,18 +44,18 @@ import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
import org.sufficientlysecure.keychain.util.Log;
import org.sufficientlysecure.keychain.util.ParcelableProxy;
public class FacebookKeyserver extends Keyserver {
public class FacebookKeyserverClient implements KeyserverClient {
private static final String FB_KEY_URL_FORMAT
= "https://www.facebook.com/%s/publickey/download";
private static final String FB_HOST = "facebook.com";
private static final String FB_HOST_WWW = "www." + FB_HOST;
public static FacebookKeyserver getInstance() {
return new FacebookKeyserver();
public static FacebookKeyserverClient getInstance() {
return new FacebookKeyserverClient();
}
private FacebookKeyserver() { }
private FacebookKeyserverClient() { }
@Override

87
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/HkpKeyserverAddress.java Normal file
View file

@ -0,0 +1,87 @@
/*
* Copyright (C) 2016-2017 Dominik Schürmann <dominik@dominikschuermann.de>
* Copyright (C) 2017 Vincent Breitmoser <look@my.amazin.horse>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.sufficientlysecure.keychain.keyimport;
import java.net.URI;
import java.net.URISyntaxException;
import android.os.Parcelable;
import android.support.annotation.NonNull;
import com.google.auto.value.AutoValue;
@AutoValue
public abstract class HkpKeyserverAddress implements Parcelable {
private static final short PORT_DEFAULT = 11371;
private static final short PORT_DEFAULT_HKPS = 443;
public abstract String getUrl();
public abstract String getOnion();
public static HkpKeyserverAddress createWithOnionProxy(@NonNull String url, String onion) {
return new AutoValue_HkpKeyserverAddress(url, onion == null ? null : onion.trim());
}
public static HkpKeyserverAddress createFromUri(@NonNull String url) {
return new AutoValue_HkpKeyserverAddress(url, null);
}
public URI getUrlURI() throws URISyntaxException {
return getURI(getUrl());
}
public URI getOnionURI() throws URISyntaxException {
return getOnion() != null ? getURI(getOnion()) : null;
}
/**
* @param keyserverUrl "<code>hostname</code>" (eg. "<code>pool.sks-keyservers.net</code>"), then it will
* connect using {@link #PORT_DEFAULT}. However, port may be specified after colon
* ("<code>hostname:port</code>", eg. "<code>p80.pool.sks-keyservers.net:80</code>").
*/
private URI getURI(String keyserverUrl) throws URISyntaxException {
URI originalURI = new URI(keyserverUrl);
String scheme = originalURI.getScheme();
if (scheme == null) {
throw new URISyntaxException("", "scheme null!");
}
if (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme)
&& !"hkp".equalsIgnoreCase(scheme) && !"hkps".equalsIgnoreCase(scheme)) {
throw new URISyntaxException(scheme, "unsupported scheme!");
}
int port = originalURI.getPort();
if ("hkps".equalsIgnoreCase(scheme)) {
scheme = "https";
port = port == -1 ? PORT_DEFAULT_HKPS : port;
} else if ("hkp".equalsIgnoreCase(scheme)) {
scheme = "http";
port = port == -1 ? PORT_DEFAULT : port;
}
return new URI(scheme, originalURI.getUserInfo(), originalURI.getHost(), port,
originalURI.getPath(), originalURI.getQuery(), originalURI.getFragment());
}
}

303
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/ParcelableHkpKeyserver.java → OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/HkpKeyserverClient.java
View file

@ -1,5 +1,6 @@
/*
* Copyright (C) 2016-2017 Dominik Schürmann <dominik@dominikschuermann.de>
* Copyright (C) 2017 Vincent Breitmoser <look@my.amazin.horse>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -27,22 +28,14 @@ import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.nio.charset.UnsupportedCharsetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.TimeZone;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import android.os.Parcel;
import android.os.Parcelable;
import android.support.annotation.NonNull;
import de.measite.minidns.Client;
import de.measite.minidns.Question;
import de.measite.minidns.Record;
import de.measite.minidns.record.SRV;
import okhttp3.FormBody;
import okhttp3.HttpUrl;
import okhttp3.OkHttpClient;
@ -56,8 +49,8 @@ import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
import org.sufficientlysecure.keychain.util.Log;
import org.sufficientlysecure.keychain.util.ParcelableProxy;
public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
public class HkpKeyserverClient implements KeyserverClient {
/**
* pub:%keyid%:%algo%:%keylen%:%creationdate%:%expirationdate%:%flags%
* <ul>
@ -123,132 +116,28 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
.compile("uid:([^:]*):([0-9]+):([0-9]*):([rde]*)",
Pattern.CASE_INSENSITIVE);
private static final short PORT_DEFAULT = 11371;
private static final short PORT_DEFAULT_HKPS = 443;
private static final Charset UTF_8 = Charset.forName("utf-8");
private String mUrl;
private String mOnion;
public ParcelableHkpKeyserver(@NonNull String url, String onion) {
mUrl = url.trim();
mOnion = onion == null ? null : onion.trim();
private HkpKeyserverAddress hkpKeyserver;
public static HkpKeyserverClient fromHkpKeyserverAddress(HkpKeyserverAddress hkpKeyserver) {
return new HkpKeyserverClient(hkpKeyserver);
}
public ParcelableHkpKeyserver(@NonNull String url) {
this(url, null);
private HkpKeyserverClient(HkpKeyserverAddress hkpKeyserver) {
this.hkpKeyserver = hkpKeyserver;
}
public String getUrl() {
return mUrl;
}
public String getOnion() {
return mOnion;
}
public URI getUrlURI() throws URISyntaxException {
return getURI(mUrl);
}
public URI getOnionURI() throws URISyntaxException {
return mOnion != null ? getURI(mOnion) : null;
}
/**
* @param keyserverUrl "<code>hostname</code>" (eg. "<code>pool.sks-keyservers.net</code>"), then it will
* connect using {@link #PORT_DEFAULT}. However, port may be specified after colon
* ("<code>hostname:port</code>", eg. "<code>p80.pool.sks-keyservers.net:80</code>").
*/
private URI getURI(String keyserverUrl) throws URISyntaxException {
URI originalURI = new URI(keyserverUrl);
String scheme = originalURI.getScheme();
if (scheme == null) {
throw new URISyntaxException("", "scheme null!");
}
if (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme)
&& !"hkp".equalsIgnoreCase(scheme) && !"hkps".equalsIgnoreCase(scheme)) {
throw new URISyntaxException(scheme, "unsupported scheme!");
}
int port = originalURI.getPort();
if ("hkps".equalsIgnoreCase(scheme)) {
scheme = "https";
port = port == -1 ? PORT_DEFAULT_HKPS : port;
} else if ("hkp".equalsIgnoreCase(scheme)) {
scheme = "http";
port = port == -1 ? PORT_DEFAULT : port;
}
return new URI(scheme, originalURI.getUserInfo(), originalURI.getHost(), port,
originalURI.getPath(), originalURI.getQuery(), originalURI.getFragment());
}
private HttpUrl getHttpUrl(ParcelableProxy proxy) throws URISyntaxException {
URI base = getUrlURI();
if (proxy.isTorEnabled() && getOnionURI() != null) {
base = getOnionURI();
}
return HttpUrl.get(base).newBuilder()
.addPathSegment("pks")
.build();
}
private String query(HttpUrl url, @NonNull ParcelableProxy proxy) throws Keyserver.QueryFailedException, HttpError {
try {
OkHttpClient client = OkHttpClientFactory.getClientPinnedIfAvailable(url.url(), proxy.getProxy());
Request request = new Request.Builder()
.url(url)
.build();
Response response = client
.newCall(request)
.execute();
// contains body both in case of success or failure
String responseBody = getResponseBodyAsUtf8(response);
if (response.isSuccessful()) {
return responseBody;
} else {
throw new HttpError(response.code(), responseBody);
}
} catch (IOException e) {
Log.e(Constants.TAG, "IOException at HkpKeyserver", e);
String proxyInfo = proxy.getProxy() == Proxy.NO_PROXY ? "" : " Using proxy " + proxy.getProxy();
String causeName = e.getCause().getClass().getSimpleName();
throw new Keyserver.QueryFailedException(String.format(
"Network error (%s) for '%s'. Check your Internet connection! %s",
causeName, mUrl, proxyInfo));
}
}
private String getResponseBodyAsUtf8(Response response) throws IOException {
String responseBody;
byte[] responseBytes = response.body().bytes();
try {
responseBody = new String(responseBytes, response.body().contentType().charset(UTF_8));
} catch (UnsupportedCharsetException e) {
responseBody = new String(responseBytes, UTF_8);
}
return responseBody;
}
/**
* Results are sorted by creation date of key!
*/
@Override
public ArrayList<ImportKeysListEntry> search(String query, ParcelableProxy proxy)
throws Keyserver.QueryFailedException, Keyserver.QueryNeedsRepairException {
throws KeyserverClient.QueryFailedException, KeyserverClient.QueryNeedsRepairException {
ArrayList<ImportKeysListEntry> results = new ArrayList<>();
if (query.length() < 3) {
throw new Keyserver.QueryTooShortException();
throw new KeyserverClient.QueryTooShortException();
}
String data;
@ -273,19 +162,19 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
// NOTE: This is also a 404 error for some keyservers!
return results;
} else if (e.getData().toLowerCase(Locale.ENGLISH).contains("too many")) {
throw new Keyserver.TooManyResponsesException();
throw new KeyserverClient.TooManyResponsesException();
} else if (e.getData().toLowerCase(Locale.ENGLISH).contains("insufficient")) {
throw new Keyserver.QueryTooShortException();
throw new KeyserverClient.QueryTooShortException();
} else if (e.getCode() == 404) {
// NOTE: handle this 404 at last, maybe it was a "no keys found" error
throw new Keyserver.QueryFailedException("Keyserver '" + mUrl + "' not found. Error 404");
throw new KeyserverClient.QueryFailedException("Keyserver '" + hkpKeyserver.getUrl() + "' not found. Error 404");
} else {
// NOTE: some keyserver do not provide a more detailed error response
throw new Keyserver.QueryTooShortOrTooManyResponsesException();
throw new KeyserverClient.QueryTooShortOrTooManyResponsesException();
}
}
throw new Keyserver.QueryFailedException("Querying server(s) for '" + mUrl + "' failed.");
throw new KeyserverClient.QueryFailedException("Querying server(s) for '" + hkpKeyserver.getUrl() + "' failed.");
}
final Matcher matcher = PUB_KEY_LINE.matcher(data);
@ -372,7 +261,7 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
}
entry.setUserIds(userIds);
entry.setPrimaryUserId(userIds.get(0));
entry.setKeyserver(this);
entry.setKeyserver(hkpKeyserver);
results.add(entry);
}
@ -380,7 +269,7 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
}
@Override
public String get(String keyIdHex, ParcelableProxy proxy) throws Keyserver.QueryFailedException {
public String get(String keyIdHex, ParcelableProxy proxy) throws KeyserverClient.QueryFailedException {
String data;
try {
HttpUrl url = getHttpUrl(proxy).newBuilder()
@ -398,23 +287,23 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
} catch (HttpError httpError) {
Log.d(Constants.TAG, "Failed to get key at HkpKeyserver", httpError);
if (httpError.getCode() == 404) {
throw new Keyserver.QueryNotFoundException("not found");
throw new KeyserverClient.QueryNotFoundException("not found");
}
throw new Keyserver.QueryFailedException("not found");
throw new KeyserverClient.QueryFailedException("not found");
}
if (data == null) {
throw new Keyserver.QueryFailedException("data is null");
throw new KeyserverClient.QueryFailedException("data is null");
}
Matcher matcher = PgpHelper.PGP_PUBLIC_KEY.matcher(data);
if (matcher.find()) {
return matcher.group(1);
}
throw new Keyserver.QueryFailedException("data is null");
throw new KeyserverClient.QueryFailedException("data is null");
}
@Override
public void add(String armoredKey, ParcelableProxy proxy) throws Keyserver.AddKeyException {
public void add(String armoredKey, ParcelableProxy proxy) throws KeyserverClient.AddKeyException {
try {
HttpUrl url = getHttpUrl(proxy).newBuilder()
.addPathSegment("add")
@ -441,127 +330,89 @@ public class ParcelableHkpKeyserver extends Keyserver implements Parcelable {
+ ", body: " + responseBody);
if (response.code() != 200) {
throw new Keyserver.AddKeyException();
throw new KeyserverClient.AddKeyException();
}
} catch (IOException e) {
Log.e(Constants.TAG, "IOException", e);
throw new Keyserver.AddKeyException();
throw new KeyserverClient.AddKeyException();
} catch (URISyntaxException e) {
Log.e(Constants.TAG, "Unsupported keyserver URI", e);
throw new Keyserver.AddKeyException();
throw new KeyserverClient.AddKeyException();
}
}
private String getHostID() {
private HttpUrl getHttpUrl(ParcelableProxy proxy) throws URISyntaxException {
URI base = hkpKeyserver.getUrlURI();
if (proxy.isTorEnabled() && hkpKeyserver.getOnionURI() != null) {
base = hkpKeyserver.getOnionURI();
}
return HttpUrl.get(base).newBuilder()
.addPathSegment("pks")
.build();
}
private String query(HttpUrl url, @NonNull ParcelableProxy proxy) throws KeyserverClient.QueryFailedException, HttpError {
try {
return (new URI(mUrl)).getHost();
} catch (URISyntaxException e) {
return mUrl;
}
}
OkHttpClient client = OkHttpClientFactory.getClientPinnedIfAvailable(url.url(), proxy.getProxy());
@Override
public String toString() {
return getHostID();
}
Request request = new Request.Builder()
.url(url)
.build();
@Override
public boolean equals(Object obj) {
if (! (obj instanceof ParcelableHkpKeyserver)) {
return false;
}
Response response = client
.newCall(request)
.execute();
ParcelableHkpKeyserver other = (ParcelableHkpKeyserver) obj;
if (other.mUrl == null ^ mUrl == null) {
return false;
}
if (other.mOnion == null ^ mOnion == null) {
return false;
}
if (mUrl != null && !mUrl.equals(other.mUrl)) {
return false;
}
if (mOnion != null && !mOnion.equals(other.mOnion)) {
return false;
}
// contains body both in case of success or failure
String responseBody = getResponseBodyAsUtf8(response);
return true;
}
/**
* Tries to find a server responsible for a given domain
*
* @return A responsible Keyserver or null if not found.
*/
public static ParcelableHkpKeyserver resolve(String domain) {
try {
Record[] records = new Client().query(new Question("_hkp._tcp." + domain, Record.TYPE.SRV)).getAnswers();
if (records.length > 0) {
Arrays.sort(records, new Comparator<Record>() {
@Override
public int compare(Record lhs, Record rhs) {
if (lhs.getPayload().getType() != Record.TYPE.SRV) return 1;
if (rhs.getPayload().getType() != Record.TYPE.SRV) return -1;
return ((SRV) lhs.getPayload()).getPriority() - ((SRV) rhs.getPayload()).getPriority();
}
});
Record record = records[0]; // This is our best choice
if (record.getPayload().getType() == Record.TYPE.SRV) {
SRV payload = (SRV) record.getPayload();
return new ParcelableHkpKeyserver(payload.getName() + ":" + payload.getPort());
}
if (response.isSuccessful()) {
return responseBody;
} else {
throw new HttpError(response.code(), responseBody);
}
} catch (Exception ignored) {
} catch (IOException e) {
Log.e(Constants.TAG, "IOException at HkpKeyserver", e);
String proxyInfo = proxy.getProxy() == Proxy.NO_PROXY ? "" : " Using proxy " + proxy.getProxy();
String causeName = e.getCause().getClass().getSimpleName();
throw new KeyserverClient.QueryFailedException(String.format(
"Network error (%s) for '%s'. Check your Internet connection! %s",
causeName, hkpKeyserver.getUrl(), proxyInfo));
}
return null;
}
private String getResponseBodyAsUtf8(Response response) throws IOException {
String responseBody;
byte[] responseBytes = response.body().bytes();
try {
responseBody = new String(responseBytes, response.body().contentType().charset(UTF_8));
} catch (UnsupportedCharsetException e) {
responseBody = new String(responseBytes, UTF_8);
}
return responseBody;
}
private static class HttpError extends Exception {
private static final long serialVersionUID = 1718783705229428893L;
private int mCode;
private String mData;
private int code;
private String data;
HttpError(int code, String data) {
super("" + code + ": " + data);
mCode = code;
mData = data;
this.code = code;
this.data = data;
}
public int getCode() {
return mCode;
return code;
}
public String getData() {
return mData;
return data;
}
}
protected ParcelableHkpKeyserver(Parcel in) {
mUrl = in.readString();
mOnion = in.readString();
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(mUrl);
dest.writeString(mOnion);
}
@Override
public int describeContents() {
return 0;
}
public static final Creator<ParcelableHkpKeyserver> CREATOR = new Creator<ParcelableHkpKeyserver>() {
@Override
public ParcelableHkpKeyserver createFromParcel(Parcel in) {
return new ParcelableHkpKeyserver(in);
}
@Override
public ParcelableHkpKeyserver[] newArray(int size) {
return new ParcelableHkpKeyserver[size];
}
};
}

8
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/ImportKeysListEntry.java
View file

@ -63,7 +63,7 @@ public class ImportKeysListEntry implements Serializable, Parcelable {
private String mAlgorithm;
private UserId mPrimaryUserId;
private ParcelableHkpKeyserver mKeyserver;
private HkpKeyserverAddress mKeyserver;
private String mKeybaseName;
private String mFbUsername;
@ -189,11 +189,11 @@ public class ImportKeysListEntry implements Serializable, Parcelable {
mPrimaryUserId = primaryUserId;
}
public ParcelableHkpKeyserver getKeyserver() {
public HkpKeyserverAddress getKeyserver() {
return mKeyserver;
}
public void setKeyserver(ParcelableHkpKeyserver keyserver) {
public void setKeyserver(HkpKeyserverAddress keyserver) {
mKeyserver = keyserver;
}
@ -399,7 +399,7 @@ public class ImportKeysListEntry implements Serializable, Parcelable {
vr.mBitStrength = source.readInt() != 0 ? source.readInt() : null;
vr.mAlgorithm = source.readString();
vr.mSecretKey = source.readByte() == 1;
vr.mKeyserver = source.readParcelable(ParcelableHkpKeyserver.class.getClassLoader());
vr.mKeyserver = source.readParcelable(HkpKeyserverAddress.class.getClassLoader());
vr.mKeybaseName = source.readString();
vr.mFbUsername = source.readString();

8
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeybaseKeyserver.java → OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeybaseKeyserverClient.java
View file

@ -31,13 +31,13 @@ import org.sufficientlysecure.keychain.util.ParcelableProxy;
import java.util.ArrayList;
import java.util.List;
public class KeybaseKeyserver extends Keyserver {
public class KeybaseKeyserverClient implements KeyserverClient {
public static KeybaseKeyserver getInstance() {
return new KeybaseKeyserver();
public static KeybaseKeyserverClient getInstance() {
return new KeybaseKeyserverClient();
}
private KeybaseKeyserver() { }
private KeybaseKeyserverClient() { }
@Override
public ArrayList<ImportKeysListEntry> search(String query, ParcelableProxy proxy) throws QueryFailedException,

43
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/Keyserver.java → OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeyserverClient.java
View file

@ -1,7 +1,5 @@
/*
* Copyright (C) 2012-2014 Dominik Schürmann <dominik@dominikschuermann.de>
* Copyright (C) 2011-2014 Thialfihar <thi@thialfihar.org>
* Copyright (C) 2011 Senecaso
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -25,9 +23,9 @@ import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public abstract class Keyserver {
public interface KeyserverClient {
public static class CloudSearchFailureException extends Exception {
class CloudSearchFailureException extends Exception {
private static final long serialVersionUID = 2703768928624654515L;
public CloudSearchFailureException(String message) {
@ -39,7 +37,7 @@ public abstract class Keyserver {
}
}
public static class QueryFailedException extends CloudSearchFailureException {
class QueryFailedException extends CloudSearchFailureException {
private static final long serialVersionUID = 2703768928624654512L;
public QueryFailedException(String message) {
@ -47,7 +45,7 @@ public abstract class Keyserver {
}
}
public static class QueryNotFoundException extends QueryFailedException {
class QueryNotFoundException extends QueryFailedException {
private static final long serialVersionUID = 2693768928624654513L;
public QueryNotFoundException(String message) {
@ -55,52 +53,37 @@ public abstract class Keyserver {
}
}
public static class QueryNeedsRepairException extends CloudSearchFailureException {
class QueryNeedsRepairException extends CloudSearchFailureException {
private static final long serialVersionUID = 2693768928624654512L;
}
public static class TooManyResponsesException extends QueryNeedsRepairException {
class TooManyResponsesException extends QueryNeedsRepairException {
private static final long serialVersionUID = 2703768928624654513L;
}
public static class QueryTooShortException extends QueryNeedsRepairException {
class QueryTooShortException extends QueryNeedsRepairException {
private static final long serialVersionUID = 2703768928624654514L;
}
/**
* query too short _or_ too many responses
*/
public static class QueryTooShortOrTooManyResponsesException extends QueryNeedsRepairException {
class QueryTooShortOrTooManyResponsesException extends QueryNeedsRepairException {
private static final long serialVersionUID = 2703768928624654518L;
}
public static class QueryNoEnabledSourceException extends QueryNeedsRepairException {
class QueryNoEnabledSourceException extends QueryNeedsRepairException {
private static final long serialVersionUID = 2703768928624654519L;
}
public static class AddKeyException extends Exception {
class AddKeyException extends Exception {
private static final long serialVersionUID = -507574859137295530L;
}
public abstract List<ImportKeysListEntry> search(String query, ParcelableProxy proxy)
List<ImportKeysListEntry> search(String query, ParcelableProxy proxy)
throws QueryFailedException, QueryNeedsRepairException;
public abstract String get(String keyIdHex, ParcelableProxy proxy) throws QueryFailedException;
String get(String keyIdHex, ParcelableProxy proxy) throws QueryFailedException;
public abstract void add(String armoredKey, ParcelableProxy proxy) throws AddKeyException;
public static String readAll(InputStream in, String encoding) throws IOException {
ByteArrayOutputStream raw = new ByteArrayOutputStream();
byte buffer[] = new byte[1 << 16];
int n = 0;
while ((n = in.read(buffer)) != -1) {
raw.write(buffer, 0, n);
}
if (encoding == null) {
encoding = "utf8";
}
return raw.toString(encoding);
}
void add(String armoredKey, ParcelableProxy proxy) throws AddKeyException;
}

14
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/processing/ImportKeysListCloudLoader.java
View file

@ -24,7 +24,7 @@ import android.support.v4.content.AsyncTaskLoader;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.keyimport.CloudSearch;
import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
import org.sufficientlysecure.keychain.keyimport.Keyserver;
import org.sufficientlysecure.keychain.keyimport.KeyserverClient;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.operations.results.GetKeyResult;
import org.sufficientlysecure.keychain.operations.results.OperationResult;
@ -167,23 +167,23 @@ public class ImportKeysListCloudLoader
}
GetKeyResult getKeyResult = new GetKeyResult(GetKeyResult.RESULT_OK, null);
mEntryListWrapper = new AsyncTaskResultWrapper<>(mEntryList, getKeyResult);
} catch (Keyserver.CloudSearchFailureException e) {
} catch (KeyserverClient.CloudSearchFailureException e) {
// convert exception to result parcel
int error = GetKeyResult.RESULT_ERROR;
OperationResult.LogType logType = null;
if (e instanceof Keyserver.QueryFailedException) {
if (e instanceof KeyserverClient.QueryFailedException) {
error = GetKeyResult.RESULT_ERROR_QUERY_FAILED;
logType = OperationResult.LogType.MSG_GET_QUERY_FAILED;
} else if (e instanceof Keyserver.TooManyResponsesException) {
} else if (e instanceof KeyserverClient.TooManyResponsesException) {
error = GetKeyResult.RESULT_ERROR_TOO_MANY_RESPONSES;
logType = OperationResult.LogType.MSG_GET_TOO_MANY_RESPONSES;
} else if (e instanceof Keyserver.QueryTooShortException) {
} else if (e instanceof KeyserverClient.QueryTooShortException) {
error = GetKeyResult.RESULT_ERROR_QUERY_TOO_SHORT;
logType = OperationResult.LogType.MSG_GET_QUERY_TOO_SHORT;
} else if (e instanceof Keyserver.QueryTooShortOrTooManyResponsesException) {
} else if (e instanceof KeyserverClient.QueryTooShortOrTooManyResponsesException) {
error = GetKeyResult.RESULT_ERROR_TOO_SHORT_OR_TOO_MANY_RESPONSES;
logType = OperationResult.LogType.MSG_GET_QUERY_TOO_SHORT_OR_TOO_MANY_RESPONSES;
} else if (e instanceof Keyserver.QueryNoEnabledSourceException) {
} else if (e instanceof KeyserverClient.QueryNoEnabledSourceException) {
error = GetKeyResult.RESULT_ERROR_NO_ENABLED_SOURCE;
logType = OperationResult.LogType.MSG_GET_NO_ENABLED_SOURCE;
}

49
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/ImportOperation.java
View file

@ -37,11 +37,12 @@ import android.support.annotation.Nullable;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.FacebookKeyserver;
import org.sufficientlysecure.keychain.keyimport.KeybaseKeyserver;
import org.sufficientlysecure.keychain.keyimport.Keyserver;
import org.sufficientlysecure.keychain.keyimport.Keyserver.QueryNotFoundException;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.FacebookKeyserverClient;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverClient;
import org.sufficientlysecure.keychain.keyimport.KeybaseKeyserverClient;
import org.sufficientlysecure.keychain.keyimport.KeyserverClient;
import org.sufficientlysecure.keychain.keyimport.KeyserverClient.QueryNotFoundException;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.network.orbot.OrbotHelper;
import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
@ -87,8 +88,8 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
private static final int MAX_THREADS = 10;
public static final String CACHE_FILE_NAME = "key_import.pcl";
private FacebookKeyserver facebookServer;
private KeybaseKeyserver keybaseServer;
private FacebookKeyserverClient facebookServer;
private KeybaseKeyserverClient keybaseServer;
public ImportOperation(Context context, KeyWritableRepository databaseInteractor, Progressable progressable) {
super(context, databaseInteractor, progressable);
@ -101,13 +102,13 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
// Overloaded functions for using progressable supplied in constructor during import
public ImportKeyResult serialKeyRingImport(Iterator<ParcelableKeyRing> entries, int num,
ParcelableHkpKeyserver keyserver, ParcelableProxy proxy, boolean skipSave) {
HkpKeyserverAddress keyserver, ParcelableProxy proxy, boolean skipSave) {
return serialKeyRingImport(entries, num, keyserver, mProgressable, proxy, skipSave);
}
@NonNull
private ImportKeyResult serialKeyRingImport(ParcelableFileCache<ParcelableKeyRing> cache,
ParcelableHkpKeyserver keyserver, ParcelableProxy proxy, boolean skipSave) {
HkpKeyserverAddress keyserver, ParcelableProxy proxy, boolean skipSave) {
// get entries from cached file
try {
@ -139,7 +140,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
*/
@NonNull
private ImportKeyResult serialKeyRingImport(Iterator<ParcelableKeyRing> entries, int numTotalKeys,
ParcelableHkpKeyserver hkpKeyserver, Progressable progressable,
HkpKeyserverAddress hkpKeyserver, Progressable progressable,
@NonNull ParcelableProxy proxy, boolean skipSave) {
if (progressable != null) {
progressable.setProgress(R.string.progress_importing, 0, 100);
@ -324,7 +325,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
return result;
}
private UncachedKeyRing fetchKeyFromInternet(ParcelableHkpKeyserver hkpKeyserver, @NonNull ParcelableProxy proxy,
private UncachedKeyRing fetchKeyFromInternet(HkpKeyserverAddress hkpKeyserver, @NonNull ParcelableProxy proxy,
OperationLog log, ParcelableKeyRing entry, UncachedKeyRing key)
throws PgpGeneralException, IOException, QueryNotFoundException {
QueryNotFoundException queryNotFoundException = null;
@ -368,21 +369,23 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
}
@Nullable
private UncachedKeyRing fetchKeyFromKeyserver(ParcelableHkpKeyserver hkpKeyserver, @NonNull ParcelableProxy proxy,
OperationLog log, ParcelableKeyRing entry) throws PgpGeneralException, IOException, Keyserver.QueryNotFoundException {
private UncachedKeyRing fetchKeyFromKeyserver(HkpKeyserverAddress hkpKeyserver, @NonNull ParcelableProxy proxy,
OperationLog log, ParcelableKeyRing entry) throws PgpGeneralException, IOException, KeyserverClient.QueryNotFoundException {
try {
byte[] data;
log.add(LogType.MSG_IMPORT_KEYSERVER, 1, hkpKeyserver);
HkpKeyserverClient keyserverInteractor = HkpKeyserverClient.fromHkpKeyserverAddress(hkpKeyserver);
// Download by fingerprint, or keyId - whichever is available
if (entry.getExpectedFingerprint() != null) {
String fingerprintHex = KeyFormattingUtils.convertFingerprintToHex(entry.getExpectedFingerprint());
log.add(LogType.MSG_IMPORT_FETCH_KEYSERVER, 2, "0x" +
fingerprintHex.substring(24));
data = hkpKeyserver.get("0x" + fingerprintHex, proxy).getBytes();
data = keyserverInteractor.get("0x" + fingerprintHex, proxy).getBytes();
} else {
log.add(LogType.MSG_IMPORT_FETCH_KEYSERVER, 2, entry.getKeyIdHex());
data = hkpKeyserver.get(entry.getKeyIdHex(), proxy).getBytes();
data = keyserverInteractor.get(entry.getKeyIdHex(), proxy).getBytes();
}
UncachedKeyRing keyserverKey = UncachedKeyRing.decodeFromData(data);
if (keyserverKey != null) {
@ -392,9 +395,9 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
}
return keyserverKey;
} catch (Keyserver.QueryNotFoundException e) {
} catch (KeyserverClient.QueryNotFoundException e) {
throw e;
} catch (Keyserver.QueryFailedException e) {
} catch (KeyserverClient.QueryFailedException e) {
Log.d(Constants.TAG, "query failed", e);
log.add(LogType.MSG_IMPORT_FETCH_ERROR_KEYSERVER, 3, e.getMessage());
return null;
@ -404,7 +407,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
private UncachedKeyRing fetchKeyFromKeybase(@NonNull ParcelableProxy proxy, OperationLog log, ParcelableKeyRing entry)
throws PgpGeneralException, IOException {
if (keybaseServer == null) {
keybaseServer = KeybaseKeyserver.getInstance();
keybaseServer = KeybaseKeyserverClient.getInstance();
}
try {
@ -419,7 +422,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
}
return keybaseKey;
} catch (Keyserver.QueryFailedException e) {
} catch (KeyserverClient.QueryFailedException e) {
// download failed, too bad. just proceed
Log.e(Constants.TAG, "query failed", e);
log.add(LogType.MSG_IMPORT_FETCH_ERROR_KEYSERVER, 3, e.getMessage());
@ -430,7 +433,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
private UncachedKeyRing fetchKeyFromFacebook(@NonNull ParcelableProxy proxy, OperationLog log, ParcelableKeyRing entry)
throws PgpGeneralException, IOException {
if (facebookServer == null) {
facebookServer = FacebookKeyserver.getInstance();
facebookServer = FacebookKeyserverClient.getInstance();
}
try {
@ -445,7 +448,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
}
return facebookKey;
} catch (Keyserver.QueryFailedException e) {
} catch (KeyserverClient.QueryFailedException e) {
// download failed, too bad. just proceed
Log.e(Constants.TAG, "query failed", e);
log.add(LogType.MSG_IMPORT_FETCH_ERROR_KEYSERVER, 3, e.getMessage());
@ -475,7 +478,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
@Override
public ImportKeyResult execute(ImportKeyringParcel importInput, CryptoInputParcel cryptoInput) {
ArrayList<ParcelableKeyRing> keyList = importInput.getKeyList();
ParcelableHkpKeyserver keyServer = importInput.getKeyserver();
HkpKeyserverAddress keyServer = importInput.getKeyserver();
boolean skipSave = importInput.isSkipSave();
ImportKeyResult result;
@ -508,7 +511,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
@NonNull
private ImportKeyResult multiThreadedKeyImport(ArrayList<ParcelableKeyRing> keyList,
final ParcelableHkpKeyserver keyServer, final ParcelableProxy proxy,
final HkpKeyserverAddress keyServer, final ParcelableProxy proxy,
final boolean skipSave) {
Log.d(Constants.TAG, "Multi-threaded key import starting");

13
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/UploadOperation.java
View file

@ -27,8 +27,9 @@ import android.support.annotation.Nullable;
import org.bouncycastle.bcpg.ArmoredOutputStream;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.Keyserver.AddKeyException;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverClient;
import org.sufficientlysecure.keychain.keyimport.KeyserverClient.AddKeyException;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
import org.sufficientlysecure.keychain.operations.results.UploadResult;
@ -94,7 +95,7 @@ public class UploadOperation extends BaseOperation<UploadKeyringParcel> {
log.add(LogType.MSG_UPLOAD_PROXY, 1, parcelableProxy.getProxy().toString());
}
ParcelableHkpKeyserver hkpKeyserver;
HkpKeyserverAddress hkpKeyserver;
{
hkpKeyserver = uploadInput.getKeyserver();
log.add(LogType.MSG_UPLOAD_SERVER, 1, hkpKeyserver.toString());
@ -139,19 +140,21 @@ public class UploadOperation extends BaseOperation<UploadKeyringParcel> {
@NonNull
private UploadResult uploadKeyRingToServer(
OperationLog log, ParcelableHkpKeyserver server, CanonicalizedPublicKeyRing keyring,
OperationLog log, HkpKeyserverAddress hkpKeyserverAddress, CanonicalizedPublicKeyRing keyring,
ParcelableProxy proxy) {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ArmoredOutputStream aos = null;
HkpKeyserverClient keyserverInteractor = HkpKeyserverClient.fromHkpKeyserverAddress(hkpKeyserverAddress);
try {
aos = new ArmoredOutputStream(bos);
keyring.encode(aos);
aos.close();
String armoredKey = bos.toString("UTF-8");
server.add(armoredKey, proxy);
keyserverInteractor.add(armoredKey, proxy);
updateProgress(R.string.progress_uploading, 1, 1);

6
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/CertifyActionsParcel.java
View file

@ -28,7 +28,7 @@ import android.support.annotation.CheckResult;
import android.support.annotation.Nullable;
import com.google.auto.value.AutoValue;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute;
@ -37,7 +37,7 @@ public abstract class CertifyActionsParcel implements Parcelable {
public abstract long getMasterKeyId();
public abstract ArrayList<CertifyAction> getCertifyActions();
@Nullable
public abstract ParcelableHkpKeyserver getParcelableKeyServer();
public abstract HkpKeyserverAddress getParcelableKeyServer();
public static Builder builder(long masterKeyId) {
return new AutoValue_CertifyActionsParcel.Builder()
@ -49,7 +49,7 @@ public abstract class CertifyActionsParcel implements Parcelable {
public abstract static class Builder {
abstract Builder setMasterKeyId(long masterKeyId);
public abstract Builder setCertifyActions(ArrayList<CertifyAction> certifyActions);
public abstract Builder setParcelableKeyServer(ParcelableHkpKeyserver uri);
public abstract Builder setParcelableKeyServer(HkpKeyserverAddress uri);
abstract ArrayList<CertifyAction> getCertifyActions();

8
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/ImportKeyringParcel.java
View file

@ -25,7 +25,7 @@ import android.os.Parcelable;
import android.support.annotation.Nullable;
import com.google.auto.value.AutoValue;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
@AutoValue
@ -33,16 +33,16 @@ public abstract class ImportKeyringParcel implements Parcelable {
@Nullable // If null, keys are expected to be read from a cache file in ImportExportOperations
public abstract ArrayList<ParcelableKeyRing> getKeyList();
@Nullable // must be set if keys are to be imported from a keyserver
public abstract ParcelableHkpKeyserver getKeyserver();
public abstract HkpKeyserverAddress getKeyserver();
public abstract boolean isSkipSave();
public static ImportKeyringParcel createImportKeyringParcel(ArrayList<ParcelableKeyRing> keyList,
ParcelableHkpKeyserver keyserver) {
HkpKeyserverAddress keyserver) {
return new AutoValue_ImportKeyringParcel(keyList, keyserver, false);
}
public static ImportKeyringParcel createWithSkipSave(ArrayList<ParcelableKeyRing> keyList,
ParcelableHkpKeyserver keyserver) {
HkpKeyserverAddress keyserver) {
return new AutoValue_ImportKeyringParcel(keyList, keyserver, true);
}

7
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/RevokeKeyringParcel.java
View file

@ -24,17 +24,18 @@ import android.os.Parcelable;
import android.support.annotation.Nullable;
import com.google.auto.value.AutoValue;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
@AutoValue
public abstract class RevokeKeyringParcel implements Parcelable {
public abstract long getMasterKeyId();
public abstract boolean isShouldUpload();
@Nullable
public abstract ParcelableHkpKeyserver getKeyserver();
public abstract HkpKeyserverAddress getKeyserver();
public static RevokeKeyringParcel createRevokeKeyringParcel(long masterKeyId, boolean upload,
ParcelableHkpKeyserver keyserver) {
HkpKeyserverAddress keyserver) {
return new AutoValue_RevokeKeyringParcel(masterKeyId, upload, keyserver);
}
}

8
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/SaveKeyringParcel.java
View file

@ -28,7 +28,7 @@ import android.os.Parcelable;
import android.support.annotation.Nullable;
import com.google.auto.value.AutoValue;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute;
import org.sufficientlysecure.keychain.util.Passphrase;
@ -78,7 +78,7 @@ public abstract class SaveKeyringParcel implements Parcelable {
public abstract boolean isShouldUpload();
public abstract boolean isShouldUploadAtomic();
@Nullable
public abstract ParcelableHkpKeyserver getUploadKeyserver();
public abstract HkpKeyserverAddress getUploadKeyserver();
@Nullable
public abstract ChangeUnlockParcel getNewUnlock();
@ -151,9 +151,9 @@ public abstract class SaveKeyringParcel implements Parcelable {
abstract Builder setRevokeSubKeys(List<Long> revokeSubKeys);
abstract Builder setShouldUpload(boolean upload);
abstract Builder setShouldUploadAtomic(boolean uploadAtomic);
abstract Builder setUploadKeyserver(ParcelableHkpKeyserver keyserver);
abstract Builder setUploadKeyserver(HkpKeyserverAddress keyserver);
public void setUpdateOptions(boolean upload, boolean uploadAtomic, ParcelableHkpKeyserver keyserver) {
public void setUpdateOptions(boolean upload, boolean uploadAtomic, HkpKeyserverAddress keyserver) {
setShouldUpload(upload);
setShouldUploadAtomic(uploadAtomic);
setUploadKeyserver(keyserver);

9
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/UploadKeyringParcel.java
View file

@ -25,11 +25,12 @@ import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import com.google.auto.value.AutoValue;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
@AutoValue
public abstract class UploadKeyringParcel implements Parcelable {
public abstract ParcelableHkpKeyserver getKeyserver();
public abstract HkpKeyserverAddress getKeyserver();
@Nullable
public abstract Long getMasterKeyId();
@Nullable
@ -37,11 +38,11 @@ public abstract class UploadKeyringParcel implements Parcelable {
public abstract byte[] getUncachedKeyringBytes();
public static UploadKeyringParcel createWithKeyId(ParcelableHkpKeyserver keyserver, long masterKeyId) {
public static UploadKeyringParcel createWithKeyId(HkpKeyserverAddress keyserver, long masterKeyId) {
return new AutoValue_UploadKeyringParcel(keyserver, masterKeyId, null);
}
public static UploadKeyringParcel createWithKeyringBytes(ParcelableHkpKeyserver keyserver,
public static UploadKeyringParcel createWithKeyringBytes(HkpKeyserverAddress keyserver,
@NonNull byte[] uncachedKeyringBytes) {
return new AutoValue_UploadKeyringParcel(keyserver, null, uncachedKeyringBytes);
}

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyFinalFragment.java
View file

@ -53,7 +53,7 @@ import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
import org.sufficientlysecure.keychain.ui.CreateKeyActivity.FragAction;
import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
import org.sufficientlysecure.keychain.util.Log;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.util.Passphrase;
import org.sufficientlysecure.keychain.util.Preferences;
@ -519,7 +519,7 @@ public class CreateKeyFinalFragment extends Fragment {
// set data uri as path to keyring
final long masterKeyId = saveKeyResult.mMasterKeyId;
// upload to favorite keyserver
final ParcelableHkpKeyserver keyserver = Preferences.getPreferences(activity).getPreferredKeyserver();
final HkpKeyserverAddress keyserver = Preferences.getPreferences(activity).getPreferredKeyserver();
CryptoOperationHelper.Callback<UploadKeyringParcel, UploadResult> callback
= new CryptoOperationHelper.Callback<UploadKeyringParcel, UploadResult>() {

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateSecurityTokenImportResetFragment.java
View file

@ -43,7 +43,7 @@ import org.sufficientlysecure.keychain.ui.CreateKeyActivity.FragAction;
import org.sufficientlysecure.keychain.ui.CreateKeyActivity.SecurityTokenListenerFragment;
import org.sufficientlysecure.keychain.ui.base.QueueingCryptoOperationFragment;
import org.sufficientlysecure.keychain.ui.keyview.ViewKeyActivity;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.util.Preferences;
import java.io.IOException;
@ -77,7 +77,7 @@ public class CreateSecurityTokenImportResetFragment
private View mResetWarning;
// for CryptoOperationFragment key import
private ParcelableHkpKeyserver mKeyserver;
private HkpKeyserverAddress mKeyserver;
private ArrayList<ParcelableKeyRing> mKeyList;
public static Fragment newInstance(byte[] scannedFingerprints, byte[] nfcAid, String userId) {

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFragment.java
View file

@ -43,7 +43,7 @@ import org.openintents.openpgp.OpenPgpSignatureResult;
import org.openintents.openpgp.util.OpenPgpUtils;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
@ -140,7 +140,7 @@ public abstract class DecryptFragment extends Fragment implements LoaderManager.
private void lookupUnknownKey(long unknownKeyId) {
final ArrayList<ParcelableKeyRing> keyList;
final ParcelableHkpKeyserver keyserver;
final HkpKeyserverAddress keyserver;
// search config
keyserver = Preferences.getPreferences(getActivity()).getPreferredKeyserver();

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptListFragment.java
View file

@ -74,6 +74,7 @@ import org.openintents.openpgp.OpenPgpSignatureResult;
import org.sufficientlysecure.keychain.BuildConfig;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
import org.sufficientlysecure.keychain.operations.results.InputDataResult;
@ -96,7 +97,6 @@ import org.sufficientlysecure.keychain.ui.util.Notify.Style;
import org.sufficientlysecure.keychain.util.FileHelper;
import org.sufficientlysecure.keychain.util.Log;
import org.sufficientlysecure.keychain.util.ParcelableHashMap;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.util.Preferences;
@ -760,7 +760,7 @@ public class DecryptListFragment
private void lookupUnknownKey(final Uri inputUri, long unknownKeyId) {
final ArrayList<ParcelableKeyRing> keyList;
final ParcelableHkpKeyserver keyserver;
final HkpKeyserverAddress keyserver;
// search config
keyserver = Preferences.getPreferences(getActivity()).getPreferredKeyserver();

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DeleteKeyDialogActivity.java
View file

@ -37,7 +37,7 @@ import android.widget.TextView;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.operations.results.DeleteResult;
import org.sufficientlysecure.keychain.operations.results.OperationResult;
import org.sufficientlysecure.keychain.operations.results.RevokeResult;
@ -152,7 +152,7 @@ public class DeleteKeyDialogActivity extends FragmentActivity {
@Override
public RevokeKeyringParcel createOperationInput() {
return RevokeKeyringParcel.createRevokeKeyringParcel(mMasterKeyIds[0], true,
(ParcelableHkpKeyserver) getIntent().getParcelableExtra(EXTRA_KEYSERVER));
(HkpKeyserverAddress) getIntent().getParcelableExtra(EXTRA_KEYSERVER));
}
@Override

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EditIdentitiesFragment.java
View file

@ -41,7 +41,7 @@ import android.widget.ListView;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.compatibility.DialogFragmentWorkaround;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.operations.results.EditKeyResult;
import org.sufficientlysecure.keychain.operations.results.OperationResult;
import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
@ -388,7 +388,7 @@ public class EditIdentitiesFragment extends Fragment
final long masterKeyId = editKeyResult.mMasterKeyId;
// upload to favorite keyserver
final ParcelableHkpKeyserver keyserver = Preferences.getPreferences(activity).getPreferredKeyserver();
final HkpKeyserverAddress keyserver = Preferences.getPreferences(activity).getPreferredKeyserver();
CryptoOperationHelper.Callback<UploadKeyringParcel, UploadResult> callback
= new CryptoOperationHelper.Callback<UploadKeyringParcel, UploadResult>() {

10
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ImportKeysActivity.java
View file

@ -28,7 +28,8 @@ import android.view.ViewGroup;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.FacebookKeyserver;
import org.sufficientlysecure.keychain.keyimport.FacebookKeyserverClient;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.keyimport.processing.ImportKeysListener;
@ -43,7 +44,6 @@ import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
import org.sufficientlysecure.keychain.ui.util.Notify;
import org.sufficientlysecure.keychain.util.Log;
import org.sufficientlysecure.keychain.util.ParcelableFileCache;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.util.Preferences;
import java.io.IOException;
@ -119,7 +119,7 @@ public class ImportKeysActivity extends BaseActivity implements ImportKeysListen
}
if (Intent.ACTION_VIEW.equals(action)) {
if (FacebookKeyserver.isFacebookHost(dataUri)) {
if (FacebookKeyserverClient.isFacebookHost(dataUri)) {
action = ACTION_IMPORT_KEY_FROM_FACEBOOK;
} else if ("http".equalsIgnoreCase(scheme) || "https".equalsIgnoreCase(scheme)) {
action = ACTION_SEARCH_KEYSERVER_FROM_URL;
@ -202,7 +202,7 @@ public class ImportKeysActivity extends BaseActivity implements ImportKeysListen
break;
}
case ACTION_IMPORT_KEY_FROM_FACEBOOK: {
String fbUsername = FacebookKeyserver.getUsernameFromUri(dataUri);
String fbUsername = FacebookKeyserverClient.getUsernameFromUri(dataUri);
Preferences.CloudSearchPrefs cloudSearchPrefs =
new Preferences.CloudSearchPrefs(false, true, true, null);
@ -212,7 +212,7 @@ public class ImportKeysActivity extends BaseActivity implements ImportKeysListen
}
case ACTION_SEARCH_KEYSERVER_FROM_URL: {
// get keyserver from URL
ParcelableHkpKeyserver keyserver = new ParcelableHkpKeyserver(
HkpKeyserverAddress keyserver = HkpKeyserverAddress.createFromUri(
dataUri.getScheme() + "://" + dataUri.getAuthority());
Preferences.CloudSearchPrefs cloudSearchPrefs = new Preferences.CloudSearchPrefs(
true, false, false, keyserver);

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ImportKeysProxyActivity.java
View file

@ -43,7 +43,7 @@ import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
import org.sufficientlysecure.keychain.util.IntentIntegratorSupportV4;
import org.sufficientlysecure.keychain.util.Log;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.util.Preferences;
import java.util.ArrayList;
@ -63,7 +63,7 @@ public class ImportKeysProxyActivity extends FragmentActivity
public static final String EXTRA_FINGERPRINT = "fingerprint";
// for CryptoOperationHelper
private ParcelableHkpKeyserver mKeyserver;
private HkpKeyserverAddress mKeyserver;
private ArrayList<ParcelableKeyRing> mKeyList;
private CryptoOperationHelper<ImportKeyringParcel, ImportKeyResult> mImportOpHelper;

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java
View file

@ -50,7 +50,7 @@ import com.tonicartos.superslim.LayoutManager;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.operations.results.BenchmarkResult;
import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
@ -94,7 +94,7 @@ public class KeyListFragment extends RecyclerFragment<KeySectionedListAdapter>
// for CryptoOperationHelper import
private ArrayList<ParcelableKeyRing> mKeyList;
private ParcelableHkpKeyserver mKeyserver;
private HkpKeyserverAddress mKeyserver;
private CryptoOperationHelper<ImportKeyringParcel, ImportKeyResult> mImportOpHelper;
// for ConsolidateOperation

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SafeSlingerActivity.java
View file

@ -35,7 +35,7 @@ import edu.cmu.cylab.starslinger.exchange.ExchangeActivity;
import edu.cmu.cylab.starslinger.exchange.ExchangeConfig;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.operations.ImportOperation;
import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
@ -64,7 +64,7 @@ public class SafeSlingerActivity extends BaseActivity
// for CryptoOperationHelper
private ArrayList<ParcelableKeyRing> mKeyList;
private ParcelableHkpKeyserver mKeyserver;
private HkpKeyserverAddress mKeyserver;
private CryptoOperationHelper<ImportKeyringParcel, ImportKeyResult> mOperationHelper;

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SettingsActivity.java
View file

@ -53,7 +53,7 @@ import org.sufficientlysecure.keychain.service.ContactSyncAdapterService;
import org.sufficientlysecure.keychain.ui.base.BaseActivity;
import org.sufficientlysecure.keychain.ui.util.Notify;
import org.sufficientlysecure.keychain.ui.util.ThemeChanger;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.util.Log;
import org.sufficientlysecure.keychain.util.Preferences;
import org.sufficientlysecure.keychain.network.orbot.OrbotHelper;
@ -185,7 +185,7 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
}
public static String keyserverSummary(Context context) {
ArrayList<ParcelableHkpKeyserver> servers = sPreferences.getKeyServers();
ArrayList<HkpKeyserverAddress> servers = sPreferences.getKeyServers();
String serverSummary = context.getResources().getQuantityString(
R.plurals.n_keyservers, servers.size(), servers.size());
return serverSummary + "; " + context.getString(R.string.label_preferred) + ": " + sPreferences

6
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SettingsKeyServerActivity.java
View file

@ -22,7 +22,7 @@ import android.os.Bundle;
import android.view.MenuItem;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.ui.base.BaseActivity;
import java.util.ArrayList;
@ -36,7 +36,7 @@ public class SettingsKeyServerActivity extends BaseActivity {
super.onCreate(savedInstanceState);
Intent intent = getIntent();
ArrayList<ParcelableHkpKeyserver> servers = intent.getParcelableArrayListExtra(EXTRA_KEY_SERVERS);
ArrayList<HkpKeyserverAddress> servers = intent.getParcelableArrayListExtra(EXTRA_KEY_SERVERS);
loadFragment(savedInstanceState, servers);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
@ -58,7 +58,7 @@ public class SettingsKeyServerActivity extends BaseActivity {
setContentView(R.layout.key_server_preference);
}
private void loadFragment(Bundle savedInstanceState, ArrayList<ParcelableHkpKeyserver> keyservers) {
private void loadFragment(Bundle savedInstanceState, ArrayList<HkpKeyserverAddress> keyservers) {
// However, if we're being restored from a previous state,
// then we don't need to do anything and should return or else
// we could end up with overlapping fragments.

20
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SettingsKeyserverFragment.java
View file

@ -43,7 +43,7 @@ import android.widget.ImageView;
import android.widget.TextView;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.provider.KeyWritableRepository;
import org.sufficientlysecure.keychain.ui.dialog.AddEditKeyserverDialogFragment;
import org.sufficientlysecure.keychain.ui.util.FormattingUtils;
@ -60,13 +60,13 @@ public class SettingsKeyserverFragment extends Fragment implements RecyclerItemC
private static final String ARG_KEYSERVER_ARRAY = "arg_keyserver_array";
private ItemTouchHelper mItemTouchHelper;
private ArrayList<ParcelableHkpKeyserver> mKeyserversMutable;
private List<ParcelableHkpKeyserver> mKeyservers;
private ArrayList<HkpKeyserverAddress> mKeyserversMutable;
private List<HkpKeyserverAddress> mKeyservers;
private KeyserverListAdapter mAdapter;
private KeyWritableRepository databaseReadWriteInteractor;
public static SettingsKeyserverFragment newInstance(ArrayList<ParcelableHkpKeyserver> keyservers) {
public static SettingsKeyserverFragment newInstance(ArrayList<HkpKeyserverAddress> keyservers) {
Bundle args = new Bundle();
args.putParcelableArrayList(ARG_KEYSERVER_ARRAY, keyservers);
@ -139,7 +139,7 @@ public class SettingsKeyserverFragment extends Fragment implements RecyclerItemC
}
private void startEditKeyserverDialog(AddEditKeyserverDialogFragment.DialogAction action,
ParcelableHkpKeyserver keyserver, final int position) {
HkpKeyserverAddress keyserver, final int position) {
Handler returnHandler = new Handler() {
@Override
public void handleMessage(Message message) {
@ -168,7 +168,7 @@ public class SettingsKeyserverFragment extends Fragment implements RecyclerItemC
R.string.add_keyserver_without_verification,
Notify.Style.WARN).show();
}
ParcelableHkpKeyserver keyserver = data.getParcelable(
HkpKeyserverAddress keyserver = data.getParcelable(
AddEditKeyserverDialogFragment.MESSAGE_KEYSERVER);
AddEditKeyserverDialogFragment.DialogAction dialogAction
@ -195,13 +195,13 @@ public class SettingsKeyserverFragment extends Fragment implements RecyclerItemC
dialogFragment.show(getFragmentManager(), "addKeyserverDialog");
}
private void addKeyserver(ParcelableHkpKeyserver keyserver) {
private void addKeyserver(HkpKeyserverAddress keyserver) {
mKeyserversMutable.add(keyserver);
mAdapter.notifyItemInserted(mKeyserversMutable.size() - 1);
saveKeyserverList();
}
private void editKeyserver(ParcelableHkpKeyserver newKeyserver, int position) {
private void editKeyserver(HkpKeyserverAddress newKeyserver, int position) {
mKeyserversMutable.set(position, newKeyserver);
mAdapter.notifyItemChanged(position);
saveKeyserverList();
@ -243,9 +243,9 @@ public class SettingsKeyserverFragment extends Fragment implements RecyclerItemC
public class KeyserverListAdapter extends RecyclerView.Adapter<KeyserverListAdapter.ViewHolder>
implements ItemTouchHelperAdapter {
private final ArrayList<ParcelableHkpKeyserver> mKeyservers;
private final ArrayList<HkpKeyserverAddress> mKeyservers;
public KeyserverListAdapter(ArrayList<ParcelableHkpKeyserver> keyservers) {
public KeyserverListAdapter(ArrayList<HkpKeyserverAddress> keyservers) {
mKeyservers = keyservers;
}

10
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/UploadKeyActivity.java
View file

@ -35,7 +35,7 @@ import org.sufficientlysecure.keychain.provider.KeychainContract;
import org.sufficientlysecure.keychain.service.UploadKeyringParcel;
import org.sufficientlysecure.keychain.ui.base.BaseActivity;
import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.util.Log;
import org.sufficientlysecure.keychain.util.Preferences;
@ -52,7 +52,7 @@ public class UploadKeyActivity extends BaseActivity
private Uri mDataUri;
// CryptoOperationHelper.Callback vars
private ParcelableHkpKeyserver mKeyserver;
private HkpKeyserverAddress mKeyserver;
private CryptoOperationHelper<UploadKeyringParcel, UploadResult> mUploadOpHelper;
@Override
@ -94,11 +94,11 @@ public class UploadKeyActivity extends BaseActivity
}
private String[] getKeyserversArray() {
ArrayList<ParcelableHkpKeyserver> keyservers = Preferences.getPreferences(this)
ArrayList<HkpKeyserverAddress> keyservers = Preferences.getPreferences(this)
.getKeyServers();
String[] keyserversArray = new String[keyservers.size()];
int i = 0;
for (ParcelableHkpKeyserver k : keyservers) {
for (HkpKeyserverAddress k : keyservers) {
keyserversArray[i] = k.getUrl();
i++;
}
@ -121,7 +121,7 @@ public class UploadKeyActivity extends BaseActivity
private void uploadKey() {
String keyserverUrl = (String) mKeyServerSpinner.getSelectedItem();
// TODO: Currently, not using onion addresses here!
mKeyserver = new ParcelableHkpKeyserver(keyserverUrl);
mKeyserver = HkpKeyserverAddress.createFromUri(keyserverUrl);
mUploadOpHelper = new CryptoOperationHelper<>(1, this, this, R.string.progress_uploading);
mUploadOpHelper.cryptoOperation();

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/adapter/ImportKeysAdapter.java
View file

@ -35,8 +35,8 @@ import android.view.ViewGroup;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.databinding.ImportKeysListItemBinding;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.keyimport.processing.ImportKeysListener;
import org.sufficientlysecure.keychain.keyimport.processing.ImportKeysOperationCallback;
@ -243,7 +243,7 @@ public class ImportKeysAdapter extends RecyclerView.Adapter<ImportKeysAdapter.Vi
ArrayList<ParcelableKeyRing> keysList = new ArrayList<>();
keysList.add(keyRing);
ParcelableHkpKeyserver keyserver = entry.getKeyserver();
HkpKeyserverAddress keyserver = entry.getKeyserver();
if (skipSave) {
return ImportKeyringParcel.createWithSkipSave(keysList, keyserver);

21
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/AddEditKeyserverDialogFragment.java
View file

@ -53,7 +53,7 @@ import okhttp3.OkHttpClient;
import okhttp3.Request;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.network.OkHttpClientFactory;
import org.sufficientlysecure.keychain.network.TlsCertificatePinning;
import org.sufficientlysecure.keychain.network.orbot.OrbotHelper;
@ -100,7 +100,7 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
public static AddEditKeyserverDialogFragment newInstance(Messenger messenger,
DialogAction action,
ParcelableHkpKeyserver keyserver,
HkpKeyserverAddress keyserver,
int position) {
AddEditKeyserverDialogFragment frag = new AddEditKeyserverDialogFragment();
Bundle args = new Bundle();
@ -149,7 +149,7 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
}
case EDIT: {
alert.setTitle(R.string.edit_keyserver_dialog_title);
ParcelableHkpKeyserver keyserver = getArguments().getParcelable(ARG_KEYSERVER);
HkpKeyserverAddress keyserver = getArguments().getParcelable(ARG_KEYSERVER);
mKeyserverEditText.setText(keyserver.getUrl());
mKeyserverEditOnionText.setText(keyserver.getOnion());
break;
@ -235,7 +235,8 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
String keyserverUrl = mKeyserverEditText.getText().toString();
String keyserverOnion = mKeyserverEditOnionText.getText() == null ? null
: mKeyserverEditOnionText.getText().toString();
final ParcelableHkpKeyserver keyserver = new ParcelableHkpKeyserver(keyserverUrl, keyserverOnion);
final HkpKeyserverAddress keyserver =
HkpKeyserverAddress.createWithOnionProxy(keyserverUrl, keyserverOnion);
if (mVerifyKeyserverCheckBox.isChecked()) {
final ParcelableProxy proxy = Preferences.getPreferences(getActivity())
.getParcelableProxy();
@ -281,7 +282,7 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
}
}
public void keyserverEdited(ParcelableHkpKeyserver keyserver, boolean verified) {
public void keyserverEdited(HkpKeyserverAddress keyserver, boolean verified) {
dismiss();
Bundle data = new Bundle();
data.putSerializable(MESSAGE_DIALOG_ACTION, mDialogAction);
@ -326,11 +327,11 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
}
public void verifyConnection(ParcelableHkpKeyserver keyserver, final ParcelableProxy proxy, final boolean onlyTrustedKeyserver) {
public void verifyConnection(HkpKeyserverAddress keyserver, final ParcelableProxy proxy, final boolean onlyTrustedKeyserver) {
new AsyncTask<ParcelableHkpKeyserver, Void, VerifyReturn>() {
new AsyncTask<HkpKeyserverAddress, Void, VerifyReturn>() {
ProgressDialog mProgressDialog;
ParcelableHkpKeyserver mKeyserver;
HkpKeyserverAddress mKeyserver;
@Override
protected void onPreExecute() {
@ -341,7 +342,7 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
}
@Override
protected VerifyReturn doInBackground(ParcelableHkpKeyserver... keyservers) {
protected VerifyReturn doInBackground(HkpKeyserverAddress... keyservers) {
mKeyserver = keyservers[0];
return verifyKeyserver(mKeyserver, proxy, onlyTrustedKeyserver);
@ -359,7 +360,7 @@ public class AddEditKeyserverDialogFragment extends DialogFragment implements On
}.execute(keyserver);
}
private VerifyReturn verifyKeyserver(ParcelableHkpKeyserver keyserver, final ParcelableProxy proxy, final boolean onlyTrustedKeyserver) {
private VerifyReturn verifyKeyserver(HkpKeyserverAddress keyserver, final ParcelableProxy proxy, final boolean onlyTrustedKeyserver) {
VerifyReturn reason = VerifyReturn.GOOD;
try {
URI keyserverUriHttp = keyserver.getUrlURI();

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/keyview/ViewKeyActivity.java
View file

@ -69,7 +69,7 @@ import android.widget.Toast;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.operations.results.EditKeyResult;
import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
@ -144,7 +144,7 @@ public class ViewKeyActivity extends BaseSecurityTokenActivity implements
protected Uri mDataUri;
// For CryptoOperationHelper.Callback
private ParcelableHkpKeyserver mKeyserver;
private HkpKeyserverAddress mKeyserver;
private ArrayList<ParcelableKeyRing> mKeyList;
private CryptoOperationHelper<ImportKeyringParcel, ImportKeyResult> mImportOpHelper;
private CryptoOperationHelper<ChangeUnlockParcel, EditKeyResult> mEditOpHelper;

66
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/EmailKeyHelper.java
View file

@ -17,22 +17,30 @@
package org.sufficientlysecure.keychain.util;
import android.content.Context;
import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
import org.sufficientlysecure.keychain.keyimport.Keyserver;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
import org.sufficientlysecure.keychain.service.ImportKeyringParcel;
import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import android.content.Context;
import de.measite.minidns.Client;
import de.measite.minidns.Question;
import de.measite.minidns.Record;
import de.measite.minidns.record.SRV;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverClient;
import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
import org.sufficientlysecure.keychain.keyimport.KeyserverClient;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
import org.sufficientlysecure.keychain.service.ImportKeyringParcel;
import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
public class EmailKeyHelper {
// TODO: Make this not require a proxy in it's constructor, redesign when it is to be used
// to import keys, simply use CryptoOperationHelper with this callback
@ -40,15 +48,15 @@ public class EmailKeyHelper {
implements CryptoOperationHelper.Callback<ImportKeyringParcel, ImportKeyResult> {
private ArrayList<ParcelableKeyRing> mKeyList;
private ParcelableHkpKeyserver mKeyserver;
private HkpKeyserverAddress mKeyserver;
public ImportContactKeysCallback(Context context, ParcelableHkpKeyserver keyserver,
public ImportContactKeysCallback(Context context, HkpKeyserverAddress keyserver,
ParcelableProxy proxy) {
this(context, new ContactHelper(context).getContactMails(), keyserver, proxy);
}
public ImportContactKeysCallback(Context context, List<String> mails,
ParcelableHkpKeyserver keyserver, ParcelableProxy proxy) {
HkpKeyserverAddress keyserver, ParcelableProxy proxy) {
Set<ImportKeysListEntry> entries = new HashSet<>();
for (String mail : mails) {
entries.addAll(getEmailKeys(context, mail, proxy));
@ -76,7 +84,7 @@ public class EmailKeyHelper {
// Try _hkp._tcp SRV record first
String[] mailparts = mail.split("@");
if (mailparts.length == 2) {
ParcelableHkpKeyserver hkp = ParcelableHkpKeyserver.resolve(mailparts[1]);
HkpKeyserverAddress hkp = findKeyserverFromDns(mailparts[1]);
if (hkp != null) {
keys.addAll(getEmailKeys(mail, hkp, proxy));
}
@ -84,7 +92,7 @@ public class EmailKeyHelper {
if (keys.isEmpty()) {
// Most users don't have the SRV record, so ask a default server as well
ParcelableHkpKeyserver server = Preferences.getPreferences(context).getPreferredKeyserver();
HkpKeyserverAddress server = Preferences.getPreferences(context).getPreferredKeyserver();
if (server != null) {
keys.addAll(getEmailKeys(mail, server, proxy));
}
@ -92,11 +100,12 @@ public class EmailKeyHelper {
return keys;
}
public static List<ImportKeysListEntry> getEmailKeys(String mail, Keyserver keyServer,
public static List<ImportKeysListEntry> getEmailKeys(String mail, HkpKeyserverAddress keyServer,
ParcelableProxy proxy) {
Set<ImportKeysListEntry> keys = new HashSet<>();
try {
for (ImportKeysListEntry key : keyServer.search(mail, proxy)) {
for (ImportKeysListEntry key : HkpKeyserverClient
.fromHkpKeyserverAddress(keyServer).search(mail, proxy)) {
if (key.isRevokedOrExpiredOrInsecure()) continue;
for (String userId : key.getUserIds()) {
if (userId.toLowerCase().contains(mail.toLowerCase(Locale.ENGLISH))) {
@ -104,8 +113,31 @@ public class EmailKeyHelper {
}
}
}
} catch (Keyserver.CloudSearchFailureException ignored) {
} catch (KeyserverClient.CloudSearchFailureException ignored) {
}
return new ArrayList<>(keys);
}
public static HkpKeyserverAddress findKeyserverFromDns(String domain) {
try {
Record[] records = new Client().query(new Question("_hkp._tcp." + domain, Record.TYPE.SRV)).getAnswers();
if (records.length > 0) {
Arrays.sort(records, new Comparator<Record>() {
@Override
public int compare(Record lhs, Record rhs) {
if (lhs.getPayload().getType() != Record.TYPE.SRV) return 1;
if (rhs.getPayload().getType() != Record.TYPE.SRV) return -1;
return ((SRV) lhs.getPayload()).getPriority() - ((SRV) rhs.getPayload()).getPriority();
}
});
Record record = records[0]; // This is our best choice
if (record.getPayload().getType() == Record.TYPE.SRV) {
SRV payload = (SRV) record.getPayload();
return HkpKeyserverAddress.createFromUri(payload.getName() + ":" + payload.getPort());
}
}
} catch (Exception ignored) {
}
return null;
}
}

40
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/Preferences.java
View file

@ -32,7 +32,7 @@ import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.Constants.Pref;
import org.sufficientlysecure.keychain.KeychainApplication;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.keyimport.ParcelableHkpKeyserver;
import org.sufficientlysecure.keychain.keyimport.HkpKeyserverAddress;
import org.sufficientlysecure.keychain.service.KeyserverSyncAdapterService;
import java.io.Serializable;
@ -128,13 +128,13 @@ public class Preferences {
editor.commit();
}
public ArrayList<ParcelableHkpKeyserver> getKeyServers() {
public ArrayList<HkpKeyserverAddress> getKeyServers() {
String rawData = mSharedPreferences.getString(Constants.Pref.KEY_SERVERS,
Constants.Defaults.KEY_SERVERS);
if ("".equals(rawData)) {
return new ArrayList<>();
}
ArrayList<ParcelableHkpKeyserver> servers = new ArrayList<>();
ArrayList<HkpKeyserverAddress> servers = new ArrayList<>();
String[] entries = rawData.split(",");
for (String entry : entries) {
String[] addresses = entry.trim().split(";");
@ -145,20 +145,20 @@ public class Preferences {
continue;
}
servers.add(new ParcelableHkpKeyserver(url, onion));
servers.add(HkpKeyserverAddress.createWithOnionProxy(url, onion));
}
return servers;
}
public ParcelableHkpKeyserver getPreferredKeyserver() {
ArrayList<ParcelableHkpKeyserver> keyservers = getKeyServers();
public HkpKeyserverAddress getPreferredKeyserver() {
ArrayList<HkpKeyserverAddress> keyservers = getKeyServers();
return keyservers.size() == 0 ? null : keyservers.get(0);
}
public void setKeyServers(ArrayList<ParcelableHkpKeyserver> keyservers) {
public void setKeyServers(ArrayList<HkpKeyserverAddress> keyservers) {
SharedPreferences.Editor editor = mSharedPreferences.edit();
String rawData = "";
for (ParcelableHkpKeyserver server : keyservers) {
for (HkpKeyserverAddress server : keyservers) {
if (server.getUrl().isEmpty()) {
continue;
}
@ -381,7 +381,7 @@ public class Preferences {
public final boolean searchKeyserver;
public final boolean searchKeybase;
public final boolean searchFacebook;
public final ParcelableHkpKeyserver keyserver;
public final HkpKeyserverAddress keyserver;
/**
* @param searchKeyserver should passed keyserver be searched
@ -389,7 +389,7 @@ public class Preferences {
* @param keyserver the keyserver url authority to search on
*/
public CloudSearchPrefs(boolean searchKeyserver, boolean searchKeybase,
boolean searchFacebook, ParcelableHkpKeyserver keyserver) {
boolean searchFacebook, HkpKeyserverAddress keyserver) {
this.searchKeyserver = searchKeyserver;
this.searchKeybase = searchKeybase;
this.searchFacebook = searchFacebook;
@ -400,7 +400,7 @@ public class Preferences {
searchKeyserver = in.readByte() != 0x00;
searchKeybase = in.readByte() != 0x00;
searchFacebook = in.readByte() != 0x00;
keyserver = in.readParcelable(ParcelableHkpKeyserver.class.getClassLoader());
keyserver = in.readParcelable(HkpKeyserverAddress.class.getClassLoader());
}
@Override
@ -467,22 +467,22 @@ public class Preferences {
// fall through
case 3: {
// migrate keyserver to hkps
ArrayList<ParcelableHkpKeyserver> servers = getKeyServers();
ListIterator<ParcelableHkpKeyserver> it = servers.listIterator();
ArrayList<HkpKeyserverAddress> servers = getKeyServers();
ListIterator<HkpKeyserverAddress> it = servers.listIterator();
while (it.hasNext()) {
ParcelableHkpKeyserver server = it.next();
HkpKeyserverAddress server = it.next();
if (server == null) {
continue;
}
switch (server.getUrl()) {
case "pool.sks-keyservers.net": {
// use HKPS!
it.set(new ParcelableHkpKeyserver("hkps://hkps.pool.sks-keyservers.net", null));
it.set(HkpKeyserverAddress.createFromUri("hkps://hkps.pool.sks-keyservers.net"));
break;
}
case "pgp.mit.edu": {
// use HKPS!
it.set(new ParcelableHkpKeyserver("hkps://pgp.mit.edu", null));
it.set(HkpKeyserverAddress.createFromUri("hkps://pgp.mit.edu"));
break;
}
case "subkeys.pgp.net": {
@ -509,15 +509,15 @@ public class Preferences {
// fall through
case 7: {
// add onion address to sks-keyservers.net
ArrayList<ParcelableHkpKeyserver> servers = getKeyServers();
ListIterator<ParcelableHkpKeyserver> it = servers.listIterator();
ArrayList<HkpKeyserverAddress> servers = getKeyServers();
ListIterator<HkpKeyserverAddress> it = servers.listIterator();
while (it.hasNext()) {
ParcelableHkpKeyserver server = it.next();
HkpKeyserverAddress server = it.next();
if (server == null) {
continue;
}
if ("hkps://hkps.pool.sks-keyservers.net".equals(server.getUrl())) {
it.set(new ParcelableHkpKeyserver(
it.set(HkpKeyserverAddress.createWithOnionProxy(
"hkps://hkps.pool.sks-keyservers.net",
"hkp://jirk5u4osbsr34t5.onion"));
}