keychainintentservice: rearrange actions in alphabetical order

1 files changed, 281 insertions, 263 deletions

diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainIntentService.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainIntentService.java
index 2101705bc..c131430cf 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainIntentService.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainIntentService.java
@@ -253,90 +253,89 @@ public class KeychainIntentService extends IntentService implements Progressable
         String action = intent.getAction();
 
         // executeServiceMethod action from extra bundle
-        if (ACTION_SIGN_ENCRYPT.equals(action)) {
+        if (ACTION_CERTIFY_KEYRING.equals(action)) {
+
             try {
-                /* Input */
-                int source = data.get(SOURCE) != null ? data.getInt(SOURCE) : data.getInt(TARGET);
-                Bundle resultData = new Bundle();
 
-                long sigMasterKeyId = data.getLong(ENCRYPT_SIGNATURE_MASTER_ID);
-                String sigKeyPassphrase = data.getString(ENCRYPT_SIGNATURE_KEY_PASSPHRASE);
+                /* Input */
+                long masterKeyId = data.getLong(CERTIFY_KEY_MASTER_KEY_ID);
+                long pubKeyId = data.getLong(CERTIFY_KEY_PUB_KEY_ID);
+                ArrayList<String> userIds = data.getStringArrayList(CERTIFY_KEY_UIDS);
 
-                byte[] nfcHash = data.getByteArray(ENCRYPT_SIGNATURE_NFC_HASH);
-                Date nfcTimestamp = (Date) data.getSerializable(ENCRYPT_SIGNATURE_NFC_TIMESTAMP);
+                /* Operation */
+                String signaturePassphrase = PassphraseCacheService.getCachedPassphrase(this,
+                        masterKeyId, masterKeyId);
+                if (signaturePassphrase == null) {
+                    throw new PgpGeneralException("Unable to obtain passphrase");
+                }
 
-                String symmetricPassphrase = data.getString(ENCRYPT_SYMMETRIC_PASSPHRASE);
+                ProviderHelper providerHelper = new ProviderHelper(this);
+                CanonicalizedPublicKeyRing publicRing = providerHelper.getCanonicalizedPublicKeyRing(pubKeyId);
+                CanonicalizedSecretKeyRing secretKeyRing = providerHelper.getCanonicalizedSecretKeyRing(masterKeyId);
+                CanonicalizedSecretKey certificationKey = secretKeyRing.getSecretKey();
+                if (!certificationKey.unlock(signaturePassphrase)) {
+                    throw new PgpGeneralException("Error extracting key (bad passphrase?)");
+                }
+                // TODO: supply nfc stuff
+                UncachedKeyRing newRing = certificationKey.certifyUserIds(publicRing, userIds, null, null);
 
-                boolean useAsciiArmor = data.getBoolean(ENCRYPT_USE_ASCII_ARMOR);
-                long encryptionKeyIds[] = data.getLongArray(ENCRYPT_ENCRYPTION_KEYS_IDS);
-                int compressionId = data.getInt(ENCRYPT_COMPRESSION_ID);
-                int urisCount = data.containsKey(ENCRYPT_INPUT_URIS) ? data.getParcelableArrayList(ENCRYPT_INPUT_URIS).size() : 1;
-                for (int i = 0; i < urisCount; i++) {
-                    data.putInt(SELECTED_URI, i);
-                    InputData inputData = createEncryptInputData(data);
-                    OutputStream outStream = createCryptOutputStream(data);
-                    String originalFilename = getOriginalFilename(data);
+                // store the signed key in our local cache
+                providerHelper.savePublicKeyRing(newRing);
+                sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
 
-                    /* Operation */
-                    PgpSignEncrypt.Builder builder = new PgpSignEncrypt.Builder(
-                            new ProviderHelper(this), this, inputData, outStream
-                    );
-                    builder.setProgressable(this)
-                            .setEnableAsciiArmorOutput(useAsciiArmor)
-                            .setVersionHeader(PgpHelper.getVersionForHeader(this))
-                            .setCompressionId(compressionId)
-                            .setSymmetricEncryptionAlgorithm(
-                                    Preferences.getPreferences(this).getDefaultEncryptionAlgorithm())
-                            .setEncryptionMasterKeyIds(encryptionKeyIds)
-                            .setSymmetricPassphrase(symmetricPassphrase)
-                            .setOriginalFilename(originalFilename);
+            } catch (Exception e) {
+                sendErrorToHandler(e);
+            }
 
-                    try {
+        } else if (ACTION_CONSOLIDATE.equals(action)) {
 
-                        // Find the appropriate subkey to sign with
-                        CachedPublicKeyRing signingRing =
-                                new ProviderHelper(this).getCachedPublicKeyRing(sigMasterKeyId);
-                        long sigSubKeyId = signingRing.getSecretSignId();
+            ConsolidateResult result;
+            if (data.containsKey(CONSOLIDATE_RECOVERY) && data.getBoolean(CONSOLIDATE_RECOVERY)) {
+                result = new ProviderHelper(this).consolidateDatabaseStep2(this);
+            } else {
+                result = new ProviderHelper(this).consolidateDatabaseStep1(this);
+            }
+            sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, result);
 
-                        // Set signature settings
-                        builder.setSignatureMasterKeyId(sigMasterKeyId)
-                                .setSignatureSubKeyId(sigSubKeyId)
-                                .setSignaturePassphrase(sigKeyPassphrase)
-                                .setSignatureHashAlgorithm(
-                                        Preferences.getPreferences(this).getDefaultHashAlgorithm())
-                                .setAdditionalEncryptId(sigMasterKeyId);
-                        if (nfcHash != null && nfcTimestamp != null) {
-                            builder.setNfcState(nfcHash, nfcTimestamp);
-                        }
+        } else if (ACTION_DECRYPT_METADATA.equals(action)) {
 
-                    } catch (PgpGeneralException e) {
-                        // encrypt-only
-                        // TODO Just silently drop the requested signature? Shouldn't we throw here?
-                    }
+            try {
+                /* Input */
+                String passphrase = data.getString(DECRYPT_PASSPHRASE);
+                byte[] nfcDecryptedSessionKey = data.getByteArray(DECRYPT_NFC_DECRYPTED_SESSION_KEY);
 
-                    // this assumes that the bytes are cleartext (valid for current implementation!)
-                    if (source == IO_BYTES) {
-                        builder.setCleartextInput(true);
-                    }
+                InputData inputData = createDecryptInputData(data);
 
-                    SignEncryptResult result = builder.build().execute();
-                    resultData.putParcelable(SignEncryptResult.EXTRA_RESULT, result);
+                /* Operation */
 
-                    outStream.close();
+                Bundle resultData = new Bundle();
 
-                    /* Output */
+                // verifyText and decrypt returning additional resultData values for the
+                // verification of signatures
+                PgpDecryptVerify.Builder builder = new PgpDecryptVerify.Builder(
+                        new ProviderHelper(this),
+                        this, inputData, null
+                );
+                builder.setProgressable(this)
+                        .setAllowSymmetricDecryption(true)
+                        .setPassphrase(passphrase)
+                        .setDecryptMetadataOnly(true)
+                        .setNfcState(nfcDecryptedSessionKey);
 
-                    finalizeEncryptOutputStream(data, resultData, outStream);
+                DecryptVerifyResult decryptVerifyResult = builder.build().execute();
 
-                }
+                resultData.putParcelable(DecryptVerifyResult.EXTRA_RESULT, decryptVerifyResult);
 
+                /* Output */
                 Log.logDebugBundle(resultData, "resultData");
 
                 sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
             } catch (Exception e) {
                 sendErrorToHandler(e);
             }
+
         } else if (ACTION_DECRYPT_VERIFY.equals(action)) {
+
             try {
                 /* Input */
                 String passphrase = data.getString(DECRYPT_PASSPHRASE);
@@ -376,42 +375,128 @@ public class KeychainIntentService extends IntentService implements Progressable
             } catch (Exception e) {
                 sendErrorToHandler(e);
             }
-        } else if (ACTION_DECRYPT_METADATA.equals(action)) {
+
+        } else if (ACTION_DELETE.equals(action)) {
+
             try {
-                /* Input */
-                String passphrase = data.getString(DECRYPT_PASSPHRASE);
-                byte[] nfcDecryptedSessionKey = data.getByteArray(DECRYPT_NFC_DECRYPTED_SESSION_KEY);
 
-                InputData inputData = createDecryptInputData(data);
+                long[] masterKeyIds = data.getLongArray(DELETE_KEY_LIST);
+                boolean isSecret = data.getBoolean(DELETE_IS_SECRET);
 
-                /* Operation */
+                if (masterKeyIds.length == 0) {
+                    throw new PgpGeneralException("List of keys to delete is empty");
+                }
 
-                Bundle resultData = new Bundle();
+                if (isSecret && masterKeyIds.length > 1) {
+                    throw new PgpGeneralException("Secret keys can only be deleted individually!");
+                }
 
-                // verifyText and decrypt returning additional resultData values for the
-                // verification of signatures
-                PgpDecryptVerify.Builder builder = new PgpDecryptVerify.Builder(
-                        new ProviderHelper(this),
-                        this, inputData, null
-                );
-                builder.setProgressable(this)
-                        .setAllowSymmetricDecryption(true)
-                        .setPassphrase(passphrase)
-                        .setDecryptMetadataOnly(true)
-                        .setNfcState(nfcDecryptedSessionKey);
+                boolean success = false;
+                for (long masterKeyId : masterKeyIds) {
+                    int count = getContentResolver().delete(
+                            KeyRingData.buildPublicKeyRingUri(masterKeyId), null, null
+                    );
+                    success |= count > 0;
+                }
 
-                DecryptVerifyResult decryptVerifyResult = builder.build().execute();
+                if (isSecret && success) {
+                    new ProviderHelper(this).consolidateDatabaseStep1(this);
+                }
 
-                resultData.putParcelable(DecryptVerifyResult.EXTRA_RESULT, decryptVerifyResult);
+                if (success) {
+                    // make sure new data is synced into contacts
+                    ContactSyncAdapterService.requestSync();
 
-                /* Output */
-                Log.logDebugBundle(resultData, "resultData");
+                    sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
+                }
+            } catch (Exception e) {
+                sendErrorToHandler(e);
+            }
 
-                sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
+        } else if (ACTION_DELETE_FILE_SECURELY.equals(action)) {
+
+            try {
+                /* Input */
+                String deleteFile = data.getString(DELETE_FILE);
+
+                /* Operation */
+                try {
+                    PgpHelper.deleteFileSecurely(this, this, new File(deleteFile));
+                } catch (FileNotFoundException e) {
+                    throw new PgpGeneralException(
+                            getString(R.string.error_file_not_found, deleteFile));
+                } catch (IOException e) {
+                    throw new PgpGeneralException(getString(R.string.error_file_delete_failed,
+                            deleteFile));
+                }
+
+                /* Output */
+                sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
             } catch (Exception e) {
                 sendErrorToHandler(e);
             }
+
+        } else if (ACTION_DOWNLOAD_AND_IMPORT_KEYS.equals(action) || ACTION_IMPORT_KEYBASE_KEYS.equals(action)) {
+
+            ArrayList<ImportKeysListEntry> entries = data.getParcelableArrayList(DOWNLOAD_KEY_LIST);
+
+            // this downloads the keys and places them into the ImportKeysListEntry entries
+            String keyServer = data.getString(DOWNLOAD_KEY_SERVER);
+
+            ArrayList<ParcelableKeyRing> keyRings = new ArrayList<ParcelableKeyRing>(entries.size());
+            for (ImportKeysListEntry entry : entries) {
+                try {
+                    Keyserver server;
+                    ArrayList<String> origins = entry.getOrigins();
+                    if (origins == null) {
+                        origins = new ArrayList<String>();
+                    }
+                    if (origins.isEmpty()) {
+                        origins.add(keyServer);
+                    }
+                    for (String origin : origins) {
+                        if (KeybaseKeyserver.ORIGIN.equals(origin)) {
+                            server = new KeybaseKeyserver();
+                        } else {
+                            server = new HkpKeyserver(origin);
+                        }
+                        Log.d(Constants.TAG, "IMPORTING " + entry.getKeyIdHex() + " FROM: " + server);
+
+                        // if available use complete fingerprint for get request
+                        byte[] downloadedKeyBytes;
+                        if (KeybaseKeyserver.ORIGIN.equals(origin)) {
+                            downloadedKeyBytes = server.get(entry.getExtraData()).getBytes();
+                        } else if (entry.getFingerprintHex() != null) {
+                            downloadedKeyBytes = server.get("0x" + entry.getFingerprintHex()).getBytes();
+                        } else {
+                            downloadedKeyBytes = server.get(entry.getKeyIdHex()).getBytes();
+                        }
+
+                        // save key bytes in entry object for doing the
+                        // actual import afterwards
+                        keyRings.add(new ParcelableKeyRing(downloadedKeyBytes, entry.getFingerprintHex()));
+                    }
+                } catch (Exception e) {
+                    sendErrorToHandler(e);
+                }
+            }
+
+            Intent importIntent = new Intent(this, KeychainIntentService.class);
+            importIntent.setAction(ACTION_IMPORT_KEYRING);
+
+            Bundle importData = new Bundle();
+            // This is not going through binder, nothing to fear of
+            importData.putParcelableArrayList(IMPORT_KEY_LIST, keyRings);
+            importIntent.putExtra(EXTRA_DATA, importData);
+            importIntent.putExtra(EXTRA_MESSENGER, mMessenger);
+
+            // now import it with this service
+            onHandleIntent(importIntent);
+
+            // result is handled in ACTION_IMPORT_KEYRING
+
         } else if (ACTION_EDIT_KEYRING.equals(action)) {
+
             try {
                 /* Input */
                 SaveKeyringParcel saveParcel = data.getParcelable(EDIT_KEYRING_PARCEL);
@@ -489,66 +574,8 @@ public class KeychainIntentService extends IntentService implements Progressable
                 sendErrorToHandler(e);
             }
 
-        } else if (ACTION_DELETE_FILE_SECURELY.equals(action)) {
-            try {
-                /* Input */
-                String deleteFile = data.getString(DELETE_FILE);
-
-                /* Operation */
-                try {
-                    PgpHelper.deleteFileSecurely(this, this, new File(deleteFile));
-                } catch (FileNotFoundException e) {
-                    throw new PgpGeneralException(
-                            getString(R.string.error_file_not_found, deleteFile));
-                } catch (IOException e) {
-                    throw new PgpGeneralException(getString(R.string.error_file_delete_failed,
-                            deleteFile));
-                }
-
-                /* Output */
-                sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
-            } catch (Exception e) {
-                sendErrorToHandler(e);
-            }
-        } else if (ACTION_IMPORT_KEYRING.equals(action)) {
-            try {
-
-                Iterator<ParcelableKeyRing> entries;
-                int numEntries;
-                if (data.containsKey(IMPORT_KEY_LIST)) {
-                    // get entries from intent
-                    ArrayList<ParcelableKeyRing> list = data.getParcelableArrayList(IMPORT_KEY_LIST);
-                    entries = list.iterator();
-                    numEntries = list.size();
-                } else {
-                    // get entries from cached file
-                    ParcelableFileCache<ParcelableKeyRing> cache =
-                            new ParcelableFileCache<ParcelableKeyRing>(this, "key_import.pcl");
-                    IteratorWithSize<ParcelableKeyRing> it = cache.readCache();
-                    entries = it;
-                    numEntries = it.getSize();
-                }
-
-                ProviderHelper providerHelper = new ProviderHelper(this);
-                PgpImportExport pgpImportExport = new PgpImportExport(
-                        this, providerHelper, this, mActionCanceled);
-                ImportKeyResult result = pgpImportExport.importKeyRings(entries, numEntries);
-
-                // we do this even on failure or cancellation!
-                if (result.mSecret > 0) {
-                    // cannot cancel from here on out!
-                    sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_PREVENT_CANCEL);
-                    providerHelper.consolidateDatabaseStep1(this);
-                }
-
-                // make sure new data is synced into contacts
-                ContactSyncAdapterService.requestSync();
-
-                sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, result);
-            } catch (Exception e) {
-                sendErrorToHandler(e);
-            }
         } else if (ACTION_EXPORT_KEYRING.equals(action)) {
+
             try {
 
                 boolean exportSecret = data.getBoolean(EXPORT_SECRET, false);
@@ -614,166 +641,157 @@ public class KeychainIntentService extends IntentService implements Progressable
             } catch (Exception e) {
                 sendErrorToHandler(e);
             }
-        } else if (ACTION_UPLOAD_KEYRING.equals(action)) {
-            try {
 
-                /* Input */
-                String keyServer = data.getString(UPLOAD_KEY_SERVER);
-                // and dataUri!
+        } else if (ACTION_IMPORT_KEYRING.equals(action)) {
 
-                /* Operation */
-                HkpKeyserver server = new HkpKeyserver(keyServer);
+            try {
+
+                Iterator<ParcelableKeyRing> entries;
+                int numEntries;
+                if (data.containsKey(IMPORT_KEY_LIST)) {
+                    // get entries from intent
+                    ArrayList<ParcelableKeyRing> list = data.getParcelableArrayList(IMPORT_KEY_LIST);
+                    entries = list.iterator();
+                    numEntries = list.size();
+                } else {
+                    // get entries from cached file
+                    ParcelableFileCache<ParcelableKeyRing> cache =
+                            new ParcelableFileCache<ParcelableKeyRing>(this, "key_import.pcl");
+                    IteratorWithSize<ParcelableKeyRing> it = cache.readCache();
+                    entries = it;
+                    numEntries = it.getSize();
+                }
 
                 ProviderHelper providerHelper = new ProviderHelper(this);
-                CanonicalizedPublicKeyRing keyring = providerHelper.getCanonicalizedPublicKeyRing(dataUri);
-                PgpImportExport pgpImportExport = new PgpImportExport(this, new ProviderHelper(this), this);
+                PgpImportExport pgpImportExport = new PgpImportExport(
+                        this, providerHelper, this, mActionCanceled);
+                ImportKeyResult result = pgpImportExport.importKeyRings(entries, numEntries);
 
-                try {
-                    pgpImportExport.uploadKeyRingToServer(server, keyring);
-                } catch (Keyserver.AddKeyException e) {
-                    throw new PgpGeneralException("Unable to export key to selected server");
+                // we do this even on failure or cancellation!
+                if (result.mSecret > 0) {
+                    // cannot cancel from here on out!
+                    sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_PREVENT_CANCEL);
+                    providerHelper.consolidateDatabaseStep1(this);
                 }
 
-                sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
+                // make sure new data is synced into contacts
+                ContactSyncAdapterService.requestSync();
+
+                sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, result);
             } catch (Exception e) {
                 sendErrorToHandler(e);
             }
-        } else if (ACTION_DOWNLOAD_AND_IMPORT_KEYS.equals(action) || ACTION_IMPORT_KEYBASE_KEYS.equals(action)) {
-            ArrayList<ImportKeysListEntry> entries = data.getParcelableArrayList(DOWNLOAD_KEY_LIST);
 
-                // this downloads the keys and places them into the ImportKeysListEntry entries
-                String keyServer = data.getString(DOWNLOAD_KEY_SERVER);
+        } else if (ACTION_SIGN_ENCRYPT.equals(action)) {
+
+            try {
+                /* Input */
+                int source = data.get(SOURCE) != null ? data.getInt(SOURCE) : data.getInt(TARGET);
+                Bundle resultData = new Bundle();
+
+                long sigMasterKeyId = data.getLong(ENCRYPT_SIGNATURE_MASTER_ID);
+                String sigKeyPassphrase = data.getString(ENCRYPT_SIGNATURE_KEY_PASSPHRASE);
+
+                byte[] nfcHash = data.getByteArray(ENCRYPT_SIGNATURE_NFC_HASH);
+                Date nfcTimestamp = (Date) data.getSerializable(ENCRYPT_SIGNATURE_NFC_TIMESTAMP);
+
+                String symmetricPassphrase = data.getString(ENCRYPT_SYMMETRIC_PASSPHRASE);
+
+                boolean useAsciiArmor = data.getBoolean(ENCRYPT_USE_ASCII_ARMOR);
+                long encryptionKeyIds[] = data.getLongArray(ENCRYPT_ENCRYPTION_KEYS_IDS);
+                int compressionId = data.getInt(ENCRYPT_COMPRESSION_ID);
+                int urisCount = data.containsKey(ENCRYPT_INPUT_URIS) ? data.getParcelableArrayList(ENCRYPT_INPUT_URIS).size() : 1;
+                for (int i = 0; i < urisCount; i++) {
+                    data.putInt(SELECTED_URI, i);
+                    InputData inputData = createEncryptInputData(data);
+                    OutputStream outStream = createCryptOutputStream(data);
+                    String originalFilename = getOriginalFilename(data);
+
+                    /* Operation */
+                    PgpSignEncrypt.Builder builder = new PgpSignEncrypt.Builder(
+                            new ProviderHelper(this), this, inputData, outStream
+                    );
+                    builder.setProgressable(this)
+                            .setEnableAsciiArmorOutput(useAsciiArmor)
+                            .setVersionHeader(PgpHelper.getVersionForHeader(this))
+                            .setCompressionId(compressionId)
+                            .setSymmetricEncryptionAlgorithm(
+                                    Preferences.getPreferences(this).getDefaultEncryptionAlgorithm())
+                            .setEncryptionMasterKeyIds(encryptionKeyIds)
+                            .setSymmetricPassphrase(symmetricPassphrase)
+                            .setOriginalFilename(originalFilename);
 
-                ArrayList<ParcelableKeyRing> keyRings = new ArrayList<ParcelableKeyRing>(entries.size());
-                for (ImportKeysListEntry entry : entries) {
                     try {
-                        Keyserver server;
-                        ArrayList<String> origins = entry.getOrigins();
-                        if (origins == null) {
-                            origins = new ArrayList<String>();
-                        }
-                        if (origins.isEmpty()) {
-                            origins.add(keyServer);
-                        }
-                        for (String origin : origins) {
-                            if (KeybaseKeyserver.ORIGIN.equals(origin)) {
-                                server = new KeybaseKeyserver();
-                            } else {
-                                server = new HkpKeyserver(origin);
-                            }
-                            Log.d(Constants.TAG, "IMPORTING " + entry.getKeyIdHex() + " FROM: " + server);
-
-                            // if available use complete fingerprint for get request
-                            byte[] downloadedKeyBytes;
-                            if (KeybaseKeyserver.ORIGIN.equals(origin)) {
-                                downloadedKeyBytes = server.get(entry.getExtraData()).getBytes();
-                            } else if (entry.getFingerprintHex() != null) {
-                                downloadedKeyBytes = server.get("0x" + entry.getFingerprintHex()).getBytes();
-                            } else {
-                                downloadedKeyBytes = server.get(entry.getKeyIdHex()).getBytes();
-                            }
-
-                            // save key bytes in entry object for doing the
-                            // actual import afterwards
-                            keyRings.add(new ParcelableKeyRing(downloadedKeyBytes, entry.getFingerprintHex()));
+
+                        // Find the appropriate subkey to sign with
+                        CachedPublicKeyRing signingRing =
+                                new ProviderHelper(this).getCachedPublicKeyRing(sigMasterKeyId);
+                        long sigSubKeyId = signingRing.getSecretSignId();
+
+                        // Set signature settings
+                        builder.setSignatureMasterKeyId(sigMasterKeyId)
+                                .setSignatureSubKeyId(sigSubKeyId)
+                                .setSignaturePassphrase(sigKeyPassphrase)
+                                .setSignatureHashAlgorithm(
+                                        Preferences.getPreferences(this).getDefaultHashAlgorithm())
+                                .setAdditionalEncryptId(sigMasterKeyId);
+                        if (nfcHash != null && nfcTimestamp != null) {
+                            builder.setNfcState(nfcHash, nfcTimestamp);
                         }
-                    } catch (Exception e) {
-                        sendErrorToHandler(e);
-                    }
-                }
 
-                Intent importIntent = new Intent(this, KeychainIntentService.class);
-                importIntent.setAction(ACTION_IMPORT_KEYRING);
+                    } catch (PgpGeneralException e) {
+                        // encrypt-only
+                        // TODO Just silently drop the requested signature? Shouldn't we throw here?
+                    }
 
-                Bundle importData = new Bundle();
-                // This is not going through binder, nothing to fear of
-                importData.putParcelableArrayList(IMPORT_KEY_LIST, keyRings);
-                importIntent.putExtra(EXTRA_DATA, importData);
-                importIntent.putExtra(EXTRA_MESSENGER, mMessenger);
+                    // this assumes that the bytes are cleartext (valid for current implementation!)
+                    if (source == IO_BYTES) {
+                        builder.setCleartextInput(true);
+                    }
 
-                // now import it with this service
-                onHandleIntent(importIntent);
+                    SignEncryptResult result = builder.build().execute();
+                    resultData.putParcelable(SignEncryptResult.EXTRA_RESULT, result);
 
-                // result is handled in ACTION_IMPORT_KEYRING
-        } else if (ACTION_CERTIFY_KEYRING.equals(action)) {
-            try {
+                    outStream.close();
 
-                /* Input */
-                long masterKeyId = data.getLong(CERTIFY_KEY_MASTER_KEY_ID);
-                long pubKeyId = data.getLong(CERTIFY_KEY_PUB_KEY_ID);
-                ArrayList<String> userIds = data.getStringArrayList(CERTIFY_KEY_UIDS);
+                    /* Output */
 
-                /* Operation */
-                String signaturePassphrase = PassphraseCacheService.getCachedPassphrase(this,
-                        masterKeyId, masterKeyId);
-                if (signaturePassphrase == null) {
-                    throw new PgpGeneralException("Unable to obtain passphrase");
-                }
+                    finalizeEncryptOutputStream(data, resultData, outStream);
 
-                ProviderHelper providerHelper = new ProviderHelper(this);
-                CanonicalizedPublicKeyRing publicRing = providerHelper.getCanonicalizedPublicKeyRing(pubKeyId);
-                CanonicalizedSecretKeyRing secretKeyRing = providerHelper.getCanonicalizedSecretKeyRing(masterKeyId);
-                CanonicalizedSecretKey certificationKey = secretKeyRing.getSecretKey();
-                if (!certificationKey.unlock(signaturePassphrase)) {
-                    throw new PgpGeneralException("Error extracting key (bad passphrase?)");
                 }
-                // TODO: supply nfc stuff
-                UncachedKeyRing newRing = certificationKey.certifyUserIds(publicRing, userIds, null, null);
 
-                // store the signed key in our local cache
-                providerHelper.savePublicKeyRing(newRing);
-                sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
+                Log.logDebugBundle(resultData, "resultData");
 
+                sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
             } catch (Exception e) {
                 sendErrorToHandler(e);
             }
 
-        } else if (ACTION_DELETE.equals(action)) {
+        } else if (ACTION_UPLOAD_KEYRING.equals(action)) {
 
             try {
 
-                long[] masterKeyIds = data.getLongArray(DELETE_KEY_LIST);
-                boolean isSecret = data.getBoolean(DELETE_IS_SECRET);
-
-                if (masterKeyIds.length == 0) {
-                    throw new PgpGeneralException("List of keys to delete is empty");
-                }
-
-                if (isSecret && masterKeyIds.length > 1) {
-                    throw new PgpGeneralException("Secret keys can only be deleted individually!");
-                }
-
-                boolean success = false;
-                for (long masterKeyId : masterKeyIds) {
-                    int count = getContentResolver().delete(
-                            KeyRingData.buildPublicKeyRingUri(masterKeyId), null, null
-                    );
-                    success |= count > 0;
-                }
+                /* Input */
+                String keyServer = data.getString(UPLOAD_KEY_SERVER);
+                // and dataUri!
 
-                if (isSecret && success) {
-                    new ProviderHelper(this).consolidateDatabaseStep1(this);
-                }
+                /* Operation */
+                HkpKeyserver server = new HkpKeyserver(keyServer);
 
-                if (success) {
-                    // make sure new data is synced into contacts
-                    ContactSyncAdapterService.requestSync();
+                ProviderHelper providerHelper = new ProviderHelper(this);
+                CanonicalizedPublicKeyRing keyring = providerHelper.getCanonicalizedPublicKeyRing(dataUri);
+                PgpImportExport pgpImportExport = new PgpImportExport(this, new ProviderHelper(this), this);
 
-                    sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
+                try {
+                    pgpImportExport.uploadKeyRingToServer(server, keyring);
+                } catch (Keyserver.AddKeyException e) {
+                    throw new PgpGeneralException("Unable to export key to selected server");
                 }
 
+                sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
             } catch (Exception e) {
                 sendErrorToHandler(e);
             }
-
-        } else if (ACTION_CONSOLIDATE.equals(action)) {
-            ConsolidateResult result;
-            if (data.containsKey(CONSOLIDATE_RECOVERY) && data.getBoolean(CONSOLIDATE_RECOVERY)) {
-                result = new ProviderHelper(this).consolidateDatabaseStep2(this);
-            } else {
-                result = new ProviderHelper(this).consolidateDatabaseStep1(this);
-            }
-            sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, result);
         }
 
     }