From 14dd8cc0789de0d0518038b5d0410b7f751b207a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dominik=20Sch=C3=BCrmann?= Date: Wed, 7 May 2014 16:31:28 +0200 Subject: [PATCH] Initial import from main repo --- .gitignore | 29 ++ AndroidManifest.xml | 13 + LICENSE | 202 +++++++++++++ build.gradle | 35 +++ build.xml | 92 ++++++ proguard-project.txt | 20 ++ project.properties | 15 + .../ic_action_cancel_launchersize.png | Bin 0 -> 1520 bytes .../ic_action_cancel_launchersize_light.png | Bin 0 -> 1940 bytes .../ic_action_cancel_launchersize.png | Bin 0 -> 1032 bytes .../ic_action_cancel_launchersize_light.png | Bin 0 -> 1098 bytes .../ic_action_cancel_launchersize.png | Bin 0 -> 1570 bytes .../ic_action_cancel_launchersize_light.png | Bin 0 -> 2039 bytes .../ic_action_cancel_launchersize.png | Bin 0 -> 2345 bytes .../ic_action_cancel_launchersize_light.png | Bin 0 -> 2404 bytes res/values/strings.xml | 7 + .../openintents/openpgp/IOpenPgpService.aidl | 24 ++ src/org/openintents/openpgp/OpenPgpError.java | 118 ++++++++ .../openpgp/OpenPgpSignatureResult.java | 163 +++++++++++ .../openintents/openpgp/util/OpenPgpApi.java | 270 ++++++++++++++++++ .../openpgp/util/OpenPgpListPreference.java | 257 +++++++++++++++++ .../util/OpenPgpServiceConnection.java | 118 ++++++++ .../openpgp/util/OpenPgpUtils.java | 76 +++++ .../util/ParcelFileDescriptorUtil.java | 103 +++++++ 24 files changed, 1542 insertions(+) create mode 100644 .gitignore create mode 100644 AndroidManifest.xml create mode 100644 LICENSE create mode 100644 build.gradle create mode 100644 build.xml create mode 100644 proguard-project.txt create mode 100644 project.properties create mode 100644 res/drawable-hdpi/ic_action_cancel_launchersize.png create mode 100644 res/drawable-hdpi/ic_action_cancel_launchersize_light.png create mode 100644 res/drawable-mdpi/ic_action_cancel_launchersize.png create mode 100644 res/drawable-mdpi/ic_action_cancel_launchersize_light.png create mode 100644 res/drawable-xhdpi/ic_action_cancel_launchersize.png create mode 100644 res/drawable-xhdpi/ic_action_cancel_launchersize_light.png create mode 100644 res/drawable-xxhdpi/ic_action_cancel_launchersize.png create mode 100644 res/drawable-xxhdpi/ic_action_cancel_launchersize_light.png create mode 100644 res/values/strings.xml create mode 100644 src/org/openintents/openpgp/IOpenPgpService.aidl create mode 100644 src/org/openintents/openpgp/OpenPgpError.java create mode 100644 src/org/openintents/openpgp/OpenPgpSignatureResult.java create mode 100644 src/org/openintents/openpgp/util/OpenPgpApi.java create mode 100644 src/org/openintents/openpgp/util/OpenPgpListPreference.java create mode 100644 src/org/openintents/openpgp/util/OpenPgpServiceConnection.java create mode 100644 src/org/openintents/openpgp/util/OpenPgpUtils.java create mode 100644 src/org/openintents/openpgp/util/ParcelFileDescriptorUtil.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..aa8bb576 --- /dev/null +++ b/.gitignore @@ -0,0 +1,29 @@ +#Android specific +bin +gen +obj +lint.xml +local.properties +release.properties +ant.properties +*.class +*.apk + +#Gradle +.gradle +build +gradle.properties + +#Maven +target +pom.xml.* + +#Eclipse +.project +.classpath +.settings +.metadata + +#IntelliJ IDEA +.idea +*.iml diff --git a/AndroidManifest.xml b/AndroidManifest.xml new file mode 100644 index 00000000..98cb89fa --- /dev/null +++ b/AndroidManifest.xml @@ -0,0 +1,13 @@ + + + + + + + + \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..d6456956 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. diff --git a/build.gradle b/build.gradle new file mode 100644 index 00000000..69b937c1 --- /dev/null +++ b/build.gradle @@ -0,0 +1,35 @@ +// please leave this here, so this library builds on its own +buildscript { + repositories { + mavenCentral() + } + + dependencies { + classpath 'com.android.tools.build:gradle:0.10.0' + } +} + +apply plugin: 'android-library' + +android { + compileSdkVersion 19 + buildToolsVersion '19.0.3' + + // NOTE: We are using the old folder structure to also support Eclipse + sourceSets { + main { + manifest.srcFile 'AndroidManifest.xml' + java.srcDirs = ['src'] + resources.srcDirs = ['src'] + aidl.srcDirs = ['src'] + renderscript.srcDirs = ['src'] + res.srcDirs = ['res'] + assets.srcDirs = ['assets'] + } + } + + // Do not abort build if lint finds errors + lintOptions { + abortOnError false + } +} diff --git a/build.xml b/build.xml new file mode 100644 index 00000000..48ebf198 --- /dev/null +++ b/build.xml @@ -0,0 +1,92 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/proguard-project.txt b/proguard-project.txt new file mode 100644 index 00000000..f2fe1559 --- /dev/null +++ b/proguard-project.txt @@ -0,0 +1,20 @@ +# To enable ProGuard in your project, edit project.properties +# to define the proguard.config property as described in that file. +# +# Add project specific ProGuard rules here. +# By default, the flags in this file are appended to flags specified +# in ${sdk.dir}/tools/proguard/proguard-android.txt +# You can edit the include path and order by changing the ProGuard +# include property in project.properties. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# Add any project specific keep options here: + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} diff --git a/project.properties b/project.properties new file mode 100644 index 00000000..91d2b024 --- /dev/null +++ b/project.properties @@ -0,0 +1,15 @@ +# This file is automatically generated by Android Tools. +# Do not modify this file -- YOUR CHANGES WILL BE ERASED! +# +# This file must be checked in Version Control Systems. +# +# To customize properties used by the Ant build system edit +# "ant.properties", and override values to adapt the script to your +# project structure. +# +# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home): +#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt + +# Project target. +target=android-19 +android.library=true diff --git a/res/drawable-hdpi/ic_action_cancel_launchersize.png b/res/drawable-hdpi/ic_action_cancel_launchersize.png new file mode 100644 index 0000000000000000000000000000000000000000..71b9118dc0f992fc88cf91375090f1c04fc76e84 GIT binary patch literal 1520 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 literal 0 HcmV?d00001 diff --git a/res/drawable-mdpi/ic_action_cancel_launchersize.png b/res/drawable-mdpi/ic_action_cancel_launchersize.png new file mode 100644 index 0000000000000000000000000000000000000000..270abf45fdd55510fc885046717a66bd73cc9379 GIT binary patch literal 1032 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 literal 0 HcmV?d00001 diff --git a/res/drawable-xhdpi/ic_action_cancel_launchersize_light.png b/res/drawable-xhdpi/ic_action_cancel_launchersize_light.png new file mode 100644 index 0000000000000000000000000000000000000000..d505046b4d59b4c26511f68b404cdbc4f933edff GIT binary patch literal 2039 zcmaJ?eKZq}8lGV*`N+44_=#G+lFu@f^0lU+D3hYlSY||%)@D>ftk5MNW0_w{WMd{I zE1`(Rtu{8yRHL?pntmu(_y2pJ_dM@&&U4=L{PUjoyg7kLUo{m&6#xLB2KVzivaXST zxB;}@#dlKotPAK2!q*G1_NQo_wMFaB#za3 z7ChKBzV2LwdwB+59FtYZa5_BQ-t?Q3jNQr)%MRS{)71G1n6s0#|o?!OViK<)d*KnqVtZSlk7(XWU#|9amsQA(I=lekDK31>}r{%^$L z-_9+~F0Fh>BZ-!-6DO37-+fwkN{AC0LvySDX(j9KXQyURo2=JI{4PzU*SddW?;L2_ z`oSVnlObzpvL=R_q(9UP`zo+Z9F=F*5ZG%QRn0FX$X&)9H7-Z4xWl;_yE1CA)YQ8@ zs2{~L4GW@KT#vkpobSd>x6D1$nm_veM5i-%(Obmj?1iT*u*o~pDkq`2Vo$3q+}(pf zB>#8tNY5R3U&b0>5-!bD?bwVZMiamnkB?XgBD^MDZ<>yt z%0qQo&T4*hz!iptGn`1~qu=K|zAO#-Q zLOd{XnU=7*v4|ajuxE^Z`9XSAms?jiv$PV8@(BrPP`lj7+tM=x5jnuCfVE^BIDzvd z%XUHMv6}F9a7c*LjAN#`3^1t}ai|^S*4i0Q7?N*g*u*h=3ujhz|pKL@b4BNO=!#$Ub zrTmGOPW5mm@u7MNwl(wRdm7;-P@=^+yOJ_Ke@AJ6)1Afa)iO5Ll7*{CD=4wG@0|Sy z0d#{LeL89ab?<4COAK*eyCSsF3gf8BhD@#)u^B zeKXIj33whU;8e;keZnb?oqA02*M?CS{+qWK-bYsXd0h1aY(H1t%w9y`>J>=dDUSM~ zW*&_Z)V`s&bQ&**63-hRR!_9vo*%^k7lP&|=ErvnU~C>Xb^BQ9MvXm6z6jNaR=?F( z)h=2+5t$AuY8ZT-BB=>+UWcg9kPX-$fqa#g01;WVQ5RJoLfMAcM!_72a*V7d;Q2(Yk-9W) zRnv}pA{<(yRx)K40`BM79eQDlY{@nred@1O)zCs#6)g9b^Ix%fX?K5J3te3`rh(nc zudQ;S4z(WNP{sLYB>s^S{g0VUtqD+q7jlMV@ImH-iHRhb&PE$>3rRts^(zRox>8XZ z9+;f;HvAV59anSv3(EM_<8$n;f)p1aOLAP=ej2TpRO6xsYtEuOZ+)L3OM}n(o=r6n(l&>?|8)3wk28}=}-N9{+Tl~`IgxB_wuiV zN=YiP+)lV5Eb?cKj)PD%nP)!5cW=pu#tz7j7e2BR+J*y>qZ1n|kw&n_Tzag)wfp+{ zil$B_;mxO)d)BP%+jD3jAN-jT46M59FuWBTL3PBFEGS63%dvgk*>4hbyyqvKkGzla z4s@7C>GWJ7b)}yiF%i2hkxgz?8~7{28Z+o7kgwZT%crI>kMzCgztcSMLjZ8_Rvch0 zJ2BP8vK02fM*!v=&U$yDnDwL31CN+})&T!MpboDAUI&I8C@jCZu>PU}aBrm7qXUtd F{{iyG+f)Dm literal 0 HcmV?d00001 diff --git a/res/drawable-xxhdpi/ic_action_cancel_launchersize.png b/res/drawable-xxhdpi/ic_action_cancel_launchersize.png new file mode 100644 index 0000000000000000000000000000000000000000..52044601e4036ee1da50f18550af7cdf9dc458b0 GIT binary patch literal 2345 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 + + + None + Install OpenKeychain via %s + + \ No newline at end of file diff --git a/src/org/openintents/openpgp/IOpenPgpService.aidl b/src/org/openintents/openpgp/IOpenPgpService.aidl new file mode 100644 index 00000000..7ee79d6a --- /dev/null +++ b/src/org/openintents/openpgp/IOpenPgpService.aidl @@ -0,0 +1,24 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * 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.openintents.openpgp; + +interface IOpenPgpService { + + // see OpenPgpApi for documentation + Intent execute(in Intent data, in ParcelFileDescriptor input, in ParcelFileDescriptor output); + +} \ No newline at end of file diff --git a/src/org/openintents/openpgp/OpenPgpError.java b/src/org/openintents/openpgp/OpenPgpError.java new file mode 100644 index 00000000..b894a460 --- /dev/null +++ b/src/org/openintents/openpgp/OpenPgpError.java @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * 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.openintents.openpgp; + +import android.os.Parcel; +import android.os.Parcelable; + +/** + * Parcelable versioning has been copied from Dashclock Widget + * https://code.google.com/p/dashclock/source/browse/api/src/main/java/com/google/android/apps/dashclock/api/ExtensionData.java + */ +public class OpenPgpError implements Parcelable { + /** + * Since there might be a case where new versions of the client using the library getting + * old versions of the protocol (and thus old versions of this class), we need a versioning + * system for the parcels sent between the clients and the providers. + */ + public static final int PARCELABLE_VERSION = 1; + + // possible values for errorId + public static final int CLIENT_SIDE_ERROR = -1; + public static final int GENERIC_ERROR = 0; + public static final int INCOMPATIBLE_API_VERSIONS = 1; + public static final int NO_OR_WRONG_PASSPHRASE = 2; + public static final int NO_USER_IDS = 3; + + int errorId; + String message; + + public OpenPgpError() { + } + + public OpenPgpError(int errorId, String message) { + this.errorId = errorId; + this.message = message; + } + + public OpenPgpError(OpenPgpError b) { + this.errorId = b.errorId; + this.message = b.message; + } + + public int getErrorId() { + return errorId; + } + + public void setErrorId(int errorId) { + this.errorId = errorId; + } + + public String getMessage() { + return message; + } + + public void setMessage(String message) { + this.message = message; + } + + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel dest, int flags) { + /** + * NOTE: When adding fields in the process of updating this API, make sure to bump + * {@link #PARCELABLE_VERSION}. + */ + dest.writeInt(PARCELABLE_VERSION); + // Inject a placeholder that will store the parcel size from this point on + // (not including the size itself). + int sizePosition = dest.dataPosition(); + dest.writeInt(0); + int startPosition = dest.dataPosition(); + // version 1 + dest.writeInt(errorId); + dest.writeString(message); + // Go back and write the size + int parcelableSize = dest.dataPosition() - startPosition; + dest.setDataPosition(sizePosition); + dest.writeInt(parcelableSize); + dest.setDataPosition(startPosition + parcelableSize); + } + + public static final Creator CREATOR = new Creator() { + public OpenPgpError createFromParcel(final Parcel source) { + int parcelableVersion = source.readInt(); + int parcelableSize = source.readInt(); + int startPosition = source.dataPosition(); + + OpenPgpError error = new OpenPgpError(); + error.errorId = source.readInt(); + error.message = source.readString(); + + // skip over all fields added in future versions of this parcel + source.setDataPosition(startPosition + parcelableSize); + + return error; + } + + public OpenPgpError[] newArray(final int size) { + return new OpenPgpError[size]; + } + }; +} diff --git a/src/org/openintents/openpgp/OpenPgpSignatureResult.java b/src/org/openintents/openpgp/OpenPgpSignatureResult.java new file mode 100644 index 00000000..7a4d799d --- /dev/null +++ b/src/org/openintents/openpgp/OpenPgpSignatureResult.java @@ -0,0 +1,163 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * 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.openintents.openpgp; + +import android.os.Parcel; +import android.os.Parcelable; + +import org.openintents.openpgp.util.OpenPgpUtils; + +import java.util.Locale; + +/** + * Parcelable versioning has been copied from Dashclock Widget + * https://code.google.com/p/dashclock/source/browse/api/src/main/java/com/google/android/apps/dashclock/api/ExtensionData.java + */ +public class OpenPgpSignatureResult implements Parcelable { + /** + * Since there might be a case where new versions of the client using the library getting + * old versions of the protocol (and thus old versions of this class), we need a versioning + * system for the parcels sent between the clients and the providers. + */ + public static final int PARCELABLE_VERSION = 1; + + // generic error on signature verification + public static final int SIGNATURE_ERROR = 0; + // successfully verified signature, with certified public key + public static final int SIGNATURE_SUCCESS_CERTIFIED = 1; + // no public key was found for this signature verification + public static final int SIGNATURE_UNKNOWN_PUB_KEY = 2; + // successfully verified signature, but with uncertified public key + public static final int SIGNATURE_SUCCESS_UNCERTIFIED = 3; + + int status; + boolean signatureOnly; + String userId; + long keyId; + + public int getStatus() { + return status; + } + + public void setStatus(int status) { + this.status = status; + } + + public boolean isSignatureOnly() { + return signatureOnly; + } + + public void setSignatureOnly(boolean signatureOnly) { + this.signatureOnly = signatureOnly; + } + + public String getUserId() { + return userId; + } + + public void setUserId(String userId) { + this.userId = userId; + } + + public long getKeyId() { + return keyId; + } + + public void setKeyId(long keyId) { + this.keyId = keyId; + } + + public OpenPgpSignatureResult() { + + } + + public OpenPgpSignatureResult(int signatureStatus, String signatureUserId, + boolean signatureOnly, long keyId) { + this.status = signatureStatus; + this.signatureOnly = signatureOnly; + this.userId = signatureUserId; + this.keyId = keyId; + } + + public OpenPgpSignatureResult(OpenPgpSignatureResult b) { + this.status = b.status; + this.userId = b.userId; + this.signatureOnly = b.signatureOnly; + this.keyId = b.keyId; + } + + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel dest, int flags) { + /** + * NOTE: When adding fields in the process of updating this API, make sure to bump + * {@link #PARCELABLE_VERSION}. + */ + dest.writeInt(PARCELABLE_VERSION); + // Inject a placeholder that will store the parcel size from this point on + // (not including the size itself). + int sizePosition = dest.dataPosition(); + dest.writeInt(0); + int startPosition = dest.dataPosition(); + // version 1 + dest.writeInt(status); + dest.writeByte((byte) (signatureOnly ? 1 : 0)); + dest.writeString(userId); + dest.writeLong(keyId); + // Go back and write the size + int parcelableSize = dest.dataPosition() - startPosition; + dest.setDataPosition(sizePosition); + dest.writeInt(parcelableSize); + dest.setDataPosition(startPosition + parcelableSize); + } + + public static final Creator CREATOR = new Creator() { + public OpenPgpSignatureResult createFromParcel(final Parcel source) { + int parcelableVersion = source.readInt(); + int parcelableSize = source.readInt(); + int startPosition = source.dataPosition(); + + OpenPgpSignatureResult vr = new OpenPgpSignatureResult(); + vr.status = source.readInt(); + vr.signatureOnly = source.readByte() == 1; + vr.userId = source.readString(); + vr.keyId = source.readLong(); + + // skip over all fields added in future versions of this parcel + source.setDataPosition(startPosition + parcelableSize); + + return vr; + } + + public OpenPgpSignatureResult[] newArray(final int size) { + return new OpenPgpSignatureResult[size]; + } + }; + + @Override + public String toString() { + String out = new String(); + out += "\nstatus: " + status; + out += "\nuserId: " + userId; + out += "\nsignatureOnly: " + signatureOnly; + out += "\nkeyId: " + OpenPgpUtils.convertKeyIdToHex(keyId); + return out; + } + +} diff --git a/src/org/openintents/openpgp/util/OpenPgpApi.java b/src/org/openintents/openpgp/util/OpenPgpApi.java new file mode 100644 index 00000000..f6a78d0e --- /dev/null +++ b/src/org/openintents/openpgp/util/OpenPgpApi.java @@ -0,0 +1,270 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * 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.openintents.openpgp.util; + +import android.annotation.TargetApi; +import android.content.Context; +import android.content.Intent; +import android.os.AsyncTask; +import android.os.Build; +import android.os.ParcelFileDescriptor; +import android.util.Log; + +import org.openintents.openpgp.IOpenPgpService; +import org.openintents.openpgp.OpenPgpError; + +import java.io.InputStream; +import java.io.OutputStream; + +public class OpenPgpApi { + + public static final String TAG = "OpenPgp API"; + + public static final int API_VERSION = 3; + public static final String SERVICE_INTENT = "org.openintents.openpgp.IOpenPgpService"; + + /** + * General extras + * -------------- + * + * required extras: + * int EXTRA_API_VERSION (always required) + * + * returned extras: + * int RESULT_CODE (RESULT_CODE_ERROR, RESULT_CODE_SUCCESS or RESULT_CODE_USER_INTERACTION_REQUIRED) + * OpenPgpError RESULT_ERROR (if RESULT_CODE == RESULT_CODE_ERROR) + * PendingIntent RESULT_INTENT (if RESULT_CODE == RESULT_CODE_USER_INTERACTION_REQUIRED) + */ + + /** + * Sign only + *

