moparisthebest/open-keychain
1
0
Fork 0
mirror of https://github.com/moparisthebest/open-keychain synced 2024-11-27 11:12:15 -05:00
Code Issues Releases Wiki Activity

Replace PgpGeneralException with NotFoundException where appropriate

Browse Source
This commit is contained in:
Dominik Schürmann 2014-10-09 00:58:07 +02:00
parent 3165f3ffa8
commit 49b4ff6312
20 changed files with 119 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedKeyRing.java
View File

@ -19,7 +19,7 @@
package org.sufficientlysecure.keychain.pgp;
import org.spongycastle.openpgp.PGPKeyRing;
import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
import org.sufficientlysecure.keychain.provider.ProviderHelper.NotFoundException;
import org.sufficientlysecure.keychain.util.IterableIterator;
import java.io.IOException;
@ -56,11 +56,11 @@ public abstract class CanonicalizedKeyRing extends KeyRing {
return getRing().getPublicKey().getFingerprint();
}
public String getPrimaryUserId() throws PgpGeneralException {
public String getPrimaryUserId() throws NotFoundException {
return getPublicKey().getPrimaryUserId();
}
public String getPrimaryUserIdWithFallback() throws PgpGeneralException {
public String getPrimaryUserIdWithFallback() throws NotFoundException {
return getPublicKey().getPrimaryUserIdWithFallback();
}
@ -87,24 +87,24 @@ public abstract class CanonicalizedKeyRing extends KeyRing {
return creationDate.after(now) || (expiryDate != null && expiryDate.before(now));
}
public boolean canCertify() throws PgpGeneralException {
public boolean canCertify() throws NotFoundException {
return getRing().getPublicKey().isEncryptionKey();
}
public long getEncryptId() throws PgpGeneralException {
public long getEncryptId() throws NotFoundException {
for(CanonicalizedPublicKey key : publicKeyIterator()) {
if (key.canEncrypt() && key.isValid()) {
return key.getKeyId();
}
}
throw new PgpGeneralException("No valid encryption key found!");
throw new NotFoundException("No valid encryption key found!");
}
public boolean hasEncrypt() throws PgpGeneralException {
public boolean hasEncrypt() throws NotFoundException {
try {
getEncryptId();
return true;
} catch(PgpGeneralException e) {
} catch(NotFoundException e) {
return false;
}
}

10
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedPublicKeyRing.java
View File

@ -21,7 +21,7 @@ package org.sufficientlysecure.keychain.pgp;
import org.spongycastle.openpgp.PGPObjectFactory;
import org.spongycastle.openpgp.PGPPublicKey;
import org.spongycastle.openpgp.PGPPublicKeyRing;
import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
import org.sufficientlysecure.keychain.provider.ProviderHelper.NotFoundException;
import org.sufficientlysecure.keychain.util.IterableIterator;
import java.io.IOException;
@ -61,16 +61,16 @@ public class CanonicalizedPublicKeyRing extends CanonicalizedKeyRing {
}
/** Getter that returns the subkey that should be used for signing. */
CanonicalizedPublicKey getEncryptionSubKey() throws PgpGeneralException {
CanonicalizedPublicKey getEncryptionSubKey() throws NotFoundException {
PGPPublicKey key = getRing().getPublicKey(getEncryptId());
if(key != null) {
if (key != null) {
CanonicalizedPublicKey cKey = new CanonicalizedPublicKey(this, key);
if(!cKey.canEncrypt()) {
throw new PgpGeneralException("key error");
throw new NotFoundException("key error");
}
return cKey;
}
throw new PgpGeneralException("no encryption key available");
throw new NotFoundException("no encryption key available");
}
public IterableIterator<CanonicalizedPublicKey> publicKeyIterator() {

5
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedSecretKey.java
View File

@ -41,6 +41,7 @@ import org.spongycastle.openpgp.operator.jcajce.NfcSyncPGPContentSignerBuilder;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralMsgIdException;
import org.sufficientlysecure.keychain.provider.ProviderHelper;
import org.sufficientlysecure.keychain.util.IterableIterator;
import org.sufficientlysecure.keychain.util.Log;
@ -254,9 +255,11 @@ public class CanonicalizedSecretKey extends CanonicalizedPublicKey {
spGen.setSignatureCreationTime(false, nfcCreationTimestamp);
signatureGenerator.setHashedSubpackets(spGen.generate());
return signatureGenerator;
} catch (PGPException e) {
} catch (ProviderHelper.NotFoundException e) {
// TODO: simply throw PGPException!
throw new PgpGeneralException("Error initializing signature!", e);
} catch (PGPException e) {
throw new PgpGeneralException("Error initializing signature!", e);
}
}

20
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/KeyRing.java
View File

@ -20,7 +20,7 @@ package org.sufficientlysecure.keychain.pgp;
import android.text.TextUtils;
import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
import org.sufficientlysecure.keychain.provider.ProviderHelper.NotFoundException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@ -38,25 +38,25 @@ import java.util.regex.Pattern;
*/
public abstract class KeyRing {
abstract public long getMasterKeyId() throws PgpGeneralException;
abstract public long getMasterKeyId() throws NotFoundException;
abstract public String getPrimaryUserId() throws PgpGeneralException;
abstract public String getPrimaryUserId() throws NotFoundException;
abstract public String getPrimaryUserIdWithFallback() throws PgpGeneralException;
abstract public String getPrimaryUserIdWithFallback() throws NotFoundException;
public String[] getSplitPrimaryUserIdWithFallback() throws PgpGeneralException {
public String[] getSplitPrimaryUserIdWithFallback() throws NotFoundException {
return splitUserId(getPrimaryUserIdWithFallback());
}
abstract public boolean isRevoked() throws PgpGeneralException;
abstract public boolean isRevoked() throws NotFoundException;
abstract public boolean canCertify() throws PgpGeneralException;
abstract public boolean canCertify() throws NotFoundException;
abstract public long getEncryptId() throws PgpGeneralException;
abstract public long getEncryptId() throws NotFoundException;
abstract public boolean hasEncrypt() throws PgpGeneralException;
abstract public boolean hasEncrypt() throws NotFoundException;
abstract public int getVerified() throws PgpGeneralException;
abstract public int getVerified() throws NotFoundException;
private static final Pattern USER_ID_PATTERN = Pattern.compile("^(.*?)(?: \\((.*)\\))?(?: <(.*)>)?$");

3
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/OpenPgpSignatureResultBuilder.java
View File

@ -20,6 +20,7 @@ package org.sufficientlysecure.keychain.pgp;
import org.openintents.openpgp.OpenPgpSignatureResult;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
import org.sufficientlysecure.keychain.provider.ProviderHelper;
import org.sufficientlysecure.keychain.util.Log;
import java.util.ArrayList;
@ -96,7 +97,7 @@ public class OpenPgpSignatureResultBuilder {
setKeyId(signingRing.getMasterKeyId());
try {
setPrimaryUserId(signingRing.getPrimaryUserIdWithFallback());
} catch (PgpGeneralException e) {
} catch (ProviderHelper.NotFoundException e) {
Log.d(Constants.TAG, "No primary user id in keyring with master key id " + signingRing.getMasterKeyId());
}
setSignatureKeyCertified(signingRing.getVerified() > 0);

13
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncrypt.java
View File

@ -385,18 +385,21 @@ public class PgpSignEncrypt {
// Asymmetric encryption
for (long id : mEncryptionMasterKeyIds) {
CanonicalizedPublicKeyRing keyRing = null;
try {
CanonicalizedPublicKeyRing keyRing = mProviderHelper.getCanonicalizedPublicKeyRing(
keyRing = mProviderHelper.getCanonicalizedPublicKeyRing(
KeyRings.buildUnifiedKeyRingUri(id));
} catch (ProviderHelper.NotFoundException e) {
log.add(LogType.MSG_SE_KEY_UNKNOWN, indent + 1,
KeyFormattingUtils.convertKeyIdToHex(id));
}
try {
CanonicalizedPublicKey key = keyRing.getEncryptionSubKey();
cPk.addMethod(key.getPubKeyEncryptionGenerator());
log.add(LogType.MSG_SE_KEY_OK, indent + 1,
KeyFormattingUtils.convertKeyIdToHex(id));
} catch (PgpGeneralException e) {
log.add(LogType.MSG_SE_KEY_WARN, indent + 1,
KeyFormattingUtils.convertKeyIdToHex(id));
} catch (ProviderHelper.NotFoundException e) {
log.add(LogType.MSG_SE_KEY_UNKNOWN, indent + 1,
log.add(LogType.MSG_SE_KEY_WARN, indent + 1,
KeyFormattingUtils.convertKeyIdToHex(id));
}
}

146
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/CachedPublicKeyRing.java
View File

@ -30,21 +30,21 @@ import org.sufficientlysecure.keychain.provider.KeychainContract.Keys;
import org.sufficientlysecure.keychain.provider.ProviderHelper.NotFoundException;
import org.sufficientlysecure.keychain.util.Log;
/** This implementation of KeyRing provides a cached view of PublicKeyRing
/**
* This implementation of KeyRing provides a cached view of PublicKeyRing
* objects based on database queries exclusively.
*
* <p/>
* This class should be used where only few points of data but no actual
* cryptographic operations are required about a PublicKeyRing which is already
* in the database. This happens commonly in UI code, where parsing of a PGP
* key for examination would be a very expensive operation.
*
* <p/>
* Each getter method is implemented using a more or less expensive database
* query, while object construction is (almost) free. A common pattern is
* mProviderHelper.getCachedKeyRing(uri).getterMethod()
*
* <p/>
* TODO Ensure that the values returned here always match the ones returned by
* the parsed KeyRing!
*
*/
public class CachedPublicKeyRing extends KeyRing {
@ -57,21 +57,17 @@ public class CachedPublicKeyRing extends KeyRing {
}
@Override
public long getMasterKeyId() throws PgpGeneralException {
try {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.MASTER_KEY_ID, ProviderHelper.FIELD_TYPE_INTEGER);
return (Long) data;
} catch (ProviderHelper.NotFoundException e) {
throw new PgpGeneralException(e);
}
public long getMasterKeyId() throws NotFoundException {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.MASTER_KEY_ID, ProviderHelper.FIELD_TYPE_INTEGER);
return (Long) data;
}
/**
* Find the master key id related to a given query. The id will either be extracted from the
* query, which should work for all specific /key_rings/ queries, or will be queried if it can't.
*/
public long extractOrGetMasterKeyId() throws PgpGeneralException {
public long extractOrGetMasterKeyId() throws NotFoundException {
// try extracting from the uri first
String firstSegment = mUri.getPathSegments().get(1);
if (!firstSegment.equals("find")) try {
@ -83,114 +79,82 @@ public class CachedPublicKeyRing extends KeyRing {
return getMasterKeyId();
}
public byte[] getFingerprint() throws PgpGeneralException {
try {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.FINGERPRINT, ProviderHelper.FIELD_TYPE_BLOB);
return (byte[]) data;
} catch (ProviderHelper.NotFoundException e) {
throw new PgpGeneralException(e);
}
public byte[] getFingerprint() throws NotFoundException {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.FINGERPRINT, ProviderHelper.FIELD_TYPE_BLOB);
return (byte[]) data;
}
@Override
public String getPrimaryUserId() throws PgpGeneralException {
try {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.USER_ID,
ProviderHelper.FIELD_TYPE_STRING);
return (String) data;
} catch(ProviderHelper.NotFoundException e) {
throw new PgpGeneralException(e);
}
public String getPrimaryUserId() throws NotFoundException {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.USER_ID,
ProviderHelper.FIELD_TYPE_STRING);
return (String) data;
}
public String getPrimaryUserIdWithFallback() throws PgpGeneralException {
public String getPrimaryUserIdWithFallback() throws NotFoundException {
return getPrimaryUserId();
}
@Override
public boolean isRevoked() throws PgpGeneralException {
try {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.IS_REVOKED,
ProviderHelper.FIELD_TYPE_INTEGER);
return (Long) data > 0;
} catch(ProviderHelper.NotFoundException e) {
throw new PgpGeneralException(e);
}
public boolean isRevoked() throws NotFoundException {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.IS_REVOKED,
ProviderHelper.FIELD_TYPE_INTEGER);
return (Long) data > 0;
}
@Override
public boolean canCertify() throws PgpGeneralException {
try {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.HAS_CERTIFY,
ProviderHelper.FIELD_TYPE_NULL);
return !((Boolean) data);
} catch(ProviderHelper.NotFoundException e) {
throw new PgpGeneralException(e);
}
public boolean canCertify() throws NotFoundException {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.HAS_CERTIFY,
ProviderHelper.FIELD_TYPE_NULL);
return !((Boolean) data);
}
@Override
public long getEncryptId() throws PgpGeneralException {
try {
Object data = mProviderHelper.getGenericData(mUri,
KeyRings.HAS_ENCRYPT,
ProviderHelper.FIELD_TYPE_INTEGER);
return (Long) data;
} catch(ProviderHelper.NotFoundException e) {
throw new PgpGeneralException(e);
}
public long getEncryptId() throws NotFoundException {
Object data = mProviderHelper.getGenericData(mUri,
KeyRings.HAS_ENCRYPT,
ProviderHelper.FIELD_TYPE_INTEGER);
return (Long) data;
}
@Override
public boolean hasEncrypt() throws PgpGeneralException {
public boolean hasEncrypt() throws NotFoundException {
return getEncryptId() != 0;
}
/** Returns the key id which should be used for signing.
*
/**
* Returns the key id which should be used for signing.
* <p/>
* This method returns keys which are actually available (ie. secret available, and not stripped,
* revoked, or expired), hence only works on keyrings where a secret key is available!
*
*/
public long getSecretSignId() throws PgpGeneralException {
try {
Object data = mProviderHelper.getGenericData(mUri,
KeyRings.HAS_SIGN,
ProviderHelper.FIELD_TYPE_INTEGER);
return (Long) data;
} catch(ProviderHelper.NotFoundException e) {
throw new PgpGeneralException(e);
}
public long getSecretSignId() throws NotFoundException {
Object data = mProviderHelper.getGenericData(mUri,
KeyRings.HAS_SIGN,
ProviderHelper.FIELD_TYPE_INTEGER);
return (Long) data;
}
@Override
public int getVerified() throws PgpGeneralException {
try {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.VERIFIED,
ProviderHelper.FIELD_TYPE_INTEGER);
return (Integer) data;
} catch(ProviderHelper.NotFoundException e) {
throw new PgpGeneralException(e);
}
public int getVerified() throws NotFoundException {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.VERIFIED,
ProviderHelper.FIELD_TYPE_INTEGER);
return (Integer) data;
}
public boolean hasAnySecret() throws PgpGeneralException {
try {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.HAS_ANY_SECRET,
ProviderHelper.FIELD_TYPE_INTEGER);
return (Long) data > 0;
} catch(ProviderHelper.NotFoundException e) {
throw new PgpGeneralException(e);
}
public boolean hasAnySecret() throws NotFoundException {
Object data = mProviderHelper.getGenericData(mUri,
KeychainContract.KeyRings.HAS_ANY_SECRET,
ProviderHelper.FIELD_TYPE_INTEGER);
return (Long) data > 0;
}
private Cursor getSubkeys() throws PgpGeneralException {
private Cursor getSubkeys() throws NotFoundException {
Uri keysUri = KeychainContract.Keys.buildKeysUri(extractOrGetMasterKeyId());
return mProviderHelper.getContentResolver().query(keysUri, null, null, null, null);
}

23
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/OpenPgpService.java
View File

@ -272,23 +272,24 @@ public class OpenPgpService extends RemoteService {
InputData inputData = new InputData(is, inputLength);
// Find the appropriate subkey to sign with
CachedPublicKeyRing signingRing =
new ProviderHelper(this).getCachedPublicKeyRing(accSettings.getKeyId());
final long sigSubKeyId = signingRing.getSecretSignId();
final long sigSubKeyId;
try {
CachedPublicKeyRing signingRing =
new ProviderHelper(this).getCachedPublicKeyRing(accSettings.getKeyId());
sigSubKeyId = signingRing.getSecretSignId();
} catch (NotFoundException e) {
// secret key that is set for this account is deleted?
// show account config again!
return getCreateAccountIntent(data, getAccountName(data));
}
// get passphrase from cache, if key has "no" passphrase, this returns an empty String
String passphrase;
if (data.hasExtra(OpenPgpApi.EXTRA_PASSPHRASE)) {
passphrase = data.getStringExtra(OpenPgpApi.EXTRA_PASSPHRASE);
} else {
try {
passphrase = PassphraseCacheService.getCachedPassphrase(getContext(),
accSettings.getKeyId(), sigSubKeyId);
} catch (PassphraseCacheService.KeyNotFoundException e) {
// secret key that is set for this account is deleted?
// show account config again!
return getCreateAccountIntent(data, getAccountName(data));
}
passphrase = PassphraseCacheService.getCachedPassphrase(getContext(),
accSettings.getKeyId(), sigSubKeyId);
}
if (passphrase == null) {
// get PendingIntent for passphrase input, add it to given params and return to client

3
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/ui/AccountSettingsActivity.java
View File

@ -27,13 +27,12 @@ import android.view.View;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.ui.util.ActionBarHelper;
import org.sufficientlysecure.keychain.provider.ProviderHelper;
import org.sufficientlysecure.keychain.remote.AccountSettings;
import org.sufficientlysecure.keychain.service.results.OperationResult;
import org.sufficientlysecure.keychain.service.results.OperationResult.LogLevel;
import org.sufficientlysecure.keychain.service.results.OperationResult.LogType;
import org.sufficientlysecure.keychain.service.results.SingletonResult;
import org.sufficientlysecure.keychain.ui.util.ActionBarHelper;
import org.sufficientlysecure.keychain.util.Log;
public class AccountSettingsActivity extends ActionBarActivity {

2
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/ui/AccountSettingsFragment.java
View File

@ -67,7 +67,7 @@ public class AccountSettingsFragment extends Fragment {
}
public void setAccSettings(AccountSettings accountSettings) {
this.mAccSettings = accountSettings;
mAccSettings = accountSettings;
mAccNameView.setText(accountSettings.getAccountName());
mSelectKeySpinner.setSelectedKeyId(accountSettings.getKeyId());

2
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainIntentService.java
View File

@ -719,7 +719,7 @@ public class KeychainIntentService extends IntentService implements Progressable
builder.setNfcState(nfcHash, nfcTimestamp);
}
} catch (PgpGeneralException e) {
} catch (NotFoundException e) {
// encrypt-only
// TODO Just silently drop the requested signature? Shouldn't we throw here?
}

3
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EditKeyFragment.java
View File

@ -229,9 +229,6 @@ public class EditKeyFragment extends LoaderFragment implements
} catch (NotFoundException e) {
finishWithError(LogType.MSG_EK_ERROR_NOT_FOUND);
return;
} catch (PgpGeneralException e) {
finishWithError(LogType.MSG_EK_ERROR_NOT_FOUND);
return;
}
try {

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptAsymmetricFragment.java
View File

@ -139,7 +139,7 @@ public class EncryptAsymmetricFragment extends Fragment implements EncryptActivi
setSignatureKeyId(keyring.getMasterKeyId());
mSign.setSelectedKeyId(mEncryptInterface.getSignatureKey());
}
} catch (PgpGeneralException e) {
} catch (ProviderHelper.NotFoundException e) {
Log.e(Constants.TAG, "key not found!", e);
}
}
@ -151,7 +151,7 @@ public class EncryptAsymmetricFragment extends Fragment implements EncryptActivi
CachedPublicKeyRing ring = mProviderHelper.getCachedPublicKeyRing(
KeyRings.buildUnifiedKeyRingsFindBySubkeyUri(preselectedId));
mEncryptKeyView.addObject(mEncryptKeyView.new EncryptionKey(ring));
} catch (PgpGeneralException e) {
} catch (ProviderHelper.NotFoundException e) {
Log.e(Constants.TAG, "key not found!", e);
}
}

2
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/MultiCertifyKeyFragment.java
View File

@ -115,7 +115,7 @@ public class MultiCertifyKeyFragment extends LoaderFragment
if (key.canCertify()) {
mCertifyKeySpinner.setSelectedKeyId(certifyKeyId);
}
} catch (PgpGeneralException e) {
} catch (ProviderHelper.NotFoundException e) {
Log.e(Constants.TAG, "certify certify check failed", e);
}
}

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/PassphraseDialogActivity.java
View File

@ -151,7 +151,7 @@ public class PassphraseDialogActivity extends FragmentActivity {
// the catch clause doesn't return.
try {
userId = mSecretRing.getPrimaryUserIdWithFallback();
} catch (PgpGeneralException e) {
} catch (ProviderHelper.NotFoundException e) {
userId = null;
}
@ -312,7 +312,7 @@ public class PassphraseDialogActivity extends FragmentActivity {
PassphraseCacheService.addCachedPassphrase(getActivity(),
mSecretRing.getMasterKeyId(), mSubKeyId, passphrase,
mSecretRing.getPrimaryUserIdWithFallback());
} catch (PgpGeneralException e) {
} catch (ProviderHelper.NotFoundException e) {
Log.e(Constants.TAG, "adding of a passphrase failed", e);
}

2
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewCertActivity.java
View File

@ -185,7 +185,7 @@ public class ViewCertActivity extends ActionBarActivity
KeyRings.buildUnifiedKeyRingsFindBySubkeyUri(mCertifierKeyId)).getMasterKeyId();
viewIntent.setData(KeyRings.buildGenericKeyRingUri(signerMasterKeyId));
startActivity(viewIntent);
} catch (PgpGeneralException e) {
} catch (ProviderHelper.NotFoundException e) {
// TODO notify user of this, maybe offer download?
Log.e(Constants.TAG, "key not found!", e);
}

2
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyMainFragment.java
View File

@ -308,7 +308,7 @@ public class ViewKeyMainFragment extends LoaderFragment implements
}
// used instead of startActivity set actionbar based on callingPackage
startActivityForResult(intent, 0);
} catch (PgpGeneralException e) {
} catch (NotFoundException e) {
Log.e(Constants.TAG, "key not found!", e);
}
}

4
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/PassphraseDialogFragment.java
View File

@ -145,7 +145,7 @@ public class PassphraseDialogFragment extends DialogFragment implements OnEditor
// the catch clause doesn't return.
try {
userId = mSecretRing.getPrimaryUserIdWithFallback();
} catch (PgpGeneralException e) {
} catch (ProviderHelper.NotFoundException e) {
userId = null;
}
@ -308,7 +308,7 @@ public class PassphraseDialogFragment extends DialogFragment implements OnEditor
PassphraseCacheService.addCachedPassphrase(getActivity(),
mSecretRing.getMasterKeyId(), mSubKeyId, passphrase,
mSecretRing.getPrimaryUserIdWithFallback());
} catch (PgpGeneralException e) {
} catch (ProviderHelper.NotFoundException e) {
Log.e(Constants.TAG, "adding of a passphrase failed", e);
}

3
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/widget/EncryptKeyCompletionView.java
View File

@ -42,6 +42,7 @@ import com.tokenautocomplete.TokenCompleteTextView;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.provider.ProviderHelper;
import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
import org.sufficientlysecure.keychain.util.ContactHelper;
import org.sufficientlysecure.keychain.pgp.KeyRing;
@ -198,7 +199,7 @@ public class EncryptKeyCompletionView extends TokenCompleteTextView {
}
public EncryptionKey(CachedPublicKeyRing ring) throws PgpGeneralException {
public EncryptionKey(CachedPublicKeyRing ring) throws ProviderHelper.NotFoundException {
this(ring.getPrimaryUserId(), ring.extractOrGetMasterKeyId(),
KeyFormattingUtils.convertFingerprintToHex(ring.getFingerprint()));
}

2
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/ExportHelper.java
View File

@ -57,7 +57,7 @@ public class ExportHelper {
DeleteKeyDialogFragment deleteKeyDialog = DeleteKeyDialogFragment.newInstance(messenger,
new long[]{ masterKeyId });
deleteKeyDialog.show(mActivity.getSupportFragmentManager(), "deleteKeyDialog");
} catch (PgpGeneralException e) {
} catch (ProviderHelper.NotFoundException e) {
Log.e(Constants.TAG, "key not found!", e);
}
}