generalize nfc crypto input structure

4 files changed, 142 insertions, 109 deletions

diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedSecretKey.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedSecretKey.java
index ab91d7747..df409902f 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedSecretKey.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedSecretKey.java
@@ -42,10 +42,13 @@ import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
 import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException;
 import org.sufficientlysecure.keychain.util.Log;
 
+import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+
 
 /**
  * Wrapper for a PGPSecretKey.
@@ -183,13 +186,13 @@ public class CanonicalizedSecretKey extends CanonicalizedPublicKey {
         return PgpConstants.sPreferredHashAlgorithms;
     }
 
-    private PGPContentSignerBuilder getContentSignerBuilder(int hashAlgo, byte[] nfcSignedHash,
-                                                            Date nfcCreationTimestamp) {
+    private PGPContentSignerBuilder getContentSignerBuilder(int hashAlgo,
+            Map<ByteBuffer,byte[]> signedHashes) {
         if (mPrivateKeyState == PRIVATE_KEY_STATE_DIVERT_TO_CARD) {
             // use synchronous "NFC based" SignerBuilder
             return new NfcSyncPGPContentSignerBuilder(
                     mSecretKey.getPublicKey().getAlgorithm(), hashAlgo,
-                    mSecretKey.getKeyID(), nfcSignedHash, nfcCreationTimestamp)
+                    mSecretKey.getKeyID(), signedHashes)
                     .setProvider(Constants.BOUNCY_CASTLE_PROVIDER_NAME);
         } else {
             // content signer based on signing key algorithm and chosen hash algorithm
@@ -200,28 +203,24 @@ public class CanonicalizedSecretKey extends CanonicalizedPublicKey {
     }
 
     public PGPSignatureGenerator getSignatureGenerator(int hashAlgo, boolean cleartext,
-                                                       byte[] nfcSignedHash, Date nfcCreationTimestamp)
+            Map<ByteBuffer,byte[]> signedHashes, Date creationTimestamp)
             throws PgpGeneralException {
         if (mPrivateKeyState == PRIVATE_KEY_STATE_LOCKED) {
             throw new PrivateKeyNotUnlockedException();
         }
-        if (nfcSignedHash != null && nfcCreationTimestamp == null) {
-            throw new PgpGeneralException("Got nfc hash without timestamp!!");
-        }
 
         // We explicitly create a signature creation timestamp in this place.
         // That way, we can inject an artificial one from outside, ie the one
         // used in previous runs of this function.
-        if (nfcCreationTimestamp == null) {
+        if (creationTimestamp == null) {
             // to sign using nfc PgpSignEncrypt is executed two times.
             // the first time it stops to return the PendingIntent for nfc connection and signing the hash
             // the second time the signed hash is used.
             // to get the same hash we cache the timestamp for the second round!
-            nfcCreationTimestamp = new Date();
+            creationTimestamp = new Date();
         }
 
-        PGPContentSignerBuilder contentSignerBuilder = getContentSignerBuilder(hashAlgo,
-                nfcSignedHash, nfcCreationTimestamp);
+        PGPContentSignerBuilder contentSignerBuilder = getContentSignerBuilder(hashAlgo, signedHashes);
 
         int signatureType;
         if (cleartext) {
@@ -237,7 +236,7 @@ public class CanonicalizedSecretKey extends CanonicalizedPublicKey {
 
             PGPSignatureSubpacketGenerator spGen = new PGPSignatureSubpacketGenerator();
             spGen.setSignerUserID(false, mRing.getPrimaryUserIdWithFallback());
-            spGen.setSignatureCreationTime(false, nfcCreationTimestamp);
+            spGen.setSignatureCreationTime(false, creationTimestamp);
             signatureGenerator.setHashedSubpackets(spGen.generate());
             return signatureGenerator;
         } catch (PgpKeyNotFoundException | PGPException e) {
@@ -267,8 +266,9 @@ public class CanonicalizedSecretKey extends CanonicalizedPublicKey {
      * @param userIds       User IDs to certify
      * @return A keyring with added certifications
      */
