re-merge libkeychain

OpenKeychain/build.gradle

@@ -53,7 +53,6 @@ dependencies {
     implementation 'org.piwik.sdk:piwik-sdk:3.0.3'
 
     // libs as submodules
-    implementation project(':libkeychain')
     implementation project(':openpgp-api-lib')
     implementation project(':nfcsweetspot')
     implementation project(':sshauthentication-api')

OpenKeychain/src/main/java/org/bouncycastle/openpgp/AuthenticationSignatureGenerator.java

@@ -0,0 +1,86 @@
+package org.bouncycastle.openpgp;
+
+import org.bouncycastle.bcpg.PublicKeyAlgorithmTags;
+import org.bouncycastle.openpgp.operator.PGPContentSigner;
+import org.bouncycastle.openpgp.operator.PGPContentSignerBuilder;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * Generator for authentication signatures.
+ */
+public class AuthenticationSignatureGenerator {
+    private OutputStream sigOut;
+    private PGPContentSignerBuilder contentSignerBuilder;
+    private PGPContentSigner contentSigner;
+    private int sigType;
+
+    /**
+     * Create a signature generator built on the passed in contentSignerBuilder.
+     *
+     * @param contentSignerBuilder builder to produce PGPContentSigner objects for generating signatures.
+     */
+    public AuthenticationSignatureGenerator(PGPContentSignerBuilder contentSignerBuilder) {
+        this.contentSignerBuilder = contentSignerBuilder;
+    }
+
+    /**
+     * Initialise the generator for signing.
+     *
+     * @param signatureType
+     * @param key
+     * @throws PGPException
+     */
+    public void init(int signatureType, PGPPrivateKey key) throws PGPException {
+        contentSigner = contentSignerBuilder.build(signatureType, key);
+        sigOut = contentSigner.getOutputStream();
+        sigType = contentSigner.getType();
+    }
+
+    public void update(byte b) {
+        byteUpdate(b);
+    }
+
+    public void update(byte[] b) {
+        update(b, 0, b.length);
+    }
+
+    public void update(byte[] b, int off, int len) {
+        blockUpdate(b, off, len);
+    }
+
+    private void byteUpdate(byte b) {
+        try {
+            sigOut.write(b);
+        } catch (IOException e) {
+            throw new PGPRuntimeOperationException(e.getMessage(), e);
+        }
+    }
+
+    private void blockUpdate(byte[] block, int off, int len) {
+        try {
+            sigOut.write(block, off, len);
+        } catch (IOException e) {
+            throw new PGPRuntimeOperationException(e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Return the signature.
+     *
+     * @return byte[]
+     * @throws PGPException
+     */
+    public byte[] getSignature() throws PGPException {
+        if (contentSigner.getKeyAlgorithm() == PublicKeyAlgorithmTags.RSA_SIGN
+                || contentSigner.getKeyAlgorithm() == PublicKeyAlgorithmTags.RSA_GENERAL
+                || contentSigner.getKeyAlgorithm() == PublicKeyAlgorithmTags.EDDSA
+                || contentSigner.getKeyAlgorithm() == PublicKeyAlgorithmTags.ECDSA
+                || contentSigner.getKeyAlgorithm() == PublicKeyAlgorithmTags.DSA) {
+            return contentSigner.getSignature();
+        } else {
+           throw new UnsupportedOperationException("Unsupported algorithm");
+        }
+    }
+}

OpenKeychain/src/main/java/org/bouncycastle/openpgp/jcajce/JcaSkipMarkerPGPObjectFactory.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2016 Vincent Breitmoser
+ *
+ * Licensed under the Bouncy Castle License (MIT license). See LICENSE file for details.
+ */
+
+package org.bouncycastle.openpgp.jcajce;
+
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.bouncycastle.openpgp.PGPMarker;
+
+/** This class wraps the regular PGPObjectFactory, changing its behavior to
+ * ignore all PGPMarker packets it encounters while reading. These packets
+ * carry no semantics of their own, and should be ignored according to
+ * RFC 4880.
+ * 
+ * @see https://tools.ietf.org/html/rfc4880#section-5.8
+ * @see org.bouncycastle.openpgp.PGPMarker
+ * 
+ */
+public class JcaSkipMarkerPGPObjectFactory extends JcaPGPObjectFactory {
+
+    public JcaSkipMarkerPGPObjectFactory(InputStream in) {
+        super(in);
+    }
+
+    @Override
+    public Object nextObject() throws IOException {
+        Object o = super.nextObject();
+        while (o instanceof PGPMarker) {
+            o = super.nextObject();
+        }
+        return o;
+    }
+}

OpenKeychain/src/main/java/org/bouncycastle/openpgp/operator/jcajce/CachingDataDecryptorFactory.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2013-2014 Philipp Jakubeit, Signe Rüsch, Dominik Schürmann
+ * Copyright (c) 2017 Vincent Breitmoser
+ *
+ * Licensed under the Bouncy Castle License (MIT license). See LICENSE file for details.
+ */
+
+package org.bouncycastle.openpgp.operator.jcajce;
+
+
+import java.nio.ByteBuffer;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.bouncycastle.jcajce.util.NamedJcaJceHelper;
+import org.bouncycastle.openpgp.PGPException;
+import org.bouncycastle.openpgp.PGPPublicKeyEncryptedData;
+import org.bouncycastle.openpgp.operator.PGPDataDecryptor;
+import org.bouncycastle.openpgp.operator.PublicKeyDataDecryptorFactory;
+
+public class CachingDataDecryptorFactory implements PublicKeyDataDecryptorFactory
+{
+    private final PublicKeyDataDecryptorFactory mWrappedDecryptor;
+    private final HashMap<ByteBuffer, byte[]> mSessionKeyCache;
+
+    private OperatorHelper mOperatorHelper;
+
+    public CachingDataDecryptorFactory(String providerName, Map<ByteBuffer, byte[]> sessionKeyCache)
+    {
+        this((PublicKeyDataDecryptorFactory) null, sessionKeyCache);
+
+        mOperatorHelper = new OperatorHelper(new NamedJcaJceHelper(providerName));
+    }
+
+    public CachingDataDecryptorFactory(PublicKeyDataDecryptorFactory wrapped,
+            Map<ByteBuffer, byte[]> sessionKeyCache)
+    {
+        mSessionKeyCache = new HashMap<>();
+        if (sessionKeyCache != null)
+        {
+            mSessionKeyCache.putAll(sessionKeyCache);
+        }
+
+        mWrappedDecryptor = wrapped;
+    }
+
+    public boolean hasCachedSessionData(PGPPublicKeyEncryptedData encData) throws PGPException {
+        ByteBuffer bi = ByteBuffer.wrap(encData.getSessionKey()[0]);
+        return mSessionKeyCache.containsKey(bi);
+    }
+
+    public Map<ByteBuffer, byte[]> getCachedSessionKeys() {
+        return Collections.unmodifiableMap(mSessionKeyCache);
+    }
+
+    public boolean canDecrypt() {
+        return mWrappedDecryptor != null;
+    }
+
+    @Override
+    public byte[] recoverSessionData(int keyAlgorithm, byte[][] secKeyData) throws PGPException {
+        ByteBuffer bi = ByteBuffer.wrap(secKeyData[0]);  // encoded MPI
+        if (mSessionKeyCache.containsKey(bi)) {
+            return mSessionKeyCache.get(bi);
+        }
+
+        if (mWrappedDecryptor == null) {
+            throw new IllegalStateException("tried to decrypt without wrapped decryptor, this is a bug!");
+        }
+
+        byte[] sessionData = mWrappedDecryptor.recoverSessionData(keyAlgorithm, secKeyData);
+        mSessionKeyCache.put(bi, sessionData);
+        return sessionData;
+    }
+
+    @Override
+    public PGPDataDecryptor createDataDecryptor(boolean withIntegrityPacket, int encAlgorithm, byte[] key)
+            throws PGPException {
+        if (mWrappedDecryptor != null) {
+            return mWrappedDecryptor.createDataDecryptor(withIntegrityPacket, encAlgorithm, key);
+        }
+        return mOperatorHelper.createDataDecryptor(withIntegrityPacket, encAlgorithm, key);
+    }
+
+}

OpenKeychain/src/main/java/org/bouncycastle/openpgp/operator/jcajce/EdDsaAuthenticationContentSignerBuilder.java

@@ -0,0 +1,101 @@
+package org.bouncycastle.openpgp.operator.jcajce;
+
+import org.bouncycastle.jcajce.provider.asymmetric.eddsa.EdDSAEngine;
+import org.bouncycastle.jcajce.provider.asymmetric.eddsa.spec.EdDSANamedCurveTable;
+import org.bouncycastle.jcajce.provider.asymmetric.eddsa.spec.EdDSAParameterSpec;
+import org.bouncycastle.openpgp.PGPException;
+import org.bouncycastle.openpgp.PGPPrivateKey;
+import org.bouncycastle.openpgp.PGPRuntimeOperationException;
+import org.bouncycastle.openpgp.operator.PGPContentSigner;
+import org.bouncycastle.openpgp.operator.PGPContentSignerBuilder;
+
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.security.*;
+
+public class EdDsaAuthenticationContentSignerBuilder implements PGPContentSignerBuilder {
+    private JcaPGPKeyConverter keyConverter = new JcaPGPKeyConverter();
+    private int hashAlgorithm;
+    private int keyAlgorithm;
+
+    public EdDsaAuthenticationContentSignerBuilder(int keyAlgorithm, int hashAlgorithm) {
+        this.keyAlgorithm = keyAlgorithm;
+        this.hashAlgorithm = hashAlgorithm;
+    }
+
+    public EdDsaAuthenticationContentSignerBuilder setProvider(Provider provider) {
+        keyConverter.setProvider(provider);
+        return this;
+    }
+
+    public EdDsaAuthenticationContentSignerBuilder setProvider(String providerName) {
+        keyConverter.setProvider(providerName);
+        return this;
+    }
+
+    private Signature createSignature() throws NoSuchAlgorithmException {
+        EdDSAParameterSpec spec = EdDSANamedCurveTable.getByName("Ed25519");
+        return new EdDSAEngine(MessageDigest.getInstance(spec.getHashAlgorithm()));
+    }
+
+    public PGPContentSigner build(final int signatureType, final long keyID, final PrivateKey privateKey)
+            throws PGPException {
+        Signature signatureEdDsa;
+        try {
+            signatureEdDsa = createSignature();
+        } catch (NoSuchAlgorithmException e) {
+            throw new PGPException("unable to create Signature.", e);
+        }
+        final Signature signature = signatureEdDsa;
+
+        final ByteArrayOutputStream dataOutputStream = new ByteArrayOutputStream();
+
+        try {
+            signature.initSign(privateKey);
+        } catch (InvalidKeyException e) {
+            throw new PGPException("invalid key.", e);
+        }
+
+        return new PGPContentSigner() {
+            public int getType() {
+                return signatureType;
+            }
+
+            public int getHashAlgorithm() {
+                return hashAlgorithm;
+            }
+
+            public int getKeyAlgorithm() {
+                return keyAlgorithm;
+            }
+
+            public long getKeyID() {
+                return keyID;
+            }
+
+            public OutputStream getOutputStream() {
+                return new SignatureOutputStream(signature);
+            }
+
+            public byte[] getSignature() {
+                try {
+                    return signature.sign();
+                } catch (SignatureException e) {
+                    throw new PGPRuntimeOperationException("Unable to create signature: " + e.getMessage(), e);
+                }
+            }
+
+            public byte[] getDigest() {
+                return null;
+            }
+        };
+    }
+
+    public PGPContentSigner build(final int signatureType, PGPPrivateKey privateKey) throws PGPException {
+        if (privateKey instanceof JcaPGPPrivateKey) {
+            return build(signatureType, privateKey.getKeyID(), ((JcaPGPPrivateKey) privateKey).getPrivateKey());
+        } else {
+            return build(signatureType, privateKey.getKeyID(), keyConverter.getPrivateKey(privateKey));
+        }
+    }
+}

OpenKeychain/src/main/java/org/bouncycastle/openpgp/operator/jcajce/NfcSyncPGPContentSignerBuilder.java

@@ -0,0 +1,142 @@
+/**
+ * Copyright (c) 2013-2014 Philipp Jakubeit, Signe Rüsch, Dominik Schürmann
+ * Copyright (c) 2000-2013 The Legion of the Bouncy Castle Inc. (http://www.bouncycastle.org)
+ *
+ * Licensed under the Bouncy Castle License (MIT license). See LICENSE file for details.
+ */
+
+package org.bouncycastle.openpgp.operator.jcajce;
+
+import org.bouncycastle.openpgp.PGPException;
+import org.bouncycastle.openpgp.PGPPrivateKey;
+import org.bouncycastle.openpgp.operator.PGPContentSigner;
+import org.bouncycastle.openpgp.operator.PGPContentSignerBuilder;
+import org.bouncycastle.openpgp.operator.PGPDigestCalculator;
+
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.security.Provider;
+import java.util.Map;
+
+
+/**
+ * This class is based on JcaPGPContentSignerBuilder.
+ *
+ * Instead of using a Signature object based on a privateKey, this class only calculates the digest
+ * of the output stream and gives the result back using a RuntimeException.
+ */
+public class NfcSyncPGPContentSignerBuilder
+    implements PGPContentSignerBuilder
+{
+    private JcaPGPDigestCalculatorProviderBuilder digestCalculatorProviderBuilder = new JcaPGPDigestCalculatorProviderBuilder();
+    private int     hashAlgorithm;
+    private int     keyAlgorithm;
+    private long    keyID;
+
+    private Map signedHashes;
+
+    public static class NfcInteractionNeeded extends RuntimeException
+    {
+        public byte[] hashToSign;
+        public int hashAlgo;
+
+        public NfcInteractionNeeded(byte[] hashToSign, int hashAlgo)
+        {
+            super("NFC interaction required!");
+            this.hashToSign = hashToSign;
+            this.hashAlgo = hashAlgo;
+        }
+    }
+
+    public NfcSyncPGPContentSignerBuilder(int keyAlgorithm, int hashAlgorithm, long keyID, Map signedHashes)
+    {
+        this.keyAlgorithm = keyAlgorithm;
+        this.hashAlgorithm = hashAlgorithm;
+        this.keyID = keyID;
+        this.signedHashes = signedHashes;
+    }
+
+    public NfcSyncPGPContentSignerBuilder setProvider(Provider provider)
+    {
+        digestCalculatorProviderBuilder.setProvider(provider);
+
+        return this;
+    }
+
+    public NfcSyncPGPContentSignerBuilder setProvider(String providerName)
+    {
+        digestCalculatorProviderBuilder.setProvider(providerName);
+
+        return this;
+    }
+
+    public NfcSyncPGPContentSignerBuilder setDigestProvider(Provider provider)
+    {
+        digestCalculatorProviderBuilder.setProvider(provider);
+
+        return this;
+    }
+
+    public NfcSyncPGPContentSignerBuilder setDigestProvider(String providerName)
+    {
+        digestCalculatorProviderBuilder.setProvider(providerName);
+
+        return this;
+    }
+
+    public PGPContentSigner build(final int signatureType, PGPPrivateKey privateKey)
+        throws PGPException {
+        // NOTE: privateKey is null in this case!
+        return build(signatureType, keyID);
+    }
+
+    public PGPContentSigner build(final int signatureType, final long keyID)
+        throws PGPException
+    {
+        final PGPDigestCalculator digestCalculator = digestCalculatorProviderBuilder.build().get(hashAlgorithm);
+
+        return new PGPContentSigner()
+        {
+            public int getType()
+            {
+                return signatureType;
+            }
+
+            public int getHashAlgorithm()
+            {
+                return hashAlgorithm;
+            }
+
+            public int getKeyAlgorithm()
+            {
+                return keyAlgorithm;
+            }
+
+            public long getKeyID()
+            {
+                return keyID;
+            }
+
+            public OutputStream getOutputStream()
+            {
+                return digestCalculator.getOutputStream();
+            }
+
+            public byte[] getSignature() {
+                byte[] digest = digestCalculator.getDigest();
+                ByteBuffer buf = ByteBuffer.wrap(digest);
+                if (signedHashes.containsKey(buf)) {
+                    return (byte[]) signedHashes.get(buf);
+                }
+                // catch this when signatureGenerator.generate() is executed and divert digest to card,
+                // when doing the operation again reuse creationTimestamp (this will be hashed)
+                throw new NfcInteractionNeeded(digest, getHashAlgorithm());
+            }
+
+            public byte[] getDigest()
+            {
+                return digestCalculator.getDigest();
+            }
+        };
+    }
+}

OpenKeychain/src/main/java/org/bouncycastle/openpgp/operator/jcajce/SessionKeySecretKeyDecryptorBuilder.java

@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) 2016 Vincent Breitmoser
+ *
+ * Licensed under the Bouncy Castle License (MIT license). See LICENSE file for details.
+ */
+
+package org.bouncycastle.openpgp.operator.jcajce;
+
+
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.Provider;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.spec.IvParameterSpec;
+import org.bouncycastle.bcpg.S2K;
+import org.bouncycastle.jcajce.util.DefaultJcaJceHelper;
+import org.bouncycastle.jcajce.util.NamedJcaJceHelper;
+import org.bouncycastle.jcajce.util.ProviderJcaJceHelper;
+import org.bouncycastle.openpgp.PGPException;
+import org.bouncycastle.openpgp.operator.PBESecretKeyDecryptor;
+import org.bouncycastle.openpgp.operator.PGPDigestCalculatorProvider;
+
+
+/** This is a builder for a special PBESecretKeyDecryptor which is parametrized by a
+ * fixed session key, which is used in place of the one obtained from a passphrase.
+ */
+public class SessionKeySecretKeyDecryptorBuilder
+{
+    private OperatorHelper helper = new OperatorHelper(new DefaultJcaJceHelper());
+    private PGPDigestCalculatorProvider calculatorProvider;
+
+    private JcaPGPDigestCalculatorProviderBuilder calculatorProviderBuilder;
+
+    public SessionKeySecretKeyDecryptorBuilder()
+    {
+        this.calculatorProviderBuilder = new JcaPGPDigestCalculatorProviderBuilder();
+    }
+
+    public SessionKeySecretKeyDecryptorBuilder(PGPDigestCalculatorProvider calculatorProvider)
+    {
+        this.calculatorProvider = calculatorProvider;
+    }
+
+    public SessionKeySecretKeyDecryptorBuilder setProvider(Provider provider)
+    {
+        this.helper = new OperatorHelper(new ProviderJcaJceHelper(provider));
+
+        if (calculatorProviderBuilder != null)
+        {
+            calculatorProviderBuilder.setProvider(provider);
+        }
+
+        return this;
+    }
+
+    public SessionKeySecretKeyDecryptorBuilder setProvider(String providerName)
+    {
+        this.helper = new OperatorHelper(new NamedJcaJceHelper(providerName));
+
+        if (calculatorProviderBuilder != null)
+        {
+            calculatorProviderBuilder.setProvider(providerName);
+        }
+
+        return this;
+    }
+
+    public PBESecretKeyDecryptor build(final byte[] sessionKey)
+        throws PGPException
+    {
+        if (calculatorProvider == null)
+        {
+            calculatorProvider = calculatorProviderBuilder.build();
+        }
+
+        return new PBESecretKeyDecryptor(null, calculatorProvider)
+        {
+            @Override
+            public byte[] makeKeyFromPassPhrase(int keyAlgorithm, S2K s2k) throws PGPException {
+                return sessionKey;
+            }
+
+            public byte[] recoverKeyData(int encAlgorithm, byte[] key, byte[] iv, byte[] keyData, int keyOff, int keyLen)
+                throws PGPException
+            {
+                try
+                {
+                    Cipher c = helper.createCipher(PGPUtil.getSymmetricCipherName(encAlgorithm) + "/CFB/NoPadding");
+
+                    c.init(Cipher.DECRYPT_MODE, PGPUtil.makeSymmetricKey(encAlgorithm, key), new IvParameterSpec(iv));
+
+                    return c.doFinal(keyData, keyOff, keyLen);
+                }
+                catch (IllegalBlockSizeException e)
+                {
+                    throw new PGPException("illegal block size: " + e.getMessage(), e);
+                }
+                catch (BadPaddingException e)
+                {
+                    throw new PGPException("bad padding: " + e.getMessage(), e);
+                }
+                catch (InvalidAlgorithmParameterException e)
+                {
+                    throw new PGPException("invalid parameter: " + e.getMessage(), e);
+                }
+                catch (InvalidKeyException e)
+                {
+                    throw new PGPException("invalid key: " + e.getMessage(), e);
+                }
+            }
+        };
+    }
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/analytics/AnalyticsConsentRequester.java

@@ -13,7 +13,6 @@ import android.text.method.LinkMovementMethod;
 import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.BuildConfig;
-import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.KeychainApplication;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.ui.SettingsActivity;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/ui/RequestKeyPermissionActivity.java

@@ -36,9 +36,7 @@ import android.widget.Button;
 import android.widget.ImageView;
 import android.widget.TextView;
 
-import org.openintents.openpgp.util.OpenPgpUtils.UserId;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.model.SubKey.UnifiedKeyInfo;
 import org.sufficientlysecure.keychain.remote.ui.RequestKeyPermissionPresenter.RequestKeyPermissionMvpView;
 import org.sufficientlysecure.keychain.ui.dialog.CustomAlertDialogBuilder;
 import org.sufficientlysecure.keychain.ui.util.KeyInfoFormatter;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/securitytoken/NfcTransport.java

@@ -19,13 +19,10 @@ package org.sufficientlysecure.keychain.securitytoken;
 
 import android.nfc.Tag;
 import android.support.annotation.Nullable;
-import android.util.Log;
 
-import org.bouncycastle.util.encoders.Hex;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.securitytoken.SecurityTokenInfo.TokenType;
 import org.sufficientlysecure.keychain.securitytoken.SecurityTokenInfo.TransportType;
-import org.sufficientlysecure.keychain.ui.base.BaseSecurityTokenActivity;
 
 import java.io.IOException;
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/ContactSyncAdapterService.java

@@ -18,7 +18,6 @@
 package org.sufficientlysecure.keychain.service;
 
 
-import android.Manifest;
 import android.accounts.Account;
 import android.app.PendingIntent;
 import android.app.Service;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/BackupCodeFragment.java

@@ -35,8 +35,6 @@ import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.CheckBox;
-import android.widget.CompoundButton;
-import android.widget.CompoundButton.OnCheckedChangeListener;
 import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.Constants;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CertifyFingerprintActivity.java

@@ -18,10 +18,7 @@
 package org.sufficientlysecure.keychain.ui;
 
 import android.arch.lifecycle.ViewModelProviders;
-import android.content.Intent;
-import android.net.Uri;
 import android.os.Bundle;
-import android.view.View;
 
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.ui.base.BaseActivity;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateSecurityTokenAlgorithmFragment.java

@@ -32,7 +32,6 @@ import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.securitytoken.KeyFormat;
-import org.sufficientlysecure.keychain.securitytoken.SecurityTokenConnection;
 import org.sufficientlysecure.keychain.ui.CreateKeyActivity.FragAction;
 import org.sufficientlysecure.keychain.util.Choice;
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateSecurityTokenPinFragment.java

@@ -30,7 +30,6 @@ import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.securitytoken.SecurityTokenConnection;
 import org.sufficientlysecure.keychain.ui.CreateKeyActivity.FragAction;
 import org.sufficientlysecure.keychain.util.Passphrase;
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptModeAsymmetricFragment.java

@@ -42,12 +42,8 @@ import org.sufficientlysecure.keychain.livedata.GenericLiveData;
 import org.sufficientlysecure.keychain.model.SubKey.UnifiedKeyInfo;
 import org.sufficientlysecure.keychain.ui.chips.EncryptRecipientChipsInput;
 import org.sufficientlysecure.keychain.ui.chips.EncryptRecipientChipsInput.EncryptRecipientChip;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
-import org.sufficientlysecure.keychain.ui.util.Notify;
-import org.sufficientlysecure.keychain.ui.util.Notify.Style;
 import org.sufficientlysecure.keychain.ui.widget.KeySpinner;
 import org.sufficientlysecure.keychain.util.Passphrase;
-import timber.log.Timber;
 
 
 public class EncryptModeAsymmetricFragment extends EncryptModeFragment {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptTextActivity.java

@@ -22,10 +22,8 @@ import java.io.IOException;
 
 import android.app.Activity;
 import android.content.Intent;
-import android.net.Uri;
 import android.os.Bundle;
 import android.support.v4.app.FragmentTransaction;
-import android.util.Log;
 import android.widget.Toast;
 
 import org.apache.james.mime4j.util.MimeUtil;
@@ -34,7 +32,6 @@ import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.ui.util.Notify;
 import org.sufficientlysecure.keychain.ui.util.Notify.Style;
 import org.sufficientlysecure.keychain.util.FileHelper;
-import timber.log.Timber;
 
 
 public class EncryptTextActivity extends EncryptActivity {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SettingsSmartPGPAuthoritiesActivity.java

@@ -27,13 +27,9 @@ import org.sufficientlysecure.keychain.ui.base.BaseActivity;
 
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
-import java.io.IOException;
 import java.security.KeyStore;
-import java.security.KeyStoreException;
-import java.security.NoSuchAlgorithmException;
-import java.security.cert.CertificateException;
+
 
 public class SettingsSmartPGPAuthoritiesActivity extends BaseActivity {
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/adapter/FlexibleKeyHeader.java

@@ -7,7 +7,6 @@ import android.view.View;
 import android.widget.TextView;
 
 import eu.davidea.flexibleadapter.FlexibleAdapter;
-import eu.davidea.flexibleadapter.items.AbstractHeaderItem;
 import eu.davidea.flexibleadapter.items.IFlexible;
 import eu.davidea.flexibleadapter.items.IHeader;
 import eu.davidea.viewholders.FlexibleViewHolder;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/adapter/SubkeyAddedItem.java

@@ -18,27 +18,20 @@
 package org.sufficientlysecure.keychain.ui.adapter;
 
 
-import java.util.Calendar;
 import java.util.Date;
 import java.util.List;
-import java.util.TimeZone;
 
-import android.content.Context;
-import android.graphics.Typeface;
-import android.text.format.DateFormat;
 import android.view.View;
 
 import eu.davidea.flexibleadapter.FlexibleAdapter;
 import eu.davidea.flexibleadapter.items.AbstractFlexibleItem;
 import eu.davidea.flexibleadapter.items.IFlexible;
-import org.bouncycastle.bcpg.sig.KeyFlags;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedSecretKey.SecretKeyType;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel.SubkeyAdd;
 import org.sufficientlysecure.keychain.ui.SubKeyItem.SubkeyViewHolder;
 import org.sufficientlysecure.keychain.ui.ViewKeyAdvSubkeysFragment;
 import org.sufficientlysecure.keychain.ui.ViewKeyAdvSubkeysFragment.SubkeyEditViewModel;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 
 
 public class SubkeyAddedItem extends AbstractFlexibleItem<SubkeyViewHolder> {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/keyview/view/IdentitiesCardView.java

@@ -26,7 +26,6 @@ import android.support.v7.widget.RecyclerView.AdapterDataObserver;
 import android.util.AttributeSet;
 import android.view.LayoutInflater;
 import android.view.View;
-import android.widget.Button;
 
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.ui.adapter.IdentityAdapter;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/transfer/view/TransferFragment.java

@@ -28,7 +28,6 @@ import android.content.Intent;
 import android.content.IntentFilter;
 import android.graphics.Bitmap;
 import android.net.NetworkInfo;
-import android.net.Uri;
 import android.net.wifi.WifiManager;
 import android.os.Build.VERSION_CODES;
 import android.os.Bundle;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/util/FormattingUtils.java

@@ -19,9 +19,6 @@ package org.sufficientlysecure.keychain.ui.util;
 
 import android.content.Context;
 import android.content.res.Resources.Theme;
-import android.text.SpannableStringBuilder;
-import android.text.Spanned;
-import android.text.style.StrikethroughSpan;
 import android.util.TypedValue;
 
 public class FormattingUtils {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/CharsetVerifier.java

@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2017 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.sufficientlysecure.keychain.util;
+
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CoderResult;
+import java.nio.charset.CodingErrorAction;
+
+import android.content.ClipDescription;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+
+/** This class can be used to guess whether a stream of data is encoded in a given
+ * charset or not.
+ *
+ * An object of this class must be initialized with a byte[] buffer, which should
+ * be filled with data, then processed with {@link #readBytesFromBuffer}. This can
+ * be done any number of times. Once all data has been read, a final status can be
+ * read using the getter methods.
+ */
+public class CharsetVerifier {
+
+    private final ByteBuffer bufWrap;
+    private final CharBuffer dummyOutput;
+
+    private final CharsetDecoder charsetDecoder;
+
+    private boolean isFinished;
+    private boolean isFaulty;
+    private boolean isGuessed;
+    private boolean isPossibleTextMimeType;
+    private boolean isTextMimeType;
+    private String charset;
+    private String mimeType;
+
+    public CharsetVerifier(@NonNull  byte[] buf, @NonNull String mimeType, @Nullable String charset) {
+
+        this.mimeType = mimeType;
+        isTextMimeType = ClipDescription.compareMimeTypes(mimeType, "text/*");
+        isPossibleTextMimeType = isTextMimeType
+                || ClipDescription.compareMimeTypes(mimeType, "application/octet-stream")
+                || ClipDescription.compareMimeTypes(mimeType, "application/x-download");
+        if (!isPossibleTextMimeType) {
+            charsetDecoder = null;
+            bufWrap = null;
+            dummyOutput = null;
+            return;
+        }
+
+        bufWrap = ByteBuffer.wrap(buf);
+        dummyOutput = CharBuffer.allocate(buf.length);
+
+        // the charset defaults to us-ascii, but we want to default to utf-8
+        if (charset == null || "us-ascii".equals(charset)) {
+            charset = "utf-8";
+            isGuessed = true;
+        } else {
+            isGuessed = false;
+        }
+        this.charset = charset;
+
+        charsetDecoder = Charset.forName(charset).newDecoder();
+        charsetDecoder.onMalformedInput(CodingErrorAction.REPORT);
+        charsetDecoder.onUnmappableCharacter(CodingErrorAction.REPORT);
+        charsetDecoder.reset();
+    }
+
+    public void readBytesFromBuffer(int pos, int len) {
+        if (isFinished) {
+            throw new IllegalStateException("cannot write again after reading charset status!");
+        }
+        if (isFaulty || bufWrap == null) {
+            return;
+        }
+        bufWrap.rewind();
+        bufWrap.position(pos);
+        bufWrap.limit(len);
+        dummyOutput.rewind();
+        CoderResult result = charsetDecoder.decode(bufWrap, dummyOutput, false);
+        if (result.isError()) {
+            isFaulty = true;
+        }
+    }
+
+    private void finishIfNecessary() {
+        if (isFinished || isFaulty || bufWrap == null) {
+            return;
+        }
+        isFinished = true;
+        bufWrap.rewind();
+        bufWrap.limit(0);
+        dummyOutput.rewind();
+        CoderResult result = charsetDecoder.decode(bufWrap, dummyOutput, true);
+        if (result.isError()) {
+            isFaulty = true;
+        }
+    }
+
+    public String getGuessedMimeType() {
+        if (isTextMimeType) {
+            return mimeType;
+        }
+        if (isProbablyText()) {
+            return "text/plain";
+        }
+        return mimeType;
+    }
+
+    public boolean isCharsetFaulty() {
+        finishIfNecessary();
+        return isFaulty;
+    }
+
+    public boolean isCharsetGuessed() {
+        finishIfNecessary();
+        return isGuessed;
+    }
+
+    public String getCharset() {
+        finishIfNecessary();
+        if (!isPossibleTextMimeType || (isGuessed && isFaulty)) {
+            return null;
+        }
+        return charset;
+    }
+
+    public String getMaybeFaultyCharset() {
+        return charset;
+    }
+
+    /** Returns true if the data which was read is definitely binary.
+     *
+     * This can happen when either the supplied mimeType indicated a non-ambiguous
+     * binary data type, or if we guessed a charset but got errors while decoding.
+     */
+    public boolean isDefinitelyBinary() {
+        finishIfNecessary();
+        return !isTextMimeType && (!isPossibleTextMimeType || (isGuessed && isFaulty));
+    }
+
+    /** Returns true iff the data which was read is probably (or
+     * definitely) text.
+     *
+     * The corner case where isDefinitelyBinary returns false but isProbablyText
+     * returns true is where the charset was provided by the data (so is not
+     * guessed) but is still faulty.
+     */
+    public boolean isProbablyText() {
+        finishIfNecessary();
+        return isTextMimeType || isPossibleTextMimeType && (!isGuessed || !isFaulty);
+    }
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/CountingOutputStream.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2007 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.sufficientlysecure.keychain.util;
+
+
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+import android.support.annotation.NonNull;
+
+
+public final class CountingOutputStream extends FilterOutputStream {
+
+    private long count;
+
+    /**
+     * Wraps another output stream, counting the number of bytes written.
+     *
+     * @param out
+     *         the output stream to be wrapped
+     */
+    public CountingOutputStream(@NonNull OutputStream out) {
+        super(out);
+    }
+
+    /**
+     * Returns the number of bytes written.
+     */
+    public long getCount() {
+        return count;
+    }
+
+    @Override
+    public void write(@NonNull byte[] b, int off, int len) throws IOException {
+        out.write(b, off, len);
+        count += len;
+    }
+
+    @Override
+    public void write(int b) throws IOException {
+        out.write(b);
+        count++;
+    }
+
+    // Overriding close() because FilterOutputStream's close() method pre-JDK8 has bad behavior:
+    // it silently ignores any exception thrown by flush(). Instead, just close the delegate stream.
+    // It should flush itself if necessary.
+    @Override
+    public void close() throws IOException {
+        out.close();
+    }
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/FileHelper.java

@@ -52,7 +52,6 @@ import android.provider.OpenableColumns;
 import android.support.v4.app.Fragment;
 import android.widget.Toast;
 
-import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import timber.log.Timber;
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/InputData.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2010-2014 Thialfihar <thi@thialfihar.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.sufficientlysecure.keychain.util;
+
+import java.io.InputStream;
+
+/**
+ * Wrapper to include size besides an InputStream
+ */
+public class InputData {
+    public static final int UNKNOWN_FILESIZE = -1;
+
+    private PositionAwareInputStream mInputStream;
+    private long mSize;
+    String mOriginalFilename;
+
+    public InputData(InputStream inputStream, long size, String originalFilename) {
+        mInputStream = new PositionAwareInputStream(inputStream);
+        mSize = size;
+        mOriginalFilename = originalFilename;
+    }
+
+    public InputData(InputStream inputStream, long size) {
+        mInputStream = new PositionAwareInputStream(inputStream);
+        mSize = size;
+        mOriginalFilename = "";
+    }
+
+    public InputStream getInputStream() {
+        return mInputStream;
+    }
+
+    public String getOriginalFilename () {
+        return mOriginalFilename;
+    }
+
+    public long getSize() {
+        return mSize;
+    }
+
+    public long getStreamPosition() {
+        return mInputStream.position();
+    }
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/IterableIterator.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2010-2014 Thialfihar <thi@thialfihar.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.sufficientlysecure.keychain.util;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+public class IterableIterator<T> implements Iterable<T> {
+    private Iterator<T> mIter;
+
+    public IterableIterator(Iterator<T> iter, boolean failsafe) {
+        mIter = iter;
+        if (failsafe && mIter == null) {
+            // is there a better way?
+            mIter = new ArrayList<T>().iterator();
+        }
+    }
+    public IterableIterator(Iterator<T> iter) {
+        this(iter, false);
+    }
+
+    public Iterator<T> iterator() {
+        return mIter;
+    }
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/IteratorWithSize.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2017 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.sufficientlysecure.keychain.util;
+
+import java.util.Iterator;
+
+/**
+ * An extended iterator interface, which knows the total number of its entries beforehand.
+ */
+public interface IteratorWithSize<E> extends Iterator<E> {
+
+    /**
+     * Returns the total number of entries in this iterator.
+     *
+     * @return the number of entries in this iterator.
+     */
+    int getSize();
+
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/PRNGFixes.java

@@ -12,7 +12,6 @@ package org.sufficientlysecure.keychain.util;
 
 import android.os.Build;
 import android.os.Process;
-import android.util.Log;
 
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/PositionAwareInputStream.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2010-2014 Thialfihar <thi@thialfihar.org>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.sufficientlysecure.keychain.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+public class PositionAwareInputStream extends InputStream {
+    private InputStream mStream;
+    private long mPosition;
+
+    public PositionAwareInputStream(InputStream in) {
+        mStream = in;
+        mPosition = 0;
+    }
+
+    @Override
+    public int read() throws IOException {
+        int ch = mStream.read();
+        ++mPosition;
+        return ch;
+    }
+
+    @Override
+    public int available() throws IOException {
+        return mStream.available();
+    }
+
+    @Override
+    public void close() throws IOException {
+        mStream.close();
+    }
+
+    @Override
+    public boolean markSupported() {
+        return false;
+    }
+
+    @Override
+    public int read(byte[] b) throws IOException {
+        int result = mStream.read(b);
+        mPosition += result;
+        return result;
+    }
+
+    @Override
+    public int read(byte[] b, int offset, int length) throws IOException {
+        int result = mStream.read(b, offset, length);
+        mPosition += result;
+        return result;
+    }
+
+    @Override
+    public synchronized void reset() throws IOException {
+        mStream.reset();
+        mPosition = 0;
+    }
+
+    @Override
+    public long skip(long n) throws IOException {
+        long result = mStream.skip(n);
+        mPosition += result;
+        return result;
+    }
+
+    public long position() {
+        return mPosition;
+    }
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/Utf8Util.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2014 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.sufficientlysecure.keychain.util;
+
+import org.sufficientlysecure.keychain.Constants;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CodingErrorAction;
+
+import android.util.Log;
+
+
+public class Utf8Util {
+
+    public static boolean isValidUTF8(byte[] input) {
+        CharsetDecoder cs = Charset.forName("UTF-8").newDecoder();
+
+        try {
+            cs.decode(ByteBuffer.wrap(input));
+            return true;
+        } catch (CharacterCodingException e) {
+            return false;
+        }
+    }
+
+    public static String fromUTF8ByteArrayReplaceBadEncoding(byte[] input) {
+        final CharsetDecoder charsetDecoder = Charset.forName("UTF-8").newDecoder();
+        charsetDecoder.onMalformedInput(CodingErrorAction.REPLACE);
+        charsetDecoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
+
+        try {
+            return charsetDecoder.decode(ByteBuffer.wrap(input)).toString();
+        } catch (CharacterCodingException e) {
+            Log.e(Constants.TAG, "Decoding failed!", e);
+            return charsetDecoder.replacement();
+        }
+    }
+}