rename Wrapped*Key* to Canonicalized*Key*

12 files changed, 98 insertions, 111 deletions

diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedKeyRing.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedKeyRing.java
index a054255dc..ee0dfefa4 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedKeyRing.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedKeyRing.java
@@ -16,13 +16,11 @@ import java.io.OutputStream;
  * getter method.
  *
  */
-public abstract class WrappedKeyRing extends KeyRing {
+public abstract class CanonicalizedKeyRing extends KeyRing {
 
-    private final boolean mHasAnySecret;
     private final int mVerified;
 
-    WrappedKeyRing(boolean hasAnySecret, int verified) {
-        mHasAnySecret = hasAnySecret;
+    CanonicalizedKeyRing(int verified) {
         mVerified = verified;
     }
 
@@ -30,10 +28,6 @@ public abstract class WrappedKeyRing extends KeyRing {
         return getRing().getPublicKey().getKeyID();
     }
 
-    public boolean hasAnySecret() {
-        return mHasAnySecret;
-    }
-
     public int getVerified() {
         return mVerified;
     }
@@ -56,7 +50,7 @@ public abstract class WrappedKeyRing extends KeyRing {
     }
 
     public long getEncryptId() throws PgpGeneralException {
-        for(WrappedPublicKey key : publicKeyIterator()) {
+        for(CanonicalizedPublicKey key : publicKeyIterator()) {
             if(key.canEncrypt()) {
                 return key.getKeyId();
             }
@@ -74,7 +68,7 @@ public abstract class WrappedKeyRing extends KeyRing {
     }
 
     public long getSignId() throws PgpGeneralException {
-        for(WrappedPublicKey key : publicKeyIterator()) {
+        for(CanonicalizedPublicKey key : publicKeyIterator()) {
             if(key.canSign()) {
                 return key.getKeyId();
             }
@@ -103,14 +97,14 @@ public abstract class WrappedKeyRing extends KeyRing {
 
     abstract PGPKeyRing getRing();
 
-    abstract public IterableIterator<WrappedPublicKey> publicKeyIterator();
+    abstract public IterableIterator<CanonicalizedPublicKey> publicKeyIterator();
 
-    public WrappedPublicKey getPublicKey() {
-        return new WrappedPublicKey(this, getRing().getPublicKey());
+    public CanonicalizedPublicKey getPublicKey() {
+        return new CanonicalizedPublicKey(this, getRing().getPublicKey());
     }
 
-    public WrappedPublicKey getPublicKey(long id) {
-        return new WrappedPublicKey(this, getRing().getPublicKey(id));
+    public CanonicalizedPublicKey getPublicKey(long id) {
+        return new CanonicalizedPublicKey(this, getRing().getPublicKey(id));
     }
 
     public byte[] getEncoded() throws IOException {
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedPublicKey.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedPublicKey.java
index 69a4fbdee..981caad49 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedPublicKey.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedPublicKey.java
@@ -14,12 +14,12 @@ import org.sufficientlysecure.keychain.util.IterableIterator;
  * stored in the database.
  *
  */
-public class WrappedPublicKey extends UncachedPublicKey {
+public class CanonicalizedPublicKey extends UncachedPublicKey {
 
     // this is the parent key ring
     final KeyRing mRing;
 
-    WrappedPublicKey(KeyRing ring, PGPPublicKey key) {
+    CanonicalizedPublicKey(KeyRing ring, PGPPublicKey key) {
         super(key);
         mRing = ring;
     }
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedPublicKeyRing.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedPublicKeyRing.java
index bb1f7d778..70288dceb 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedPublicKeyRing.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedPublicKeyRing.java
@@ -10,33 +10,36 @@ import org.sufficientlysecure.keychain.util.IterableIterator;
 import java.io.IOException;
 import java.util.Iterator;
 
-public class WrappedPublicKeyRing extends WrappedKeyRing {
+public class CanonicalizedPublicKeyRing extends CanonicalizedKeyRing {
 
     private PGPPublicKeyRing mRing;
-    private final byte[] mPubKey;
 
-    public WrappedPublicKeyRing(byte[] blob, boolean hasAnySecret, int verified) {
-        super(hasAnySecret, verified);
-        mPubKey = blob;
+    CanonicalizedPublicKeyRing(PGPPublicKeyRing ring, int verified) {
+        super(verified);
+        mRing = ring;
     }
 
-    PGPPublicKeyRing getRing() {
+    public CanonicalizedPublicKeyRing(byte[] blob, int verified) {
+        super(verified);
         if(mRing == null) {
             // get first object in block
-            PGPObjectFactory factory = new PGPObjectFactory(mPubKey);
+            PGPObjectFactory factory = new PGPObjectFactory(blob);
             try {
                 Object obj = factory.nextObject();
                 if (! (obj instanceof PGPPublicKeyRing)) {
-                    throw new RuntimeException("Error constructing WrappedPublicKeyRing, should never happen!");
+                    throw new RuntimeException("Error constructing CanonicalizedPublicKeyRing, should never happen!");
                 }
                 mRing = (PGPPublicKeyRing) obj;
                 if (factory.nextObject() != null) {
                     throw new RuntimeException("Encountered trailing data after keyring, should never happen!");
                 }
             } catch (IOException e) {
-                throw new RuntimeException("IO Error constructing WrappedPublicKeyRing, should never happen!");
+                throw new RuntimeException("IO Error constructing CanonicalizedPublicKeyRing, should never happen!");
             }
         }
+    }
+
+    PGPPublicKeyRing getRing() {
         return mRing;
     }
 
@@ -45,10 +48,10 @@ public class WrappedPublicKeyRing extends WrappedKeyRing {
     }
 
     /** Getter that returns the subkey that should be used for signing. */
-    WrappedPublicKey getEncryptionSubKey() throws PgpGeneralException {
+    CanonicalizedPublicKey getEncryptionSubKey() throws PgpGeneralException {
         PGPPublicKey key = getRing().getPublicKey(getEncryptId());
         if(key != null) {
-            WrappedPublicKey cKey = new WrappedPublicKey(this, key);
+            CanonicalizedPublicKey cKey = new CanonicalizedPublicKey(this, key);
             if(!cKey.canEncrypt()) {
                 throw new PgpGeneralException("key error");
             }
@@ -57,18 +60,18 @@ public class WrappedPublicKeyRing extends WrappedKeyRing {
         throw new PgpGeneralException("no encryption key available");
     }
 
-    public IterableIterator<WrappedPublicKey> publicKeyIterator() {
+    public IterableIterator<CanonicalizedPublicKey> publicKeyIterator() {
         @SuppressWarnings("unchecked")
         final Iterator<PGPPublicKey> it = getRing().getPublicKeys();
-        return new IterableIterator<WrappedPublicKey>(new Iterator<WrappedPublicKey>() {
+        return new IterableIterator<CanonicalizedPublicKey>(new Iterator<CanonicalizedPublicKey>() {
             @Override
             public boolean hasNext() {
                 return it.hasNext();
             }
 
             @Override
-            public WrappedPublicKey next() {
-                return new WrappedPublicKey(WrappedPublicKeyRing.this, it.next());
+            public CanonicalizedPublicKey next() {
+                return new CanonicalizedPublicKey(CanonicalizedPublicKeyRing.this, it.next());
             }
 
             @Override
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedSecretKey.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedSecretKey.java
index f0485d801..2eb517697 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedSecretKey.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedSecretKey.java
@@ -37,18 +37,18 @@ import java.util.List;
  * properly imported secret keys only.
  *
  */
-public class WrappedSecretKey extends WrappedPublicKey {
+public class CanonicalizedSecretKey extends CanonicalizedPublicKey {
 
     private final PGPSecretKey mSecretKey;
     private PGPPrivateKey mPrivateKey = null;
 
-    WrappedSecretKey(WrappedSecretKeyRing ring, PGPSecretKey key) {
+    CanonicalizedSecretKey(CanonicalizedSecretKeyRing ring, PGPSecretKey key) {
         super(ring, key.getPublicKey());
         mSecretKey = key;
     }
 
-    public WrappedSecretKeyRing getRing() {
-        return (WrappedSecretKeyRing) mRing;
+    public CanonicalizedSecretKeyRing getRing() {
+        return (CanonicalizedSecretKeyRing) mRing;
     }
 
     public boolean unlock(String passphrase) throws PgpGeneralException {
@@ -140,7 +140,7 @@ public class WrappedSecretKey extends WrappedPublicKey {
      * @param userIds          User IDs to certify, must not be null or empty
      * @return A keyring with added certifications
      */
-    public UncachedKeyRing certifyUserIds(WrappedPublicKeyRing publicKeyRing, List<String> userIds)
+    public UncachedKeyRing certifyUserIds(CanonicalizedPublicKeyRing publicKeyRing, List<String> userIds)
             throws PgpGeneralMsgIdException, NoSuchAlgorithmException, NoSuchProviderException,
             PGPException, SignatureException {
 
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedSecretKeyRing.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedSecretKeyRing.java
index 5cb24cf88..e48fe5020 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedSecretKeyRing.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/CanonicalizedSecretKeyRing.java
@@ -1,10 +1,12 @@
 package org.sufficientlysecure.keychain.pgp;
 
+import org.spongycastle.bcpg.S2K;
 import org.spongycastle.openpgp.PGPException;
 import org.spongycastle.openpgp.PGPKeyRing;
 import org.spongycastle.openpgp.PGPObjectFactory;
 import org.spongycastle.openpgp.PGPPrivateKey;
 import org.spongycastle.openpgp.PGPPublicKey;
+import org.spongycastle.openpgp.PGPPublicKeyRing;
 import org.spongycastle.openpgp.PGPSecretKey;
 import org.spongycastle.openpgp.PGPSecretKeyRing;
 import org.spongycastle.openpgp.operator.PBESecretKeyDecryptor;
@@ -15,15 +17,21 @@ import org.sufficientlysecure.keychain.util.IterableIterator;
 import org.sufficientlysecure.keychain.util.Log;
 
 import java.io.IOException;
+import java.util.HashSet;
 import java.util.Iterator;
 
-public class WrappedSecretKeyRing extends WrappedKeyRing {
+public class CanonicalizedSecretKeyRing extends CanonicalizedKeyRing {
 
     private PGPSecretKeyRing mRing;
 
-    public WrappedSecretKeyRing(byte[] blob, boolean isRevoked, int verified)
+    CanonicalizedSecretKeyRing(PGPSecretKeyRing ring, int verified) {
+        super(verified);
+        mRing = ring;
+    }
+
+    public CanonicalizedSecretKeyRing(byte[] blob, boolean isRevoked, int verified)
     {
-        super(isRevoked, verified);
+        super(verified);
         PGPObjectFactory factory = new PGPObjectFactory(blob);
         PGPKeyRing keyRing = null;
         try {
@@ -41,19 +49,32 @@ public class WrappedSecretKeyRing extends WrappedKeyRing {
         return mRing;
     }
 
-    public WrappedSecretKey getSecretKey() {
-        return new WrappedSecretKey(this, mRing.getSecretKey());
+    public CanonicalizedSecretKey getSecretKey() {
+        return new CanonicalizedSecretKey(this, mRing.getSecretKey());
+    }
+
+    public CanonicalizedSecretKey getSecretKey(long id) {
+        return new CanonicalizedSecretKey(this, mRing.getSecretKey(id));
     }
 
-    public WrappedSecretKey getSecretKey(long id) {
-        return new WrappedSecretKey(this, mRing.getSecretKey(id));
+    public HashSet<Long> getAvailableSubkeys() {
+        HashSet<Long> result = new HashSet<Long>();
+        // then, mark exactly the keys we have available
+        for (PGPSecretKey sub : new IterableIterator<PGPSecretKey>(getRing().getSecretKeys())) {
+            S2K s2k = sub.getS2K();
+            // Set to 1, except if the encryption type is GNU_DUMMY_S2K
+            if(s2k == null || s2k.getType() != S2K.GNU_DUMMY_S2K) {
+                result.add(sub.getKeyID());
+            }
+        }
+        return result;
     }
 
     /** Getter that returns the subkey that should be used for signing. */
-    WrappedSecretKey getSigningSubKey() throws PgpGeneralException {
+    CanonicalizedSecretKey getSigningSubKey() throws PgpGeneralException {
         PGPSecretKey key = mRing.getSecretKey(getSignId());
         if(key != null) {
-            WrappedSecretKey cKey = new WrappedSecretKey(this, key);
+            CanonicalizedSecretKey cKey = new CanonicalizedSecretKey(this, key);
             if(!cKey.canSign()) {
                 throw new PgpGeneralException("key error");
             }
@@ -88,17 +109,17 @@ public class WrappedSecretKeyRing extends WrappedKeyRing {
         }
     }
 
-    public IterableIterator<WrappedSecretKey> secretKeyIterator() {
+    public IterableIterator<CanonicalizedSecretKey> secretKeyIterator() {
         final Iterator<PGPSecretKey> it = mRing.getSecretKeys();
-        return new IterableIterator<WrappedSecretKey>(new Iterator<WrappedSecretKey>() {
+        return new IterableIterator<CanonicalizedSecretKey>(new Iterator<CanonicalizedSecretKey>() {
             @Override
             public boolean hasNext() {
                 return it.hasNext();
             }
 
             @Override
-            public WrappedSecretKey next() {
-                return new WrappedSecretKey(WrappedSecretKeyRing.this, it.next());
+            public CanonicalizedSecretKey next() {
+                return new CanonicalizedSecretKey(CanonicalizedSecretKeyRing.this, it.next());
             }
 
             @Override
@@ -108,17 +129,17 @@ public class WrappedSecretKeyRing extends WrappedKeyRing {
         });
     }
 
-    public IterableIterator<WrappedPublicKey> publicKeyIterator() {
+    public IterableIterator<CanonicalizedPublicKey> publicKeyIterator() {
         final Iterator<PGPPublicKey> it = getRing().getPublicKeys();
-        return new IterableIterator<WrappedPublicKey>(new Iterator<WrappedPublicKey>() {
+        return new IterableIterator<CanonicalizedPublicKey>(new Iterator<CanonicalizedPublicKey>() {
             @Override
             public boolean hasNext() {
                 return it.hasNext();
             }
 
             @Override
-            public WrappedPublicKey next() {
-                return new WrappedPublicKey(WrappedSecretKeyRing.this, it.next());
+            public CanonicalizedPublicKey next() {
+                return new CanonicalizedPublicKey(CanonicalizedSecretKeyRing.this, it.next());
             }
 
             @Override
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/KeyRing.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/KeyRing.java
index 129ffba3e..ebc49ab05 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/KeyRing.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/KeyRing.java
@@ -12,7 +12,7 @@ import java.util.regex.Pattern;
  * keyring should in all cases agree on the output of all methods described
  * here.
  *
- * @see org.sufficientlysecure.keychain.pgp.WrappedKeyRing
+ * @see CanonicalizedKeyRing
  * @see org.sufficientlysecure.keychain.provider.CachedPublicKeyRing
  *
  */
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpDecryptVerify.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpDecryptVerify.java
index db9e2c6c6..7f2d971ed 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpDecryptVerify.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpDecryptVerify.java
@@ -231,7 +231,7 @@ public class PgpDecryptVerify {
 
         PGPPublicKeyEncryptedData encryptedDataAsymmetric = null;
         PGPPBEEncryptedData encryptedDataSymmetric = null;
-        WrappedSecretKey secretEncryptionKey = null;
+        CanonicalizedSecretKey secretEncryptionKey = null;
         Iterator<?> it = enc.getEncryptedDataObjects();
         boolean asymmetricPacketFound = false;
         boolean symmetricPacketFound = false;
@@ -243,10 +243,10 @@ public class PgpDecryptVerify {
 
                 PGPPublicKeyEncryptedData encData = (PGPPublicKeyEncryptedData) obj;
 
-                WrappedSecretKeyRing secretKeyRing;
+                CanonicalizedSecretKeyRing secretKeyRing;
                 try {
                     // get actual keyring object based on master key id
-                    secretKeyRing = mProviderHelper.getWrappedSecretKeyRing(
+                    secretKeyRing = mProviderHelper.getCanonicalizedSecretKeyRing(
                             KeyRings.buildUnifiedKeyRingsFindBySubkeyUri(encData.getKeyID())
                     );
                 } catch (ProviderHelper.NotFoundException e) {
@@ -365,8 +365,8 @@ public class PgpDecryptVerify {
         Object dataChunk = plainFact.nextObject();
         OpenPgpSignatureResultBuilder signatureResultBuilder = new OpenPgpSignatureResultBuilder();
         int signatureIndex = -1;
-        WrappedPublicKeyRing signingRing = null;
-        WrappedPublicKey signingKey = null;
+        CanonicalizedPublicKeyRing signingRing = null;
+        CanonicalizedPublicKey signingKey = null;
 
         if (dataChunk instanceof PGPCompressedData) {
             updateProgress(R.string.progress_decompressing_data, currentProgress, 100);
@@ -390,7 +390,7 @@ public class PgpDecryptVerify {
             for (int i = 0; i < sigList.size(); ++i) {
                 try {
                     long sigKeyId = sigList.get(i).getKeyID();
-                    signingRing = mProviderHelper.getWrappedPublicKeyRing(
+                    signingRing = mProviderHelper.getCanonicalizedPublicKeyRing(
                             KeyRings.buildUnifiedKeyRingsFindBySubkeyUri(sigKeyId)
                     );
                     signingKey = signingRing.getPublicKey(sigKeyId);
@@ -566,8 +566,8 @@ public class PgpDecryptVerify {
             throw new InvalidDataException();
         }
 
-        WrappedPublicKeyRing signingRing = null;
-        WrappedPublicKey signingKey = null;
+        CanonicalizedPublicKeyRing signingRing = null;
+        CanonicalizedPublicKey signingKey = null;
         int signatureIndex = -1;
 
         // go through all signatures
@@ -575,7 +575,7 @@ public class PgpDecryptVerify {
         for (int i = 0; i < sigList.size(); ++i) {
             try {
                 long sigKeyId = sigList.get(i).getKeyID();
-                signingRing = mProviderHelper.getWrappedPublicKeyRing(
+                signingRing = mProviderHelper.getCanonicalizedPublicKeyRing(
                         KeyRings.buildUnifiedKeyRingsFindBySubkeyUri(sigKeyId)
                 );
                 signingKey = signingRing.getPublicKey(sigKeyId);
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpImportExport.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpImportExport.java
index 9d334d9bd..846b00ef2 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpImportExport.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpImportExport.java
@@ -93,7 +93,7 @@ public class PgpImportExport {
         }
     }
 
-    public boolean uploadKeyRingToServer(HkpKeyserver server, WrappedPublicKeyRing keyring) {
+    public boolean uploadKeyRingToServer(HkpKeyserver server, CanonicalizedPublicKeyRing keyring) {
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         ArmoredOutputStream aos = null;
         try {
@@ -235,7 +235,7 @@ public class PgpImportExport {
             updateProgress(progress * 100 / masterKeyIdsSize, 100);
 
             try {
-                WrappedPublicKeyRing ring = mProviderHelper.getWrappedPublicKeyRing(
+                CanonicalizedPublicKeyRing ring = mProviderHelper.getCanonicalizedPublicKeyRing(
                         KeychainContract.KeyRings.buildUnifiedKeyRingUri(pubKeyMasterId)
                 );
 
@@ -263,8 +263,8 @@ public class PgpImportExport {
             updateProgress(progress * 100 / masterKeyIdsSize, 100);
 
             try {
-                WrappedSecretKeyRing secretKeyRing =
-                        mProviderHelper.getWrappedSecretKeyRing(secretKeyMasterId);
+                CanonicalizedSecretKeyRing secretKeyRing =
+                        mProviderHelper.getCanonicalizedSecretKeyRing(secretKeyMasterId);
                 secretKeyRing.encode(arOutStream);
             } catch (ProviderHelper.NotFoundException e) {
                 Log.e(Constants.TAG, "key not found!", e);
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpKeyOperation.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpKeyOperation.java
index e9d7e5958..fef15db1e 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpKeyOperation.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpKeyOperation.java
@@ -46,7 +46,6 @@ import org.spongycastle.openpgp.operator.jcajce.JcePBESecretKeyDecryptorBuilder;
 import org.spongycastle.openpgp.operator.jcajce.JcePBESecretKeyEncryptorBuilder;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralMsgIdException;
 import org.sufficientlysecure.keychain.service.OperationResultParcel;
 import org.sufficientlysecure.keychain.service.OperationResultParcel.LogLevel;
 import org.sufficientlysecure.keychain.service.OperationResultParcel.LogType;
@@ -241,7 +240,7 @@ public class PgpKeyOperation {
      * are changed by adding new certificates, which implicitly override older certificates.
      *
      */
-    public EditKeyResult modifySecretKeyRing(WrappedSecretKeyRing wsKR, SaveKeyringParcel saveParcel,
+    public EditKeyResult modifySecretKeyRing(CanonicalizedSecretKeyRing wsKR, SaveKeyringParcel saveParcel,
                                                String passphrase) {
 
         OperationLog log = new OperationLog();
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncrypt.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncrypt.java
index 4cb92c368..f0403e625 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncrypt.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncrypt.java
@@ -266,11 +266,11 @@ public class PgpSignEncrypt {
         }
 
         /* Get keys for signature generation for later usage */
-        WrappedSecretKey signingKey = null;
+        CanonicalizedSecretKey signingKey = null;
         if (enableSignature) {
-            WrappedSecretKeyRing signingKeyRing;
+            CanonicalizedSecretKeyRing signingKeyRing;
             try {
-                signingKeyRing = mProviderHelper.getWrappedSecretKeyRing(mSignatureMasterKeyId);
+                signingKeyRing = mProviderHelper.getCanonicalizedSecretKeyRing(mSignatureMasterKeyId);
             } catch (ProviderHelper.NotFoundException e) {
                 throw new NoSigningKeyException();
             }
@@ -316,9 +316,9 @@ public class PgpSignEncrypt {
                 // Asymmetric encryption
                 for (long id : mEncryptionMasterKeyIds) {
                     try {
-                        WrappedPublicKeyRing keyRing = mProviderHelper.getWrappedPublicKeyRing(
+                        CanonicalizedPublicKeyRing keyRing = mProviderHelper.getCanonicalizedPublicKeyRing(
                                 KeyRings.buildUnifiedKeyRingUri(id));
-                        WrappedPublicKey key = keyRing.getEncryptionSubKey();
+                        CanonicalizedPublicKey key = keyRing.getEncryptionSubKey();
                         cPk.addMethod(key.getPubKeyEncryptionGenerator());
                     } catch (PgpGeneralException e) {
                         Log.e(Constants.TAG, "key not found!", e);
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/UncachedKeyRing.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/UncachedKeyRing.java
index 0e59b7fdb..d8a2532f3 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/UncachedKeyRing.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/UncachedKeyRing.java
@@ -49,7 +49,7 @@ import java.util.Vector;
  * treated equally for most purposes in UI code. It is up to the programmer to
  * take care of the differences.
  *
- * @see org.sufficientlysecure.keychain.pgp.WrappedKeyRing
+ * @see CanonicalizedKeyRing
  * @see org.sufficientlysecure.keychain.pgp.UncachedPublicKey
  * @see org.sufficientlysecure.keychain.pgp.UncachedSecretKey
  *
@@ -59,18 +59,10 @@ public class UncachedKeyRing {
 
     final PGPKeyRing mRing;
     final boolean mIsSecret;
-    final boolean mIsCanonicalized;
 
     UncachedKeyRing(PGPKeyRing ring) {
         mRing = ring;
         mIsSecret = ring instanceof PGPSecretKeyRing;
-        mIsCanonicalized = false;
-    }
-
-    private UncachedKeyRing(PGPKeyRing ring, boolean canonicalized) {
-        mRing = ring;
-        mIsSecret = ring instanceof PGPSecretKeyRing;
-        mIsCanonicalized = canonicalized;
     }
 
     public long getMasterKeyId() {
@@ -105,10 +97,6 @@ public class UncachedKeyRing {
         return mIsSecret;
     }
 
-    public boolean isCanonicalized() {
-        return mIsCanonicalized;
-    }
-
     public byte[] getEncoded() throws IOException {
         return mRing.getEncoded();
     }
@@ -164,25 +152,6 @@ public class UncachedKeyRing {
         aos.close();
     }
 
-    public HashSet<Long> getAvailableSubkeys() {
-        if(!isSecret()) {
-            throw new RuntimeException("Tried to find available subkeys from non-secret keys. " +
-                    "This is a programming error and should never happen!");
-        }
-
-        HashSet<Long> result = new HashSet<Long>();
-        // then, mark exactly the keys we have available
-        for (PGPSecretKey sub : new IterableIterator<PGPSecretKey>(
-                ((PGPSecretKeyRing) mRing).getSecretKeys())) {
-            S2K s2k = sub.getS2K();
-            // Set to 1, except if the encryption type is GNU_DUMMY_S2K
-            if(s2k == null || s2k.getType() != S2K.GNU_DUMMY_S2K) {
-                result.add(sub.getKeyID());
-            }
-        }
-        return result;
-    }
-
     /** "Canonicalizes" a public key, removing inconsistencies in the process. This variant can be
      * applied to public keyrings only.
      *
@@ -207,7 +176,7 @@ public class UncachedKeyRing {
      *
      */
     @SuppressWarnings("ConstantConditions")
-    public UncachedKeyRing canonicalize(OperationLog log, int indent) {
+    public CanonicalizedKeyRing canonicalize(OperationLog log, int indent) {
 
         log.add(LogLevel.START, isSecret() ? LogType.MSG_KC_SECRET : LogType.MSG_KC_PUBLIC,
                 indent, PgpKeyHelper.convertKeyIdToHex(getMasterKeyId()));
@@ -629,7 +598,8 @@ public class UncachedKeyRing {
             log.add(LogLevel.OK, LogType.MSG_KC_SUCCESS, indent);
         }
 
-        return new UncachedKeyRing(ring, true);
+        return isSecret() ? new CanonicalizedSecretKeyRing((PGPSecretKeyRing) ring, 1)
+                          : new CanonicalizedPublicKeyRing((PGPPublicKeyRing) ring, 0);
     }
 
     /** This operation merges information from a different keyring, returning a combined
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedSignature.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedSignature.java
index 28e4c51d6..07fb4fb9e 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedSignature.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedSignature.java
@@ -113,7 +113,7 @@ public class WrappedSignature {
         return ((RevocationReason) p).getRevocationDescription();
     }
 
-    public void init(WrappedPublicKey key) throws PgpGeneralException {
+    public void init(CanonicalizedPublicKey key) throws PgpGeneralException {
         init(key.getPublicKey());
     }
 
@@ -191,7 +191,7 @@ public class WrappedSignature {
     public boolean verifySignature(UncachedPublicKey key, String uid) throws PgpGeneralException {
         return verifySignature(key.getPublicKey(), uid);
     }
-    public boolean verifySignature(WrappedPublicKey key, String uid) throws PgpGeneralException {
+    public boolean verifySignature(CanonicalizedPublicKey key, String uid) throws PgpGeneralException {
         return verifySignature(key.getPublicKey(), uid);
     }