-    public UncachedKeyRing certifyUserIds(CanonicalizedPublicKeyRing publicKeyRing, List<String> userIds,
-                                          byte[] nfcSignedHash, Date nfcCreationTimestamp) {
+    public UncachedKeyRing certifyUserIds(CanonicalizedPublicKeyRing publicKeyRing,
+            List<String> userIds,
+            HashMap<ByteBuffer,byte[]> signedHashes, Date creationTimestamp) {
         if (mPrivateKeyState == PRIVATE_KEY_STATE_LOCKED) {
             throw new PrivateKeyNotUnlockedException();
         }
@@ -283,7 +283,7 @@ public class CanonicalizedSecretKey extends CanonicalizedPublicKey {
         PGPSignatureGenerator signatureGenerator;
         {
             PGPContentSignerBuilder contentSignerBuilder = getContentSignerBuilder(
-                    PgpConstants.CERTIFY_HASH_ALGO, nfcSignedHash, nfcCreationTimestamp);
+                    PgpConstants.CERTIFY_HASH_ALGO, signedHashes);
 
             signatureGenerator = new PGPSignatureGenerator(contentSignerBuilder);
             try {
@@ -296,9 +296,9 @@ public class CanonicalizedSecretKey extends CanonicalizedPublicKey {
 
         { // supply signatureGenerator with a SubpacketVector
             PGPSignatureSubpacketGenerator spGen = new PGPSignatureSubpacketGenerator();
-            if (nfcCreationTimestamp != null) {
-                spGen.setSignatureCreationTime(false, nfcCreationTimestamp);
-                Log.d(Constants.TAG, "For NFC: set sig creation time to " + nfcCreationTimestamp);
+            if (creationTimestamp != null) {
+                spGen.setSignatureCreationTime(false, creationTimestamp);
+                Log.d(Constants.TAG, "For NFC: set sig creation time to " + creationTimestamp);
             }
             PGPSignatureSubpacketVector packetVector = spGen.generate();
             signatureGenerator.setHashedSubpackets(packetVector);
@@ -331,7 +331,8 @@ public class CanonicalizedSecretKey extends CanonicalizedPublicKey {
      * @return A keyring with added certifications
      */
     public UncachedKeyRing certifyUserAttributes(CanonicalizedPublicKeyRing publicKeyRing,
-            List<WrappedUserAttribute> userAttributes, byte[] nfcSignedHash, Date nfcCreationTimestamp) {
+            List<WrappedUserAttribute> userAttributes,
+            HashMap<ByteBuffer,byte[]> signedHashes, Date creationTimestamp) {
         if (mPrivateKeyState == PRIVATE_KEY_STATE_LOCKED) {
             throw new PrivateKeyNotUnlockedException();
         }
@@ -346,7 +347,7 @@ public class CanonicalizedSecretKey extends CanonicalizedPublicKey {
         PGPSignatureGenerator signatureGenerator;
         {
             PGPContentSignerBuilder contentSignerBuilder = getContentSignerBuilder(
-                    PgpConstants.CERTIFY_HASH_ALGO, nfcSignedHash, nfcCreationTimestamp);
+                    PgpConstants.CERTIFY_HASH_ALGO, signedHashes);
 
             signatureGenerator = new PGPSignatureGenerator(contentSignerBuilder);
             try {
@@ -359,9 +360,9 @@ public class CanonicalizedSecretKey extends CanonicalizedPublicKey {
 
         { // supply signatureGenerator with a SubpacketVector
             PGPSignatureSubpacketGenerator spGen = new PGPSignatureSubpacketGenerator();
-            if (nfcCreationTimestamp != null) {
-                spGen.setSignatureCreationTime(false, nfcCreationTimestamp);
-                Log.d(Constants.TAG, "For NFC: set sig creation time to " + nfcCreationTimestamp);
+            if (creationTimestamp != null) {
+                spGen.setSignatureCreationTime(false, creationTimestamp);
+                Log.d(Constants.TAG, "For NFC: set sig creation time to " + creationTimestamp);
             }
             PGPSignatureSubpacketVector packetVector = spGen.generate();
             signatureGenerator.setHashedSubpackets(packetVector);
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptInput.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptInputParcel.java
index 2dec4b9c2..00ecc179e 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptInput.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptInputParcel.java
@@ -20,10 +20,17 @@ package org.sufficientlysecure.keychain.pgp;
 
 import org.spongycastle.bcpg.CompressionAlgorithmTags;
 import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
 
+import java.nio.ByteBuffer;
 import java.util.Date;
+import java.util.Map;
 
-public class PgpSignEncryptInput {
+import android.os.Parcel;
+import android.os.Parcelable;
+
+
+public class PgpSignEncryptInputParcel implements Parcelable {
 
     protected String mVersionHeader = null;
     protected boolean mEnableAsciiArmorOutput = false;
@@ -36,13 +43,71 @@ public class PgpSignEncryptInput {
     protected int mSignatureHashAlgorithm = PgpConstants.OpenKeychainHashAlgorithmTags.USE_PREFERRED;
     protected String mSignaturePassphrase = null;
     protected long mAdditionalEncryptId = Constants.key.none;
-    protected byte[] mNfcSignedHash = null;
-    protected Date mNfcCreationTimestamp = null;
     protected boolean mFailOnMissingEncryptionKeyIds = false;
     protected String mCharset;
     protected boolean mCleartextSignature;
     protected boolean mDetachedSignature = false;
     protected boolean mHiddenRecipients = false;
+    protected CryptoInputParcel mCryptoInput = new CryptoInputParcel(null);
+
+    public PgpSignEncryptInputParcel() {
+
+    }
+
+    PgpSignEncryptInputParcel(Parcel source) {
+
+        // we do all of those here, so the PgpSignEncryptInput class doesn't have to be parcelable
+        mVersionHeader = source.readString();
+        mEnableAsciiArmorOutput  = source.readInt() == 1;
+        mCompressionId = source.readInt();
+        mEncryptionMasterKeyIds = source.createLongArray();
+        mSymmetricPassphrase = source.readString();
+        mSymmetricEncryptionAlgorithm = source.readInt();
+        mSignatureMasterKeyId = source.readLong();
+        mSignatureSubKeyId = source.readInt() == 1 ? source.readLong() : null;
+        mSignatureHashAlgorithm = source.readInt();
+        mSignaturePassphrase = source.readString();
+        mAdditionalEncryptId = source.readLong();
+        mFailOnMissingEncryptionKeyIds = source.readInt() == 1;
+        mCharset = source.readString();
+        mCleartextSignature = source.readInt() == 1;
+        mDetachedSignature = source.readInt() == 1;
+        mHiddenRecipients = source.readInt() == 1;
+
+        mCryptoInput = source.readParcelable(PgpSignEncryptInputParcel.class.getClassLoader());
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeString(mVersionHeader);
+        dest.writeInt(mEnableAsciiArmorOutput ? 1 : 0);
+        dest.writeInt(mCompressionId);
+        dest.writeLongArray(mEncryptionMasterKeyIds);
+        dest.writeString(mSymmetricPassphrase);
+        dest.writeInt(mSymmetricEncryptionAlgorithm);
+        dest.writeLong(mSignatureMasterKeyId);
+        if (mSignatureSubKeyId != null) {
+            dest.writeInt(1);
+            dest.writeLong(mSignatureSubKeyId);
+        } else {
+            dest.writeInt(0);
+        }
+        dest.writeInt(mSignatureHashAlgorithm);
+        dest.writeString(mSignaturePassphrase);
+        dest.writeLong(mAdditionalEncryptId);
+        dest.writeInt(mFailOnMissingEncryptionKeyIds ? 1 : 0);
+        dest.writeString(mCharset);
+        dest.writeInt(mCleartextSignature ? 1 : 0);
+        dest.writeInt(mDetachedSignature ? 1 : 0);
+        dest.writeInt(mHiddenRecipients ? 1 : 0);
+
+        dest.writeParcelable(mCryptoInput, 0);
+    }
 
     public String getCharset() {
         return mCharset;
@@ -56,19 +121,11 @@ public class PgpSignEncryptInput {
         return mFailOnMissingEncryptionKeyIds;
     }
 
-    public Date getNfcCreationTimestamp() {
-        return mNfcCreationTimestamp;
-    }
-
-    public byte[] getNfcSignedHash() {
-        return mNfcSignedHash;
-    }
-
     public long getAdditionalEncryptId() {
         return mAdditionalEncryptId;
     }
 
-    public PgpSignEncryptInput setAdditionalEncryptId(long additionalEncryptId) {
+    public PgpSignEncryptInputParcel setAdditionalEncryptId(long additionalEncryptId) {
         mAdditionalEncryptId = additionalEncryptId;
         return this;
     }
@@ -77,7 +134,7 @@ public class PgpSignEncryptInput {
         return mSignaturePassphrase;
     }
 
-    public PgpSignEncryptInput setSignaturePassphrase(String signaturePassphrase) {
+    public PgpSignEncryptInputParcel setSignaturePassphrase(String signaturePassphrase) {
         mSignaturePassphrase = signaturePassphrase;
         return this;
     }
@@ -86,7 +143,7 @@ public class PgpSignEncryptInput {
         return mSignatureHashAlgorithm;
     }
 
-    public PgpSignEncryptInput setSignatureHashAlgorithm(int signatureHashAlgorithm) {
+    public PgpSignEncryptInputParcel setSignatureHashAlgorithm(int signatureHashAlgorithm) {
         mSignatureHashAlgorithm = signatureHashAlgorithm;
         return this;
     }
@@ -95,7 +152,7 @@ public class PgpSignEncryptInput {
         return mSignatureSubKeyId;
     }
 
-    public PgpSignEncryptInput setSignatureSubKeyId(long signatureSubKeyId) {
+    public PgpSignEncryptInputParcel setSignatureSubKeyId(long signatureSubKeyId) {
         mSignatureSubKeyId = signatureSubKeyId;
         return this;
     }
@@ -104,7 +161,7 @@ public class PgpSignEncryptInput {
         return mSignatureMasterKeyId;
     }
 
-    public PgpSignEncryptInput setSignatureMasterKeyId(long signatureMasterKeyId) {
+    public PgpSignEncryptInputParcel setSignatureMasterKeyId(long signatureMasterKeyId) {
         mSignatureMasterKeyId = signatureMasterKeyId;
         return this;
     }
@@ -113,7 +170,7 @@ public class PgpSignEncryptInput {
         return mSymmetricEncryptionAlgorithm;
     }
 
-    public PgpSignEncryptInput setSymmetricEncryptionAlgorithm(int symmetricEncryptionAlgorithm) {
+    public PgpSignEncryptInputParcel setSymmetricEncryptionAlgorithm(int symmetricEncryptionAlgorithm) {
         mSymmetricEncryptionAlgorithm = symmetricEncryptionAlgorithm;
         return this;
     }
@@ -122,7 +179,7 @@ public class PgpSignEncryptInput {
         return mSymmetricPassphrase;
     }
 
-    public PgpSignEncryptInput setSymmetricPassphrase(String symmetricPassphrase) {
+    public PgpSignEncryptInputParcel setSymmetricPassphrase(String symmetricPassphrase) {
         mSymmetricPassphrase = symmetricPassphrase;
         return this;
     }
@@ -131,7 +188,7 @@ public class PgpSignEncryptInput {
         return mEncryptionMasterKeyIds;
     }
 
-    public PgpSignEncryptInput setEncryptionMasterKeyIds(long[] encryptionMasterKeyIds) {
+    public PgpSignEncryptInputParcel setEncryptionMasterKeyIds(long[] encryptionMasterKeyIds) {
         mEncryptionMasterKeyIds = encryptionMasterKeyIds;
         return this;
     }
@@ -140,7 +197,7 @@ public class PgpSignEncryptInput {
         return mCompressionId;
     }
 
-    public PgpSignEncryptInput setCompressionId(int compressionId) {
+    public PgpSignEncryptInputParcel setCompressionId(int compressionId) {
         mCompressionId = compressionId;
         return this;
     }
@@ -153,28 +210,22 @@ public class PgpSignEncryptInput {
         return mVersionHeader;
     }
 
-    public PgpSignEncryptInput setVersionHeader(String versionHeader) {
+    public PgpSignEncryptInputParcel setVersionHeader(String versionHeader) {
         mVersionHeader = versionHeader;
         return this;
     }
 
-    public PgpSignEncryptInput setEnableAsciiArmorOutput(boolean enableAsciiArmorOutput) {
+    public PgpSignEncryptInputParcel setEnableAsciiArmorOutput(boolean enableAsciiArmorOutput) {
         mEnableAsciiArmorOutput = enableAsciiArmorOutput;
         return this;
     }
 
-    public PgpSignEncryptInput setFailOnMissingEncryptionKeyIds(boolean failOnMissingEncryptionKeyIds) {
+    public PgpSignEncryptInputParcel setFailOnMissingEncryptionKeyIds(boolean failOnMissingEncryptionKeyIds) {
         mFailOnMissingEncryptionKeyIds = failOnMissingEncryptionKeyIds;
         return this;
     }
 
-    public PgpSignEncryptInput setNfcState(byte[] signedHash, Date creationTimestamp) {
-        mNfcSignedHash = signedHash;
-        mNfcCreationTimestamp = creationTimestamp;
-        return this;
-    }
-
-    public PgpSignEncryptInput setCleartextSignature(boolean cleartextSignature) {
+    public PgpSignEncryptInputParcel setCleartextSignature(boolean cleartextSignature) {
         this.mCleartextSignature = cleartextSignature;
         return this;
     }
@@ -183,7 +234,7 @@ public class PgpSignEncryptInput {
         return mCleartextSignature;
     }
 
-    public PgpSignEncryptInput setDetachedSignature(boolean detachedSignature) {
+    public PgpSignEncryptInputParcel setDetachedSignature(boolean detachedSignature) {
         this.mDetachedSignature = detachedSignature;
         return this;
     }
@@ -192,7 +243,7 @@ public class PgpSignEncryptInput {
         return mDetachedSignature;
     }
 
-    public PgpSignEncryptInput setHiddenRecipients(boolean hiddenRecipients) {
+    public PgpSignEncryptInputParcel setHiddenRecipients(boolean hiddenRecipients) {
         this.mHiddenRecipients = hiddenRecipients;
         return this;
     }
@@ -200,5 +251,29 @@ public class PgpSignEncryptInput {
     public boolean isHiddenRecipients() {
         return mHiddenRecipients;
     }
+
+    public PgpSignEncryptInputParcel setCryptoInput(CryptoInputParcel cryptoInput) {
+        mCryptoInput = cryptoInput;
+        return this;
+    }
+
+    public Map<ByteBuffer, byte[]> getCryptoData() {
+        return mCryptoInput.getCryptoData();
+    }
+
+    public Date getSignatureTime() {
+        return mCryptoInput.getSignatureTime();
+    }
+
+    public static final Creator<PgpSignEncryptInputParcel> CREATOR = new Creator<PgpSignEncryptInputParcel>() {
+        public PgpSignEncryptInputParcel createFromParcel(final Parcel source) {
+            return new PgpSignEncryptInputParcel(source);
+        }
+
+        public PgpSignEncryptInputParcel[] newArray(final int size) {
+            return new PgpSignEncryptInputParcel[size];
+        }
+    };
+
 }
 
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptOperation.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptOperation.java
index 94e04060d..2e515137a 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptOperation.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptOperation.java
@@ -44,6 +44,8 @@ import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
 import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
+import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
+import org.sufficientlysecure.keychain.service.input.NfcOperationsParcel;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.InputData;
 import org.sufficientlysecure.keychain.util.Log;
@@ -71,7 +73,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
  *
  * For a high-level operation based on URIs, see SignEncryptOperation.
  *
- * @see org.sufficientlysecure.keychain.pgp.PgpSignEncryptInput
+ * @see PgpSignEncryptInputParcel
  * @see org.sufficientlysecure.keychain.operations.results.PgpSignEncryptResult
  * @see org.sufficientlysecure.keychain.operations.SignEncryptOperation
  *
@@ -99,7 +101,7 @@ public class PgpSignEncryptOperation extends BaseOperation {
     /**
      * Signs and/or encrypts data based on parameters of class
      */
-    public PgpSignEncryptResult execute(PgpSignEncryptInput input,
+    public PgpSignEncryptResult execute(PgpSignEncryptInputParcel input,
                                      InputData inputData, OutputStream outputStream) {
 
         int indent = 0;
@@ -282,7 +284,8 @@ public class PgpSignEncryptOperation extends BaseOperation {
             try {
                 boolean cleartext = input.isCleartextSignature() && input.isEnableAsciiArmorOutput() && !enableEncryption;
                 signatureGenerator = signingKey.getSignatureGenerator(
-                        input.getSignatureHashAlgorithm(), cleartext, input.getNfcSignedHash(), input.getNfcCreationTimestamp());
+                        input.getSignatureHashAlgorithm(), cleartext,
+                        input.getCryptoData(), input.getSignatureTime());
             } catch (PgpGeneralException e) {
                 log.add(LogType.MSG_PSE_ERROR_NFC, indent);
                 return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
@@ -489,7 +492,8 @@ public class PgpSignEncryptOperation extends BaseOperation {
                             new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_PENDING_NFC, log);
                     // Note that the checked key here is the master key, not the signing key
                     // (although these are always the same on Yubikeys)
-                    result.setNfcData(input.getSignatureSubKeyId(), e.hashToSign, e.hashAlgo, e.creationTimestamp, input.getSignaturePassphrase());
+                    result.setNfcData(signingKey.getKeyId(), e.hashToSign, e.hashAlgo,
+                            input.getSignaturePassphrase());
                     Log.d(Constants.TAG, "e.hashToSign" + Hex.toHexString(e.hashToSign));
                     return result;
                 }
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/SignEncryptParcel.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/SignEncryptParcel.java
index 8e71e8815..1b14e78fb 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/SignEncryptParcel.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/SignEncryptParcel.java
@@ -20,7 +20,6 @@ package org.sufficientlysecure.keychain.pgp;
 
 import android.net.Uri;
 import android.os.Parcel;
-import android.os.Parcelable;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -40,7 +39,7 @@ import java.util.List;
  *   left, which will be returned in a byte array as part of the result parcel.
  *
  */
-public class SignEncryptParcel extends PgpSignEncryptInput implements Parcelable {
+public class SignEncryptParcel extends PgpSignEncryptInputParcel {
 
     public ArrayList<Uri> mInputUris = new ArrayList<>();
     public ArrayList<Uri> mOutputUris = new ArrayList<>();
@@ -51,26 +50,7 @@ public class SignEncryptParcel extends PgpSignEncryptInput implements Parcelable
     }
 
     public SignEncryptParcel(Parcel src) {
-
-        // we do all of those here, so the PgpSignEncryptInput class doesn't have to be parcelable
-        mVersionHeader = src.readString();
-        mEnableAsciiArmorOutput  = src.readInt() == 1;
-        mCompressionId = src.readInt();
-        mEncryptionMasterKeyIds = src.createLongArray();
-        mSymmetricPassphrase = src.readString();
-        mSymmetricEncryptionAlgorithm = src.readInt();
-        mSignatureMasterKeyId = src.readLong();
-        mSignatureSubKeyId = src.readInt() == 1 ? src.readLong() : null;
-        mSignatureHashAlgorithm = src.readInt();
-        mSignaturePassphrase = src.readString();
-        mAdditionalEncryptId = src.readLong();
-        mNfcSignedHash = src.createByteArray();
-        mNfcCreationTimestamp = src.readInt() == 1 ? new Date(src.readLong()) : null;
-        mFailOnMissingEncryptionKeyIds = src.readInt() == 1;
-        mCharset = src.readString();
-        mCleartextSignature = src.readInt() == 1;
-        mDetachedSignature = src.readInt() == 1;
-        mHiddenRecipients = src.readInt() == 1;
+        super(src);
 
         mInputUris = src.createTypedArrayList(Uri.CREATOR);
         mOutputUris = src.createTypedArrayList(Uri.CREATOR);
@@ -108,34 +88,7 @@ public class SignEncryptParcel extends PgpSignEncryptInput implements Parcelable
     }
 
     public void writeToParcel(Parcel dest, int flags) {
-        dest.writeString(mVersionHeader);
-        dest.writeInt(mEnableAsciiArmorOutput ? 1 : 0);
-        dest.writeInt(mCompressionId);
-        dest.writeLongArray(mEncryptionMasterKeyIds);
-        dest.writeString(mSymmetricPassphrase);
-        dest.writeInt(mSymmetricEncryptionAlgorithm);
-        dest.writeLong(mSignatureMasterKeyId);
-        if (mSignatureSubKeyId != null) {
-            dest.writeInt(1);
-            dest.writeLong(mSignatureSubKeyId);
-        } else {
-            dest.writeInt(0);
-        }
-        dest.writeInt(mSignatureHashAlgorithm);
-        dest.writeString(mSignaturePassphrase);
-        dest.writeLong(mAdditionalEncryptId);
-        dest.writeByteArray(mNfcSignedHash);
-        if (mNfcCreationTimestamp != null) {
-            dest.writeInt(1);
-            dest.writeLong(mNfcCreationTimestamp.getTime());
-        } else {
-            dest.writeInt(0);
-        }
-        dest.writeInt(mFailOnMissingEncryptionKeyIds ? 1 : 0);
-        dest.writeString(mCharset);
-        dest.writeInt(mCleartextSignature ? 1 : 0);
-        dest.writeInt(mDetachedSignature ? 1 : 0);
-        dest.writeInt(mHiddenRecipients ? 1 : 0);
+        super.writeToParcel(dest, flags);
 
         dest.writeTypedList(mInputUris);
         dest.writeTypedList(mOutputUris);