925 lines
40 KiB
Java
925 lines
40 KiB
Java
/*
|
|
* Copyright (C) 2012-2013 Dominik Schürmann <dominik@dominikschuermann.de>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package org.sufficientlysecure.keychain.service;
|
|
|
|
import android.app.IntentService;
|
|
import android.content.Intent;
|
|
import android.net.Uri;
|
|
import android.os.Bundle;
|
|
import android.os.Message;
|
|
import android.os.Messenger;
|
|
import android.os.RemoteException;
|
|
|
|
import org.spongycastle.bcpg.sig.KeyFlags;
|
|
import org.spongycastle.openpgp.PGPKeyRing;
|
|
import org.spongycastle.openpgp.PGPObjectFactory;
|
|
import org.spongycastle.openpgp.PGPPublicKey;
|
|
import org.spongycastle.openpgp.PGPPublicKeyRing;
|
|
import org.spongycastle.openpgp.PGPSecretKey;
|
|
import org.spongycastle.openpgp.PGPSecretKeyRing;
|
|
import org.spongycastle.openpgp.PGPUtil;
|
|
|
|
import org.sufficientlysecure.keychain.Constants;
|
|
import org.sufficientlysecure.keychain.Id;
|
|
import org.sufficientlysecure.keychain.R;
|
|
import org.sufficientlysecure.keychain.helper.FileHelper;
|
|
import org.sufficientlysecure.keychain.helper.OtherHelper;
|
|
import org.sufficientlysecure.keychain.helper.Preferences;
|
|
import org.sufficientlysecure.keychain.pgp.PgpConversionHelper;
|
|
import org.sufficientlysecure.keychain.pgp.PgpDecryptVerifyResult;
|
|
import org.sufficientlysecure.keychain.pgp.PgpHelper;
|
|
import org.sufficientlysecure.keychain.pgp.PgpImportExport;
|
|
import org.sufficientlysecure.keychain.pgp.PgpKeyHelper;
|
|
import org.sufficientlysecure.keychain.pgp.PgpKeyOperation;
|
|
import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
|
|
import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralMsgIdException;
|
|
import org.sufficientlysecure.keychain.provider.ProviderHelper;
|
|
import org.sufficientlysecure.keychain.ui.adapter.ImportKeysListEntry;
|
|
import org.sufficientlysecure.keychain.util.HkpKeyServer;
|
|
import org.sufficientlysecure.keychain.util.InputData;
|
|
import org.sufficientlysecure.keychain.util.KeychainServiceListener;
|
|
import org.sufficientlysecure.keychain.util.Log;
|
|
import org.sufficientlysecure.keychain.util.ProgressDialogUpdater;
|
|
import org.sufficientlysecure.keychain.util.ProgressScaler;
|
|
|
|
import java.io.BufferedInputStream;
|
|
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 java.util.List;
|
|
|
|
/**
|
|
* 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, KeychainServiceListener {
|
|
|
|
/* extras that can be given by intent */
|
|
public static final String EXTRA_MESSENGER = "messenger";
|
|
public static final String EXTRA_DATA = "data";
|
|
|
|
/* possible actions */
|
|
public static final String ACTION_ENCRYPT_SIGN = Constants.INTENT_PREFIX + "ENCRYPT_SIGN";
|
|
|
|
public static final String ACTION_DECRYPT_VERIFY = Constants.INTENT_PREFIX + "DECRYPT_VERIFY";
|
|
|
|
public static final String ACTION_SAVE_KEYRING = Constants.INTENT_PREFIX + "SAVE_KEYRING";
|
|
public static final String ACTION_GENERATE_KEY = Constants.INTENT_PREFIX + "GENERATE_KEY";
|
|
public static final String ACTION_GENERATE_DEFAULT_RSA_KEYS = Constants.INTENT_PREFIX
|
|
+ "GENERATE_DEFAULT_RSA_KEYS";
|
|
|
|
public static final String ACTION_DELETE_FILE_SECURELY = Constants.INTENT_PREFIX
|
|
+ "DELETE_FILE_SECURELY";
|
|
|
|
public static final String ACTION_IMPORT_KEYRING = Constants.INTENT_PREFIX + "IMPORT_KEYRING";
|
|
public static final String ACTION_EXPORT_KEYRING = Constants.INTENT_PREFIX + "EXPORT_KEYRING";
|
|
|
|
public static final String ACTION_UPLOAD_KEYRING = Constants.INTENT_PREFIX + "UPLOAD_KEYRING";
|
|
public static final String ACTION_DOWNLOAD_AND_IMPORT_KEYS = Constants.INTENT_PREFIX + "QUERY_KEYRING";
|
|
|
|
public static final String ACTION_CERTIFY_KEYRING = Constants.INTENT_PREFIX + "SIGN_KEYRING";
|
|
|
|
/* 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_URI = 2;
|
|
public static final int TARGET_STREAM = 3;
|
|
|
|
// encrypt
|
|
public static final String ENCRYPT_SIGNATURE_KEY_ID = "secret_key_id";
|
|
public static final String ENCRYPT_USE_ASCII_ARMOR = "use_ascii_armor";
|
|
public static final String ENCRYPT_ENCRYPTION_KEYS_IDS = "encryption_keys_ids";
|
|
public static final String ENCRYPT_COMPRESSION_ID = "compression_id";
|
|
public static final String ENCRYPT_MESSAGE_BYTES = "message_bytes";
|
|
public static final String ENCRYPT_INPUT_FILE = "input_file";
|
|
public static final String ENCRYPT_OUTPUT_FILE = "output_file";
|
|
public static final String ENCRYPT_PROVIDER_URI = "provider_uri";
|
|
public static final String ENCRYPT_SYMMETRIC_PASSPHRASE = "passphrase";
|
|
|
|
// decrypt/verify
|
|
public static final String DECRYPT_CIPHERTEXT_BYTES = "ciphertext_bytes";
|
|
public static final String DECRYPT_PASSPHRASE = "passphrase";
|
|
|
|
// save keyring
|
|
public static final String SAVE_KEYRING_PARCEL = "save_parcel";
|
|
public static final String SAVE_KEYRING_CAN_SIGN = "can_sign";
|
|
|
|
|
|
// generate key
|
|
public static final String GENERATE_KEY_ALGORITHM = "algorithm";
|
|
public static final String GENERATE_KEY_KEY_SIZE = "key_size";
|
|
public static final String GENERATE_KEY_SYMMETRIC_PASSPHRASE = "passphrase";
|
|
public static final String GENERATE_KEY_MASTER_KEY = "master_key";
|
|
|
|
// delete file securely
|
|
public static final String DELETE_FILE = "deleteFile";
|
|
|
|
// import key
|
|
public static final String IMPORT_KEY_LIST = "import_key_list";
|
|
|
|
// export key
|
|
public static final String EXPORT_OUTPUT_STREAM = "export_output_stream";
|
|
public static final String EXPORT_FILENAME = "export_filename";
|
|
public static final String EXPORT_KEY_TYPE = "export_key_type";
|
|
public static final String EXPORT_ALL = "export_all";
|
|
public static final String EXPORT_KEY_RING_MASTER_KEY_ID = "export_key_ring_id";
|
|
|
|
// upload key
|
|
public static final String UPLOAD_KEY_SERVER = "upload_key_server";
|
|
|
|
// query key
|
|
public static final String DOWNLOAD_KEY_SERVER = "query_key_server";
|
|
public static final String DOWNLOAD_KEY_LIST = "query_key_id";
|
|
|
|
// sign key
|
|
public static final String CERTIFY_KEY_MASTER_KEY_ID = "sign_key_master_key_id";
|
|
public static final String CERTIFY_KEY_PUB_KEY_ID = "sign_key_pub_key_id";
|
|
public static final String CERTIFY_KEY_UIDS = "sign_key_uids";
|
|
|
|
/*
|
|
* possible data keys as result send over messenger
|
|
*/
|
|
// keys
|
|
public static final String RESULT_NEW_KEY = "new_key";
|
|
public static final String RESULT_KEY_USAGES = "new_key_usages";
|
|
|
|
// encrypt
|
|
public static final String RESULT_SIGNATURE_BYTES = "signature_data";
|
|
public static final String RESULT_SIGNATURE_STRING = "signature_text";
|
|
public static final String RESULT_ENCRYPTED_STRING = "encrypted_message";
|
|
public static final String RESULT_BYTES = "encrypted_data";
|
|
public static final String RESULT_URI = "result_uri";
|
|
|
|
// decrypt/verify
|
|
public static final String RESULT_DECRYPTED_BYTES = "decrypted_data";
|
|
public static final String RESULT_DECRYPT_VERIFY_RESULT = "signature";
|
|
|
|
// 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_DATA = "query_key_data";
|
|
public static final String RESULT_QUERY_KEY_SEARCH_RESULT = "query_key_search_result";
|
|
|
|
Messenger mMessenger;
|
|
|
|
private boolean mIsCanceled;
|
|
|
|
public KeychainIntentService() {
|
|
super("KeychainIntentService");
|
|
}
|
|
|
|
@Override
|
|
public void onDestroy() {
|
|
super.onDestroy();
|
|
this.mIsCanceled = true;
|
|
}
|
|
|
|
/**
|
|
* 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) || (intent
|
|
.getAction() == null))) {
|
|
Log.e(Constants.TAG,
|
|
"Extra bundle must contain a messenger, a data bundle, and an action!");
|
|
return;
|
|
}
|
|
|
|
Uri dataUri = intent.getData();
|
|
|
|
mMessenger = (Messenger) extras.get(EXTRA_MESSENGER);
|
|
Bundle data = extras.getBundle(EXTRA_DATA);
|
|
|
|
OtherHelper.logDebugBundle(data, "EXTRA_DATA");
|
|
|
|
String action = intent.getAction();
|
|
|
|
// executeServiceMethod action from extra bundle
|
|
if (ACTION_ENCRYPT_SIGN.equals(action)) {
|
|
try {
|
|
/* Input */
|
|
int target = data.getInt(TARGET);
|
|
|
|
long signatureKeyId = data.getLong(ENCRYPT_SIGNATURE_KEY_ID);
|
|
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);
|
|
InputStream inStream;
|
|
long inLength;
|
|
InputData inputData;
|
|
OutputStream outStream;
|
|
// 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_URI: /* 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_external_storage_not_ready));
|
|
}
|
|
|
|
inStream = new FileInputStream(inputFile);
|
|
File file = new File(inputFile);
|
|
inLength = file.length();
|
|
inputData = new InputData(inStream, inLength);
|
|
|
|
outStream = new FileOutputStream(outputFile);
|
|
|
|
break;
|
|
|
|
// TODO: not used currently
|
|
// case TARGET_STREAM: /* Encrypting stream from content uri */
|
|
// Uri providerUri = (Uri) data.getParcelable(ENCRYPT_PROVIDER_URI);
|
|
//
|
|
// // InputStream
|
|
// InputStream in = getContentResolver().openInputStream(providerUri);
|
|
// inLength = PgpHelper.getLengthOfStream(in);
|
|
// inputData = new InputData(in, inLength);
|
|
//
|
|
// // OutputStream
|
|
// try {
|
|
// while (true) {
|
|
// streamFilename = PgpHelper.generateRandomFilename(32);
|
|
// if (streamFilename == null) {
|
|
// throw new 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 PgpGeneralException("No target choosen!");
|
|
|
|
}
|
|
|
|
/* Operation */
|
|
PgpSignEncrypt.Builder builder =
|
|
new PgpSignEncrypt.Builder(this, inputData, outStream);
|
|
builder.progress(this);
|
|
|
|
builder.enableAsciiArmorOutput(useAsciiArmor)
|
|
.compressionId(compressionId)
|
|
.symmetricEncryptionAlgorithm(
|
|
Preferences.getPreferences(this).getDefaultEncryptionAlgorithm())
|
|
.signatureForceV3(Preferences.getPreferences(this).getForceV3Signatures())
|
|
.encryptionKeyIds(encryptionKeyIds)
|
|
.symmetricPassphrase(symmetricPassphrase)
|
|
.signatureKeyId(signatureKeyId)
|
|
.signatureHashAlgorithm(
|
|
Preferences.getPreferences(this).getDefaultHashAlgorithm())
|
|
.signaturePassphrase(
|
|
PassphraseCacheService.getCachedPassphrase(this, signatureKeyId));
|
|
|
|
builder.build().execute();
|
|
|
|
outStream.close();
|
|
|
|
/* Output */
|
|
|
|
Bundle resultData = new Bundle();
|
|
|
|
switch (target) {
|
|
case TARGET_BYTES:
|
|
byte output[] = ((ByteArrayOutputStream) outStream).toByteArray();
|
|
|
|
resultData.putByteArray(RESULT_BYTES, output);
|
|
|
|
break;
|
|
case TARGET_URI:
|
|
// 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);
|
|
}
|
|
} else if (ACTION_DECRYPT_VERIFY.equals(action)) {
|
|
try {
|
|
/* Input */
|
|
int target = data.getInt(TARGET);
|
|
|
|
byte[] bytes = data.getByteArray(DECRYPT_CIPHERTEXT_BYTES);
|
|
String passphrase = data.getString(DECRYPT_PASSPHRASE);
|
|
|
|
InputStream inStream;
|
|
long inLength;
|
|
InputData inputData;
|
|
OutputStream outStream;
|
|
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_URI: /* 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_external_storage_not_ready));
|
|
}
|
|
|
|
// 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;
|
|
|
|
// TODO: not used, maybe contains code useful for new decrypt method for files?
|
|
// case TARGET_STREAM: /* decrypting stream from content uri */
|
|
// Uri providerUri = (Uri) data.getParcelable(ENCRYPT_PROVIDER_URI);
|
|
//
|
|
// // InputStream
|
|
// InputStream in = getContentResolver().openInputStream(providerUri);
|
|
// inLength = PgpHelper.getLengthOfStream(in);
|
|
// inputData = new InputData(in, inLength);
|
|
//
|
|
// // OutputStream
|
|
// try {
|
|
// while (true) {
|
|
// streamFilename = PgpHelper.generateRandomFilename(32);
|
|
// if (streamFilename == null) {
|
|
// throw new 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 PgpGeneralException("No target choosen!");
|
|
|
|
}
|
|
|
|
/* Operation */
|
|
|
|
Bundle resultData = new Bundle();
|
|
|
|
// verifyText and decrypt returning additional resultData values for the
|
|
// verification of signatures
|
|
PgpDecryptVerify.Builder builder = new PgpDecryptVerify.Builder(this, inputData, outStream);
|
|
builder.progressDialogUpdater(this);
|
|
|
|
builder.allowSymmetricDecryption(true)
|
|
.passphrase(passphrase);
|
|
|
|
PgpDecryptVerifyResult decryptVerifyResult = builder.build().execute();
|
|
|
|
outStream.close();
|
|
|
|
resultData.putParcelable(RESULT_DECRYPT_VERIFY_RESULT, decryptVerifyResult);
|
|
|
|
/* Output */
|
|
|
|
switch (target) {
|
|
case TARGET_BYTES:
|
|
byte output[] = ((ByteArrayOutputStream) outStream).toByteArray();
|
|
resultData.putByteArray(RESULT_DECRYPTED_BYTES, output);
|
|
break;
|
|
case TARGET_URI:
|
|
// 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);
|
|
}
|
|
} else if (ACTION_SAVE_KEYRING.equals(action)) {
|
|
try {
|
|
/* Input */
|
|
SaveKeyringParcel saveParams = data.getParcelable(SAVE_KEYRING_PARCEL);
|
|
String oldPassPhrase = saveParams.oldPassPhrase;
|
|
String newPassPhrase = saveParams.newPassPhrase;
|
|
boolean canSign = true;
|
|
|
|
if (data.containsKey(SAVE_KEYRING_CAN_SIGN)) {
|
|
canSign = data.getBoolean(SAVE_KEYRING_CAN_SIGN);
|
|
}
|
|
|
|
if (newPassPhrase == null) {
|
|
newPassPhrase = oldPassPhrase;
|
|
}
|
|
|
|
long masterKeyId = saveParams.keys.get(0).getKeyID();
|
|
|
|
/* Operation */
|
|
if (!canSign) {
|
|
PgpKeyOperation keyOperations = new PgpKeyOperation(new ProgressScaler(this, 0, 50, 100));
|
|
PGPSecretKeyRing keyRing = ProviderHelper
|
|
.getPGPSecretKeyRingByKeyId(this, masterKeyId);
|
|
keyRing = keyOperations.changeSecretKeyPassphrase(keyRing,
|
|
oldPassPhrase, newPassPhrase);
|
|
setProgress(R.string.progress_saving_key_ring, 50, 100);
|
|
ProviderHelper.saveKeyRing(this, keyRing);
|
|
setProgress(R.string.progress_done, 100, 100);
|
|
} else {
|
|
PgpKeyOperation keyOperations =
|
|
new PgpKeyOperation(new ProgressScaler(this, 0, 90, 100));
|
|
PGPSecretKeyRing privkey =
|
|
ProviderHelper.getPGPSecretKeyRingByMasterKeyId(this, masterKeyId);
|
|
PGPPublicKeyRing pubkey =
|
|
ProviderHelper.getPGPPublicKeyRingByMasterKeyId(this, masterKeyId);
|
|
PgpKeyOperation.Pair<PGPSecretKeyRing, PGPPublicKeyRing> pair =
|
|
keyOperations.buildSecretKey(privkey, pubkey, saveParams);
|
|
setProgress(R.string.progress_saving_key_ring, 90, 100);
|
|
ProviderHelper.saveKeyRing(this, pair.first);
|
|
ProviderHelper.saveKeyRing(this, pair.second);
|
|
setProgress(R.string.progress_done, 100, 100);
|
|
}
|
|
PassphraseCacheService.addCachedPassphrase(this, masterKeyId, newPassPhrase);
|
|
|
|
/* Output */
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
|
|
} catch (Exception e) {
|
|
sendErrorToHandler(e);
|
|
}
|
|
} else if (ACTION_GENERATE_KEY.equals(action)) {
|
|
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);
|
|
boolean masterKey = data.getBoolean(GENERATE_KEY_MASTER_KEY);
|
|
|
|
/* Operation */
|
|
PgpKeyOperation keyOperations = new PgpKeyOperation(new ProgressScaler(this, 0, 100, 100));
|
|
PGPSecretKey newKey = keyOperations.createKey(algorithm, keysize,
|
|
passphrase, masterKey);
|
|
|
|
/* Output */
|
|
Bundle resultData = new Bundle();
|
|
resultData.putByteArray(RESULT_NEW_KEY,
|
|
PgpConversionHelper.PGPSecretKeyToBytes(newKey));
|
|
|
|
OtherHelper.logDebugBundle(resultData, "resultData");
|
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
|
} catch (Exception e) {
|
|
sendErrorToHandler(e);
|
|
}
|
|
} else if (ACTION_GENERATE_DEFAULT_RSA_KEYS.equals(action)) {
|
|
// generate one RSA 4096 key for signing and one subkey for encrypting!
|
|
try {
|
|
/* Input */
|
|
String passphrase = data.getString(GENERATE_KEY_SYMMETRIC_PASSPHRASE);
|
|
ArrayList<PGPSecretKey> newKeys = new ArrayList<PGPSecretKey>();
|
|
ArrayList<Integer> keyUsageList = new ArrayList<Integer>();
|
|
|
|
/* Operation */
|
|
int keysTotal = 3;
|
|
int keysCreated = 0;
|
|
setProgress(
|
|
getApplicationContext().getResources().
|
|
getQuantityString(R.plurals.progress_generating, keysTotal),
|
|
keysCreated,
|
|
keysTotal);
|
|
PgpKeyOperation keyOperations = new PgpKeyOperation(new ProgressScaler(this, 0, 100, 100));
|
|
|
|
PGPSecretKey masterKey = keyOperations.createKey(Id.choice.algorithm.rsa,
|
|
4096, passphrase, true);
|
|
newKeys.add(masterKey);
|
|
keyUsageList.add(KeyFlags.CERTIFY_OTHER);
|
|
keysCreated++;
|
|
setProgress(keysCreated, keysTotal);
|
|
|
|
PGPSecretKey subKey = keyOperations.createKey(Id.choice.algorithm.rsa,
|
|
4096, passphrase, false);
|
|
newKeys.add(subKey);
|
|
keyUsageList.add(KeyFlags.ENCRYPT_COMMS | KeyFlags.ENCRYPT_STORAGE);
|
|
keysCreated++;
|
|
setProgress(keysCreated, keysTotal);
|
|
|
|
subKey = keyOperations.createKey(Id.choice.algorithm.rsa,
|
|
4096, passphrase, false);
|
|
newKeys.add(subKey);
|
|
keyUsageList.add(KeyFlags.SIGN_DATA);
|
|
keysCreated++;
|
|
setProgress(keysCreated, keysTotal);
|
|
|
|
// TODO: default to one master for cert, one sub for encrypt and one sub
|
|
// for sign
|
|
|
|
/* Output */
|
|
|
|
Bundle resultData = new Bundle();
|
|
resultData.putByteArray(RESULT_NEW_KEY,
|
|
PgpConversionHelper.PGPSecretKeyArrayListToBytes(newKeys));
|
|
resultData.putIntegerArrayList(RESULT_KEY_USAGES, keyUsageList);
|
|
|
|
OtherHelper.logDebugBundle(resultData, "resultData");
|
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
|
} catch (Exception e) {
|
|
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 {
|
|
List<ImportKeysListEntry> entries = data.getParcelableArrayList(IMPORT_KEY_LIST);
|
|
|
|
Bundle resultData = new Bundle();
|
|
|
|
PgpImportExport pgpImportExport = new PgpImportExport(this, this);
|
|
resultData = pgpImportExport.importKeyRings(entries);
|
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
|
} catch (Exception e) {
|
|
sendErrorToHandler(e);
|
|
}
|
|
} else if (ACTION_EXPORT_KEYRING.equals(action)) {
|
|
try {
|
|
|
|
/* Input */
|
|
int keyType = Id.type.public_key;
|
|
if (data.containsKey(EXPORT_KEY_TYPE)) {
|
|
keyType = data.getInt(EXPORT_KEY_TYPE);
|
|
}
|
|
long[] masterKeyIds = data.getLongArray(EXPORT_KEY_RING_MASTER_KEY_ID);
|
|
String outputFile = data.getString(EXPORT_FILENAME);
|
|
|
|
// If not exporting all keys get the masterKeyIds of the keys to export from the intent
|
|
boolean exportAll = data.getBoolean(EXPORT_ALL);
|
|
|
|
/* Operation */
|
|
|
|
// check if storage is ready
|
|
if (!FileHelper.isStorageMounted(outputFile)) {
|
|
throw new PgpGeneralException(getString(R.string.error_external_storage_not_ready));
|
|
}
|
|
|
|
ArrayList<Long> publicMasterKeyIds = new ArrayList<Long>();
|
|
ArrayList<Long> secretMasterKeyIds = new ArrayList<Long>();
|
|
ArrayList<Long> allPublicMasterKeyIds = ProviderHelper.getPublicKeyRingsMasterKeyIds(this);
|
|
ArrayList<Long> allSecretMasterKeyIds = ProviderHelper.getSecretKeyRingsMasterKeyIds(this);
|
|
|
|
if (exportAll) {
|
|
// get all public key ring MasterKey ids
|
|
if (keyType == Id.type.public_key || keyType == Id.type.public_secret_key) {
|
|
publicMasterKeyIds = allPublicMasterKeyIds;
|
|
}
|
|
// get all secret key ring MasterKey ids
|
|
if (keyType == Id.type.secret_key || keyType == Id.type.public_secret_key) {
|
|
secretMasterKeyIds = allSecretMasterKeyIds;
|
|
}
|
|
} else {
|
|
|
|
for (long masterKeyId : masterKeyIds) {
|
|
if ((keyType == Id.type.public_key || keyType == Id.type.public_secret_key)
|
|
&& allPublicMasterKeyIds.contains(masterKeyId)) {
|
|
publicMasterKeyIds.add(masterKeyId);
|
|
}
|
|
if ((keyType == Id.type.secret_key || keyType == Id.type.public_secret_key)
|
|
&& allSecretMasterKeyIds.contains(masterKeyId)) {
|
|
secretMasterKeyIds.add(masterKeyId);
|
|
}
|
|
}
|
|
}
|
|
|
|
PgpImportExport pgpImportExport = new PgpImportExport(this, this, this);
|
|
Bundle resultData = pgpImportExport
|
|
.exportKeyRings(publicMasterKeyIds, secretMasterKeyIds,
|
|
new FileOutputStream(outputFile));
|
|
|
|
if (mIsCanceled) {
|
|
boolean isDeleted = new File(outputFile).delete();
|
|
}
|
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
|
} catch (Exception e) {
|
|
sendErrorToHandler(e);
|
|
}
|
|
} else if (ACTION_UPLOAD_KEYRING.equals(action)) {
|
|
try {
|
|
|
|
/* Input */
|
|
String keyServer = data.getString(UPLOAD_KEY_SERVER);
|
|
// and dataUri!
|
|
|
|
/* Operation */
|
|
HkpKeyServer server = new HkpKeyServer(keyServer);
|
|
|
|
PGPPublicKeyRing keyring = (PGPPublicKeyRing) ProviderHelper.getPGPKeyRing(this, dataUri);
|
|
if (keyring != null) {
|
|
PgpImportExport pgpImportExport = new PgpImportExport(this, null);
|
|
|
|
boolean uploaded = pgpImportExport.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);
|
|
}
|
|
} else if (ACTION_DOWNLOAD_AND_IMPORT_KEYS.equals(action)) {
|
|
try {
|
|
ArrayList<ImportKeysListEntry> entries = data.getParcelableArrayList(DOWNLOAD_KEY_LIST);
|
|
String keyServer = data.getString(DOWNLOAD_KEY_SERVER);
|
|
|
|
// TODO: add extra which requires fingerprint suport and force verification!
|
|
// only supported by newer sks keyserver versions
|
|
|
|
// this downloads the keys and places them into the ImportKeysListEntry entries
|
|
HkpKeyServer server = new HkpKeyServer(keyServer);
|
|
|
|
for (ImportKeysListEntry entry : entries) {
|
|
// if available use complete fingerprint for get request
|
|
byte[] downloadedKeyBytes;
|
|
if (entry.getFingerPrintHex() != null) {
|
|
downloadedKeyBytes = server.get("0x" + entry.getFingerPrintHex()).getBytes();
|
|
} else {
|
|
downloadedKeyBytes = server.get(entry.getKeyIdHex()).getBytes();
|
|
}
|
|
|
|
// create PGPKeyRing object based on downloaded armored key
|
|
PGPKeyRing downloadedKey = null;
|
|
BufferedInputStream bufferedInput =
|
|
new BufferedInputStream(new ByteArrayInputStream(downloadedKeyBytes));
|
|
if (bufferedInput.available() > 0) {
|
|
InputStream in = PGPUtil.getDecoderStream(bufferedInput);
|
|
PGPObjectFactory objectFactory = new PGPObjectFactory(in);
|
|
|
|
// get first object in block
|
|
Object obj;
|
|
if ((obj = objectFactory.nextObject()) != null) {
|
|
Log.d(Constants.TAG, "Found class: " + obj.getClass());
|
|
|
|
if (obj instanceof PGPKeyRing) {
|
|
downloadedKey = (PGPKeyRing) obj;
|
|
} else {
|
|
throw new PgpGeneralException("Object not recognized as PGPKeyRing!");
|
|
}
|
|
}
|
|
}
|
|
|
|
// verify downloaded key by comparing fingerprints
|
|
if (entry.getFingerPrintHex() != null) {
|
|
String downloadedKeyFp = PgpKeyHelper.convertFingerprintToHex(
|
|
downloadedKey.getPublicKey().getFingerprint());
|
|
if (downloadedKeyFp.equals(entry.getFingerPrintHex())) {
|
|
Log.d(Constants.TAG, "fingerprint of downloaded key is the same as " +
|
|
"the requested fingerprint!");
|
|
} else {
|
|
throw new PgpGeneralException("fingerprint of downloaded key is " +
|
|
"NOT the same as the requested fingerprint!");
|
|
}
|
|
}
|
|
|
|
// save key bytes in entry object for doing the
|
|
// actual import afterwards
|
|
entry.setBytes(downloadedKey.getEncoded());
|
|
}
|
|
|
|
|
|
Intent importIntent = new Intent(this, KeychainIntentService.class);
|
|
importIntent.setAction(ACTION_IMPORT_KEYRING);
|
|
Bundle importData = new Bundle();
|
|
importData.putParcelableArrayList(IMPORT_KEY_LIST, entries);
|
|
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
|
|
} catch (Exception e) {
|
|
sendErrorToHandler(e);
|
|
}
|
|
} else if (ACTION_CERTIFY_KEYRING.equals(action)) {
|
|
try {
|
|
|
|
/* 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);
|
|
|
|
/* Operation */
|
|
String signaturePassPhrase = PassphraseCacheService.getCachedPassphrase(this,
|
|
masterKeyId);
|
|
if (signaturePassPhrase == null) {
|
|
throw new PgpGeneralException("Unable to obtain passphrase");
|
|
}
|
|
|
|
PgpKeyOperation keyOperation = new PgpKeyOperation(new ProgressScaler(this, 0, 100, 100));
|
|
PGPPublicKeyRing publicRing = ProviderHelper
|
|
.getPGPPublicKeyRingByKeyId(this, pubKeyId);
|
|
PGPPublicKey publicKey = publicRing.getPublicKey(pubKeyId);
|
|
PGPSecretKey certificationKey = PgpKeyHelper.getCertificationKey(this,
|
|
masterKeyId);
|
|
publicKey = keyOperation.certifyKey(certificationKey, publicKey,
|
|
userIds, signaturePassPhrase);
|
|
publicRing = PGPPublicKeyRing.insertPublicKey(publicRing, publicKey);
|
|
|
|
// store the signed key in our local cache
|
|
PgpImportExport pgpImportExport = new PgpImportExport(this, null);
|
|
int retval = pgpImportExport.storeKeyRingInCache(publicRing);
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void sendErrorToHandler(Exception e) {
|
|
// Service was canceled. Do not send error to handler.
|
|
if (this.mIsCanceled) {
|
|
return;
|
|
}
|
|
// contextualize the exception, if necessary
|
|
if (e instanceof PgpGeneralMsgIdException) {
|
|
e = ((PgpGeneralMsgIdException) e).getContextualized(this);
|
|
}
|
|
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) {
|
|
// Service was canceled. Do not send message to handler.
|
|
if (this.mIsCanceled) {
|
|
return;
|
|
}
|
|
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 progressDialogUpdater 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 progressDialogUpdater=" + 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);
|
|
}
|
|
|
|
@Override
|
|
public boolean hasServiceStopped() {
|
|
return mIsCanceled;
|
|
}
|
|
}
|