385 lines
16 KiB
Java
385 lines
16 KiB
Java
package org.sufficientlysecure.keychain.remote;
|
|
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
|
|
import android.app.PendingIntent;
|
|
import android.content.ContentResolver;
|
|
import android.content.Intent;
|
|
import android.database.Cursor;
|
|
import android.net.Uri;
|
|
import android.support.annotation.NonNull;
|
|
import android.support.annotation.VisibleForTesting;
|
|
|
|
import org.openintents.openpgp.util.OpenPgpApi;
|
|
import org.sufficientlysecure.keychain.Constants;
|
|
import org.sufficientlysecure.keychain.provider.KeychainContract.ApiAutocryptPeer;
|
|
import org.sufficientlysecure.keychain.provider.KeychainExternalContract;
|
|
import org.sufficientlysecure.keychain.provider.KeychainExternalContract.AutocryptStatus;
|
|
import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
|
|
import org.sufficientlysecure.keychain.util.Log;
|
|
|
|
|
|
class OpenPgpServiceKeyIdExtractor {
|
|
@VisibleForTesting
|
|
static final String[] PROJECTION_MAIL_STATUS = {
|
|
AutocryptStatus.ADDRESS,
|
|
AutocryptStatus.UID_MASTER_KEY_ID,
|
|
AutocryptStatus.UID_KEY_STATUS,
|
|
AutocryptStatus.UID_CANDIDATES,
|
|
AutocryptStatus.AUTOCRYPT_MASTER_KEY_ID,
|
|
AutocryptStatus.AUTOCRYPT_KEY_STATUS,
|
|
AutocryptStatus.AUTOCRYPT_PEER_STATE
|
|
};
|
|
private static final int INDEX_EMAIL_ADDRESS = 0;
|
|
private static final int INDEX_MASTER_KEY_ID = 1;
|
|
private static final int INDEX_USER_ID_STATUS = 2;
|
|
private static final int INDEX_USER_ID_CANDIDATES = 3;
|
|
private static final int INDEX_AUTOCRYPT_MASTER_KEY_ID = 4;
|
|
private static final int INDEX_AUTOCRYPT_KEY_STATUS = 5;
|
|
private static final int INDEX_AUTOCRYPT_PEER_STATE = 6;
|
|
|
|
|
|
private final ApiPendingIntentFactory apiPendingIntentFactory;
|
|
private final ContentResolver contentResolver;
|
|
|
|
|
|
static OpenPgpServiceKeyIdExtractor getInstance(ContentResolver contentResolver, ApiPendingIntentFactory apiPendingIntentFactory) {
|
|
return new OpenPgpServiceKeyIdExtractor(contentResolver, apiPendingIntentFactory);
|
|
}
|
|
|
|
private OpenPgpServiceKeyIdExtractor(ContentResolver contentResolver,
|
|
ApiPendingIntentFactory apiPendingIntentFactory) {
|
|
this.contentResolver = contentResolver;
|
|
this.apiPendingIntentFactory = apiPendingIntentFactory;
|
|
}
|
|
|
|
|
|
KeyIdResult returnKeyIdsFromIntent(Intent data, boolean askIfNoUserIdsProvided, String callingPackageName) {
|
|
boolean hasKeysFromSelectPubkeyActivity = data.hasExtra(OpenPgpApi.EXTRA_KEY_IDS_SELECTED);
|
|
|
|
KeyIdResult result;
|
|
if (hasKeysFromSelectPubkeyActivity) {
|
|
HashSet<Long> encryptKeyIds = new HashSet<>();
|
|
for (long keyId : data.getLongArrayExtra(OpenPgpApi.EXTRA_KEY_IDS_SELECTED)) {
|
|
encryptKeyIds.add(keyId);
|
|
}
|
|
result = createKeysOkResult(encryptKeyIds, false, null);
|
|
} else if (data.hasExtra(OpenPgpApi.EXTRA_USER_IDS) || askIfNoUserIdsProvided) {
|
|
String[] userIds = data.getStringArrayExtra(OpenPgpApi.EXTRA_USER_IDS);
|
|
result = returnKeyIdsFromEmails(data, userIds, callingPackageName);
|
|
} else {
|
|
result = createNoKeysResult();
|
|
}
|
|
|
|
// add key ids from non-ambiguous key id extra
|
|
if (data.hasExtra(OpenPgpApi.EXTRA_KEY_IDS)) {
|
|
HashSet<Long> explicitKeyIds = new HashSet<>();
|
|
for (long keyId : data.getLongArrayExtra(OpenPgpApi.EXTRA_KEY_IDS)) {
|
|
explicitKeyIds.add(keyId);
|
|
}
|
|
result = result.withExplicitKeyIds(explicitKeyIds);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private KeyIdResult returnKeyIdsFromEmails(Intent data, String[] encryptionAddresses, String callingPackageName) {
|
|
boolean hasAddresses = (encryptionAddresses != null && encryptionAddresses.length > 0);
|
|
|
|
boolean allKeysConfirmed = false;
|
|
HashSet<Long> keyIds = new HashSet<>();
|
|
ArrayList<String> missingEmails = new ArrayList<>();
|
|
ArrayList<String> duplicateEmails = new ArrayList<>();
|
|
AutocryptState combinedAutocryptState = null;
|
|
|
|
if (hasAddresses) {
|
|
HashMap<String, AddressQueryResult> userIdEntries = getStatusMapForQueriedAddresses(
|
|
encryptionAddresses, callingPackageName);
|
|
|
|
boolean anyKeyNotVerified = false;
|
|
for (String queriedAddress : encryptionAddresses) {
|
|
AddressQueryResult addressQueryResult = userIdEntries.get(queriedAddress);
|
|
if (addressQueryResult == null) {
|
|
throw new IllegalStateException("No result for address - shouldn't happen!");
|
|
}
|
|
|
|
if (addressQueryResult.autocryptMasterKeyId != null) {
|
|
keyIds.add(addressQueryResult.autocryptMasterKeyId);
|
|
|
|
if (addressQueryResult.autocryptKeyStatus != KeychainExternalContract.KEY_STATUS_VERIFIED) {
|
|
anyKeyNotVerified = true;
|
|
}
|
|
|
|
if (combinedAutocryptState == null) {
|
|
combinedAutocryptState = addressQueryResult.autocryptState;
|
|
} else {
|
|
combinedAutocryptState = combinedAutocryptState.combineWith(addressQueryResult.autocryptState);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (addressQueryResult.uidMasterKeyId != null) {
|
|
keyIds.add(addressQueryResult.uidMasterKeyId);
|
|
combinedAutocryptState = AutocryptState.EXTERNAL;
|
|
|
|
if (addressQueryResult.uidHasMultipleCandidates) {
|
|
duplicateEmails.add(queriedAddress);
|
|
}
|
|
|
|
if (addressQueryResult.uidKeyStatus != KeychainExternalContract.KEY_STATUS_VERIFIED) {
|
|
anyKeyNotVerified = true;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
missingEmails.add(queriedAddress);
|
|
}
|
|
|
|
if (userIdEntries.size() != encryptionAddresses.length) {
|
|
Log.e(Constants.TAG, "Number of rows doesn't match number of retrieved rows! Probably a bug?");
|
|
}
|
|
|
|
allKeysConfirmed = !anyKeyNotVerified;
|
|
}
|
|
|
|
if (!missingEmails.isEmpty()) {
|
|
return createMissingKeysResult(data, keyIds, missingEmails, duplicateEmails);
|
|
}
|
|
|
|
if (!duplicateEmails.isEmpty()) {
|
|
return createDuplicateKeysResult(data, callingPackageName, duplicateEmails);
|
|
}
|
|
|
|
if (keyIds.isEmpty()) {
|
|
return createNoKeysResult(data, keyIds, missingEmails, duplicateEmails);
|
|
}
|
|
|
|
return createKeysOkResult(keyIds, allKeysConfirmed, combinedAutocryptState);
|
|
}
|
|
|
|
/** This method queries the KeychainExternalProvider for all addresses given in encryptionUserIds.
|
|
* It returns a map with one UserIdStatus per queried address. If multiple key candidates exist,
|
|
* the one with the highest verification status is selected. If two candidates with the same
|
|
* verification status exist, the first one is returned and marked as having a duplicate.
|
|
*/
|
|
@NonNull
|
|
private HashMap<String, AddressQueryResult> getStatusMapForQueriedAddresses(String[] encryptionUserIds, String callingPackageName) {
|
|
HashMap<String,AddressQueryResult> keyRows = new HashMap<>();
|
|
Uri queryUri = AutocryptStatus.CONTENT_URI.buildUpon().appendPath(callingPackageName).build();
|
|
Cursor cursor = contentResolver.query(queryUri, PROJECTION_MAIL_STATUS, null, encryptionUserIds, null);
|
|
if (cursor == null) {
|
|
throw new IllegalStateException("Internal error, received null cursor!");
|
|
}
|
|
|
|
try {
|
|
while (cursor.moveToNext()) {
|
|
String queryAddress = cursor.getString(INDEX_EMAIL_ADDRESS);
|
|
Long uidMasterKeyId =
|
|
cursor.isNull(INDEX_MASTER_KEY_ID) ? null : cursor.getLong(INDEX_MASTER_KEY_ID);
|
|
int uidKeyStatus = cursor.getInt(INDEX_USER_ID_STATUS);
|
|
boolean uidHasMultipleCandidates = cursor.getInt(INDEX_USER_ID_CANDIDATES) > 1;
|
|
|
|
Long autocryptMasterKeyId =
|
|
cursor.isNull(INDEX_AUTOCRYPT_MASTER_KEY_ID) ? null : cursor.getLong(INDEX_AUTOCRYPT_MASTER_KEY_ID);
|
|
int autocryptKeyStatus = cursor.getInt(INDEX_AUTOCRYPT_KEY_STATUS);
|
|
int autocryptPeerStatus = cursor.getInt(INDEX_AUTOCRYPT_PEER_STATE);
|
|
|
|
AddressQueryResult status = new AddressQueryResult(
|
|
uidMasterKeyId, uidKeyStatus, uidHasMultipleCandidates, autocryptMasterKeyId,
|
|
autocryptKeyStatus, AutocryptState.fromDbValue(autocryptPeerStatus));
|
|
|
|
keyRows.put(queryAddress, status);
|
|
}
|
|
} finally {
|
|
cursor.close();
|
|
}
|
|
return keyRows;
|
|
}
|
|
|
|
private static class AddressQueryResult {
|
|
private final Long uidMasterKeyId;
|
|
private final int uidKeyStatus;
|
|
private boolean uidHasMultipleCandidates;
|
|
private final Long autocryptMasterKeyId;
|
|
private final int autocryptKeyStatus;
|
|
private final AutocryptState autocryptState;
|
|
|
|
AddressQueryResult(Long uidMasterKeyId, int uidKeyStatus, boolean uidHasMultipleCandidates, Long autocryptMasterKeyId,
|
|
int autocryptKeyStatus, AutocryptState autocryptState) {
|
|
this.uidMasterKeyId = uidMasterKeyId;
|
|
this.uidKeyStatus = uidKeyStatus;
|
|
this.uidHasMultipleCandidates = uidHasMultipleCandidates;
|
|
this.autocryptMasterKeyId = autocryptMasterKeyId;
|
|
this.autocryptKeyStatus = autocryptKeyStatus;
|
|
this.autocryptState = autocryptState;
|
|
}
|
|
}
|
|
|
|
enum AutocryptState {
|
|
EXTERNAL, RESET, GOSSIP, SELECTED, AVAILABLE, MUTUAL;
|
|
|
|
static AutocryptState fromDbValue(int state) {
|
|
switch (state) {
|
|
case ApiAutocryptPeer.RESET:
|
|
return RESET;
|
|
case ApiAutocryptPeer.AVAILABLE:
|
|
return AVAILABLE;
|
|
case ApiAutocryptPeer.SELECTED:
|
|
return SELECTED;
|
|
case ApiAutocryptPeer.GOSSIP:
|
|
return GOSSIP;
|
|
case ApiAutocryptPeer.MUTUAL:
|
|
return MUTUAL;
|
|
default:
|
|
throw new IllegalStateException();
|
|
}
|
|
}
|
|
|
|
public AutocryptState combineWith(AutocryptState other) {
|
|
if (this == EXTERNAL || other == EXTERNAL) {
|
|
return EXTERNAL;
|
|
}
|
|
if (this == RESET || other == RESET) {
|
|
return RESET;
|
|
}
|
|
if (this == GOSSIP || other == GOSSIP) {
|
|
return GOSSIP;
|
|
}
|
|
if (this == SELECTED || other == SELECTED) {
|
|
return SELECTED;
|
|
}
|
|
if (this == AVAILABLE || other == AVAILABLE) {
|
|
return AVAILABLE;
|
|
}
|
|
if (this == MUTUAL && other == MUTUAL) {
|
|
return MUTUAL;
|
|
}
|
|
throw new IllegalStateException("Bug: autocrypt states can't be combined!");
|
|
}
|
|
}
|
|
|
|
static class KeyIdResult {
|
|
private final PendingIntent mKeySelectionPendingIntent;
|
|
private final HashSet<Long> mUserKeyIds;
|
|
private final HashSet<Long> mExplicitKeyIds;
|
|
private final KeyIdResultStatus mStatus;
|
|
private final boolean mAllKeysConfirmed;
|
|
private final AutocryptState mCombinedAutocryptState;
|
|
|
|
private KeyIdResult(PendingIntent keySelectionPendingIntent, KeyIdResultStatus keyIdResultStatus) {
|
|
mKeySelectionPendingIntent = keySelectionPendingIntent;
|
|
mUserKeyIds = null;
|
|
mAllKeysConfirmed = false;
|
|
mStatus = keyIdResultStatus;
|
|
mExplicitKeyIds = null;
|
|
mCombinedAutocryptState = null;
|
|
}
|
|
|
|
private KeyIdResult(HashSet<Long> keyIds, boolean allKeysConfirmed, KeyIdResultStatus keyIdResultStatus,
|
|
AutocryptState combinedAutocryptState) {
|
|
mKeySelectionPendingIntent = null;
|
|
mUserKeyIds = keyIds;
|
|
mAllKeysConfirmed = allKeysConfirmed;
|
|
mStatus = keyIdResultStatus;
|
|
mExplicitKeyIds = null;
|
|
mCombinedAutocryptState = combinedAutocryptState;
|
|
}
|
|
|
|
private KeyIdResult(KeyIdResult keyIdResult, HashSet<Long> explicitKeyIds) {
|
|
mKeySelectionPendingIntent = keyIdResult.mKeySelectionPendingIntent;
|
|
mUserKeyIds = keyIdResult.mUserKeyIds;
|
|
mAllKeysConfirmed = keyIdResult.mAllKeysConfirmed;
|
|
mStatus = keyIdResult.mStatus;
|
|
mExplicitKeyIds = explicitKeyIds;
|
|
mCombinedAutocryptState = keyIdResult.mCombinedAutocryptState;
|
|
}
|
|
|
|
boolean hasKeySelectionPendingIntent() {
|
|
return mKeySelectionPendingIntent != null;
|
|
}
|
|
|
|
PendingIntent getKeySelectionPendingIntent() {
|
|
if (mKeySelectionPendingIntent == null) {
|
|
throw new AssertionError("result intent must not be null when getResultIntent is called!");
|
|
}
|
|
if (mUserKeyIds != null) {
|
|
throw new AssertionError("key ids must be null when getKeyIds is called!");
|
|
}
|
|
return mKeySelectionPendingIntent;
|
|
}
|
|
|
|
long[] getKeyIds() {
|
|
if (mKeySelectionPendingIntent != null) {
|
|
throw new AssertionError("result intent must be null when getKeyIds is called!");
|
|
}
|
|
HashSet<Long> allKeyIds = new HashSet<>();
|
|
if (mUserKeyIds != null) {
|
|
allKeyIds.addAll(mUserKeyIds);
|
|
}
|
|
if (mExplicitKeyIds != null) {
|
|
allKeyIds.addAll(mExplicitKeyIds);
|
|
}
|
|
return KeyFormattingUtils.getUnboxedLongArray(allKeyIds);
|
|
}
|
|
|
|
boolean isAllKeysConfirmed() {
|
|
return mAllKeysConfirmed;
|
|
}
|
|
|
|
private KeyIdResult withExplicitKeyIds(HashSet<Long> explicitKeyIds) {
|
|
return new KeyIdResult(this, explicitKeyIds);
|
|
}
|
|
|
|
KeyIdResultStatus getStatus() {
|
|
return mStatus;
|
|
}
|
|
|
|
public AutocryptState getCombinedAutocryptState() {
|
|
return mCombinedAutocryptState;
|
|
}
|
|
}
|
|
|
|
enum KeyIdResultStatus {
|
|
OK, MISSING, DUPLICATE, NO_KEYS, NO_KEYS_ERROR
|
|
}
|
|
|
|
private KeyIdResult createKeysOkResult(HashSet<Long> encryptKeyIds, boolean allKeysConfirmed,
|
|
AutocryptState combinedAutocryptState) {
|
|
return new KeyIdResult(encryptKeyIds, allKeysConfirmed, KeyIdResultStatus.OK, combinedAutocryptState);
|
|
}
|
|
|
|
private KeyIdResult createNoKeysResult(Intent data,
|
|
HashSet<Long> selectedKeyIds, ArrayList<String> missingEmails, ArrayList<String> duplicateEmails) {
|
|
long[] keyIdsArray = KeyFormattingUtils.getUnboxedLongArray(selectedKeyIds);
|
|
PendingIntent selectKeyPendingIntent = apiPendingIntentFactory.createSelectPublicKeyPendingIntent(
|
|
data, keyIdsArray, missingEmails, duplicateEmails, false);
|
|
|
|
return new KeyIdResult(selectKeyPendingIntent, KeyIdResultStatus.NO_KEYS);
|
|
}
|
|
|
|
private KeyIdResult createDuplicateKeysResult(Intent data, String packageName, ArrayList<String> duplicateEmails) {
|
|
PendingIntent selectKeyPendingIntent = apiPendingIntentFactory.createDeduplicatePendingIntent(
|
|
packageName, data, duplicateEmails);
|
|
|
|
return new KeyIdResult(selectKeyPendingIntent, KeyIdResultStatus.DUPLICATE);
|
|
}
|
|
|
|
private KeyIdResult createMissingKeysResult(Intent data,
|
|
HashSet<Long> selectedKeyIds, ArrayList<String> missingEmails, ArrayList<String> duplicateEmails) {
|
|
long[] keyIdsArray = KeyFormattingUtils.getUnboxedLongArray(selectedKeyIds);
|
|
PendingIntent selectKeyPendingIntent = apiPendingIntentFactory.createSelectPublicKeyPendingIntent(
|
|
data, keyIdsArray, missingEmails, duplicateEmails, false);
|
|
|
|
return new KeyIdResult(selectKeyPendingIntent, KeyIdResultStatus.MISSING);
|
|
}
|
|
|
|
private KeyIdResult createNoKeysResult() {
|
|
return new KeyIdResult(null, KeyIdResultStatus.NO_KEYS_ERROR);
|
|
}
|
|
}
|