diff options
Diffstat (limited to 'OpenPGP-Keychain/src/org/sufficientlysecure/keychain/service/KeychainIntentService.java')
| -rw-r--r-- | OpenPGP-Keychain/src/org/sufficientlysecure/keychain/service/KeychainIntentService.java | 884 |
1 files changed, 884 insertions, 0 deletions
diff --git a/OpenPGP-Keychain/src/org/sufficientlysecure/keychain/service/KeychainIntentService.java b/OpenPGP-Keychain/src/org/sufficientlysecure/keychain/service/KeychainIntentService.java new file mode 100644 index 000000000..e525fe96e --- /dev/null +++ b/OpenPGP-Keychain/src/org/sufficientlysecure/keychain/service/KeychainIntentService.java @@ -0,0 +1,884 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * 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.service; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.ArrayList; + +import org.spongycastle.openpgp.PGPPublicKeyRing; +import org.spongycastle.openpgp.PGPSecretKey; +import org.spongycastle.openpgp.PGPSecretKeyRing; +import org.sufficientlysecure.keychain.Constants; +import org.sufficientlysecure.keychain.Id; +import org.sufficientlysecure.keychain.helper.FileHelper; +import org.sufficientlysecure.keychain.helper.OtherHelper; +import org.sufficientlysecure.keychain.helper.PgpConversionHelper; +import org.sufficientlysecure.keychain.helper.PgpMain; +import org.sufficientlysecure.keychain.helper.Preferences; +import org.sufficientlysecure.keychain.helper.PgpMain.PgpGeneralException; +import org.sufficientlysecure.keychain.provider.ProviderHelper; +import org.sufficientlysecure.keychain.provider.KeychainContract.DataStream; +import org.sufficientlysecure.keychain.util.HkpKeyServer; +import org.sufficientlysecure.keychain.util.InputData; +import org.sufficientlysecure.keychain.util.Log; +import org.sufficientlysecure.keychain.util.ProgressDialogUpdater; +import org.sufficientlysecure.keychain.util.KeyServer.KeyInfo; +import org.sufficientlysecure.keychain.R; + +import android.app.IntentService; +import android.content.Context; +import android.content.Intent; +import android.net.Uri; +import android.os.Bundle; +import android.os.Message; +import android.os.Messenger; +import android.os.RemoteException; + + +/** + * This Service contains all important long lasting operations for APG. It receives Intents with + * data from the activities or other apps, queues these intents, executes them, and stops itself + * after doing them. + */ +public class KeychainIntentService extends IntentService implements ProgressDialogUpdater { + + /* extras that can be given by intent */ + public static final String EXTRA_MESSENGER = "messenger"; + public static final String EXTRA_ACTION = "action"; + public static final String EXTRA_DATA = "data"; + + /* possible EXTRA_ACTIONs */ + public static final int ACTION_ENCRYPT_SIGN = 10; + + public static final int ACTION_DECRYPT_VERIFY = 20; + + public static final int ACTION_SAVE_KEYRING = 30; + public static final int ACTION_GENERATE_KEY = 31; + public static final int ACTION_GENERATE_DEFAULT_RSA_KEYS = 32; + + public static final int ACTION_DELETE_FILE_SECURELY = 40; + + public static final int ACTION_IMPORT_KEYRING = 50; + public static final int ACTION_EXPORT_KEYRING = 51; + + public static final int ACTION_UPLOAD_KEYRING = 60; + public static final int ACTION_QUERY_KEYRING = 61; + + public static final int ACTION_SIGN_KEYRING = 70; + + /* keys for data bundle */ + + // encrypt, decrypt, import export + public static final String TARGET = "target"; + // possible targets: + public static final int TARGET_BYTES = 1; + public static final int TARGET_FILE = 2; + public static final int TARGET_STREAM = 3; + + // encrypt + public static final String ENCRYPT_SECRET_KEY_ID = "secretKeyId"; + public static final String ENCRYPT_USE_ASCII_AMOR = "useAsciiAmor"; + public static final String ENCRYPT_ENCRYPTION_KEYS_IDS = "encryptionKeysIds"; + public static final String ENCRYPT_COMPRESSION_ID = "compressionId"; + public static final String ENCRYPT_GENERATE_SIGNATURE = "generateSignature"; + public static final String ENCRYPT_SIGN_ONLY = "signOnly"; + public static final String ENCRYPT_MESSAGE_BYTES = "messageBytes"; + public static final String ENCRYPT_INPUT_FILE = "inputFile"; + public static final String ENCRYPT_OUTPUT_FILE = "outputFile"; + public static final String ENCRYPT_PROVIDER_URI = "providerUri"; + + // decrypt/verify + public static final String DECRYPT_SIGNED_ONLY = "signedOnly"; + public static final String DECRYPT_RETURN_BYTES = "returnBinary"; + public static final String DECRYPT_CIPHERTEXT_BYTES = "ciphertextBytes"; + public static final String DECRYPT_ASSUME_SYMMETRIC = "assumeSymmetric"; + public static final String DECRYPT_LOOKUP_UNKNOWN_KEY = "lookupUnknownKey"; + + // save keyring + public static final String SAVE_KEYRING_NEW_PASSPHRASE = "newPassphrase"; + public static final String SAVE_KEYRING_CURRENT_PASSPHRASE = "currentPassphrase"; + public static final String SAVE_KEYRING_USER_IDS = "userIds"; + public static final String SAVE_KEYRING_KEYS = "keys"; + public static final String SAVE_KEYRING_KEYS_USAGES = "keysUsages"; + public static final String SAVE_KEYRING_MASTER_KEY_ID = "masterKeyId"; + + // generate key + public static final String GENERATE_KEY_ALGORITHM = "algorithm"; + public static final String GENERATE_KEY_KEY_SIZE = "keySize"; + public static final String GENERATE_KEY_SYMMETRIC_PASSPHRASE = "passphrase"; + public static final String GENERATE_KEY_MASTER_KEY = "masterKey"; + + // delete file securely + public static final String DELETE_FILE = "deleteFile"; + + // import key + public static final String IMPORT_INPUT_STREAM = "importInputStream"; + public static final String IMPORT_FILENAME = "importFilename"; + public static final String IMPORT_BYTES = "importBytes"; + // public static final String IMPORT_KEY_TYPE = "importKeyType"; + + // export key + public static final String EXPORT_OUTPUT_STREAM = "exportOutputStream"; + public static final String EXPORT_FILENAME = "exportFilename"; + public static final String EXPORT_KEY_TYPE = "exportKeyType"; + public static final String EXPORT_ALL = "exportAll"; + public static final String EXPORT_KEY_RING_MASTER_KEY_ID = "exportKeyRingId"; + + // upload key + public static final String UPLOAD_KEY_SERVER = "uploadKeyServer"; + public static final String UPLOAD_KEY_KEYRING_ROW_ID = "uploadKeyRingId"; + + // query key + public static final String QUERY_KEY_SERVER = "queryKeyServer"; + public static final String QUERY_KEY_TYPE = "queryKeyType"; + public static final String QUERY_KEY_STRING = "queryKeyString"; + public static final String QUERY_KEY_ID = "queryKeyId"; + + // sign key + public static final String SIGN_KEY_MASTER_KEY_ID = "signKeyMasterKeyId"; + public static final String SIGN_KEY_PUB_KEY_ID = "signKeyPubKeyId"; + + /* + * possible data keys as result send over messenger + */ + // keys + public static final String RESULT_NEW_KEY = "newKey"; + public static final String RESULT_NEW_KEY2 = "newKey2"; + + // encrypt + public static final String RESULT_SIGNATURE_BYTES = "signatureData"; + public static final String RESULT_SIGNATURE_STRING = "signatureText"; + public static final String RESULT_ENCRYPTED_STRING = "encryptedMessage"; + public static final String RESULT_ENCRYPTED_BYTES = "encryptedData"; + public static final String RESULT_URI = "resultUri"; + + // decrypt/verify + public static final String RESULT_DECRYPTED_STRING = "decryptedMessage"; + public static final String RESULT_DECRYPTED_BYTES = "decryptedData"; + public static final String RESULT_SIGNATURE = "signature"; + public static final String RESULT_SIGNATURE_KEY_ID = "signatureKeyId"; + public static final String RESULT_SIGNATURE_USER_ID = "signatureUserId"; + + public static final String RESULT_SIGNATURE_SUCCESS = "signatureSuccess"; + public static final String RESULT_SIGNATURE_UNKNOWN = "signatureUnknown"; + public static final String RESULT_SIGNATURE_LOOKUP_KEY = "lookupKey"; + + // import + public static final String RESULT_IMPORT_ADDED = "added"; + public static final String RESULT_IMPORT_UPDATED = "updated"; + public static final String RESULT_IMPORT_BAD = "bad"; + + // export + public static final String RESULT_EXPORT = "exported"; + + // query + public static final String RESULT_QUERY_KEY_KEY_DATA = "queryKeyKeyData"; + public static final String RESULT_QUERY_KEY_SEARCH_RESULT = "queryKeySearchResult"; + + Messenger mMessenger; + + public KeychainIntentService() { + super("ApgService"); + } + + /** + * The IntentService calls this method from the default worker thread with the intent that + * started the service. When this method returns, IntentService stops the service, as + * appropriate. + */ + @Override + protected void onHandleIntent(Intent intent) { + Bundle extras = intent.getExtras(); + if (extras == null) { + Log.e(Constants.TAG, "Extras bundle is null!"); + return; + } + + if (!(extras.containsKey(EXTRA_MESSENGER) || extras.containsKey(EXTRA_DATA) || extras + .containsKey(EXTRA_ACTION))) { + Log.e(Constants.TAG, + "Extra bundle must contain a messenger, a data bundle, and an action!"); + return; + } + + mMessenger = (Messenger) extras.get(EXTRA_MESSENGER); + Bundle data = extras.getBundle(EXTRA_DATA); + + OtherHelper.logDebugBundle(data, "EXTRA_DATA"); + + int action = extras.getInt(EXTRA_ACTION); + + // execute action from extra bundle + switch (action) { + case ACTION_ENCRYPT_SIGN: + + try { + /* Input */ + int target = data.getInt(TARGET); + + long secretKeyId = data.getLong(ENCRYPT_SECRET_KEY_ID); + String encryptionPassphrase = data.getString(GENERATE_KEY_SYMMETRIC_PASSPHRASE); + + boolean useAsciiArmor = data.getBoolean(ENCRYPT_USE_ASCII_AMOR); + long encryptionKeyIds[] = data.getLongArray(ENCRYPT_ENCRYPTION_KEYS_IDS); + int compressionId = data.getInt(ENCRYPT_COMPRESSION_ID); + boolean generateSignature = data.getBoolean(ENCRYPT_GENERATE_SIGNATURE); + boolean signOnly = data.getBoolean(ENCRYPT_SIGN_ONLY); + + InputStream inStream = null; + long inLength = -1; + InputData inputData = null; + OutputStream outStream = null; + String streamFilename = null; + switch (target) { + case TARGET_BYTES: /* encrypting bytes directly */ + byte[] bytes = data.getByteArray(ENCRYPT_MESSAGE_BYTES); + + inStream = new ByteArrayInputStream(bytes); + inLength = bytes.length; + + inputData = new InputData(inStream, inLength); + outStream = new ByteArrayOutputStream(); + + break; + case TARGET_FILE: /* encrypting file */ + String inputFile = data.getString(ENCRYPT_INPUT_FILE); + String outputFile = data.getString(ENCRYPT_OUTPUT_FILE); + + // check if storage is ready + if (!FileHelper.isStorageMounted(inputFile) + || !FileHelper.isStorageMounted(outputFile)) { + throw new PgpGeneralException( + getString(R.string.error_externalStorageNotReady)); + } + + inStream = new FileInputStream(inputFile); + File file = new File(inputFile); + inLength = file.length(); + inputData = new InputData(inStream, inLength); + + outStream = new FileOutputStream(outputFile); + + break; + + case TARGET_STREAM: /* Encrypting stream from content uri */ + Uri providerUri = (Uri) data.getParcelable(ENCRYPT_PROVIDER_URI); + + // InputStream + InputStream in = getContentResolver().openInputStream(providerUri); + inLength = PgpMain.getLengthOfStream(in); + inputData = new InputData(in, inLength); + + // OutputStream + try { + while (true) { + streamFilename = PgpMain.generateRandomFilename(32); + if (streamFilename == null) { + throw new PgpMain.PgpGeneralException( + "couldn't generate random file name"); + } + openFileInput(streamFilename).close(); + } + } catch (FileNotFoundException e) { + // found a name that isn't used yet + } + outStream = openFileOutput(streamFilename, Context.MODE_PRIVATE); + + break; + + default: + throw new PgpMain.PgpGeneralException("No target choosen!"); + + } + + /* Operation */ + + if (generateSignature) { + Log.d(Constants.TAG, "generating signature..."); + PgpMain.generateSignature(this, this, inputData, outStream, useAsciiArmor, + false, secretKeyId, PassphraseCacheService.getCachedPassphrase(this, + secretKeyId), Preferences.getPreferences(this) + .getDefaultHashAlgorithm(), Preferences.getPreferences(this) + .getForceV3Signatures()); + } else if (signOnly) { + Log.d(Constants.TAG, "sign only..."); + PgpMain.signText(this, this, inputData, outStream, secretKeyId, + PassphraseCacheService.getCachedPassphrase(this, secretKeyId), + Preferences.getPreferences(this).getDefaultHashAlgorithm(), Preferences + .getPreferences(this).getForceV3Signatures()); + } else { + Log.d(Constants.TAG, "encrypt..."); + PgpMain.encryptAndSign(this, this, inputData, outStream, useAsciiArmor, + compressionId, encryptionKeyIds, encryptionPassphrase, Preferences + .getPreferences(this).getDefaultEncryptionAlgorithm(), + secretKeyId, + Preferences.getPreferences(this).getDefaultHashAlgorithm(), Preferences + .getPreferences(this).getForceV3Signatures(), + PassphraseCacheService.getCachedPassphrase(this, secretKeyId)); + } + + outStream.close(); + + /* Output */ + + Bundle resultData = new Bundle(); + + switch (target) { + case TARGET_BYTES: + if (useAsciiArmor) { + String output = new String( + ((ByteArrayOutputStream) outStream).toByteArray()); + if (generateSignature) { + resultData.putString(RESULT_SIGNATURE_STRING, output); + } else { + resultData.putString(RESULT_ENCRYPTED_STRING, output); + } + } else { + byte output[] = ((ByteArrayOutputStream) outStream).toByteArray(); + if (generateSignature) { + resultData.putByteArray(RESULT_SIGNATURE_BYTES, output); + } else { + resultData.putByteArray(RESULT_ENCRYPTED_BYTES, output); + } + } + + break; + case TARGET_FILE: + // nothing, file was written, just send okay + + break; + case TARGET_STREAM: + String uri = DataStream.buildDataStreamUri(streamFilename).toString(); + resultData.putString(RESULT_URI, uri); + + break; + } + + OtherHelper.logDebugBundle(resultData, "resultData"); + + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData); + } catch (Exception e) { + sendErrorToHandler(e); + } + + break; + + case ACTION_DECRYPT_VERIFY: + try { + /* Input */ + int target = data.getInt(TARGET); + + long secretKeyId = data.getLong(ENCRYPT_SECRET_KEY_ID); + byte[] bytes = data.getByteArray(DECRYPT_CIPHERTEXT_BYTES); + boolean signedOnly = data.getBoolean(DECRYPT_SIGNED_ONLY); + boolean returnBytes = data.getBoolean(DECRYPT_RETURN_BYTES); + boolean assumeSymmetricEncryption = data.getBoolean(DECRYPT_ASSUME_SYMMETRIC); + + boolean lookupUnknownKey = data.getBoolean(DECRYPT_LOOKUP_UNKNOWN_KEY); + + InputStream inStream = null; + long inLength = -1; + InputData inputData = null; + OutputStream outStream = null; + String streamFilename = null; + switch (target) { + case TARGET_BYTES: /* decrypting bytes directly */ + inStream = new ByteArrayInputStream(bytes); + inLength = bytes.length; + + inputData = new InputData(inStream, inLength); + outStream = new ByteArrayOutputStream(); + + break; + + case TARGET_FILE: /* decrypting file */ + String inputFile = data.getString(ENCRYPT_INPUT_FILE); + String outputFile = data.getString(ENCRYPT_OUTPUT_FILE); + + // check if storage is ready + if (!FileHelper.isStorageMounted(inputFile) + || !FileHelper.isStorageMounted(outputFile)) { + throw new PgpGeneralException( + getString(R.string.error_externalStorageNotReady)); + } + + // InputStream + inLength = -1; + inStream = new FileInputStream(inputFile); + File file = new File(inputFile); + inLength = file.length(); + inputData = new InputData(inStream, inLength); + + // OutputStream + outStream = new FileOutputStream(outputFile); + + break; + + case TARGET_STREAM: /* decrypting stream from content uri */ + Uri providerUri = (Uri) data.getParcelable(ENCRYPT_PROVIDER_URI); + + // InputStream + InputStream in = getContentResolver().openInputStream(providerUri); + inLength = PgpMain.getLengthOfStream(in); + inputData = new InputData(in, inLength); + + // OutputStream + try { + while (true) { + streamFilename = PgpMain.generateRandomFilename(32); + if (streamFilename == null) { + throw new PgpMain.PgpGeneralException( + "couldn't generate random file name"); + } + openFileInput(streamFilename).close(); + } + } catch (FileNotFoundException e) { + // found a name that isn't used yet + } + outStream = openFileOutput(streamFilename, Context.MODE_PRIVATE); + + break; + + default: + throw new PgpMain.PgpGeneralException("No target choosen!"); + + } + + /* Operation */ + + Bundle resultData = new Bundle(); + + // verifyText and decrypt returning additional resultData values for the + // verification of signatures + if (signedOnly) { + resultData = PgpMain.verifyText(this, this, inputData, outStream, + lookupUnknownKey); + } else { + resultData = PgpMain.decryptAndVerify(this, this, inputData, outStream, + PassphraseCacheService.getCachedPassphrase(this, secretKeyId), + assumeSymmetricEncryption); + } + + outStream.close(); + + /* Output */ + + switch (target) { + case TARGET_BYTES: + if (returnBytes) { + byte output[] = ((ByteArrayOutputStream) outStream).toByteArray(); + resultData.putByteArray(RESULT_DECRYPTED_BYTES, output); + } else { + String output = new String( + ((ByteArrayOutputStream) outStream).toByteArray()); + resultData.putString(RESULT_DECRYPTED_STRING, output); + } + + break; + case TARGET_FILE: + // nothing, file was written, just send okay and verification bundle + + break; + case TARGET_STREAM: + String uri = DataStream.buildDataStreamUri(streamFilename).toString(); + resultData.putString(RESULT_URI, uri); + + break; + } + + OtherHelper.logDebugBundle(resultData, "resultData"); + + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData); + } catch (Exception e) { + sendErrorToHandler(e); + } + + break; + + case ACTION_SAVE_KEYRING: + + try { + /* Input */ + String oldPassPhrase = data.getString(SAVE_KEYRING_CURRENT_PASSPHRASE); + String newPassPhrase = data.getString(SAVE_KEYRING_NEW_PASSPHRASE); + if (newPassPhrase == null) { + newPassPhrase = oldPassPhrase; + } + ArrayList<String> userIds = data.getStringArrayList(SAVE_KEYRING_USER_IDS); + ArrayList<PGPSecretKey> keys = PgpConversionHelper.BytesToPGPSecretKeyList(data + .getByteArray(SAVE_KEYRING_KEYS)); + ArrayList<Integer> keysUsages = data.getIntegerArrayList(SAVE_KEYRING_KEYS_USAGES); + long masterKeyId = data.getLong(SAVE_KEYRING_MASTER_KEY_ID); + + /* Operation */ + PgpMain.buildSecretKey(this, userIds, keys, keysUsages, masterKeyId, oldPassPhrase, + newPassPhrase, this); + PassphraseCacheService.addCachedPassphrase(this, masterKeyId, newPassPhrase); + + /* Output */ + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY); + } catch (Exception e) { + sendErrorToHandler(e); + } + + break; + + case ACTION_GENERATE_KEY: + + try { + /* Input */ + int algorithm = data.getInt(GENERATE_KEY_ALGORITHM); + String passphrase = data.getString(GENERATE_KEY_SYMMETRIC_PASSPHRASE); + int keysize = data.getInt(GENERATE_KEY_KEY_SIZE); + PGPSecretKey masterKey = null; + if (data.containsKey(GENERATE_KEY_MASTER_KEY)) { + masterKey = PgpConversionHelper.BytesToPGPSecretKey(data + .getByteArray(GENERATE_KEY_MASTER_KEY)); + } + + /* Operation */ + PGPSecretKeyRing newKeyRing = PgpMain.createKey(this, algorithm, keysize, + passphrase, masterKey); + + /* Output */ + Bundle resultData = new Bundle(); + resultData.putByteArray(RESULT_NEW_KEY, + PgpConversionHelper.PGPSecretKeyRingToBytes(newKeyRing)); + + OtherHelper.logDebugBundle(resultData, "resultData"); + + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData); + } catch (Exception e) { + sendErrorToHandler(e); + } + + break; + + case ACTION_GENERATE_DEFAULT_RSA_KEYS: + // generate one RSA 2048 key for signing and one subkey for encrypting! + try { + /* Input */ + String passphrase = data.getString(GENERATE_KEY_SYMMETRIC_PASSPHRASE); + + /* Operation */ + PGPSecretKeyRing masterKeyRing = PgpMain.createKey(this, Id.choice.algorithm.rsa, + 2048, passphrase, null); + + PGPSecretKeyRing subKeyRing = PgpMain.createKey(this, Id.choice.algorithm.rsa, + 2048, passphrase, masterKeyRing.getSecretKey()); + + /* Output */ + Bundle resultData = new Bundle(); + resultData.putByteArray(RESULT_NEW_KEY, + PgpConversionHelper.PGPSecretKeyRingToBytes(masterKeyRing)); + resultData.putByteArray(RESULT_NEW_KEY2, + PgpConversionHelper.PGPSecretKeyRingToBytes(subKeyRing)); + + OtherHelper.logDebugBundle(resultData, "resultData"); + + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData); + } catch (Exception e) { + sendErrorToHandler(e); + } + + break; + + case ACTION_DELETE_FILE_SECURELY: + try { + /* Input */ + String deleteFile = data.getString(DELETE_FILE); + + /* Operation */ + try { + PgpMain.deleteFileSecurely(this, this, new File(deleteFile)); + } catch (FileNotFoundException e) { + throw new PgpMain.PgpGeneralException(getString(R.string.error_fileNotFound, + deleteFile)); + } catch (IOException e) { + throw new PgpMain.PgpGeneralException(getString( + R.string.error_fileDeleteFailed, deleteFile)); + } + + /* Output */ + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY); + } catch (Exception e) { + sendErrorToHandler(e); + } + + break; + + case ACTION_IMPORT_KEYRING: + try { + + /* Input */ + int target = data.getInt(TARGET); + + // int keyType = Id.type.public_key; + // if (data.containsKey(IMPORT_KEY_TYPE)) { + // keyType = data.getInt(IMPORT_KEY_TYPE); + // } + + /* Operation */ + InputStream inStream = null; + long inLength = -1; + InputData inputData = null; + switch (target) { + case TARGET_BYTES: /* import key from bytes directly */ + byte[] bytes = data.getByteArray(IMPORT_BYTES); + + inStream = new ByteArrayInputStream(bytes); + inLength = bytes.length; + + inputData = new InputData(inStream, inLength); + + break; + case TARGET_FILE: /* import key from file */ + String inputFile = data.getString(IMPORT_FILENAME); + + inStream = new FileInputStream(inputFile); + File file = new File(inputFile); + inLength = file.length(); + inputData = new InputData(inStream, inLength); + + break; + + case TARGET_STREAM: + // TODO: not implemented + break; + } + + Bundle resultData = new Bundle(); + resultData = PgpMain.importKeyRings(this, inputData, this); + + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData); + } catch (Exception e) { + sendErrorToHandler(e); + } + + break; + + case ACTION_EXPORT_KEYRING: + try { + + /* Input */ + int keyType = Id.type.public_key; + if (data.containsKey(EXPORT_KEY_TYPE)) { + keyType = data.getInt(EXPORT_KEY_TYPE); + } + + String outputFile = data.getString(EXPORT_FILENAME); + + boolean exportAll = data.getBoolean(EXPORT_ALL); + long keyRingMasterKeyId = -1; + if (!exportAll) { + keyRingMasterKeyId = data.getLong(EXPORT_KEY_RING_MASTER_KEY_ID); + } + + /* Operation */ + + // check if storage is ready + if (!FileHelper.isStorageMounted(outputFile)) { + throw new PgpGeneralException(getString(R.string.error_externalStorageNotReady)); + } + + // OutputStream + FileOutputStream outStream = new FileOutputStream(outputFile); + + ArrayList<Long> keyRingMasterKeyIds = new ArrayList<Long>(); + if (exportAll) { + // get all key ring row ids based on export type + + if (keyType == Id.type.public_key) { + keyRingMasterKeyIds = ProviderHelper.getPublicKeyRingsMasterKeyIds(this); + } else { + keyRingMasterKeyIds = ProviderHelper.getSecretKeyRingsMasterKeyIds(this); + } + } else { + keyRingMasterKeyIds.add(keyRingMasterKeyId); + } + + Bundle resultData = new Bundle(); + resultData = PgpMain.exportKeyRings(this, keyRingMasterKeyIds, keyType, outStream, + this); + + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData); + } catch (Exception e) { + sendErrorToHandler(e); + } + + break; + + case ACTION_UPLOAD_KEYRING: + try { + + /* Input */ + int keyRingRowId = data.getInt(UPLOAD_KEY_KEYRING_ROW_ID); + String keyServer = data.getString(UPLOAD_KEY_SERVER); + + /* Operation */ + HkpKeyServer server = new HkpKeyServer(keyServer); + + PGPPublicKeyRing keyring = ProviderHelper.getPGPPublicKeyRingByRowId(this, + keyRingRowId); + if (keyring != null) { + boolean uploaded = PgpMain.uploadKeyRingToServer(server, + (PGPPublicKeyRing) keyring); + if (!uploaded) { + throw new PgpGeneralException("Unable to export key to selected server"); + } + } + + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY); + } catch (Exception e) { + sendErrorToHandler(e); + } + + break; + + case ACTION_QUERY_KEYRING: + try { + + /* Input */ + int queryType = data.getInt(QUERY_KEY_TYPE); + String keyServer = data.getString(QUERY_KEY_SERVER); + + String queryString = data.getString(QUERY_KEY_STRING); + long keyId = data.getLong(QUERY_KEY_ID); + + /* Operation */ + Bundle resultData = new Bundle(); + + HkpKeyServer server = new HkpKeyServer(keyServer); + if (queryType == Id.keyserver.search) { + ArrayList<KeyInfo> searchResult = server.search(queryString); + + resultData.putParcelableArrayList(RESULT_QUERY_KEY_SEARCH_RESULT, searchResult); + } else if (queryType == Id.keyserver.get) { + String keyData = server.get(keyId); + + resultData.putString(RESULT_QUERY_KEY_KEY_DATA, keyData); + } + + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData); + } catch (Exception e) { + sendErrorToHandler(e); + } + + break; + + case ACTION_SIGN_KEYRING: + try { + + /* Input */ + long masterKeyId = data.getLong(SIGN_KEY_MASTER_KEY_ID); + long pubKeyId = data.getLong(SIGN_KEY_PUB_KEY_ID); + + /* Operation */ + String signaturePassPhrase = PassphraseCacheService.getCachedPassphrase(this, + masterKeyId); + + PGPPublicKeyRing signedPubKeyRing = PgpMain.signKey(this, masterKeyId, pubKeyId, + signaturePassPhrase); + + // store the signed key in our local cache + int retval = PgpMain.storeKeyRingInCache(this, signedPubKeyRing); + if (retval != Id.return_value.ok && retval != Id.return_value.updated) { + throw new PgpGeneralException("Failed to store signed key in local cache"); + } + + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY); + } catch (Exception e) { + sendErrorToHandler(e); + } + + break; + + default: + break; + } + + } + + private void sendErrorToHandler(Exception e) { + Log.e(Constants.TAG, "ApgService Exception: ", e); + e.printStackTrace(); + + Bundle data = new Bundle(); + data.putString(KeychainIntentServiceHandler.DATA_ERROR, e.getMessage()); + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_EXCEPTION, null, data); + } + + private void sendMessageToHandler(Integer arg1, Integer arg2, Bundle data) { + Message msg = Message.obtain(); + msg.arg1 = arg1; + if (arg2 != null) { + msg.arg2 = arg2; + } + if (data != null) { + msg.setData(data); + } + + try { + mMessenger.send(msg); + } catch (RemoteException e) { + Log.w(Constants.TAG, "Exception sending message, Is handler present?", e); + } catch (NullPointerException e) { + Log.w(Constants.TAG, "Messenger is null!", e); + } + } + + private void sendMessageToHandler(Integer arg1, Bundle data) { + sendMessageToHandler(arg1, null, data); + } + + private void sendMessageToHandler(Integer arg1) { + sendMessageToHandler(arg1, null, null); + } + + /** + * Set progress of ProgressDialog by sending message to handler on UI thread + */ + public void setProgress(String message, int progress, int max) { + Log.d(Constants.TAG, "Send message by setProgress with progress=" + progress + ", max=" + + max); + + Bundle data = new Bundle(); + if (message != null) { + data.putString(KeychainIntentServiceHandler.DATA_MESSAGE, message); + } + data.putInt(KeychainIntentServiceHandler.DATA_PROGRESS, progress); + data.putInt(KeychainIntentServiceHandler.DATA_PROGRESS_MAX, max); + + sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_UPDATE_PROGRESS, null, data); + } + + public void setProgress(int resourceId, int progress, int max) { + setProgress(getString(resourceId), progress, max); + } + + public void setProgress(int progress, int max) { + setProgress(null, progress, max); + } +} |