2012-11-14 10:02:11 -05:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
package org.sufficientlysecure.keychain.service;
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
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;
|
2013-01-16 08:31:16 -05:00
|
|
|
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;
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
2013-01-16 08:31:16 -05:00
|
|
|
public class KeychainIntentService extends IntentService implements ProgressDialogUpdater {
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
2013-01-08 11:01:45 -05:00
|
|
|
public static final int ACTION_IMPORT_KEYRING = 50;
|
|
|
|
public static final int ACTION_EXPORT_KEYRING = 51;
|
2012-11-14 10:02:11 -05:00
|
|
|
|
2013-01-08 11:01:45 -05:00
|
|
|
public static final int ACTION_UPLOAD_KEYRING = 60;
|
|
|
|
public static final int ACTION_QUERY_KEYRING = 61;
|
2012-11-14 10:02:11 -05:00
|
|
|
|
2013-01-08 11:01:45 -05:00
|
|
|
public static final int ACTION_SIGN_KEYRING = 70;
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
/* 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
|
2012-12-12 13:14:09 -05:00
|
|
|
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";
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
// decrypt/verify
|
2012-12-12 13:14:09 -05:00
|
|
|
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";
|
2013-03-21 10:18:38 -04:00
|
|
|
public static final String SAVE_KEYRING_CAN_SIGN = "can_sign";
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
// generate key
|
2012-12-12 13:14:09 -05:00
|
|
|
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";
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
// 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";
|
2013-01-08 11:01:45 -05:00
|
|
|
// public static final String IMPORT_KEY_TYPE = "importKeyType";
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
// 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";
|
2013-01-08 11:48:56 -05:00
|
|
|
public static final String EXPORT_KEY_RING_MASTER_KEY_ID = "exportKeyRingId";
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
public KeychainIntentService() {
|
2012-11-14 10:02:11 -05:00
|
|
|
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);
|
|
|
|
|
2012-12-12 13:14:09 -05:00
|
|
|
long secretKeyId = data.getLong(ENCRYPT_SECRET_KEY_ID);
|
|
|
|
String encryptionPassphrase = data.getString(GENERATE_KEY_SYMMETRIC_PASSPHRASE);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
2012-12-12 13:14:09 -05:00
|
|
|
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);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
InputStream inStream = null;
|
|
|
|
long inLength = -1;
|
|
|
|
InputData inputData = null;
|
|
|
|
OutputStream outStream = null;
|
|
|
|
String streamFilename = null;
|
|
|
|
switch (target) {
|
|
|
|
case TARGET_BYTES: /* encrypting bytes directly */
|
2012-12-12 13:14:09 -05:00
|
|
|
byte[] bytes = data.getByteArray(ENCRYPT_MESSAGE_BYTES);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
inStream = new ByteArrayInputStream(bytes);
|
|
|
|
inLength = bytes.length;
|
|
|
|
|
|
|
|
inputData = new InputData(inStream, inLength);
|
|
|
|
outStream = new ByteArrayOutputStream();
|
|
|
|
|
|
|
|
break;
|
|
|
|
case TARGET_FILE: /* encrypting file */
|
2012-12-12 13:14:09 -05:00
|
|
|
String inputFile = data.getString(ENCRYPT_INPUT_FILE);
|
|
|
|
String outputFile = data.getString(ENCRYPT_OUTPUT_FILE);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
// check if storage is ready
|
|
|
|
if (!FileHelper.isStorageMounted(inputFile)
|
|
|
|
|| !FileHelper.isStorageMounted(outputFile)) {
|
2013-01-16 08:31:16 -05:00
|
|
|
throw new PgpGeneralException(
|
2012-11-14 10:02:11 -05:00
|
|
|
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 */
|
2012-12-12 13:14:09 -05:00
|
|
|
Uri providerUri = (Uri) data.getParcelable(ENCRYPT_PROVIDER_URI);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
// InputStream
|
|
|
|
InputStream in = getContentResolver().openInputStream(providerUri);
|
2013-01-16 08:31:16 -05:00
|
|
|
inLength = PgpMain.getLengthOfStream(in);
|
2012-11-14 10:02:11 -05:00
|
|
|
inputData = new InputData(in, inLength);
|
|
|
|
|
|
|
|
// OutputStream
|
|
|
|
try {
|
|
|
|
while (true) {
|
2013-01-16 08:31:16 -05:00
|
|
|
streamFilename = PgpMain.generateRandomFilename(32);
|
2012-11-14 10:02:11 -05:00
|
|
|
if (streamFilename == null) {
|
2013-01-16 08:31:16 -05:00
|
|
|
throw new PgpMain.PgpGeneralException(
|
2012-11-14 10:02:11 -05:00
|
|
|
"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:
|
2013-01-16 08:31:16 -05:00
|
|
|
throw new PgpMain.PgpGeneralException("No target choosen!");
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Operation */
|
|
|
|
|
|
|
|
if (generateSignature) {
|
|
|
|
Log.d(Constants.TAG, "generating signature...");
|
2013-01-16 08:31:16 -05:00
|
|
|
PgpMain.generateSignature(this, this, inputData, outStream, useAsciiArmor,
|
2012-11-14 10:02:11 -05:00
|
|
|
false, secretKeyId, PassphraseCacheService.getCachedPassphrase(this,
|
|
|
|
secretKeyId), Preferences.getPreferences(this)
|
|
|
|
.getDefaultHashAlgorithm(), Preferences.getPreferences(this)
|
|
|
|
.getForceV3Signatures());
|
|
|
|
} else if (signOnly) {
|
|
|
|
Log.d(Constants.TAG, "sign only...");
|
2013-01-16 08:31:16 -05:00
|
|
|
PgpMain.signText(this, this, inputData, outStream, secretKeyId,
|
2012-11-14 10:02:11 -05:00
|
|
|
PassphraseCacheService.getCachedPassphrase(this, secretKeyId),
|
|
|
|
Preferences.getPreferences(this).getDefaultHashAlgorithm(), Preferences
|
|
|
|
.getPreferences(this).getForceV3Signatures());
|
|
|
|
} else {
|
|
|
|
Log.d(Constants.TAG, "encrypt...");
|
2013-01-16 08:31:16 -05:00
|
|
|
PgpMain.encryptAndSign(this, this, inputData, outStream, useAsciiArmor,
|
2012-11-14 10:02:11 -05:00
|
|
|
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");
|
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
2012-11-14 10:02:11 -05:00
|
|
|
} catch (Exception e) {
|
|
|
|
sendErrorToHandler(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACTION_DECRYPT_VERIFY:
|
|
|
|
try {
|
|
|
|
/* Input */
|
|
|
|
int target = data.getInt(TARGET);
|
|
|
|
|
2012-12-12 13:14:09 -05:00
|
|
|
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);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
2012-12-12 13:14:09 -05:00
|
|
|
boolean lookupUnknownKey = data.getBoolean(DECRYPT_LOOKUP_UNKNOWN_KEY);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
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 */
|
2012-12-12 13:14:09 -05:00
|
|
|
String inputFile = data.getString(ENCRYPT_INPUT_FILE);
|
|
|
|
String outputFile = data.getString(ENCRYPT_OUTPUT_FILE);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
// check if storage is ready
|
|
|
|
if (!FileHelper.isStorageMounted(inputFile)
|
|
|
|
|| !FileHelper.isStorageMounted(outputFile)) {
|
2013-01-16 08:31:16 -05:00
|
|
|
throw new PgpGeneralException(
|
2012-11-14 10:02:11 -05:00
|
|
|
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 */
|
2012-12-12 13:14:09 -05:00
|
|
|
Uri providerUri = (Uri) data.getParcelable(ENCRYPT_PROVIDER_URI);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
// InputStream
|
|
|
|
InputStream in = getContentResolver().openInputStream(providerUri);
|
2013-01-16 08:31:16 -05:00
|
|
|
inLength = PgpMain.getLengthOfStream(in);
|
2012-11-14 10:02:11 -05:00
|
|
|
inputData = new InputData(in, inLength);
|
|
|
|
|
|
|
|
// OutputStream
|
|
|
|
try {
|
|
|
|
while (true) {
|
2013-01-16 08:31:16 -05:00
|
|
|
streamFilename = PgpMain.generateRandomFilename(32);
|
2012-11-14 10:02:11 -05:00
|
|
|
if (streamFilename == null) {
|
2013-01-16 08:31:16 -05:00
|
|
|
throw new PgpMain.PgpGeneralException(
|
2012-11-14 10:02:11 -05:00
|
|
|
"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:
|
2013-01-16 08:31:16 -05:00
|
|
|
throw new PgpMain.PgpGeneralException("No target choosen!");
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Operation */
|
|
|
|
|
|
|
|
Bundle resultData = new Bundle();
|
|
|
|
|
|
|
|
// verifyText and decrypt returning additional resultData values for the
|
|
|
|
// verification of signatures
|
|
|
|
if (signedOnly) {
|
2013-01-16 08:31:16 -05:00
|
|
|
resultData = PgpMain.verifyText(this, this, inputData, outStream,
|
2012-11-14 10:02:11 -05:00
|
|
|
lookupUnknownKey);
|
|
|
|
} else {
|
2013-01-16 08:31:16 -05:00
|
|
|
resultData = PgpMain.decryptAndVerify(this, this, inputData, outStream,
|
2012-11-14 10:02:11 -05:00
|
|
|
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");
|
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
2012-11-14 10:02:11 -05:00
|
|
|
} catch (Exception e) {
|
|
|
|
sendErrorToHandler(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACTION_SAVE_KEYRING:
|
|
|
|
|
|
|
|
try {
|
|
|
|
/* Input */
|
2012-12-12 13:14:09 -05:00
|
|
|
String oldPassPhrase = data.getString(SAVE_KEYRING_CURRENT_PASSPHRASE);
|
|
|
|
String newPassPhrase = data.getString(SAVE_KEYRING_NEW_PASSPHRASE);
|
2013-03-21 10:18:38 -04:00
|
|
|
boolean canSign = true;
|
|
|
|
|
|
|
|
if (data.containsKey(SAVE_KEYRING_CAN_SIGN)) {
|
|
|
|
canSign = data.getBoolean(SAVE_KEYRING_CAN_SIGN);
|
|
|
|
}
|
|
|
|
|
2012-11-14 10:02:11 -05:00
|
|
|
if (newPassPhrase == null) {
|
|
|
|
newPassPhrase = oldPassPhrase;
|
|
|
|
}
|
2012-12-12 13:14:09 -05:00
|
|
|
ArrayList<String> userIds = data.getStringArrayList(SAVE_KEYRING_USER_IDS);
|
2013-01-16 08:31:16 -05:00
|
|
|
ArrayList<PGPSecretKey> keys = PgpConversionHelper.BytesToPGPSecretKeyList(data
|
2012-12-12 13:14:09 -05:00
|
|
|
.getByteArray(SAVE_KEYRING_KEYS));
|
|
|
|
ArrayList<Integer> keysUsages = data.getIntegerArrayList(SAVE_KEYRING_KEYS_USAGES);
|
|
|
|
long masterKeyId = data.getLong(SAVE_KEYRING_MASTER_KEY_ID);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
/* Operation */
|
2013-05-13 11:10:11 -04:00
|
|
|
if (!canSign) {
|
|
|
|
PgpMain.changeSecretKeyPassphrase(this, ProviderHelper.getPGPSecretKeyRingByKeyId(this, masterKeyId),
|
|
|
|
oldPassPhrase, newPassPhrase, this);
|
2013-03-21 10:18:38 -04:00
|
|
|
} else {
|
|
|
|
PgpMain.buildSecretKey(this, userIds, keys, keysUsages, masterKeyId, oldPassPhrase,
|
2012-11-14 10:02:11 -05:00
|
|
|
newPassPhrase, this);
|
2013-03-21 10:18:38 -04:00
|
|
|
}
|
2012-11-14 10:02:11 -05:00
|
|
|
PassphraseCacheService.addCachedPassphrase(this, masterKeyId, newPassPhrase);
|
|
|
|
|
|
|
|
/* Output */
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
|
2012-11-14 10:02:11 -05:00
|
|
|
} catch (Exception e) {
|
|
|
|
sendErrorToHandler(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACTION_GENERATE_KEY:
|
|
|
|
|
|
|
|
try {
|
|
|
|
/* Input */
|
2012-12-12 13:14:09 -05:00
|
|
|
int algorithm = data.getInt(GENERATE_KEY_ALGORITHM);
|
|
|
|
String passphrase = data.getString(GENERATE_KEY_SYMMETRIC_PASSPHRASE);
|
|
|
|
int keysize = data.getInt(GENERATE_KEY_KEY_SIZE);
|
2012-11-14 10:02:11 -05:00
|
|
|
PGPSecretKey masterKey = null;
|
2012-12-12 13:14:09 -05:00
|
|
|
if (data.containsKey(GENERATE_KEY_MASTER_KEY)) {
|
2013-01-16 08:31:16 -05:00
|
|
|
masterKey = PgpConversionHelper.BytesToPGPSecretKey(data
|
2012-12-12 13:14:09 -05:00
|
|
|
.getByteArray(GENERATE_KEY_MASTER_KEY));
|
2012-11-14 10:02:11 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Operation */
|
2013-01-16 08:31:16 -05:00
|
|
|
PGPSecretKeyRing newKeyRing = PgpMain.createKey(this, algorithm, keysize,
|
2012-11-14 10:02:11 -05:00
|
|
|
passphrase, masterKey);
|
|
|
|
|
|
|
|
/* Output */
|
|
|
|
Bundle resultData = new Bundle();
|
|
|
|
resultData.putByteArray(RESULT_NEW_KEY,
|
2013-01-16 08:31:16 -05:00
|
|
|
PgpConversionHelper.PGPSecretKeyRingToBytes(newKeyRing));
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
OtherHelper.logDebugBundle(resultData, "resultData");
|
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
2012-11-14 10:02:11 -05:00
|
|
|
} 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 */
|
2012-12-12 13:14:09 -05:00
|
|
|
String passphrase = data.getString(GENERATE_KEY_SYMMETRIC_PASSPHRASE);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
/* Operation */
|
2013-01-16 08:31:16 -05:00
|
|
|
PGPSecretKeyRing masterKeyRing = PgpMain.createKey(this, Id.choice.algorithm.rsa,
|
2012-11-14 10:02:11 -05:00
|
|
|
2048, passphrase, null);
|
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
PGPSecretKeyRing subKeyRing = PgpMain.createKey(this, Id.choice.algorithm.rsa,
|
2012-11-14 10:02:11 -05:00
|
|
|
2048, passphrase, masterKeyRing.getSecretKey());
|
|
|
|
|
|
|
|
/* Output */
|
|
|
|
Bundle resultData = new Bundle();
|
|
|
|
resultData.putByteArray(RESULT_NEW_KEY,
|
2013-01-16 08:31:16 -05:00
|
|
|
PgpConversionHelper.PGPSecretKeyRingToBytes(masterKeyRing));
|
2012-11-14 10:02:11 -05:00
|
|
|
resultData.putByteArray(RESULT_NEW_KEY2,
|
2013-01-16 08:31:16 -05:00
|
|
|
PgpConversionHelper.PGPSecretKeyRingToBytes(subKeyRing));
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
OtherHelper.logDebugBundle(resultData, "resultData");
|
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
2012-11-14 10:02:11 -05:00
|
|
|
} catch (Exception e) {
|
|
|
|
sendErrorToHandler(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACTION_DELETE_FILE_SECURELY:
|
|
|
|
try {
|
|
|
|
/* Input */
|
|
|
|
String deleteFile = data.getString(DELETE_FILE);
|
|
|
|
|
|
|
|
/* Operation */
|
|
|
|
try {
|
2013-01-16 08:31:16 -05:00
|
|
|
PgpMain.deleteFileSecurely(this, this, new File(deleteFile));
|
2012-11-14 10:02:11 -05:00
|
|
|
} catch (FileNotFoundException e) {
|
2013-01-16 08:31:16 -05:00
|
|
|
throw new PgpMain.PgpGeneralException(getString(R.string.error_fileNotFound,
|
2012-11-14 10:02:11 -05:00
|
|
|
deleteFile));
|
|
|
|
} catch (IOException e) {
|
2013-01-16 08:31:16 -05:00
|
|
|
throw new PgpMain.PgpGeneralException(getString(
|
2012-11-14 10:02:11 -05:00
|
|
|
R.string.error_fileDeleteFailed, deleteFile));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Output */
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
|
2012-11-14 10:02:11 -05:00
|
|
|
} catch (Exception e) {
|
|
|
|
sendErrorToHandler(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2013-01-08 11:01:45 -05:00
|
|
|
case ACTION_IMPORT_KEYRING:
|
2012-11-14 10:02:11 -05:00
|
|
|
try {
|
|
|
|
|
|
|
|
/* Input */
|
|
|
|
int target = data.getInt(TARGET);
|
|
|
|
|
2013-01-08 11:01:45 -05:00
|
|
|
// int keyType = Id.type.public_key;
|
|
|
|
// if (data.containsKey(IMPORT_KEY_TYPE)) {
|
|
|
|
// keyType = data.getInt(IMPORT_KEY_TYPE);
|
|
|
|
// }
|
2012-11-14 10:02:11 -05:00
|
|
|
|
|
|
|
/* 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();
|
2013-01-16 08:31:16 -05:00
|
|
|
resultData = PgpMain.importKeyRings(this, inputData, this);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
2012-11-14 10:02:11 -05:00
|
|
|
} catch (Exception e) {
|
|
|
|
sendErrorToHandler(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2013-01-08 11:01:45 -05:00
|
|
|
case ACTION_EXPORT_KEYRING:
|
2012-11-14 10:02:11 -05:00
|
|
|
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);
|
2013-01-08 11:48:56 -05:00
|
|
|
long keyRingMasterKeyId = -1;
|
2012-11-14 10:02:11 -05:00
|
|
|
if (!exportAll) {
|
2013-01-08 11:48:56 -05:00
|
|
|
keyRingMasterKeyId = data.getLong(EXPORT_KEY_RING_MASTER_KEY_ID);
|
2012-11-14 10:02:11 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Operation */
|
|
|
|
|
|
|
|
// check if storage is ready
|
|
|
|
if (!FileHelper.isStorageMounted(outputFile)) {
|
2013-01-16 08:31:16 -05:00
|
|
|
throw new PgpGeneralException(getString(R.string.error_externalStorageNotReady));
|
2012-11-14 10:02:11 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// OutputStream
|
|
|
|
FileOutputStream outStream = new FileOutputStream(outputFile);
|
|
|
|
|
2013-01-08 11:48:56 -05:00
|
|
|
ArrayList<Long> keyRingMasterKeyIds = new ArrayList<Long>();
|
2012-11-14 10:02:11 -05:00
|
|
|
if (exportAll) {
|
2012-11-22 06:47:20 -05:00
|
|
|
// get all key ring row ids based on export type
|
|
|
|
|
2012-11-14 10:02:11 -05:00
|
|
|
if (keyType == Id.type.public_key) {
|
2013-01-08 11:48:56 -05:00
|
|
|
keyRingMasterKeyIds = ProviderHelper.getPublicKeyRingsMasterKeyIds(this);
|
2012-11-14 10:02:11 -05:00
|
|
|
} else {
|
2013-01-08 11:48:56 -05:00
|
|
|
keyRingMasterKeyIds = ProviderHelper.getSecretKeyRingsMasterKeyIds(this);
|
2012-11-14 10:02:11 -05:00
|
|
|
}
|
|
|
|
} else {
|
2013-01-08 11:48:56 -05:00
|
|
|
keyRingMasterKeyIds.add(keyRingMasterKeyId);
|
2012-11-14 10:02:11 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
Bundle resultData = new Bundle();
|
2013-01-16 08:31:16 -05:00
|
|
|
resultData = PgpMain.exportKeyRings(this, keyRingMasterKeyIds, keyType, outStream,
|
2013-01-08 11:48:56 -05:00
|
|
|
this);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
2012-11-14 10:02:11 -05:00
|
|
|
} catch (Exception e) {
|
|
|
|
sendErrorToHandler(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2013-01-08 11:01:45 -05:00
|
|
|
case ACTION_UPLOAD_KEYRING:
|
2012-11-14 10:02:11 -05:00
|
|
|
try {
|
|
|
|
|
|
|
|
/* Input */
|
|
|
|
int keyRingRowId = data.getInt(UPLOAD_KEY_KEYRING_ROW_ID);
|
|
|
|
String keyServer = data.getString(UPLOAD_KEY_SERVER);
|
|
|
|
|
|
|
|
/* Operation */
|
|
|
|
HkpKeyServer server = new HkpKeyServer(keyServer);
|
|
|
|
|
2012-12-12 13:14:09 -05:00
|
|
|
PGPPublicKeyRing keyring = ProviderHelper.getPGPPublicKeyRingByRowId(this,
|
|
|
|
keyRingRowId);
|
2012-11-14 10:02:11 -05:00
|
|
|
if (keyring != null) {
|
2013-01-16 08:31:16 -05:00
|
|
|
boolean uploaded = PgpMain.uploadKeyRingToServer(server,
|
2012-11-14 10:02:11 -05:00
|
|
|
(PGPPublicKeyRing) keyring);
|
|
|
|
if (!uploaded) {
|
2013-01-16 08:31:16 -05:00
|
|
|
throw new PgpGeneralException("Unable to export key to selected server");
|
2012-11-14 10:02:11 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
|
2012-11-14 10:02:11 -05:00
|
|
|
} catch (Exception e) {
|
|
|
|
sendErrorToHandler(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2013-01-08 11:01:45 -05:00
|
|
|
case ACTION_QUERY_KEYRING:
|
2012-11-14 10:02:11 -05:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
2012-11-14 10:02:11 -05:00
|
|
|
} catch (Exception e) {
|
|
|
|
sendErrorToHandler(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2013-01-08 11:01:45 -05:00
|
|
|
case ACTION_SIGN_KEYRING:
|
2012-11-14 10:02:11 -05:00
|
|
|
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);
|
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
PGPPublicKeyRing signedPubKeyRing = PgpMain.signKey(this, masterKeyId, pubKeyId,
|
2012-11-14 10:02:11 -05:00
|
|
|
signaturePassPhrase);
|
|
|
|
|
|
|
|
// store the signed key in our local cache
|
2013-01-16 08:31:16 -05:00
|
|
|
int retval = PgpMain.storeKeyRingInCache(this, signedPubKeyRing);
|
2012-11-14 10:02:11 -05:00
|
|
|
if (retval != Id.return_value.ok && retval != Id.return_value.updated) {
|
2013-01-16 08:31:16 -05:00
|
|
|
throw new PgpGeneralException("Failed to store signed key in local cache");
|
2012-11-14 10:02:11 -05:00
|
|
|
}
|
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
|
2012-11-14 10:02:11 -05:00
|
|
|
} 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();
|
2013-01-16 08:31:16 -05:00
|
|
|
data.putString(KeychainIntentServiceHandler.DATA_ERROR, e.getMessage());
|
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_EXCEPTION, null, data);
|
2012-11-14 10:02:11 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
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) {
|
2013-01-16 08:31:16 -05:00
|
|
|
data.putString(KeychainIntentServiceHandler.DATA_MESSAGE, message);
|
2012-11-14 10:02:11 -05:00
|
|
|
}
|
2013-01-16 08:31:16 -05:00
|
|
|
data.putInt(KeychainIntentServiceHandler.DATA_PROGRESS, progress);
|
|
|
|
data.putInt(KeychainIntentServiceHandler.DATA_PROGRESS_MAX, max);
|
2012-11-14 10:02:11 -05:00
|
|
|
|
2013-01-16 08:31:16 -05:00
|
|
|
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_UPDATE_PROGRESS, null, data);
|
2012-11-14 10:02:11 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|