diff options
Diffstat (limited to 'OpenPGP-Keychain-API-Lib/src')
16 files changed, 1462 insertions, 0 deletions
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/Constants.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/Constants.java new file mode 100644 index 000000000..51998a33e --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/Constants.java @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.integration; + +public class Constants { + public static final String TAG = "Keychain Integration Lib"; + + public static final String KEYCHAIN_PACKAGE_NAME = "org.sufficientlysecure.keychain"; + public static final int MIN_REQUIRED_VERSION = 50; + +} diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainContentProviderHelper.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainContentProviderHelper.java new file mode 100644 index 000000000..bc2a4ad7a --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainContentProviderHelper.java @@ -0,0 +1,266 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * Copyright (C) 2010-2011 K-9 Mail Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.integration; + +import android.content.ContentUris; +import android.content.Context; +import android.database.Cursor; +import android.net.Uri; +import android.widget.Toast; + +public class KeychainContentProviderHelper { + public static final String AUTHORITY = Constants.KEYCHAIN_PACKAGE_NAME; + + public static final Uri CONTENT_URI_PUBLIC_KEY_RING_BY_KEY_ID = Uri.parse("content://" + + AUTHORITY + "/key_rings/public/key_id/"); + public static final Uri CONTENT_URI_PUBLIC_KEY_RING_BY_EMAILS = Uri.parse("content://" + + AUTHORITY + "/key_rings/public/emails/"); + public static final Uri CONTENT_URI_PUBLIC_KEY_RING_BY_LIKE_EMAIL = Uri.parse("content://" + + AUTHORITY + "/key_rings/public/like_email/"); + + public static final Uri CONTENT_URI_SECRET_KEY_RING_BY_KEY_ID = Uri.parse("content://" + + AUTHORITY + "/key_rings/secret/key_id/"); + public static final Uri CONTENT_URI_SECRET_KEY_RING_BY_EMAILS = Uri.parse("content://" + + AUTHORITY + "/key_rings/secret/emails/"); + public static final Uri CONTENT_URI_SECRET_KEY_RING_BY_LIKE_EMAIL = Uri.parse("content://" + + AUTHORITY + "/key_rings/secret/like_email/"); + + private Context mContext; + + public KeychainContentProviderHelper(Context context) { + this.mContext = context; + } + + /** + * Get secret key ids based on a given email. + * + * @param context + * @param email + * The email in question. + * @return key ids + */ + public long[] getSecretKeyringIdsByEmail(String email) { + long ids[] = null; + try { + Uri contentUri = Uri.withAppendedPath(CONTENT_URI_SECRET_KEY_RING_BY_EMAILS, email); + Cursor c = mContext.getContentResolver().query(contentUri, + new String[] { "master_key_id" }, null, null, null); + if (c != null && c.getCount() > 0) { + ids = new long[c.getCount()]; + while (c.moveToNext()) { + ids[c.getPosition()] = c.getLong(0); + } + } + + if (c != null) { + c.close(); + } + } catch (SecurityException e) { + insufficientPermissions(); + } + + return ids; + } + + /** + * Get secret key ids based on a given String that is part of the email. + * + * Example: String: example, then emails: test@example.com, example@google.com are returned + * + * @param context + * @param email + * The email in question. + * @return key ids + */ + public long[] getSecretKeyringIdsByLikeEmail(String likeEmail) { + long ids[] = null; + try { + Uri contentUri = Uri.withAppendedPath(CONTENT_URI_SECRET_KEY_RING_BY_LIKE_EMAIL, + likeEmail); + Cursor c = mContext.getContentResolver().query(contentUri, + new String[] { "master_key_id" }, null, null, null); + if (c != null && c.getCount() > 0) { + ids = new long[c.getCount()]; + while (c.moveToNext()) { + ids[c.getPosition()] = c.getLong(0); + } + } + + if (c != null) { + c.close(); + } + } catch (SecurityException e) { + insufficientPermissions(); + } + + return ids; + } + + /** + * Get public key ids based on a given email. + * + * @param context + * @param email + * The email in question. + * @return key ids + */ + public long[] getPublicKeyringIdsByEmail(String email) { + long ids[] = null; + try { + Uri contentUri = Uri.withAppendedPath(CONTENT_URI_PUBLIC_KEY_RING_BY_EMAILS, email); + Cursor c = mContext.getContentResolver().query(contentUri, + new String[] { "master_key_id" }, null, null, null); + if (c != null && c.getCount() > 0) { + ids = new long[c.getCount()]; + while (c.moveToNext()) { + ids[c.getPosition()] = c.getLong(0); + } + } + + if (c != null) { + c.close(); + } + } catch (SecurityException e) { + insufficientPermissions(); + } + + return ids; + } + + /** + * Get public key ids based on a given String that is part of the email. + * + * Example: String: example, then emails: test@example.com, example@google.com are returned + * + * @param context + * @param email + * The email in question. + * @return key ids + */ + public long[] getPublicKeyringIdsByLikeEmail(String likeEmail) { + long ids[] = null; + try { + Uri contentUri = Uri.withAppendedPath(CONTENT_URI_PUBLIC_KEY_RING_BY_LIKE_EMAIL, + likeEmail); + Cursor c = mContext.getContentResolver().query(contentUri, + new String[] { "master_key_id" }, null, null, null); + if (c != null && c.getCount() > 0) { + ids = new long[c.getCount()]; + while (c.moveToNext()) { + ids[c.getPosition()] = c.getLong(0); + } + } + + if (c != null) { + c.close(); + } + } catch (SecurityException e) { + insufficientPermissions(); + } + + return ids; + } + + /** + * Find out if a given email has a secret key. + * + * @param context + * @param email + * The email in question. + * @return true if there is a secret key for this email. + */ + public boolean hasSecretKeyringByEmail(String email) { + try { + Uri contentUri = Uri.withAppendedPath(CONTENT_URI_SECRET_KEY_RING_BY_EMAILS, email); + Cursor c = mContext.getContentResolver().query(contentUri, + new String[] { "master_key_id" }, null, null, null); + if (c != null && c.getCount() > 0) { + c.close(); + return true; + } + if (c != null) { + c.close(); + } + } catch (SecurityException e) { + insufficientPermissions(); + } + return false; + } + + /** + * Find out if a given email has a public key. + * + * @param context + * @param email + * The email in question. + * @return true if there is a public key for this email. + */ + public boolean hasPublicKeyringByEmail(String email) { + try { + Uri contentUri = Uri.withAppendedPath(CONTENT_URI_PUBLIC_KEY_RING_BY_EMAILS, email); + Cursor c = mContext.getContentResolver().query(contentUri, + new String[] { "master_key_id" }, null, null, null); + if (c != null && c.getCount() > 0) { + c.close(); + return true; + } + if (c != null) { + c.close(); + } + } catch (SecurityException e) { + insufficientPermissions(); + } + return false; + } + + /** + * Get the user id based on the key id. + * + * @param context + * @param keyId + * @return user id + */ + public String getUserId(long keyId) { + String userId = null; + try { + Uri contentUri = ContentUris.withAppendedId(CONTENT_URI_SECRET_KEY_RING_BY_KEY_ID, + keyId); + Cursor c = mContext.getContentResolver().query(contentUri, new String[] { "user_id" }, + null, null, null); + if (c != null && c.moveToFirst()) { + userId = c.getString(0); + } + + if (c != null) { + c.close(); + } + } catch (SecurityException e) { + insufficientPermissions(); + } + + if (userId == null) { + userId = "unknown"; + } + return userId; + } + + private void insufficientPermissions() { + Toast.makeText(mContext, "Permission to access APG Provider is missing!", Toast.LENGTH_LONG) + .show(); + } +} diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainData.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainData.java new file mode 100644 index 000000000..619909c65 --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainData.java @@ -0,0 +1,116 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * Copyright (C) 2010-2011 K-9 Mail Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.integration; + +import java.io.Serializable; +import java.util.Arrays; + +public class KeychainData implements Serializable { + private static final long serialVersionUID = 6314045536270848410L; + protected long[] mPublicKeyIds = null; + protected String[] mPublicUserIds = null; + protected long mSecretKeyId = 0; + protected String mSecretKeyUserId = null; + protected boolean mSignatureSuccess = false; + protected boolean mSignatureUnknown = false; + protected String mDecryptedData = null; + protected String mEncryptedData = null; + + public void setSecretKeyId(long keyId) { + mSecretKeyId = keyId; + } + + public long getSecretKeyId() { + return mSecretKeyId; + } + + public void setPublicKeyIds(long[] keyIds) { + mPublicKeyIds = keyIds; + } + + public long[] getPublicKeys() { + return mPublicKeyIds; + } + + public void setPublicUserIds(String[] userIds) { + mPublicUserIds = userIds; + } + + public String[] getPublicUserIds() { + return mPublicUserIds; + } + + public boolean hasSecretKey() { + return mSecretKeyId != 0; + } + + public boolean hasPublicKeys() { + return (mPublicKeyIds != null) && (mPublicKeyIds.length > 0); + } + + public String getEncryptedData() { + return mEncryptedData; + } + + public void setEncryptedData(String data) { + mEncryptedData = data; + } + + public String getDecryptedData() { + return mDecryptedData; + } + + public void setDecryptedData(String data) { + mDecryptedData = data; + } + + public void setSecretKeyUserId(String userId) { + mSecretKeyUserId = userId; + } + + public String getSecretKeyUserId() { + return mSecretKeyUserId; + } + + public boolean getSignatureSuccess() { + return mSignatureSuccess; + } + + public void setSignatureSuccess(boolean success) { + mSignatureSuccess = success; + } + + public boolean getSignatureUnknown() { + return mSignatureUnknown; + } + + public void setSignatureUnknown(boolean unknown) { + mSignatureUnknown = unknown; + } + + @Override + public String toString() { + String output = "mPublicKeyIds: " + Arrays.toString(mPublicKeyIds) + "\nmSecretKeyId: " + + mSecretKeyId + "\nmSecretKeyUserId: " + mSecretKeyUserId + + "\nmSignatureSuccess: " + mSignatureSuccess + "\nmSignatureUnknown: " + + mSignatureUnknown + "\nmDecryptedData: " + mDecryptedData + "\nmEncryptedData: " + + mEncryptedData; + + return output; + } +}
\ No newline at end of file diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelper.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelper.java new file mode 100644 index 000000000..756dd974b --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelper.java @@ -0,0 +1,451 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * Copyright (C) 2010-2011 K-9 Mail Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.integration; + +import android.app.Activity; +import android.content.ActivityNotFoundException; +import android.content.Intent; +import android.widget.Toast; + +public class KeychainIntentHelper { + + public static final String APG_INTENT_PREFIX = "org.thialfihar.android.apg.intent."; + + // Intents + /** + * Encrypt + */ + // without permission + public static final String ACTION_ENCRYPT = APG_INTENT_PREFIX + "ENCRYPT"; + public static final String ACTION_ENCRYPT_FILE = APG_INTENT_PREFIX + "ENCRYPT_FILE"; + + // with permission + public static final String ACTION_ENCRYPT_AND_RETURN = APG_INTENT_PREFIX + "ENCRYPT_AND_RETURN"; + public static final String ACTION_GENERATE_SIGNATURE_AND_RETURN = APG_INTENT_PREFIX + + "GENERATE_SIGNATURE_AND_RETURN"; + public static final String ACTION_ENCRYPT_STREAM_AND_RETURN = APG_INTENT_PREFIX + + "ENCRYPT_STREAM_AND_RETURN"; + + /** + * Decrypt + */ + // without permission + public static final String ACTION_DECRYPT = APG_INTENT_PREFIX + "DECRYPT"; + public static final String ACTION_DECRYPT_FILE = APG_INTENT_PREFIX + "DECRYPT_FILE"; + + // with permission + public static final String ACTION_DECRYPT_AND_RETURN = APG_INTENT_PREFIX + "DECRYPT_AND_RETURN"; + public static final String ACTION_DECRYPT_STREAM_AND_RETURN = APG_INTENT_PREFIX + + "DECRYPT_STREAM_AND_RETURN"; + + /** + * Select keys, without permission + */ + public static final String ACTION_SELECT_PUBLIC_KEYS = APG_INTENT_PREFIX + "SELECT_PUBLIC_KEYS"; + public static final String ACTION_SELECT_SECRET_KEY = APG_INTENT_PREFIX + "SELECT_SECRET_KEY"; + + /** + * Create key/edit key, without permission + */ + public static final String ACTION_CREATE_KEY = APG_INTENT_PREFIX + "CREATE_KEY"; + public static final String ACTION_EDIT_KEY = APG_INTENT_PREFIX + "EDIT_KEY"; + + /** + * Import actions + */ + public static final String ACTION_IMPORT = APG_INTENT_PREFIX + "IMPORT"; + + // only used by IMPORT + public static final String EXTRA_IMPORT_TEXT = "text"; + public static final String EXTRA_IMPORT_KEYRING_BYTES = "keyringBytes"; + + public static final String ACTION_IMPORT_FROM_FILE = APG_INTENT_PREFIX + "IMPORT_FROM_FILE"; + public static final String ACTION_IMPORT_FROM_QR_CODE = APG_INTENT_PREFIX + + "IMPORT_FROM_QR_CODE"; + + /** + * Share actions + */ + public static final String ACTION_SHARE_KEYRING = APG_INTENT_PREFIX + "SHARE_KEYRING"; + public static final String ACTION_SHARE_KEYRING_WITH_QR_CODE = APG_INTENT_PREFIX + + "SHARE_KEYRING_WITH_QR_CODE"; + public static final String ACTION_SHARE_KEYRING_WITH_NFC = APG_INTENT_PREFIX + + "SHARE_KEYRING_WITH_NFC"; + + // used by SHARE_WITH_QR_CODE and SHARE_WITH_NFC + public static final String EXTRA_MASTER_KEY_ID = "masterKeyId"; + + public static final String EXTRA_TEXT = "text"; + public static final String EXTRA_DATA = "data"; + public static final String EXTRA_ERROR = "error"; + public static final String EXTRA_DECRYPTED_MESSAGE = "decryptedMessage"; + public static final String EXTRA_ENCRYPTED_MESSAGE = "encryptedMessage"; + public static final String EXTRA_SIGNATURE = "signature"; + public static final String EXTRA_SIGNATURE_KEY_ID = "signatureKeyId"; + public static final String EXTRA_SIGNATURE_USER_ID = "signatureUserId"; + public static final String EXTRA_SIGNATURE_SUCCESS = "signatureSuccess"; + public static final String EXTRA_SIGNATURE_UNKNOWN = "signatureUnknown"; + public static final String EXTRA_USER_ID = "userId"; + public static final String EXTRA_USER_IDS = "userIds"; + public static final String EXTRA_KEY_ID = "masterKeyId"; + public static final String EXTRA_ENCRYPTION_KEY_IDS = "encryptionKeyIds"; + public static final String EXTRA_SELECTION = "selection"; + public static final String EXTRA_MESSAGE = "message"; + public static final String EXTRA_NO_PASSPHRASE = "noPassphrase"; + public static final String EXTRA_GENERATE_DEFAULT_KEYS = "generateDefaultKeys"; + public static final String EXTRA_INTENT_VERSION = "intentVersion"; + + public static final String RESULT_EXTRA_MASTER_KEY_IDS = "masterKeyIds"; + public static final String RESULT_EXTRA_USER_IDS = "userIds"; + + // result from EditKey + public static final String RESULT_EXTRA_MASTER_KEY_ID = "masterKeyId"; + public static final String RESULT_EXTRA_USER_ID = "userId"; + + public static final String INTENT_VERSION = "1"; + + public static final int DECRYPT_MESSAGE = 0x00007121; + public static final int ENCRYPT_MESSAGE = 0x00007122; + public static final int SELECT_PUBLIC_KEYS = 0x00007123; + public static final int SELECT_SECRET_KEY = 0x00007124; + public static final int CREATE_KEY = 0x00007125; + public static final int EDIT_KEY = 0x00007126; + + private Activity activity; + + public KeychainIntentHelper(Activity activity) { + this.activity = activity; + } + + /** + * Start an activity.<br> + * This method is defined to allow different methods of activity starting for newer versions of + * Android and for compatibility library. + * + * @param intent + * Intent to start. + * @param code + * Request code for the activity + * @see android.app.Activity#startActivityForResult(Intent, int) + * @see android.app.Fragment#startActivityForResult(Intent, int) + */ + protected void startActivityForResult(Intent intent, int code) { + activity.startActivityForResult(intent, code); + } + + /** + * Open activity to scan qr code and import key in it + * + * @return true when activity was found and executed successfully + */ + public boolean importFromQrCode() { + Intent intent = new Intent(ACTION_IMPORT_FROM_QR_CODE); + intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION); + try { + startActivityForResult(intent, -1); + return true; + } catch (ActivityNotFoundException e) { + activityNotFound(); + return false; + } + } + + /** + * Opens activity with qr code for masterKeyId + * + * @return true when activity was found and executed successfully + */ + public boolean shareWithQrCode(long masterKeyId) { + Intent intent = new Intent(ACTION_SHARE_KEYRING_WITH_QR_CODE); + intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION); + intent.putExtra(EXTRA_MASTER_KEY_ID, masterKeyId); + try { + startActivityForResult(intent, -1); + return true; + } catch (ActivityNotFoundException e) { + activityNotFound(); + return false; + } + } + + /** + * Opens activity to share keyring withnc based on given masterKeyId + * + * @return true when activity was found and executed successfully + */ + public boolean shareWithNfc(long masterKeyId) { + Intent intent = new Intent(ACTION_SHARE_KEYRING_WITH_NFC); + intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION); + intent.putExtra(EXTRA_MASTER_KEY_ID, masterKeyId); + try { + startActivityForResult(intent, -1); + return true; + } catch (ActivityNotFoundException e) { + activityNotFound(); + return false; + } + } + + /** + * Opens APG activity to create new key + * + * @param userIds + * value to specify prefilled values for user that should be created + * @return true when activity was found and executed successfully + */ + public boolean createNewKey(String userIds, boolean noPassphrase, boolean generateDefaultKeys) { + Intent intent = new Intent(ACTION_CREATE_KEY); + if (userIds != null) { + intent.putExtra(EXTRA_USER_IDS, userIds); + } + intent.putExtra(EXTRA_NO_PASSPHRASE, noPassphrase); + intent.putExtra(EXTRA_GENERATE_DEFAULT_KEYS, generateDefaultKeys); + + intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION); + try { + startActivityForResult(intent, CREATE_KEY); + return true; + } catch (ActivityNotFoundException e) { + activityNotFound(); + return false; + } + } + + /** + * Opens APG activity to create new key + * + * @return true when activity was found and executed successfully + */ + public boolean createNewKey() { + return createNewKey(null, false, false); + } + + /** + * Opens APG activity to edit already existing key based on keyId + * + * @param keyId + * @return true when activity was found and executed successfully + */ + public boolean editKey(long keyId) { + Intent intent = new Intent(ACTION_EDIT_KEY); + intent.putExtra(EXTRA_KEY_ID, keyId); + intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION); + try { + startActivityForResult(intent, EDIT_KEY); + return true; + } catch (ActivityNotFoundException e) { + activityNotFound(); + return false; + } + } + + /** + * Opens APG activity to select the signature key. + * + * @return true when activity was found and executed successfully + */ + public boolean selectSecretKey() { + Intent intent = new Intent(ACTION_SELECT_SECRET_KEY); + intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION); + try { + startActivityForResult(intent, SELECT_SECRET_KEY); + return true; + } catch (ActivityNotFoundException e) { + activityNotFound(); + return false; + } + } + + /** + * Encrypts the given data by opening APGs encrypt activity. If encryptionKeys are given it + * encrypts immediately and goes back to your program after that + * + * @param data + * String that contains the message to be encrypted + * @param encryptionKeyIds + * long[] that holds the ids of the encryption keys + * @param signatureKeyId + * id of the signature key + * @return true when activity was found and executed successfully + */ + public boolean encrypt(String data, long[] encryptionKeyIds, long signatureKeyId, + boolean returnResult) { + Intent intent = new Intent(); + if (returnResult) { + intent.setAction(ACTION_ENCRYPT_AND_RETURN); + } else { + intent.setAction(ACTION_ENCRYPT); + } + intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION); + intent.setType("text/plain"); + intent.putExtra(EXTRA_TEXT, data); + intent.putExtra(EXTRA_ENCRYPTION_KEY_IDS, encryptionKeyIds); + intent.putExtra(EXTRA_SIGNATURE_KEY_ID, signatureKeyId); + try { + startActivityForResult(intent, ENCRYPT_MESSAGE); + return true; + } catch (ActivityNotFoundException e) { + activityNotFound(); + return false; + } + } + + /** + * Start the decrypt activity. + * + * @param activity + * @param data + * @param pgpData + * @return true when activity was found and executed successfully + */ + public boolean decrypt(String data, boolean returnResult) { + Intent intent = new Intent(); + if (returnResult) { + intent.setAction(ACTION_DECRYPT_AND_RETURN); + } else { + intent.setAction(ACTION_DECRYPT); + } + intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION); + intent.setType("text/plain"); + if (data == null) { + return false; + } + try { + intent.putExtra(EXTRA_TEXT, data); + startActivityForResult(intent, DECRYPT_MESSAGE); + return true; + } catch (ActivityNotFoundException e) { + activityNotFound(); + return false; + } + } + + /** + * Handle the activity results that concern us. + * + * @param requestCode + * @param resultCode + * @param data + * @return handled or not + */ + public boolean onActivityResult(int requestCode, int resultCode, Intent data, KeychainData apgData) { + + switch (requestCode) { + case CREATE_KEY: + if (resultCode != Activity.RESULT_OK || data == null) { + // user canceled! + break; + } + apgData.setSecretKeyId(data.getLongExtra(RESULT_EXTRA_MASTER_KEY_ID, 0)); + apgData.setSecretKeyUserId(data.getStringExtra(RESULT_EXTRA_USER_ID)); + + break; + case SELECT_SECRET_KEY: + if (resultCode != Activity.RESULT_OK || data == null) { + // user canceled! + break; + } + apgData.setSecretKeyId(data.getLongExtra(EXTRA_KEY_ID, 0)); + apgData.setSecretKeyUserId(data.getStringExtra(EXTRA_USER_ID)); + + break; + case SELECT_PUBLIC_KEYS: + if (resultCode != Activity.RESULT_OK || data == null) { + apgData.setPublicKeyIds(null); + break; + } + apgData.setPublicKeyIds(data.getLongArrayExtra(RESULT_EXTRA_MASTER_KEY_IDS)); + apgData.setPublicUserIds(data.getStringArrayExtra(RESULT_EXTRA_USER_IDS)); + + break; + case ENCRYPT_MESSAGE: + if (resultCode != Activity.RESULT_OK || data == null) { + apgData.setPublicKeyIds(null); + break; + } + apgData.setEncryptedData(data.getStringExtra(EXTRA_ENCRYPTED_MESSAGE)); + + break; + case DECRYPT_MESSAGE: + if (resultCode != Activity.RESULT_OK || data == null) { + break; + } + + apgData.setSecretKeyUserId(data.getStringExtra(EXTRA_SIGNATURE_USER_ID)); + apgData.setSecretKeyId(data.getLongExtra(EXTRA_SIGNATURE_KEY_ID, 0)); + apgData.setSignatureSuccess(data.getBooleanExtra(EXTRA_SIGNATURE_SUCCESS, false)); + apgData.setSignatureUnknown(data.getBooleanExtra(EXTRA_SIGNATURE_UNKNOWN, false)); + + apgData.setDecryptedData(data.getStringExtra(EXTRA_DECRYPTED_MESSAGE)); + + break; + default: + return false; + } + + return true; + } + + /** + * Select encryption keys. + * + * @param emails + * The emails that should be used for preselection. + * @return true when activity was found and executed successfully + */ + public boolean selectPublicKeys(String emails) { + return selectPublicKeys(emails, null); + } + + /** + * Select encryption keys. + * + * @param emails + * The emails that should be used for preselection. + * @param apgData + * ApgData with encryption keys and signature keys preselected + * @return true when activity was found and executed successfully + */ + public boolean selectPublicKeys(String emails, KeychainData apgData) { + Intent intent = new Intent(ACTION_SELECT_PUBLIC_KEYS); + intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION); + + long[] initialKeyIds = null; + if (apgData == null || !apgData.hasPublicKeys()) { + KeychainContentProviderHelper cPHelper = new KeychainContentProviderHelper(activity); + + initialKeyIds = cPHelper.getPublicKeyringIdsByEmail(emails); + } else { + initialKeyIds = apgData.getPublicKeys(); + } + intent.putExtra(EXTRA_SELECTION, initialKeyIds); + + try { + startActivityForResult(intent, SELECT_PUBLIC_KEYS); + return true; + } catch (ActivityNotFoundException e) { + activityNotFound(); + return false; + } + } + + private void activityNotFound() { + Toast.makeText(activity, "APG Activity not found! Is APG installed correctly?", + Toast.LENGTH_LONG).show(); + } +} diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperSupportV4.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperSupportV4.java new file mode 100644 index 000000000..c8891287b --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperSupportV4.java @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.integration; + +import android.content.Intent; +import android.support.v4.app.Fragment; + +/** + * ApgIntentHelper for the V4 Android compatibility package. + */ +public final class KeychainIntentHelperSupportV4 extends KeychainIntentHelper { + + private final Fragment fragment; + + /** + * @param fragment + * Fragment to handle activity response. + */ + public KeychainIntentHelperSupportV4(Fragment fragment) { + super(fragment.getActivity()); + this.fragment = fragment; + } + + @Override + protected void startActivityForResult(Intent intent, int code) { + fragment.startActivityForResult(intent, code); + } + +}
\ No newline at end of file diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperV30.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperV30.java new file mode 100644 index 000000000..5ecf0e4f7 --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperV30.java @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.integration; + +import android.annotation.TargetApi; +import android.app.Fragment; +import android.content.Intent; +import android.os.Build; + +/** + * ApgIntentHelper for Android version 3.0 and beyond. + */ +@TargetApi(Build.VERSION_CODES.HONEYCOMB) +public final class KeychainIntentHelperV30 extends KeychainIntentHelper { + + private final Fragment fragment; + + /** + * @param fragment + * Fragment to handle activity response. + */ + public KeychainIntentHelperV30(Fragment fragment) { + super(fragment.getActivity()); + this.fragment = fragment; + } + + @Override + protected void startActivityForResult(Intent intent, int code) { + fragment.startActivityForResult(intent, code); + } + +}
\ No newline at end of file diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainServiceHelper.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainServiceHelper.java new file mode 100644 index 000000000..54e1f517a --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainServiceHelper.java @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.integration; + +import java.io.InputStream; +import java.io.OutputStream; + +import android.content.ContentResolver; +import android.content.ContentValues; +import android.content.Context; +import android.net.Uri; +import android.util.Log; + +public class KeychainServiceHelper { + + private final static String BLOB_URI = "content://org.sufficientlysecure.keychain.provider.apgserviceblobprovider"; + + private Context context; + + public KeychainServiceHelper(Context context) { + this.context = context; + } + + /** + * Set up binary data to en/decrypt + * + * @param is + * InputStream to get the data from + */ + public void setBlob(InputStream is) { + Log.d(Constants.TAG, "setBlob() called"); + // 1. get the new contentUri + ContentResolver cr = context.getContentResolver(); + Uri contentUri = cr.insert(Uri.parse(BLOB_URI), new ContentValues()); + + // 2. insert binary data + OutputStream os = null; + try { + os = cr.openOutputStream(contentUri, "w"); + } catch (Exception e) { + Log.e(Constants.TAG, "... exception on setBlob", e); + } + + byte[] buffer = new byte[8]; + int len = 0; + try { + while ((len = is.read(buffer)) != -1) { + os.write(buffer, 0, len); + } + Log.d(Constants.TAG, "... write finished, now closing"); + os.close(); + } catch (Exception e) { + Log.e(Constants.TAG, "... error on writing buffer", e); + } + + // mArgs.putString("BLOB", contentUri.toString()); + } + + /** + * Get the binary result + * + * <p> + * This gets your binary result. It only works if you called {@link #setBlob(InputStream)} + * before. + * + * If you did not call encrypt nor decrypt, this will be the same data as you inputed. + * </p> + * + * @return InputStream of the binary data which was en/decrypted + * + * @see #setBlob(InputStream) + * @see #getResult() + */ + public InputStream getBlobResult() { + // if (mArgs.containsKey("BLOB")) { + ContentResolver cr = context.getContentResolver(); + InputStream in = null; + try { + // in = cr.openInputStream(Uri.parse(mArgs.getString("BLOB"))); + } catch (Exception e) { + Log.e(Constants.TAG, "Could not return blob in result", e); + } + return in; + // } else { + // return null; + // } + } +} diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainUtil.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainUtil.java new file mode 100644 index 000000000..19d3850d7 --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainUtil.java @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * Copyright (C) 2010-2011 K-9 Mail Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.integration; + +import android.content.Context; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager.NameNotFoundException; + +import android.widget.Toast; + +public class KeychainUtil { + + /** + * Check whether OpenPGP Keychain is installed and at a high enough version. + * + * @param context + * @return whether a suitable version of APG was found + */ + public boolean isApgAvailable(Context context) { + try { + PackageInfo pi = context.getPackageManager().getPackageInfo( + Constants.KEYCHAIN_PACKAGE_NAME, 0); + if (pi.versionCode >= Constants.MIN_REQUIRED_VERSION) { + return true; + } else { + Toast.makeText( + context, + "This OpenPGP Keychain version is not supported! Please update to a newer one!", + Toast.LENGTH_LONG).show(); + } + } catch (NameNotFoundException e) { + // not found + } + + return false; + } + + /** + * Splits userId string into naming part and email part + * + * @param userId + * @return array with naming (0) and email (1) + */ + public static String[] splitUserId(String userId) { + String[] output = new String[2]; + + String chunks[] = userId.split(" <", 2); + userId = chunks[0]; + if (chunks.length > 1) { + output[1] = "<" + chunks[1]; + output[1] = output[1].replaceAll("<", ""); + output[1] = output[1].replaceAll(">", ""); + } + output[0] = userId; + + return output; + } +} diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainApiService.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainApiService.aidl new file mode 100644 index 000000000..ac8327b8e --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainApiService.aidl @@ -0,0 +1,146 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.service; + +import org.sufficientlysecure.keychain.service.handler.IKeychainEncryptHandler; +import org.sufficientlysecure.keychain.service.handler.IKeychainDecryptHandler; +import org.sufficientlysecure.keychain.service.handler.IKeychainGetDecryptionKeyIdHandler; + +/** + * All methods are oneway, which means they are asynchronous and non-blocking. + * Results are returned into given Handler, which has to be implemented on client side. + */ +interface IKeychainApiService { + + /** + * Encrypt + * + * Either inputBytes or inputUri is given, the other should be null. + * + * @param inputBytes + * Byte array you want to encrypt + * @param inputUri + * Blob in ContentProvider you want to encrypt + * @param useAsciiArmor + * Convert bytes to ascii armored text to guard against encoding problems + * @param compression + * Compression: 0x21070001: none, 1: Zip, 2: Zlib, 3: BZip2 + * @param encryptionKeyIds + * Ids of public keys used for encryption + * @param symmetricEncryptionAlgorithm + * 7: AES-128, 8: AES-192, 9: AES-256, 4: Blowfish, 10: Twofish, 3: CAST5, + * 6: DES, 2: Triple DES, 1: IDEA + * @param handler + * Results are returned to this IKeychainEncryptDecryptHandler Handler + * to onSuccessEncrypt(in byte[] output), after successful encryption + */ + oneway void encryptAsymmetric(in byte[] inputBytes, in String inputUri, in boolean useAsciiArmor, + in int compression, in long[] encryptionKeyIds, in int symmetricEncryptionAlgorithm, + in IKeychainEncryptHandler handler); + + /** + * Same as encryptAsymmetric but using a passphrase for symmetric encryption + * + * @param encryptionPassphrase + * Passphrase for direct symmetric encryption using symmetricEncryptionAlgorithm + */ + oneway void encryptSymmetric(in byte[] inputBytes, in String inputUri, in boolean useAsciiArmor, + in int compression, in String encryptionPassphrase, in int symmetricEncryptionAlgorithm, + in IKeychainEncryptHandler handler); + + /** + * Encrypt and sign + * + * Either inputBytes or inputUri is given, the other should be null. + * + * @param inputBytes + * Byte array you want to encrypt + * @param inputUri + * Blob in ContentProvider you want to encrypt + * @param useAsciiArmor + * Convert bytes to ascii armored text to guard against encoding problems + * @param compression + * Compression: 0x21070001: none, 1: Zip, 2: Zlib, 3: BZip2 + * @param encryptionKeyIds + * Ids of public keys used for encryption + * @param symmetricEncryptionAlgorithm + * 7: AES-128, 8: AES-192, 9: AES-256, 4: Blowfish, 10: Twofish, 3: CAST5, + * 6: DES, 2: Triple DES, 1: IDEA + * @param signatureKeyId + * Key id of key to sign with + * @param signatureHashAlgorithm + * 1: MD5, 3: RIPEMD-160, 2: SHA-1, 11: SHA-224, 8: SHA-256, 9: SHA-384, + * 10: SHA-512 + * @param signatureForceV3 + * Force V3 signatures + * @param signaturePassphrase + * Passphrase to unlock signature key + * @param handler + * Results are returned to this IKeychainEncryptDecryptHandler Handler + * to onSuccessEncrypt(in byte[] output), after successful encryption and signing + */ + oneway void encryptAndSignAsymmetric(in byte[] inputBytes, in String inputUri, + in boolean useAsciiArmor, in int compression, in long[] encryptionKeyIds, + in int symmetricEncryptionAlgorithm, in long signatureKeyId, in int signatureHashAlgorithm, + in boolean signatureForceV3, in String signaturePassphrase, + in IKeychainEncryptHandler handler); + + /** + * Same as encryptAndSignAsymmetric but using a passphrase for symmetric encryption + * + * @param encryptionPassphrase + * Passphrase for direct symmetric encryption using symmetricEncryptionAlgorithm + */ + oneway void encryptAndSignSymmetric(in byte[] inputBytes, in String inputUri, + in boolean useAsciiArmor, in int compression, in String encryptionPassphrase, + in int symmetricEncryptionAlgorithm, in long signatureKeyId, in int signatureHashAlgorithm, + in boolean signatureForceV3, in String signaturePassphrase, + in IKeychainEncryptHandler handler); + + /** + * Decrypts and verifies given input bytes. If no signature is present this method + * will only decrypt. + * + * @param inputBytes + * Byte array you want to decrypt and verify + * @param inputUri + * Blob in ContentProvider you want to decrypt and verify + * @param keyPassphrase + * Passphrase to unlock secret key for decryption. + * @param handler + * Handler where to return results to after successful encryption + */ + oneway void decryptAndVerifyAsymmetric(in byte[] inputBytes, in String inputUri, + in String keyPassphrase, in IKeychainDecryptHandler handler); + + /** + * Same as decryptAndVerifyAsymmetric but for symmetric decryption. + * + * @param encryptionPassphrase + * Passphrase to decrypt + */ + oneway void decryptAndVerifySymmetric(in byte[] inputBytes, in String inputUri, + in String encryptionPassphrase, in IKeychainDecryptHandler handler); + + /** + * + */ + oneway void getDecryptionKeyId(in byte[] inputBytes, in String inputUri, + in IKeychainGetDecryptionKeyIdHandler handler); + + +}
\ No newline at end of file diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainKeyService.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainKeyService.aidl new file mode 100644 index 000000000..ecea2b8ff --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainKeyService.aidl @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.service; + +import org.sufficientlysecure.keychain.service.handler.IKeychainGetKeyringsHandler; + +/** + * All methods are oneway, which means they are asynchronous and non-blocking. + * Results are returned into given Handler, which has to be implemented on client side. + */ +interface IKeychainKeyService { + + oneway void getPublicKeyRings(in long[] masterKeyIds, in boolean asAsciiArmoredStringArray, + in IKeychainGetKeyringsHandler handler); + + oneway void getSecretKeyRings(in long[] masterKeyIds, in boolean asAsciiArmoredStringArray, + in IKeychainGetKeyringsHandler handler); +}
\ No newline at end of file diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainDecryptHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainDecryptHandler.aidl new file mode 100644 index 000000000..31ead701d --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainDecryptHandler.aidl @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.service.handler; + +interface IKeychainDecryptHandler { + + oneway void onSuccess(in byte[] outputBytes, in String outputUri, in boolean signature, + in long signatureKeyId, in String signatureUserId, in boolean signatureSuccess, + in boolean signatureUnknown); + + + oneway void onException(in int exceptionNumber, in String message); +}
\ No newline at end of file diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainEncryptHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainEncryptHandler.aidl new file mode 100644 index 000000000..5b21a0613 --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainEncryptHandler.aidl @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.service.handler; + +interface IKeychainEncryptHandler { + /** + * Either output or streamUri is given. One of them is null + * + */ + oneway void onSuccess(in byte[] outputBytes, in String outputUri); + + + oneway void onException(in int exceptionNumber, in String message); +}
\ No newline at end of file diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetDecryptionKeyIdHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetDecryptionKeyIdHandler.aidl new file mode 100644 index 000000000..2fff74a92 --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetDecryptionKeyIdHandler.aidl @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.service.handler; + +interface IKeychainGetDecryptionKeyIdHandler { + + oneway void onSuccess(in long secretKeyId, in boolean symmetric); + + + oneway void onException(in int exceptionNumber, in String message); +}
\ No newline at end of file diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetKeyringsHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetKeyringsHandler.aidl new file mode 100644 index 000000000..c3a7d1faf --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetKeyringsHandler.aidl @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.service.handler; + +interface IKeychainGetKeyringsHandler { + /** + * Either outputBytes or outputString is given. One of them is null + * + */ + oneway void onSuccess(in byte[] outputBytes, in List<String> outputString); + + + oneway void onException(in int exceptionNumber, in String message); +}
\ No newline at end of file diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainSignHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainSignHandler.aidl new file mode 100644 index 000000000..69badab4c --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainSignHandler.aidl @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.service.handler; + +interface IKeychainSignHandler { + /** + * Either output or streamUri is given. One of them is null + * + */ + oneway void onSuccess(in byte[] outputBytes, in String outputUri); + + + oneway void onException(in int exceptionNumber, in String message); +}
\ No newline at end of file diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainVerifyHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainVerifyHandler.aidl new file mode 100644 index 000000000..aaa9a7f6a --- /dev/null +++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainVerifyHandler.aidl @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.sufficientlysecure.keychain.service.handler; + +interface IKeychainVerifyHandler { + + oneway void onSuccess(in boolean signature, in long signatureKeyId, + in String signatureUserId, in boolean signatureSuccess, in boolean signatureUnknown); + + + oneway void onException(in int exceptionNumber, in String message); +}
\ No newline at end of file |