519 lines
22 KiB
Java
519 lines
22 KiB
Java
package org.thialfihar.android.apg;
|
|
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.lang.reflect.Method;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
|
|
import org.thialfihar.android.apg.provider.KeyRings;
|
|
import org.thialfihar.android.apg.provider.Keys;
|
|
import org.thialfihar.android.apg.provider.UserIds;
|
|
|
|
import android.content.Intent;
|
|
import android.database.Cursor;
|
|
import android.database.sqlite.SQLiteQueryBuilder;
|
|
import android.os.Bundle;
|
|
import android.os.IBinder;
|
|
import android.util.Log;
|
|
|
|
public class ApgService extends Service {
|
|
private final static String TAG = "ApgService";
|
|
private static final boolean LOCAL_LOGV = true;
|
|
private static final boolean LOCAL_LOGD = true;
|
|
|
|
@Override
|
|
public IBinder onBind(Intent intent) {
|
|
if( LOCAL_LOGD ) Log.d(TAG, "bound");
|
|
return mBinder;
|
|
}
|
|
|
|
/** error status */
|
|
private enum error {
|
|
ARGUMENTS_MISSING,
|
|
APG_FAILURE,
|
|
NO_MATCHING_SECRET_KEY,
|
|
PRIVATE_KEY_PASSPHRASE_WRONG,
|
|
PRIVATE_KEY_PASSPHRASE_MISSING;
|
|
|
|
public int shiftedOrdinal() {
|
|
return ordinal() + 100;
|
|
}
|
|
}
|
|
|
|
/** all arguments that can be passed by calling application */
|
|
private enum arg {
|
|
MESSAGE, // message to encrypt or to decrypt
|
|
SYMMETRIC_PASSPHRASE, // key for symmetric en/decryption
|
|
PUBLIC_KEYS, // public keys for encryption
|
|
ENCRYPTION_ALGORYTHM, // encryption algorithm
|
|
HASH_ALGORYTHM, // hash algorithm
|
|
ARMORED_OUTPUT, // whether to armor output
|
|
FORCE_V3_SIGNATURE, // whether to force v3 signature
|
|
COMPRESSION, // what compression to use for encrypted output
|
|
SIGNATURE_KEY, // key for signing
|
|
PRIVATE_KEY_PASSPHRASE, // passphrase for encrypted private key
|
|
KEY_TYPE, // type of key (private or public)
|
|
}
|
|
|
|
/** all things that might be returned */
|
|
private enum ret {
|
|
ERRORS, // string array list with errors
|
|
WARNINGS, // string array list with warnings
|
|
ERROR, // numeric error
|
|
RESULT, // en-/decrypted
|
|
FINGERPRINTS, // fingerprints of keys
|
|
USER_IDS, // user ids
|
|
}
|
|
|
|
/** required arguments for each AIDL function */
|
|
private static final HashMap<String, HashSet<arg>> FUNCTIONS_REQUIRED_ARGS = new HashMap<String, HashSet<arg>>();
|
|
static {
|
|
HashSet<arg> args = new HashSet<arg>();
|
|
args.add(arg.SYMMETRIC_PASSPHRASE);
|
|
args.add(arg.MESSAGE);
|
|
FUNCTIONS_REQUIRED_ARGS.put("encrypt_with_passphrase", args);
|
|
|
|
args = new HashSet<arg>();
|
|
args.add(arg.PUBLIC_KEYS);
|
|
args.add(arg.MESSAGE);
|
|
FUNCTIONS_REQUIRED_ARGS.put("encrypt_with_public_key", args);
|
|
|
|
args = new HashSet<arg>();
|
|
args.add(arg.MESSAGE);
|
|
FUNCTIONS_REQUIRED_ARGS.put("decrypt", args);
|
|
|
|
args = new HashSet<arg>();
|
|
args.add(arg.KEY_TYPE);
|
|
FUNCTIONS_REQUIRED_ARGS.put("get_keys", args);
|
|
}
|
|
|
|
/** optional arguments for each AIDL function */
|
|
private static final HashMap<String, HashSet<arg>> FUNCTIONS_OPTIONAL_ARGS = new HashMap<String, HashSet<arg>>();
|
|
static {
|
|
HashSet<arg> args = new HashSet<arg>();
|
|
args.add(arg.ENCRYPTION_ALGORYTHM);
|
|
args.add(arg.HASH_ALGORYTHM);
|
|
args.add(arg.ARMORED_OUTPUT);
|
|
args.add(arg.FORCE_V3_SIGNATURE);
|
|
args.add(arg.COMPRESSION);
|
|
args.add(arg.PRIVATE_KEY_PASSPHRASE);
|
|
args.add(arg.SIGNATURE_KEY);
|
|
FUNCTIONS_OPTIONAL_ARGS.put("encrypt_with_passphrase", args);
|
|
FUNCTIONS_OPTIONAL_ARGS.put("encrypt_with_public_key", args);
|
|
|
|
args = new HashSet<arg>();
|
|
args.add(arg.SYMMETRIC_PASSPHRASE);
|
|
args.add(arg.PUBLIC_KEYS);
|
|
args.add(arg.PRIVATE_KEY_PASSPHRASE);
|
|
FUNCTIONS_OPTIONAL_ARGS.put("decrypt", args);
|
|
}
|
|
|
|
/** a map from ApgService parameters to function calls to get the default */
|
|
private static final HashMap<arg, String> FUNCTIONS_DEFAULTS = new HashMap<arg, String>();
|
|
static {
|
|
FUNCTIONS_DEFAULTS.put(arg.ENCRYPTION_ALGORYTHM, "getDefaultEncryptionAlgorithm");
|
|
FUNCTIONS_DEFAULTS.put(arg.HASH_ALGORYTHM, "getDefaultHashAlgorithm");
|
|
FUNCTIONS_DEFAULTS.put(arg.ARMORED_OUTPUT, "getDefaultAsciiArmour");
|
|
FUNCTIONS_DEFAULTS.put(arg.FORCE_V3_SIGNATURE, "getForceV3Signatures");
|
|
FUNCTIONS_DEFAULTS.put(arg.COMPRESSION, "getDefaultMessageCompression");
|
|
}
|
|
|
|
/** a map of the default function names to their method */
|
|
private static final HashMap<String, Method> FUNCTIONS_DEFAULTS_METHODS = new HashMap<String, Method>();
|
|
static {
|
|
try {
|
|
FUNCTIONS_DEFAULTS_METHODS.put("getDefaultEncryptionAlgorithm", Preferences.class.getMethod("getDefaultEncryptionAlgorithm"));
|
|
FUNCTIONS_DEFAULTS_METHODS.put("getDefaultHashAlgorithm", Preferences.class.getMethod("getDefaultHashAlgorithm"));
|
|
FUNCTIONS_DEFAULTS_METHODS.put("getDefaultAsciiArmour", Preferences.class.getMethod("getDefaultAsciiArmour"));
|
|
FUNCTIONS_DEFAULTS_METHODS.put("getForceV3Signatures", Preferences.class.getMethod("getForceV3Signatures"));
|
|
FUNCTIONS_DEFAULTS_METHODS.put("getDefaultMessageCompression", Preferences.class.getMethod("getDefaultMessageCompression"));
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Function method exception: " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
private static Cursor getKeyEntries(HashMap<String, Object> pParams) {
|
|
SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
|
|
qb.setTables(KeyRings.TABLE_NAME + " INNER JOIN " + Keys.TABLE_NAME + " ON " + "(" + KeyRings.TABLE_NAME + "." + KeyRings._ID + " = " + Keys.TABLE_NAME
|
|
+ "." + Keys.KEY_RING_ID + " AND " + Keys.TABLE_NAME + "." + Keys.IS_MASTER_KEY + " = '1'" + ") " + " INNER JOIN " + UserIds.TABLE_NAME
|
|
+ " ON " + "(" + Keys.TABLE_NAME + "." + Keys._ID + " = " + UserIds.TABLE_NAME + "." + UserIds.KEY_ID + " AND " + UserIds.TABLE_NAME + "."
|
|
+ UserIds.RANK + " = '0') ");
|
|
|
|
String orderBy = pParams.containsKey("order_by") ? (String) pParams.get("order_by") : UserIds.TABLE_NAME + "." + UserIds.USER_ID + " ASC";
|
|
|
|
String typeVal[] = null;
|
|
String typeWhere = null;
|
|
if (pParams.containsKey("key_type")) {
|
|
typeWhere = KeyRings.TABLE_NAME + "." + KeyRings.TYPE + " = ?";
|
|
typeVal = new String[] {
|
|
"" + pParams.get("key_type")
|
|
};
|
|
}
|
|
return qb.query(Apg.getDatabase().db(), (String[]) pParams.get("columns"), typeWhere, typeVal, null, null, orderBy);
|
|
}
|
|
|
|
/**
|
|
* maps a fingerprint or user id of a key to a master key in database
|
|
*
|
|
* @param search_key
|
|
* fingerprint or user id to search for
|
|
* @return master key if found, or 0
|
|
*/
|
|
private static long getMasterKey(String pSearchKey, Bundle pReturn) {
|
|
if (pSearchKey == null || pSearchKey.length() != 8) {
|
|
return 0;
|
|
}
|
|
ArrayList<String> keyList = new ArrayList<String>();
|
|
keyList.add(pSearchKey);
|
|
long[] keys = getMasterKey(keyList, pReturn);
|
|
if (keys.length > 0) {
|
|
return keys[0];
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* maps fingerprints or user ids of keys to master keys in database
|
|
*
|
|
* @param search_keys
|
|
* a list of keys (fingerprints or user ids) to look for in
|
|
* database
|
|
* @return an array of master keys
|
|
*/
|
|
private static long[] getMasterKey(ArrayList<String> pSearchKeys, Bundle pReturn) {
|
|
|
|
HashMap<String, Object> qParams = new HashMap<String, Object>();
|
|
qParams.put("columns", new String[] {
|
|
KeyRings.TABLE_NAME + "." + KeyRings.MASTER_KEY_ID, // 0
|
|
UserIds.TABLE_NAME + "." + UserIds.USER_ID, // 1
|
|
});
|
|
qParams.put("key_type", Id.database.type_public);
|
|
|
|
Cursor mCursor = getKeyEntries(qParams);
|
|
|
|
if( LOCAL_LOGV ) Log.v(TAG, "going through installed user keys");
|
|
ArrayList<Long> masterKeys = new ArrayList<Long>();
|
|
while (mCursor.moveToNext()) {
|
|
long curMkey = mCursor.getLong(0);
|
|
String curUser = mCursor.getString(1);
|
|
|
|
String curFprint = Apg.getSmallFingerPrint(curMkey);
|
|
if( LOCAL_LOGV ) Log.v(TAG, "current user: " + curUser + " (" + curFprint + ")");
|
|
if (pSearchKeys.contains(curFprint) || pSearchKeys.contains(curUser)) {
|
|
if( LOCAL_LOGV ) Log.v(TAG, "master key found for: " + curFprint);
|
|
masterKeys.add(curMkey);
|
|
pSearchKeys.remove(curFprint);
|
|
} else {
|
|
if( LOCAL_LOGV ) Log.v(TAG, "Installed key " + curFprint + " is not in the list of public keys to encrypt with");
|
|
}
|
|
}
|
|
mCursor.close();
|
|
|
|
long[] masterKeyLongs = new long[masterKeys.size()];
|
|
int i = 0;
|
|
for (Long key : masterKeys) {
|
|
masterKeyLongs[i++] = key;
|
|
}
|
|
|
|
if (i == 0) {
|
|
Log.w(TAG, "Found not one public key");
|
|
pReturn.getStringArrayList(ret.WARNINGS.name()).add("Searched for public key(s) but found not one");
|
|
}
|
|
|
|
for (String key : pSearchKeys) {
|
|
Log.w(TAG, "Searched for key " + key + " but cannot find it in APG");
|
|
pReturn.getStringArrayList(ret.WARNINGS.name()).add("Searched for key " + key + " but cannot find it in APG");
|
|
}
|
|
|
|
return masterKeyLongs;
|
|
}
|
|
|
|
/**
|
|
* Add default arguments if missing
|
|
*
|
|
* @param args
|
|
* the bundle to add default parameters to if missing
|
|
*/
|
|
private void addDefaultArguments(String pCall, Bundle pArgs) {
|
|
// check whether there are optional elements defined for that call
|
|
if (FUNCTIONS_OPTIONAL_ARGS.containsKey(pCall)) {
|
|
Preferences preferences = Preferences.getPreferences(getBaseContext(), true);
|
|
|
|
Iterator<arg> iter = FUNCTIONS_DEFAULTS.keySet().iterator();
|
|
while (iter.hasNext()) {
|
|
arg currentArg = iter.next();
|
|
String currentKey = currentArg.name();
|
|
if (!pArgs.containsKey(currentKey) && FUNCTIONS_OPTIONAL_ARGS.get(pCall).contains(currentArg)) {
|
|
String currentFunctionName = FUNCTIONS_DEFAULTS.get(currentArg);
|
|
try {
|
|
Class<?> returnType = FUNCTIONS_DEFAULTS_METHODS.get(currentFunctionName).getReturnType();
|
|
if (returnType == String.class) {
|
|
pArgs.putString(currentKey, (String) FUNCTIONS_DEFAULTS_METHODS.get(currentFunctionName).invoke(preferences));
|
|
} else if (returnType == boolean.class) {
|
|
pArgs.putBoolean(currentKey, (Boolean) FUNCTIONS_DEFAULTS_METHODS.get(currentFunctionName).invoke(preferences));
|
|
} else if (returnType == int.class) {
|
|
pArgs.putInt(currentKey, (Integer) FUNCTIONS_DEFAULTS_METHODS.get(currentFunctionName).invoke(preferences));
|
|
} else {
|
|
Log.e(TAG, "Unknown return type " + returnType.toString() + " for default option");
|
|
}
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Exception in add_default_arguments " + e.getMessage());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* updates a Bundle with default return values
|
|
*
|
|
* @param pReturn
|
|
* the Bundle to update
|
|
*/
|
|
private void addDefaultReturns(Bundle pReturn) {
|
|
ArrayList<String> errors = new ArrayList<String>();
|
|
ArrayList<String> warnings = new ArrayList<String>();
|
|
|
|
pReturn.putStringArrayList(ret.ERRORS.name(), errors);
|
|
pReturn.putStringArrayList(ret.WARNINGS.name(), warnings);
|
|
}
|
|
|
|
/**
|
|
* checks for required arguments and adds them to the error if missing
|
|
*
|
|
* @param function
|
|
* the functions required arguments to check for
|
|
* @param pArgs
|
|
* the Bundle of arguments to check
|
|
* @param pReturn
|
|
* the bundle to write errors to
|
|
*/
|
|
private void checkForRequiredArgs(String pFunction, Bundle pArgs, Bundle pReturn) {
|
|
if (FUNCTIONS_REQUIRED_ARGS.containsKey(pFunction)) {
|
|
Iterator<arg> iter = FUNCTIONS_REQUIRED_ARGS.get(pFunction).iterator();
|
|
while (iter.hasNext()) {
|
|
String curArg = iter.next().name();
|
|
if (!pArgs.containsKey(curArg)) {
|
|
pReturn.getStringArrayList(ret.ERRORS.name()).add("Argument missing: " + curArg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* checks for unknown arguments and add them to warning if found
|
|
*
|
|
* @param function
|
|
* the functions name to check against
|
|
* @param pArgs
|
|
* the Bundle of arguments to check
|
|
* @param pReturn
|
|
* the bundle to write warnings to
|
|
*/
|
|
private void checkForUnknownArgs(String pFunction, Bundle pArgs, Bundle pReturn) {
|
|
|
|
HashSet<arg> allArgs = new HashSet<arg>();
|
|
if (FUNCTIONS_REQUIRED_ARGS.containsKey(pFunction)) {
|
|
allArgs.addAll(FUNCTIONS_REQUIRED_ARGS.get(pFunction));
|
|
}
|
|
if (FUNCTIONS_OPTIONAL_ARGS.containsKey(pFunction)) {
|
|
allArgs.addAll(FUNCTIONS_OPTIONAL_ARGS.get(pFunction));
|
|
}
|
|
|
|
ArrayList<String> unknownArgs = new ArrayList<String>();
|
|
Iterator<String> iter = pArgs.keySet().iterator();
|
|
while (iter.hasNext()) {
|
|
String curKey = iter.next();
|
|
try {
|
|
arg curArg = arg.valueOf(curKey);
|
|
if (!allArgs.contains(curArg)) {
|
|
pReturn.getStringArrayList(ret.WARNINGS.name()).add("Unknown argument: " + curKey);
|
|
unknownArgs.add(curKey);
|
|
}
|
|
} catch (Exception e) {
|
|
pReturn.getStringArrayList(ret.WARNINGS.name()).add("Unknown argument: " + curKey);
|
|
unknownArgs.add(curKey);
|
|
}
|
|
}
|
|
|
|
// remove unknown arguments so our bundle has just what we need
|
|
for (String arg : unknownArgs) {
|
|
pArgs.remove(arg);
|
|
}
|
|
}
|
|
|
|
private boolean prepareArgs(String pCall, Bundle pArgs, Bundle pReturn) {
|
|
Apg.initialize(getBaseContext());
|
|
|
|
/* add default return values for all functions */
|
|
addDefaultReturns(pReturn);
|
|
|
|
/* add default arguments if missing */
|
|
addDefaultArguments(pCall, pArgs);
|
|
if( LOCAL_LOGV ) Log.v(TAG, "add_default_arguments");
|
|
|
|
/* check for required arguments */
|
|
checkForRequiredArgs(pCall, pArgs, pReturn);
|
|
if( LOCAL_LOGV ) Log.v(TAG, "check_required_args");
|
|
|
|
/* check for unknown arguments and add to warning if found */
|
|
checkForUnknownArgs(pCall, pArgs, pReturn);
|
|
if( LOCAL_LOGV ) Log.v(TAG, "check_unknown_args");
|
|
|
|
/* return if errors happened */
|
|
if (pReturn.getStringArrayList(ret.ERRORS.name()).size() != 0) {
|
|
if( LOCAL_LOGV ) Log.v(TAG, "Errors after preparing, not executing "+pCall);
|
|
pReturn.putInt(ret.ERROR.name(), error.ARGUMENTS_MISSING.shiftedOrdinal());
|
|
return false;
|
|
}
|
|
if( LOCAL_LOGV ) Log.v(TAG, "error return");
|
|
|
|
return true;
|
|
}
|
|
|
|
private boolean encrypt(Bundle pArgs, Bundle pReturn) {
|
|
|
|
long pubMasterKeys[] = {};
|
|
if (pArgs.containsKey(arg.PUBLIC_KEYS.name())) {
|
|
ArrayList<String> list = pArgs.getStringArrayList(arg.PUBLIC_KEYS.name());
|
|
ArrayList<String> pubKeys = new ArrayList<String>();
|
|
if( LOCAL_LOGV ) Log.v(TAG, "Long size: " + list.size());
|
|
Iterator<String> iter = list.iterator();
|
|
while (iter.hasNext()) {
|
|
pubKeys.add(iter.next());
|
|
}
|
|
pubMasterKeys = getMasterKey(pubKeys, pReturn);
|
|
}
|
|
|
|
InputStream inStream = new ByteArrayInputStream(pArgs.getString(arg.MESSAGE.name()).getBytes());
|
|
InputData in = new InputData(inStream, 0); // XXX Size second param?
|
|
|
|
OutputStream out = new ByteArrayOutputStream();
|
|
if( LOCAL_LOGV ) Log.v(TAG, "About to encrypt");
|
|
try {
|
|
Apg.encrypt(getBaseContext(), // context
|
|
in, // input stream
|
|
out, // output stream
|
|
pArgs.getBoolean(arg.ARMORED_OUTPUT.name()), // ARMORED_OUTPUT
|
|
pubMasterKeys, // encryption keys
|
|
getMasterKey(pArgs.getString(arg.SIGNATURE_KEY.name()), pReturn), // signature key
|
|
pArgs.getString(arg.PRIVATE_KEY_PASSPHRASE.name()), // signature passphrase
|
|
null, // progress
|
|
pArgs.getInt(arg.ENCRYPTION_ALGORYTHM.name()), // encryption
|
|
pArgs.getInt(arg.HASH_ALGORYTHM.name()), // hash
|
|
pArgs.getInt(arg.COMPRESSION.name()), // compression
|
|
pArgs.getBoolean(arg.FORCE_V3_SIGNATURE.name()), // mPreferences.getForceV3Signatures(),
|
|
pArgs.getString(arg.SYMMETRIC_PASSPHRASE.name()) // passPhrase
|
|
);
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Exception in encrypt");
|
|
String msg = e.getMessage();
|
|
if (msg.equals(getBaseContext().getString(R.string.error_noSignaturePassPhrase))) {
|
|
pReturn.getStringArrayList(ret.ERRORS.name()).add("Cannot encrypt (" + arg.PRIVATE_KEY_PASSPHRASE.name() + " missing): " + msg);
|
|
pReturn.putInt(ret.ERROR.name(), error.PRIVATE_KEY_PASSPHRASE_MISSING.shiftedOrdinal());
|
|
} else if (msg.equals(getBaseContext().getString(R.string.error_couldNotExtractPrivateKey))) {
|
|
pReturn.getStringArrayList(ret.ERRORS.name()).add("Cannot encrypt (" + arg.PRIVATE_KEY_PASSPHRASE.name() + " probably wrong): " + msg);
|
|
pReturn.putInt(ret.ERROR.name(), error.PRIVATE_KEY_PASSPHRASE_WRONG.shiftedOrdinal());
|
|
} else {
|
|
pReturn.getStringArrayList(ret.ERRORS.name()).add("Internal failure (" + e.getClass() + ") in APG when encrypting: " + e.getMessage());
|
|
pReturn.putInt(ret.ERROR.name(), error.APG_FAILURE.shiftedOrdinal());
|
|
}
|
|
return false;
|
|
}
|
|
if( LOCAL_LOGV ) Log.v(TAG, "Encrypted");
|
|
pReturn.putString(ret.RESULT.name(), out.toString());
|
|
return true;
|
|
}
|
|
|
|
private final IApgService.Stub mBinder = new IApgService.Stub() {
|
|
|
|
public boolean getKeys(Bundle pArgs, Bundle pReturn) {
|
|
|
|
prepareArgs("get_keys", pArgs, pReturn);
|
|
|
|
HashMap<String, Object> qParams = new HashMap<String, Object>();
|
|
qParams.put("columns", new String[] {
|
|
KeyRings.TABLE_NAME + "." + KeyRings.MASTER_KEY_ID, // 0
|
|
UserIds.TABLE_NAME + "." + UserIds.USER_ID, // 1
|
|
});
|
|
|
|
qParams.put("key_type", pArgs.getInt(arg.KEY_TYPE.name()));
|
|
|
|
Cursor cursor = getKeyEntries(qParams);
|
|
ArrayList<String> fPrints = new ArrayList<String>();
|
|
ArrayList<String> ids = new ArrayList<String>();
|
|
while (cursor.moveToNext()) {
|
|
if( LOCAL_LOGV ) Log.v(TAG, "adding key "+Apg.getSmallFingerPrint(cursor.getLong(0)));
|
|
fPrints.add(Apg.getSmallFingerPrint(cursor.getLong(0)));
|
|
ids.add(cursor.getString(1));
|
|
}
|
|
cursor.close();
|
|
|
|
pReturn.putStringArrayList(ret.FINGERPRINTS.name(), fPrints);
|
|
pReturn.putStringArrayList(ret.USER_IDS.name(), ids);
|
|
return true;
|
|
}
|
|
|
|
public boolean encryptWithPublicKey(Bundle pArgs, Bundle pReturn) {
|
|
if (!prepareArgs("encrypt_with_public_key", pArgs, pReturn)) {
|
|
return false;
|
|
}
|
|
|
|
return encrypt(pArgs, pReturn);
|
|
}
|
|
|
|
public boolean encryptWithPassphrase(Bundle pArgs, Bundle pReturn) {
|
|
if (!prepareArgs("encrypt_with_passphrase", pArgs, pReturn)) {
|
|
return false;
|
|
}
|
|
|
|
return encrypt(pArgs, pReturn);
|
|
|
|
}
|
|
|
|
public boolean decrypt(Bundle pArgs, Bundle pReturn) {
|
|
if (!prepareArgs("decrypt", pArgs, pReturn)) {
|
|
return false;
|
|
}
|
|
|
|
String passphrase = pArgs.getString(arg.SYMMETRIC_PASSPHRASE.name()) != null ? pArgs.getString(arg.SYMMETRIC_PASSPHRASE.name()) : pArgs
|
|
.getString(arg.PRIVATE_KEY_PASSPHRASE.name());
|
|
|
|
InputStream inStream = new ByteArrayInputStream(pArgs.getString(arg.MESSAGE.name()).getBytes());
|
|
InputData in = new InputData(inStream, 0); // XXX what size in second parameter?
|
|
OutputStream out = new ByteArrayOutputStream();
|
|
if( LOCAL_LOGV ) Log.v(TAG, "About to decrypt");
|
|
try {
|
|
Apg.decrypt(getBaseContext(), in, out, passphrase, null, // progress
|
|
pArgs.getString(arg.SYMMETRIC_PASSPHRASE.name()) != null // symmetric
|
|
);
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Exception in decrypt");
|
|
String msg = e.getMessage();
|
|
if (msg.equals(getBaseContext().getString(R.string.error_noSecretKeyFound))) {
|
|
pReturn.getStringArrayList(ret.ERRORS.name()).add("Cannot decrypt: " + msg);
|
|
pReturn.putInt(ret.ERROR.name(), error.NO_MATCHING_SECRET_KEY.shiftedOrdinal());
|
|
} else if (msg.equals(getBaseContext().getString(R.string.error_wrongPassPhrase))) {
|
|
pReturn.getStringArrayList(ret.ERRORS.name()).add("Cannot decrypt (" + arg.PRIVATE_KEY_PASSPHRASE.name() + " wrong/missing): " + msg);
|
|
pReturn.putInt(ret.ERROR.name(), error.PRIVATE_KEY_PASSPHRASE_WRONG.shiftedOrdinal());
|
|
} else {
|
|
pReturn.getStringArrayList(ret.ERRORS.name()).add("Internal failure (" + e.getClass() + ") in APG when decrypting: " + msg);
|
|
pReturn.putInt(ret.ERROR.name(), error.APG_FAILURE.shiftedOrdinal());
|
|
}
|
|
return false;
|
|
}
|
|
if( LOCAL_LOGV ) Log.v(TAG, "Decrypted");
|
|
|
|
pReturn.putString(ret.RESULT.name(), out.toString());
|
|
return true;
|
|
}
|
|
|
|
};
|
|
}
|