Move logic classes for import into own sub-package

4 files changed, 835 insertions, 0 deletions

diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/HkpKeyServer.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/HkpKeyServer.java
new file mode 100644
index 000000000..85ce6bfcc
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/HkpKeyServer.java
@@ -0,0 +1,338 @@
+/*
+ * 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.
+ * 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.sufficientlysecure.keychain.keyimport;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpStatus;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.impl.client.DefaultHttpClient;
+import org.apache.http.message.BasicNameValuePair;
+import org.apache.http.util.EntityUtils;
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.pgp.PgpHelper;
+import org.sufficientlysecure.keychain.pgp.PgpKeyHelper;
+import org.sufficientlysecure.keychain.util.Log;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.HttpURLConnection;
+import java.net.InetAddress;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.GregorianCalendar;
+import java.util.List;
+import java.util.Locale;
+import java.util.TimeZone;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class HkpKeyServer extends KeyServer {
+    private static class HttpError extends Exception {
+        private static final long serialVersionUID = 1718783705229428893L;
+        private int mCode;
+        private String mData;
+
+        public HttpError(int code, String data) {
+            super("" + code + ": " + data);
+            mCode = code;
+            mData = data;
+        }
+
+        public int getCode() {
+            return mCode;
+        }
+
+        public String getData() {
+            return mData;
+        }
+    }
+
+    private String mHost;
+    private short mPort;
+
+    /**
+     * pub:%keyid%:%algo%:%keylen%:%creationdate%:%expirationdate%:%flags%
+     * <ul>
+     * <li>%<b>keyid</b>% = this is either the fingerprint or the key ID of the key.
+     * Either the 16-digit or 8-digit key IDs are acceptable, but obviously the fingerprint is best.
+     * </li>
+     * <li>%<b>algo</b>% = the algorithm number, (i.e. 1==RSA, 17==DSA, etc).
+     * See <a href="http://tools.ietf.org/html/rfc2440#section-9.1">RFC-2440</a></li>
+     * <li>%<b>keylen</b>% = the key length (i.e. 1024, 2048, 4096, etc.)</li>
+     * <li>%<b>creationdate</b>% = creation date of the key in standard
+     * <a href="http://tools.ietf.org/html/rfc2440#section-9.1">RFC-2440</a> form (i.e. number of
+     * seconds since 1/1/1970 UTC time)</li>
+     * <li>%<b>expirationdate</b>% = expiration date of the key in standard
+     * <a href="http://tools.ietf.org/html/rfc2440#section-9.1">RFC-2440</a> form (i.e. number of
+     * seconds since 1/1/1970 UTC time)</li>
+     * <li>%<b>flags</b>% = letter codes to indicate details of the key, if any. Flags may be in any
+     * order. The meaning of "disabled" is implementation-specific. Note that individual flags may
+     * be unimplemented, so the absence of a given flag does not necessarily mean the absence of the
+     * detail.
+     * <ul>
+     * <li>r == revoked</li>
+     * <li>d == disabled</li>
+     * <li>e == expired</li>
+     * </ul>
+     * </li>
+     * </ul>
+     *
+     * @see <a href="http://tools.ietf.org/html/draft-shaw-openpgp-hkp-00#section-5.2">
+     * 5.2. Machine Readable Indexes</a>
+     * in Internet-Draft OpenPGP HTTP Keyserver Protocol Document
+     */
+    public static final Pattern PUB_KEY_LINE = Pattern
+            .compile("pub:([0-9a-fA-F]+):([0-9]+):([0-9]+):([0-9]+):([0-9]*):([rde]*)[ \n\r]*" // pub line
+                    + "(uid:(.*):([0-9]+):([0-9]*):([rde]*))+", // one or more uid lines
+                    Pattern.CASE_INSENSITIVE);
+
+    /**
+     * uid:%escaped uid string%:%creationdate%:%expirationdate%:%flags%
+     * <ul>
+     * <li>%<b>escaped uid string</b>% = the user ID string, with HTTP %-escaping for anything that
+     * isn't 7-bit safe as well as for the ":" character.  Any other characters may be escaped, as
+     * desired.</li>
+     * <li>%<b>creationdate</b>% = creation date of the key in standard
+     * <a href="http://tools.ietf.org/html/rfc2440#section-9.1">RFC-2440</a> form (i.e. number of
+     * seconds since 1/1/1970 UTC time)</li>
+     * <li>%<b>expirationdate</b>% = expiration date of the key in standard
+     * <a href="http://tools.ietf.org/html/rfc2440#section-9.1">RFC-2440</a> form (i.e. number of
+     * seconds since 1/1/1970 UTC time)</li>
+     * <li>%<b>flags</b>% = letter codes to indicate details of the key, if any. Flags may be in any
+     * order. The meaning of "disabled" is implementation-specific. Note that individual flags may
+     * be unimplemented, so the absence of a given flag does not necessarily mean the absence of
+     * the detail.
+     * <ul>
+     * <li>r == revoked</li>
+     * <li>d == disabled</li>
+     * <li>e == expired</li>
+     * </ul>
+     * </li>
+     * </ul>
+     */
+    public static final Pattern UID_LINE = Pattern
+            .compile("uid:(.*):([0-9]+):([0-9]*):([rde]*)",
+                    Pattern.CASE_INSENSITIVE);
+
+    private static final short PORT_DEFAULT = 11371;
+
+    /**
+     * @param hostAndPort may be just
+     *                    "<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>").
+     */
+    public HkpKeyServer(String hostAndPort) {
+        String host = hostAndPort;
+        short port = PORT_DEFAULT;
+        final int colonPosition = hostAndPort.lastIndexOf(':');
+        if (colonPosition > 0) {
+            host = hostAndPort.substring(0, colonPosition);
+            final String portStr = hostAndPort.substring(colonPosition + 1);
+            port = Short.decode(portStr);
+        }
+        mHost = host;
+        mPort = port;
+    }
+
+    public HkpKeyServer(String host, short port) {
+        mHost = host;
+        mPort = port;
+    }
+
+    private String query(String request) throws QueryException, HttpError {
+        InetAddress ips[];
+        try {
+            ips = InetAddress.getAllByName(mHost);
+        } catch (UnknownHostException e) {
+            throw new QueryException(e.toString());
+        }
+        for (int i = 0; i < ips.length; ++i) {
+            try {
+                String url = "http://" + ips[i].getHostAddress() + ":" + mPort + request;
+                Log.d(Constants.TAG, "hkp keyserver query: " + url);
+                URL realUrl = new URL(url);
+                HttpURLConnection conn = (HttpURLConnection) realUrl.openConnection();
+                conn.setConnectTimeout(5000);
+                conn.setReadTimeout(25000);
+                conn.connect();
+                int response = conn.getResponseCode();
+                if (response >= 200 && response < 300) {
+                    return readAll(conn.getInputStream(), conn.getContentEncoding());
+                } else {
+                    String data = readAll(conn.getErrorStream(), conn.getContentEncoding());
+                    throw new HttpError(response, data);
+                }
+            } catch (MalformedURLException e) {
+                // nothing to do, try next IP
+            } catch (IOException e) {
+                // nothing to do, try next IP
+            }
+        }
+
+        throw new QueryException("querying server(s) for '" + mHost + "' failed");
+    }
+
+    @Override
+    public ArrayList<ImportKeysListEntry> search(String query) throws QueryException, TooManyResponses,
+            InsufficientQuery {
+        ArrayList<ImportKeysListEntry> results = new ArrayList<ImportKeysListEntry>();
+
+        if (query.length() < 3) {
+            throw new InsufficientQuery();
+        }
+
+        String encodedQuery;
+        try {
+            encodedQuery = URLEncoder.encode(query, "utf8");
+        } catch (UnsupportedEncodingException e) {
+            return null;
+        }
+        String request = "/pks/lookup?op=index&options=mr&search=" + encodedQuery;
+
+        String data;
+        try {
+            data = query(request);
+        } catch (HttpError e) {
+            if (e.getCode() == 404) {
+                return results;
+            } else {
+                if (e.getData().toLowerCase(Locale.US).contains("no keys found")) {
+                    return results;
+                } else if (e.getData().toLowerCase(Locale.US).contains("too many")) {
+                    throw new TooManyResponses();
+                } else if (e.getData().toLowerCase(Locale.US).contains("insufficient")) {
+                    throw new InsufficientQuery();
+                }
+            }
+            throw new QueryException("querying server(s) for '" + mHost + "' failed");
+        }
+
+        final Matcher matcher = PUB_KEY_LINE.matcher(data);
+        while (matcher.find()) {
+            final ImportKeysListEntry entry = new ImportKeysListEntry();
+
+            entry.setBitStrength(Integer.parseInt(matcher.group(3)));
+
+            final int algorithmId = Integer.decode(matcher.group(2));
+            entry.setAlgorithm(PgpKeyHelper.getAlgorithmInfo(algorithmId));
+
+            // group 1 contains the full fingerprint (v4) or the long key id if available
+            // see http://bit.ly/1d4bxbk and http://bit.ly/1gD1wwr
+            String fingerprintOrKeyId = matcher.group(1);
+            if (fingerprintOrKeyId.length() > 16) {
+                entry.setFingerPrintHex(fingerprintOrKeyId.toLowerCase(Locale.US));
+                entry.setKeyIdHex("0x" + fingerprintOrKeyId.substring(fingerprintOrKeyId.length()
+                        - 16, fingerprintOrKeyId.length()));
+            } else {
+                // set key id only
+                entry.setKeyIdHex("0x" + fingerprintOrKeyId);
+            }
+
+            final long creationDate = Long.parseLong(matcher.group(4));
+            final GregorianCalendar tmpGreg = new GregorianCalendar(TimeZone.getTimeZone("UTC"));
+            tmpGreg.setTimeInMillis(creationDate * 1000);
+            entry.setDate(tmpGreg.getTime());
+
+            entry.setRevoked(matcher.group(6).contains("r"));
+
+            ArrayList<String> userIds = new ArrayList<String>();
+            final String uidLines = matcher.group(7);
+            final Matcher uidMatcher = UID_LINE.matcher(uidLines);
+            while (uidMatcher.find()) {
+                String tmp = uidMatcher.group(1).trim();
+                if (tmp.contains("%")) {
+                    try {
+                        // converts Strings like "Universit%C3%A4t" to a proper encoding form "Universität".
+                        tmp = (URLDecoder.decode(tmp, "UTF8"));
+                    } catch (UnsupportedEncodingException ignored) {
+                        // will never happen, because "UTF8" is supported
+                    }
+                }
+                userIds.add(tmp);
+            }
+            entry.setUserIds(userIds);
+            entry.setPrimaryUserId(userIds.get(0));
+
+            results.add(entry);
+        }
+        return results;
+    }
+
+    @Override
+    public String get(String keyIdHex) throws QueryException {
+        HttpClient client = new DefaultHttpClient();
+        try {
+            String query = "http://" + mHost + ":" + mPort +
+                    "/pks/lookup?op=get&options=mr&search=" + keyIdHex;
+            Log.d(Constants.TAG, "hkp keyserver get: " + query);
+            HttpGet get = new HttpGet(query);
+            HttpResponse response = client.execute(get);
+            if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
+                throw new QueryException("not found");
+            }
+
+            HttpEntity entity = response.getEntity();
+            InputStream is = entity.getContent();
+            String data = readAll(is, EntityUtils.getContentCharSet(entity));
+            Matcher matcher = PgpHelper.PGP_PUBLIC_KEY.matcher(data);
+            if (matcher.find()) {
+                return matcher.group(1);
+            }
+        } catch (IOException e) {
+            // nothing to do, better luck on the next keyserver
+        } finally {
+            client.getConnectionManager().shutdown();
+        }
+
+        return null;
+    }
+
+    @Override
+    public void add(String armoredKey) throws AddKeyException {
+        HttpClient client = new DefaultHttpClient();
+        try {
+            String query = "http://" + mHost + ":" + mPort + "/pks/add";
+            HttpPost post = new HttpPost(query);
+            Log.d(Constants.TAG, "hkp keyserver add: " + query);
+            List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(2);
+            nameValuePairs.add(new BasicNameValuePair("keytext", armoredKey));
+            post.setEntity(new UrlEncodedFormEntity(nameValuePairs));
+
+            HttpResponse response = client.execute(post);
+            if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
+                throw new AddKeyException();
+            }
+        } catch (IOException e) {
+            // nothing to do, better luck on the next keyserver
+        } finally {
+            client.getConnectionManager().shutdown();
+        }
+    }
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/ImportKeysListEntry.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/ImportKeysListEntry.java
new file mode 100644
index 000000000..1199290e0
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/ImportKeysListEntry.java
@@ -0,0 +1,268 @@
+/*
+ * Copyright (C) 2013 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * 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 android.content.Context;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import org.spongycastle.bcpg.SignatureSubpacketTags;
+import org.spongycastle.openpgp.PGPKeyRing;
+import org.spongycastle.openpgp.PGPPublicKey;
+import org.spongycastle.openpgp.PGPSecretKeyRing;
+import org.spongycastle.openpgp.PGPSignature;
+import org.spongycastle.openpgp.operator.jcajce.JcaPGPContentVerifierBuilderProvider;
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.pgp.PgpKeyHelper;
+import org.sufficientlysecure.keychain.util.IterableIterator;
+import org.sufficientlysecure.keychain.util.Log;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Date;
+
+public class ImportKeysListEntry implements Serializable, Parcelable {
+    private static final long serialVersionUID = -7797972103284992662L;
+
+    public ArrayList<String> userIds;
+    public long keyId;
+    public String keyIdHex;
+    public boolean revoked;
+    public Date date; // TODO: not displayed
+    public String fingerPrintHex;
+    public int bitStrength;
+    public String algorithm;
+    public boolean secretKey;
+    public String mPrimaryUserId;
+
+    private boolean mSelected;
+
+    private byte[] mBytes = new byte[]{};
+
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeString(mPrimaryUserId);
+        dest.writeStringList(userIds);
+        dest.writeLong(keyId);
+        dest.writeByte((byte) (revoked ? 1 : 0));
+        dest.writeSerializable(date);
+        dest.writeString(fingerPrintHex);
+        dest.writeString(keyIdHex);
+        dest.writeInt(bitStrength);
+        dest.writeString(algorithm);
+        dest.writeByte((byte) (secretKey ? 1 : 0));
+        dest.writeByte((byte) (mSelected ? 1 : 0));
+        dest.writeInt(mBytes.length);
+        dest.writeByteArray(mBytes);
+    }
+
+    public static final Creator<ImportKeysListEntry> CREATOR = new Creator<ImportKeysListEntry>() {
+        public ImportKeysListEntry createFromParcel(final Parcel source) {
+            ImportKeysListEntry vr = new ImportKeysListEntry();
+            vr.mPrimaryUserId = source.readString();
+            vr.userIds = new ArrayList<String>();
+            source.readStringList(vr.userIds);
+            vr.keyId = source.readLong();
+            vr.revoked = source.readByte() == 1;
+            vr.date = (Date) source.readSerializable();
+            vr.fingerPrintHex = source.readString();
+            vr.keyIdHex = source.readString();
+            vr.bitStrength = source.readInt();
+            vr.algorithm = source.readString();
+            vr.secretKey = source.readByte() == 1;
+            vr.mSelected = source.readByte() == 1;
+            vr.mBytes = new byte[source.readInt()];
+            source.readByteArray(vr.mBytes);
+
+            return vr;
+        }
+
+        public ImportKeysListEntry[] newArray(final int size) {
+            return new ImportKeysListEntry[size];
+        }
+    };
+
+    public String getKeyIdHex() {
+        return keyIdHex;
+    }
+
+    public byte[] getBytes() {
+        return mBytes;
+    }
+
+    public void setBytes(byte[] bytes) {
+        this.mBytes = bytes;
+    }
+
+    public boolean isSelected() {
+        return mSelected;
+    }
+
+    public void setSelected(boolean selected) {
+        this.mSelected = selected;
+    }
+
+    public long getKeyId() {
+        return keyId;
+    }
+
+    public void setKeyId(long keyId) {
+        this.keyId = keyId;
+    }
+
+    public void setKeyIdHex(String keyIdHex) {
+        this.keyIdHex = keyIdHex;
+    }
+
+    public boolean isRevoked() {
+        return revoked;
+    }
+
+    public void setRevoked(boolean revoked) {
+        this.revoked = revoked;
+    }
+
+    public Date getDate() {
+        return date;
+    }
+
+    public void setDate(Date date) {
+        this.date = date;
+    }
+
+    public String getFingerPrintHex() {
+        return fingerPrintHex;
+    }
+
+    public void setFingerPrintHex(String fingerPrintHex) {
+        this.fingerPrintHex = fingerPrintHex;
+    }
+
+    public int getBitStrength() {
+        return bitStrength;
+    }
+
+    public void setBitStrength(int bitStrength) {
+        this.bitStrength = bitStrength;
+    }
+
+    public String getAlgorithm() {
+        return algorithm;
+    }
+
+    public void setAlgorithm(String algorithm) {
+        this.algorithm = algorithm;
+    }
+
+    public boolean isSecretKey() {
+        return secretKey;
+    }
+
+    public void setSecretKey(boolean secretKey) {
+        this.secretKey = secretKey;
+    }
+
+    public ArrayList<String> getUserIds() {
+        return userIds;
+    }
+
+    public void setUserIds(ArrayList<String> userIds) {
+        this.userIds = userIds;
+    }
+
+    public String getPrimaryUserId() {
+        return mPrimaryUserId;
+    }
+
+    public void setPrimaryUserId(String uid) {
+        mPrimaryUserId = uid;
+    }
+
+    /**
+     * Constructor for later querying from keyserver
+     */
+    public ImportKeysListEntry() {
+        // keys from keyserver are always public keys; from keybase too
+        secretKey = false;
+        // do not select by default
+        mSelected = false;
+        userIds = new ArrayList<String>();
+    }
+
+    /**
+     * Constructor based on key object, used for import from NFC, QR Codes, files
+     */
+    @SuppressWarnings("unchecked")
+    public ImportKeysListEntry(Context context, PGPKeyRing pgpKeyRing) {
+        // save actual key object into entry, used to import it later
+        try {
+            this.mBytes = pgpKeyRing.getEncoded();
+        } catch (IOException e) {
+            Log.e(Constants.TAG, "IOException on pgpKeyRing.getEncoded()", e);
+        }
+
+        // selected is default
+        this.mSelected = true;
+
+        if (pgpKeyRing instanceof PGPSecretKeyRing) {
+            secretKey = true;
+        } else {
+            secretKey = false;
+        }
+        PGPPublicKey key = pgpKeyRing.getPublicKey();
+
+        userIds = new ArrayList<String>();
+        for (String userId : new IterableIterator<String>(key.getUserIDs())) {
+            userIds.add(userId);
+            for (PGPSignature sig : new IterableIterator<PGPSignature>(key.getSignaturesForID(userId))) {
+                if (sig.getHashedSubPackets() != null
+                        && sig.getHashedSubPackets().hasSubpacket(SignatureSubpacketTags.PRIMARY_USER_ID)) {
+                    try {
+                        // make sure it's actually valid
+                        sig.init(new JcaPGPContentVerifierBuilderProvider().setProvider(
+                                Constants.BOUNCY_CASTLE_PROVIDER_NAME), key);
+                        if (sig.verifyCertification(userId, key)) {
+                            mPrimaryUserId = userId;
+                        }
+                    } catch (Exception e) {
+                        // nothing bad happens, the key is just not considered the primary key id
+                    }
+                }
+
+            }
+        }
+        // if there was no user id flagged as primary, use the first one
+        if (mPrimaryUserId == null) {
+            mPrimaryUserId = userIds.get(0);
+        }
+
+        this.keyId = key.getKeyID();
+        this.keyIdHex = PgpKeyHelper.convertKeyIdToHex(keyId);
+
+        this.revoked = key.isRevoked();
+        this.fingerPrintHex = PgpKeyHelper.convertFingerprintToHex(key.getFingerprint());
+        this.bitStrength = key.getBitStrength();
+        final int algorithm = key.getAlgorithm();
+        this.algorithm = PgpKeyHelper.getAlgorithmInfo(context, algorithm);
+    }
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeyServer.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeyServer.java
new file mode 100644
index 000000000..d6ebca5a6
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeyServer.java
@@ -0,0 +1,68 @@
+/*
+ * 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.
+ * 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.sufficientlysecure.keychain.keyimport;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+public abstract class KeyServer {
+    public static class QueryException extends Exception {
+        private static final long serialVersionUID = 2703768928624654512L;
+
+        public QueryException(String message) {
+            super(message);
+        }
+    }
+
+    public static class TooManyResponses extends Exception {
+        private static final long serialVersionUID = 2703768928624654513L;
+    }
+
+    public static class InsufficientQuery extends Exception {
+        private static final long serialVersionUID = 2703768928624654514L;
+    }
+
+    public static class AddKeyException extends Exception {
+        private static final long serialVersionUID = -507574859137295530L;
+    }
+
+    abstract List<ImportKeysListEntry> search(String query) throws QueryException, TooManyResponses,
+            InsufficientQuery;
+
+    abstract String get(String keyIdHex) throws QueryException;
+
+    abstract void add(String armoredKey) 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);
+    }
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeybaseKeyServer.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeybaseKeyServer.java
new file mode 100644
index 000000000..7ffe123c0
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeybaseKeyServer.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2014 Tim Bray <tbray@textuality.com>
+ *
+ * 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 org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.util.JWalk;
+import org.sufficientlysecure.keychain.util.Log;
+
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.GregorianCalendar;
+import java.util.TimeZone;
+import java.util.WeakHashMap;
+
+public class KeybaseKeyServer extends KeyServer {
+
+    private WeakHashMap<String, String> mKeyCache = new WeakHashMap<String, String>();
+
+    @Override
+    public ArrayList<ImportKeysListEntry> search(String query) throws QueryException, TooManyResponses,
+            InsufficientQuery {
+        ArrayList<ImportKeysListEntry> results = new ArrayList<ImportKeysListEntry>();
+
+        JSONObject fromQuery = getFromKeybase("_/api/1.0/user/autocomplete.json?q=", query);
+        try {
+
+            JSONArray matches = JWalk.getArray(fromQuery, "completions");
+            for (int i = 0; i < matches.length(); i++) {
+                JSONObject match = matches.getJSONObject(i);
+
+                // only list them if they have a key
+                if (JWalk.optObject(match, "components", "key_fingerprint") != null) {
+                    results.add(makeEntry(match));
+                }
+            }
+        } catch (Exception e) {
+            throw new QueryException("Unexpected structure in keybase search result: " + e.getMessage());
+        }
+
+        return results;
+    }
+
+    private JSONObject getUser(String keybaseID) throws QueryException {
+        try {
+            return getFromKeybase("_/api/1.0/user/lookup.json?username=", keybaseID);
+        } catch (Exception e) {
+            String detail = "";
+            if (keybaseID != null) {
+                detail = ". Query was for user '" + keybaseID + "'";
+            }
+            throw new QueryException(e.getMessage() + detail);
+        }
+    }
+
+    private ImportKeysListEntry makeEntry(JSONObject match) throws QueryException, JSONException {
+
+        String keybaseID = JWalk.getString(match, "components", "username", "val");
+        String key_fingerprint = JWalk.getString(match, "components", "key_fingerprint", "val");
+        key_fingerprint = key_fingerprint.replace(" ", "").toUpperCase();
+        match = getUser(keybaseID);
+
+        final ImportKeysListEntry entry = new ImportKeysListEntry();
+
+        // TODO: Fix; have suggested keybase provide this value to avoid search-time crypto calls
+        entry.setBitStrength(4096);
+        entry.setAlgorithm("RSA");
+        entry.setKeyIdHex("0x" + key_fingerprint);
+        entry.setRevoked(false);
+
+        // ctime
+        final long creationDate = JWalk.getLong(match, "them", "public_keys", "primary", "ctime");
+        final GregorianCalendar tmpGreg = new GregorianCalendar(TimeZone.getTimeZone("UTC"));
+        tmpGreg.setTimeInMillis(creationDate * 1000);
+        entry.setDate(tmpGreg.getTime());
+
+        // key bits
+        // we have to fetch the user object to construct the search-result list, so we might as
+        //  well (weakly) remember the key, in case they try to import it
+        mKeyCache.put(keybaseID, JWalk.getString(match,"them", "public_keys", "primary", "bundle"));
+
+        // String displayName = JWalk.getString(match, "them", "profile", "full_name");
+        ArrayList<String> userIds = new ArrayList<String>();
+        String name = "keybase.io/" + keybaseID + " <" + keybaseID + "@keybase.io>";
+        userIds.add(name);
+        userIds.add(keybaseID);
+        entry.setUserIds(userIds);
+        entry.setPrimaryUserId(name);
+        return entry;
+    }
+
+    private JSONObject getFromKeybase(String path, String query) throws QueryException {
+        try {
+            String url = "https://keybase.io/" + path + URLEncoder.encode(query, "utf8");
+            Log.d(Constants.TAG, "keybase query: " + url);
+
+            URL realUrl = new URL(url);
+            HttpURLConnection conn = (HttpURLConnection) realUrl.openConnection();
+            conn.setConnectTimeout(5000); // TODO: Reasonable values for keybase
+            conn.setReadTimeout(25000);
+            conn.connect();
+            int response = conn.getResponseCode();
+            if (response >= 200 && response < 300) {
+                String text = readAll(conn.getInputStream(), conn.getContentEncoding());
+                try {
+                    JSONObject json = new JSONObject(text);
+                    if (JWalk.getInt(json, "status", "code") != 0) {
+                        throw new QueryException("Keybase autocomplete search failed");
+                    }
+                    return json;
+                } catch (JSONException e) {
+                    throw new QueryException("Keybase.io query returned broken JSON");
+                }
+            } else {
+                String message = readAll(conn.getErrorStream(), conn.getContentEncoding());
+                throw new QueryException("Keybase.io query error (status=" + response +
+                        "): " + message);
+            }
+        } catch (Exception e) {
+            throw new QueryException("Keybase.io query error");
+        }
+    }
+
+    @Override
+    public String get(String id) throws QueryException {
+        String key = mKeyCache.get(id);
+        if (key == null) {
+            try {
+                JSONObject user = getUser(id);
+                key = JWalk.getString(user, "them", "public_keys", "primary", "bundle");
+            } catch (Exception e) {
+                throw new QueryException(e.getMessage());
+            }
+        }
+        return key;
+    }
+
+    @Override
+    public void add(String armoredKey) throws AddKeyException {
+        throw new AddKeyException();
+    }
+}
\ No newline at end of file