+ * optional extras: + * boolean EXTRA_REQUEST_ASCII_ARMOR (request ascii armor for ouput) + * String EXTRA_PASSPHRASE (key passphrase) + */ + public static final String ACTION_SIGN = "org.openintents.openpgp.action.SIGN"; + + /** + * Encrypt + *

+ * required extras: + * String[] EXTRA_USER_IDS (=emails of recipients, if more than one key has a user_id, a PendingIntent is returned via RESULT_INTENT) + * or + * long[] EXTRA_KEY_IDS + *

+ * optional extras: + * boolean EXTRA_REQUEST_ASCII_ARMOR (request ascii armor for ouput) + * String EXTRA_PASSPHRASE (key passphrase) + */ + public static final String ACTION_ENCRYPT = "org.openintents.openpgp.action.ENCRYPT"; + + /** + * Sign and encrypt + *

+ * required extras: + * String[] EXTRA_USER_IDS (=emails of recipients, if more than one key has a user_id, a PendingIntent is returned via RESULT_INTENT) + * or + * long[] EXTRA_KEY_IDS + *

+ * optional extras: + * boolean EXTRA_REQUEST_ASCII_ARMOR (request ascii armor for ouput) + * String EXTRA_PASSPHRASE (key passphrase) + */ + public static final String ACTION_SIGN_AND_ENCRYPT = "org.openintents.openpgp.action.SIGN_AND_ENCRYPT"; + + /** + * Decrypts and verifies given input stream. This methods handles encrypted-only, signed-and-encrypted, + * and also signed-only input. + *

+ * If OpenPgpSignatureResult.getStatus() == OpenPgpSignatureResult.SIGNATURE_UNKNOWN_PUB_KEY + * in addition a PendingIntent is returned via RESULT_INTENT to download missing keys. + *

+ * optional extras: + * boolean EXTRA_REQUEST_ASCII_ARMOR (request ascii armor for ouput) + *

+ * returned extras: + * OpenPgpSignatureResult RESULT_SIGNATURE + */ + public static final String ACTION_DECRYPT_VERIFY = "org.openintents.openpgp.action.DECRYPT_VERIFY"; + + /** + * Get key ids based on given user ids (=emails) + *

+ * required extras: + * String[] EXTRA_USER_IDS + *

+ * returned extras: + * long[] RESULT_KEY_IDS + */ + public static final String ACTION_GET_KEY_IDS = "org.openintents.openpgp.action.GET_KEY_IDS"; + + /** + * This action returns RESULT_CODE_SUCCESS if the OpenPGP Provider already has the key + * corresponding to the given key id in its database. + *

+ * It returns RESULT_CODE_USER_INTERACTION_REQUIRED if the Provider does not have the key. + * The PendingIntent from RESULT_INTENT can be used to retrieve those from a keyserver. + *

+ * required extras: + * long EXTRA_KEY_ID + */ + public static final String ACTION_GET_KEY = "org.openintents.openpgp.action.GET_KEY"; + + /* Intent extras */ + public static final String EXTRA_API_VERSION = "api_version"; + + public static final String EXTRA_ACCOUNT_NAME = "account_name"; + + // SIGN, ENCRYPT, SIGN_AND_ENCRYPT, DECRYPT_VERIFY + // request ASCII Armor for output + // OpenPGP Radix-64, 33 percent overhead compared to binary, see http://tools.ietf.org/html/rfc4880#page-53) + public static final String EXTRA_REQUEST_ASCII_ARMOR = "ascii_armor"; + + // ENCRYPT, SIGN_AND_ENCRYPT + public static final String EXTRA_USER_IDS = "user_ids"; + public static final String EXTRA_KEY_IDS = "key_ids"; + // optional extras: + public static final String EXTRA_PASSPHRASE = "passphrase"; + + // GET_KEY + public static final String EXTRA_KEY_ID = "key_id"; + public static final String RESULT_KEY_IDS = "key_ids"; + + /* Service Intent returns */ + public static final String RESULT_CODE = "result_code"; + + // get actual error object from RESULT_ERROR + public static final int RESULT_CODE_ERROR = 0; + // success! + public static final int RESULT_CODE_SUCCESS = 1; + // get PendingIntent from RESULT_INTENT, start PendingIntent with startIntentSenderForResult, + // and execute service method again in onActivityResult + public static final int RESULT_CODE_USER_INTERACTION_REQUIRED = 2; + + public static final String RESULT_ERROR = "error"; + public static final String RESULT_INTENT = "intent"; + + // DECRYPT_VERIFY + public static final String RESULT_SIGNATURE = "signature"; + + IOpenPgpService mService; + Context mContext; + + public OpenPgpApi(Context context, IOpenPgpService service) { + this.mContext = context; + this.mService = service; + } + + public interface IOpenPgpCallback { + void onReturn(final Intent result); + } + + private class OpenPgpAsyncTask extends AsyncTask { + Intent data; + InputStream is; + OutputStream os; + IOpenPgpCallback callback; + + private OpenPgpAsyncTask(Intent data, InputStream is, OutputStream os, IOpenPgpCallback callback) { + this.data = data; + this.is = is; + this.os = os; + this.callback = callback; + } + + @Override + protected Intent doInBackground(Void... unused) { + return executeApi(data, is, os); + } + + protected void onPostExecute(Intent result) { + callback.onReturn(result); + } + + } + + @TargetApi(Build.VERSION_CODES.HONEYCOMB) + public void executeApiAsync(Intent data, InputStream is, OutputStream os, IOpenPgpCallback callback) { + OpenPgpAsyncTask task = new OpenPgpAsyncTask(data, is, os, callback); + + // don't serialize async tasks! + // http://commonsware.com/blog/2012/04/20/asynctask-threading-regression-confirmed.html + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { + task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void[]) null); + } else { + task.execute((Void[]) null); + } + } + + public Intent executeApi(Intent data, InputStream is, OutputStream os) { + try { + data.putExtra(EXTRA_API_VERSION, OpenPgpApi.API_VERSION); + + Intent result; + + // pipe the input and output + ParcelFileDescriptor input = null; + if (is != null) { + input = ParcelFileDescriptorUtil.pipeFrom(is, + new ParcelFileDescriptorUtil.IThreadListener() { + + @Override + public void onThreadFinished(Thread thread) { + //Log.d(OpenPgpApi.TAG, "Copy to service finished"); + } + } + ); + } + ParcelFileDescriptor output = null; + if (os != null) { + output = ParcelFileDescriptorUtil.pipeTo(os, + new ParcelFileDescriptorUtil.IThreadListener() { + + @Override + public void onThreadFinished(Thread thread) { + //Log.d(OpenPgpApi.TAG, "Service finished writing!"); + } + } + ); + } + + // blocks until result is ready + result = mService.execute(data, input, output); + // close() is required to halt the TransferThread + if (output != null) { + output.close(); + } + // TODO: close input? + + // set class loader to current context to allow unparcelling + // of OpenPgpError and OpenPgpSignatureResult + // http://stackoverflow.com/a/3806769 + result.setExtrasClassLoader(mContext.getClassLoader()); + + return result; + } catch (Exception e) { + Log.e(OpenPgpApi.TAG, "Exception in executeApi call", e); + Intent result = new Intent(); + result.putExtra(RESULT_CODE, RESULT_CODE_ERROR); + result.putExtra(RESULT_ERROR, + new OpenPgpError(OpenPgpError.CLIENT_SIDE_ERROR, e.getMessage())); + return result; + } + } + +} diff --git a/src/org/openintents/openpgp/util/OpenPgpListPreference.java b/src/org/openintents/openpgp/util/OpenPgpListPreference.java new file mode 100644 index 00000000..cf586462 --- /dev/null +++ b/src/org/openintents/openpgp/util/OpenPgpListPreference.java @@ -0,0 +1,257 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * 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.openintents.openpgp.util; + +import android.app.AlertDialog.Builder; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.content.pm.ResolveInfo; +import android.content.res.TypedArray; +import android.graphics.drawable.Drawable; +import android.net.Uri; +import android.preference.DialogPreference; +import android.util.AttributeSet; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ArrayAdapter; +import android.widget.ListAdapter; +import android.widget.TextView; +import org.openintents.openpgp.R; + +import java.util.ArrayList; +import java.util.List; + +/** + * Does not extend ListPreference, but is very similar to it! + * http://grepcode.com/file_/repository.grepcode.com/java/ext/com.google.android/android/4.4_r1/android/preference/ListPreference.java/?v=source + */ +public class OpenPgpListPreference extends DialogPreference { + private static final String OPENKEYCHAIN_PACKAGE = "org.sufficientlysecure.keychain"; + private static final String MARKET_INTENT_URI_BASE = "market://details?id=%s"; + private static final Intent MARKET_INTENT = new Intent(Intent.ACTION_VIEW, Uri.parse( + String.format(MARKET_INTENT_URI_BASE, OPENKEYCHAIN_PACKAGE))); + + private ArrayList mLegacyList = new ArrayList(); + private ArrayList mList = new ArrayList(); + + private String mSelectedPackage; + + public OpenPgpListPreference(Context context, AttributeSet attrs) { + super(context, attrs); + } + + public OpenPgpListPreference(Context context) { + this(context, null); + } + + /** + * Public method to add new entries for legacy applications + * + * @param packageName + * @param simpleName + * @param icon + */ + public void addLegacyProvider(int position, String packageName, String simpleName, Drawable icon) { + mLegacyList.add(position, new OpenPgpProviderEntry(packageName, simpleName, icon)); + } + + @Override + protected void onPrepareDialogBuilder(Builder builder) { + mList.clear(); + + // add "none"-entry + mList.add(0, new OpenPgpProviderEntry("", + getContext().getString(R.string.openpgp_list_preference_none), + getContext().getResources().getDrawable(R.drawable.ic_action_cancel_launchersize))); + + // add all additional (legacy) providers + mList.addAll(mLegacyList); + + // search for OpenPGP providers... + ArrayList providerList = new ArrayList(); + Intent intent = new Intent(OpenPgpApi.SERVICE_INTENT); + List resInfo = getContext().getPackageManager().queryIntentServices(intent, 0); + if (!resInfo.isEmpty()) { + for (ResolveInfo resolveInfo : resInfo) { + if (resolveInfo.serviceInfo == null) + continue; + + String packageName = resolveInfo.serviceInfo.packageName; + String simpleName = String.valueOf(resolveInfo.serviceInfo.loadLabel(getContext() + .getPackageManager())); + Drawable icon = resolveInfo.serviceInfo.loadIcon(getContext().getPackageManager()); + + providerList.add(new OpenPgpProviderEntry(packageName, simpleName, icon)); + } + } + + if (providerList.isEmpty()) { + // add install links if provider list is empty + resInfo = getContext().getPackageManager().queryIntentActivities + (MARKET_INTENT, 0); + for (ResolveInfo resolveInfo : resInfo) { + Intent marketIntent = new Intent(MARKET_INTENT); + marketIntent.setPackage(resolveInfo.activityInfo.packageName); + Drawable icon = resolveInfo.activityInfo.loadIcon(getContext().getPackageManager()); + String marketName = String.valueOf(resolveInfo.activityInfo.applicationInfo + .loadLabel(getContext().getPackageManager())); + String simpleName = String.format(getContext().getString(R.string + .openpgp_install_openkeychain_via), marketName); + mList.add(new OpenPgpProviderEntry(OPENKEYCHAIN_PACKAGE, simpleName, + icon, marketIntent)); + } + } else { + // add provider + mList.addAll(providerList); + } + + // Init ArrayAdapter with OpenPGP Providers + ListAdapter adapter = new ArrayAdapter(getContext(), + android.R.layout.select_dialog_singlechoice, android.R.id.text1, mList) { + public View getView(int position, View convertView, ViewGroup parent) { + // User super class to create the View + View v = super.getView(position, convertView, parent); + TextView tv = (TextView) v.findViewById(android.R.id.text1); + + // Put the image on the TextView + tv.setCompoundDrawablesWithIntrinsicBounds(mList.get(position).icon, null, + null, null); + + // Add margin between image and text (support various screen densities) + int dp10 = (int) (10 * getContext().getResources().getDisplayMetrics().density + 0.5f); + tv.setCompoundDrawablePadding(dp10); + + return v; + } + }; + + builder.setSingleChoiceItems(adapter, getIndexOfProviderList(getValue()), + new DialogInterface.OnClickListener() { + + @Override + public void onClick(DialogInterface dialog, int which) { + OpenPgpProviderEntry entry = mList.get(which); + + if (entry.intent != null) { + /* + * Intents are called as activity + * + * Current approach is to assume the user installed the app. + * If he does not, the selected package is not valid. + * + * However applications should always consider this could happen, + * as the user might remove the currently used OpenPGP app. + */ + getContext().startActivity(entry.intent); + } + + mSelectedPackage = entry.packageName; + + /* + * Clicking on an item simulates the positive button click, and dismisses + * the dialog. + */ + OpenPgpListPreference.this.onClick(dialog, DialogInterface.BUTTON_POSITIVE); + dialog.dismiss(); + } + }); + + /* + * The typical interaction for list-based dialogs is to have click-on-an-item dismiss the + * dialog instead of the user having to press 'Ok'. + */ + builder.setPositiveButton(null, null); + } + + @Override + protected void onDialogClosed(boolean positiveResult) { + super.onDialogClosed(positiveResult); + + if (positiveResult && (mSelectedPackage != null)) { + if (callChangeListener(mSelectedPackage)) { + setValue(mSelectedPackage); + } + } + } + + private int getIndexOfProviderList(String packageName) { + for (OpenPgpProviderEntry app : mList) { + if (app.packageName.equals(packageName)) { + return mList.indexOf(app); + } + } + + return -1; + } + + public void setValue(String packageName) { + mSelectedPackage = packageName; + persistString(packageName); + } + + public String getValue() { + return mSelectedPackage; + } + + public String getEntry() { + return getEntryByValue(mSelectedPackage); + } + + @Override + protected Object onGetDefaultValue(TypedArray a, int index) { + return a.getString(index); + } + + @Override + protected void onSetInitialValue(boolean restoreValue, Object defaultValue) { + setValue(restoreValue ? getPersistedString(mSelectedPackage) : (String) defaultValue); + } + + public String getEntryByValue(String packageName) { + for (OpenPgpProviderEntry app : mList) { + if (app.packageName.equals(packageName)) { + return app.simpleName; + } + } + + return null; + } + + private static class OpenPgpProviderEntry { + private String packageName; + private String simpleName; + private Drawable icon; + private Intent intent; + + public OpenPgpProviderEntry(String packageName, String simpleName, Drawable icon) { + this.packageName = packageName; + this.simpleName = simpleName; + this.icon = icon; + } + + public OpenPgpProviderEntry(String packageName, String simpleName, Drawable icon, Intent intent) { + this(packageName, simpleName, icon); + this.intent = intent; + } + + @Override + public String toString() { + return simpleName; + } + } +} diff --git a/src/org/openintents/openpgp/util/OpenPgpServiceConnection.java b/src/org/openintents/openpgp/util/OpenPgpServiceConnection.java new file mode 100644 index 00000000..0395a7bc --- /dev/null +++ b/src/org/openintents/openpgp/util/OpenPgpServiceConnection.java @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * 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.openintents.openpgp.util; + +import org.openintents.openpgp.IOpenPgpService; + +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.os.IBinder; + +public class OpenPgpServiceConnection { + + // interface to create callbacks for onServiceConnected + public interface OnBound { + public void onBound(IOpenPgpService service); + } + + private Context mApplicationContext; + + private IOpenPgpService mService; + private String mProviderPackageName; + + private OnBound mOnBoundListener; + + /** + * Create new OpenPgpServiceConnection + * + * @param context + * @param providerPackageName specify package name of OpenPGP provider, + * e.g., "org.sufficientlysecure.keychain" + */ + public OpenPgpServiceConnection(Context context, String providerPackageName) { + this.mApplicationContext = context.getApplicationContext(); + this.mProviderPackageName = providerPackageName; + } + + /** + * Create new OpenPgpServiceConnection + * + * @param context + * @param providerPackageName specify package name of OpenPGP provider, + * e.g., "org.sufficientlysecure.keychain" + * @param onBoundListener callback, executed when connection to service has been established + */ + public OpenPgpServiceConnection(Context context, String providerPackageName, + OnBound onBoundListener) { + this.mApplicationContext = context.getApplicationContext(); + this.mProviderPackageName = providerPackageName; + this.mOnBoundListener = onBoundListener; + } + + public IOpenPgpService getService() { + return mService; + } + + public boolean isBound() { + return (mService != null); + } + + private ServiceConnection mServiceConnection = new ServiceConnection() { + public void onServiceConnected(ComponentName name, IBinder service) { + mService = IOpenPgpService.Stub.asInterface(service); + if (mOnBoundListener != null) { + mOnBoundListener.onBound(mService); + } + } + + public void onServiceDisconnected(ComponentName name) { + mService = null; + } + }; + + /** + * If not already bound, bind to service! + * + * @return + */ + public boolean bindToService() { + // if not already bound... + if (mService == null) { + try { + Intent serviceIntent = new Intent(); + serviceIntent.setAction(IOpenPgpService.class.getName()); + // NOTE: setPackage is very important to restrict the intent to this provider only! + serviceIntent.setPackage(mProviderPackageName); + mApplicationContext.bindService(serviceIntent, mServiceConnection, + Context.BIND_AUTO_CREATE); + + return true; + } catch (Exception e) { + return false; + } + } else { + return true; + } + } + + public void unbindFromService() { + mApplicationContext.unbindService(mServiceConnection); + } + +} diff --git a/src/org/openintents/openpgp/util/OpenPgpUtils.java b/src/org/openintents/openpgp/util/OpenPgpUtils.java new file mode 100644 index 00000000..e24c937a --- /dev/null +++ b/src/org/openintents/openpgp/util/OpenPgpUtils.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * + * 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.openintents.openpgp.util; + +import java.util.List; +import java.util.Locale; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import android.content.Context; +import android.content.Intent; +import android.content.pm.ResolveInfo; + +public class OpenPgpUtils { + + public static final Pattern PGP_MESSAGE = Pattern.compile( + ".*?(-----BEGIN PGP MESSAGE-----.*?-----END PGP MESSAGE-----).*", + Pattern.DOTALL); + + public static final Pattern PGP_SIGNED_MESSAGE = Pattern.compile( + ".*?(-----BEGIN PGP SIGNED MESSAGE-----.*?-----BEGIN PGP SIGNATURE-----.*?-----END PGP SIGNATURE-----).*", + Pattern.DOTALL); + + public static final int PARSE_RESULT_NO_PGP = -1; + public static final int PARSE_RESULT_MESSAGE = 0; + public static final int PARSE_RESULT_SIGNED_MESSAGE = 1; + + public static int parseMessage(String message) { + Matcher matcherSigned = PGP_SIGNED_MESSAGE.matcher(message); + Matcher matcherMessage = PGP_MESSAGE.matcher(message); + + if (matcherMessage.matches()) { + return PARSE_RESULT_MESSAGE; + } else if (matcherSigned.matches()) { + return PARSE_RESULT_SIGNED_MESSAGE; + } else { + return PARSE_RESULT_NO_PGP; + } + } + + public static boolean isAvailable(Context context) { + Intent intent = new Intent(OpenPgpApi.SERVICE_INTENT); + List resInfo = context.getPackageManager().queryIntentServices(intent, 0); + if (!resInfo.isEmpty()) { + return true; + } else { + return false; + } + } + + public static String convertKeyIdToHex(long keyId) { + return "0x" + convertKeyIdToHex32bit(keyId >> 32) + convertKeyIdToHex32bit(keyId); + } + + private static String convertKeyIdToHex32bit(long keyId) { + String hexString = Long.toHexString(keyId & 0xffffffffL).toLowerCase(Locale.US); + while (hexString.length() < 8) { + hexString = "0" + hexString; + } + return hexString; + } +} diff --git a/src/org/openintents/openpgp/util/ParcelFileDescriptorUtil.java b/src/org/openintents/openpgp/util/ParcelFileDescriptorUtil.java new file mode 100644 index 00000000..58c62110 --- /dev/null +++ b/src/org/openintents/openpgp/util/ParcelFileDescriptorUtil.java @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2014 Dominik Schürmann + * 2013 Flow (http://stackoverflow.com/questions/18212152/transfer-inputstream-to-another-service-across-process-boundaries-with-parcelf) + * + * 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.openintents.openpgp.util; + +import android.os.ParcelFileDescriptor; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +public class ParcelFileDescriptorUtil { + + public interface IThreadListener { + void onThreadFinished(final Thread thread); + } + + public static ParcelFileDescriptor pipeFrom(InputStream inputStream, IThreadListener listener) + throws IOException { + ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe(); + ParcelFileDescriptor readSide = pipe[0]; + ParcelFileDescriptor writeSide = pipe[1]; + + // start the transfer thread + new TransferThread(inputStream, new ParcelFileDescriptor.AutoCloseOutputStream(writeSide), + listener) + .start(); + + return readSide; + } + + public static ParcelFileDescriptor pipeTo(OutputStream outputStream, IThreadListener listener) + throws IOException { + ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe(); + ParcelFileDescriptor readSide = pipe[0]; + ParcelFileDescriptor writeSide = pipe[1]; + + // start the transfer thread + new TransferThread(new ParcelFileDescriptor.AutoCloseInputStream(readSide), outputStream, + listener) + .start(); + + return writeSide; + } + + static class TransferThread extends Thread { + final InputStream mIn; + final OutputStream mOut; + final IThreadListener mListener; + + TransferThread(InputStream in, OutputStream out, IThreadListener listener) { + super("ParcelFileDescriptor Transfer Thread"); + mIn = in; + mOut = out; + mListener = listener; + setDaemon(true); + } + + @Override + public void run() { + byte[] buf = new byte[1024]; + int len; + + try { + while ((len = mIn.read(buf)) > 0) { + mOut.write(buf, 0, len); + } + mOut.flush(); // just to be safe + } catch (IOException e) { + //Log.e(OpenPgpApi.TAG, "TransferThread" + getId() + ": writing failed", e); + } finally { + try { + mIn.close(); + } catch (IOException e) { + //Log.e(OpenPgpApi.TAG, "TransferThread" + getId(), e); + } + try { + mOut.close(); + } catch (IOException e) { + //Log.e(OpenPgpApi.TAG, "TransferThread" + getId(), e); + } + } + if (mListener != null) { + //Log.d(OpenPgpApi.TAG, "TransferThread " + getId() + " finished!"); + mListener.onThreadFinished(this); + } + } + } +} \ No newline at end of file