diff options
Diffstat (limited to 'OpenKeychain/src/main/java/org/sufficientlysecure')
7 files changed, 152 insertions, 24 deletions
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptData.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptData.java index c4e569d24..5d904331e 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptData.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptData.java @@ -30,6 +30,7 @@ public class PgpSignEncryptData implements Parcelable { protected String mVersionHeader = null; protected boolean mEnableAsciiArmorOutput = false; + protected boolean mSshAuth = false; protected int mCompressionAlgorithm = CompressionAlgorithmTags.UNCOMPRESSED; protected long[] mEncryptionMasterKeyIds = null; protected Passphrase mSymmetricPassphrase = null; @@ -53,6 +54,7 @@ public class PgpSignEncryptData implements Parcelable { mVersionHeader = source.readString(); mEnableAsciiArmorOutput = source.readInt() == 1; + mSshAuth = source.readInt() == 1; mCompressionAlgorithm = source.readInt(); mEncryptionMasterKeyIds = source.createLongArray(); mSymmetricPassphrase = source.readParcelable(loader); @@ -78,6 +80,7 @@ public class PgpSignEncryptData implements Parcelable { public void writeToParcel(Parcel dest, int flags) { dest.writeString(mVersionHeader); dest.writeInt(mEnableAsciiArmorOutput ? 1 : 0); + dest.writeInt(mSshAuth ? 1 : 0); dest.writeInt(mCompressionAlgorithm); dest.writeLongArray(mEncryptionMasterKeyIds); dest.writeParcelable(mSymmetricPassphrase, 0); @@ -183,6 +186,10 @@ public class PgpSignEncryptData implements Parcelable { return mEnableAsciiArmorOutput; } + public boolean isSshAuth() { + return mSshAuth; + } + public String getVersionHeader() { return mVersionHeader; } @@ -197,6 +204,11 @@ public class PgpSignEncryptData implements Parcelable { return this; } + public PgpSignEncryptData setSshAuth(boolean sshAuth) { + mSshAuth = sshAuth; + return this; + } + public PgpSignEncryptData setCleartextSignature(boolean cleartextSignature) { this.mCleartextSignature = cleartextSignature; return this; 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 7a1d99927..a855dcac8 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptOperation.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptOperation.java @@ -24,6 +24,7 @@ import android.net.Uri; import android.os.Parcelable; import android.support.annotation.NonNull; +import org.bouncycastle.bcpg.HashAlgorithmTags; import org.bouncycastle.bcpg.ArmoredOutputStream; import org.bouncycastle.bcpg.BCPGOutputStream; import org.bouncycastle.bcpg.CompressionAlgorithmTags; @@ -58,6 +59,10 @@ import org.sufficientlysecure.keychain.util.Log; import org.sufficientlysecure.keychain.util.Passphrase; import org.sufficientlysecure.keychain.util.ProgressScaler; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; + +import java.nio.ByteBuffer; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.BufferedReader; @@ -165,6 +170,7 @@ public class PgpSignEncryptOperation extends BaseOperation<PgpSignEncryptInputPa return executeInternal(input, cryptoInput, inputData, outputStream); } + /** * Signs and/or encrypts data based on parameters of class */ @@ -238,7 +244,10 @@ public class PgpSignEncryptOperation extends BaseOperation<PgpSignEncryptInputPa } // Make sure we are allowed to sign here! - if (!signingKey.canSign()) { + if ((!signingKey.canSign() && !data.isSshAuth()) || + (!signingKey.canAuthenticate() && data.isSshAuth())) { + Log.w(Constants.TAG, "canSign " + signingKey.canSign() + " canAuthenticate " + + signingKey.canAuthenticate() + " isSshAuth "+ data.isSshAuth()); log.add(LogType.MSG_PSE_ERROR_KEY_SIGN, indent); return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log); } @@ -298,7 +307,11 @@ public class PgpSignEncryptOperation extends BaseOperation<PgpSignEncryptInputPa // Use requested hash algo int requestedAlgorithm = data.getSignatureHashAlgorithm(); if (requestedAlgorithm == PgpSecurityConstants.OpenKeychainHashAlgorithmTags.USE_DEFAULT) { - data.setSignatureHashAlgorithm(PgpSecurityConstants.DEFAULT_HASH_ALGORITHM); + if (data.isSshAuth()) { + data.setSignatureHashAlgorithm(HashAlgorithmTags.SHA1); + } else { + data.setSignatureHashAlgorithm(PgpSecurityConstants.DEFAULT_HASH_ALGORITHM); + } } } updateProgress(R.string.progress_preparing_streams, 2, 100); @@ -386,6 +399,7 @@ public class PgpSignEncryptOperation extends BaseOperation<PgpSignEncryptInputPa ByteArrayOutputStream detachedByteOut = null; ArmoredOutputStream detachedArmorOut = null; BCPGOutputStream detachedBcpgOut = null; + MessageDigest raw_digest = null; long opTime, startTime = System.currentTimeMillis(); @@ -491,6 +505,28 @@ public class PgpSignEncryptOperation extends BaseOperation<PgpSignEncryptInputPa } else if (enableSignature && data.isDetachedSignature()) { /* detached signature */ + // JMM - GROSS HACK + // + // The PGP stack doesn't do signatures of arbitary data: it wants + // to use its own structure for the message, so we have + // to be creative. We let the pgp stack do its stuff, but when + // it calls out to the NFC stack, we catch it and swap the + // message digest for own own. + // + // this means we have to check cyrptoInput for the correct + // hash ourselves on the 2nd trip through when the + // client resents the request. + // + + if (data.isSshAuth()) { + try { + raw_digest = MessageDigest.getInstance("SHA-1"); + } catch (NoSuchAlgorithmException e) { + log.add(LogType.MSG_PSE_ERROR_IO, indent); + return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log); + } + } + updateProgress(R.string.progress_signing, 8, 100); log.add(LogType.MSG_PSE_SIGNING_DETACHED, indent); @@ -515,6 +551,9 @@ public class PgpSignEncryptOperation extends BaseOperation<PgpSignEncryptInputPa while ((length = in.read(buffer)) > 0) { // no output stream is written, no changed to original data! + if (raw_digest != null) + raw_digest.update(buffer, 0, length); + signatureGenerator.update(buffer, 0, length); alreadyWritten += length; @@ -582,11 +621,37 @@ public class PgpSignEncryptOperation extends BaseOperation<PgpSignEncryptInputPa signatureGenerator.generate().encode(pOut); } } catch (NfcSyncPGPContentSignerBuilder.NfcInteractionNeeded e) { - // this secret key diverts to a OpenPGP card, throw exception with hash that will be signed - log.add(LogType.MSG_PSE_PENDING_NFC, indent); - return new PgpSignEncryptResult(log, RequiredInputParcel.createSecurityTokenSignOperation( - signingKey.getRing().getMasterKeyId(), signingKey.getKeyId(), - e.hashToSign, e.hashAlgo, cryptoInput.getSignatureTime()), cryptoInput); + + // JMM - 2nd part of gross hack + // first swap the message digest for the raw one + // before this hits the NFC stack + + if (raw_digest != null) + e.hashToSign = raw_digest.digest(); + + // Test to see if we already have the answer for the hash + // as the test in encode() above was checking the wrong + // hash. + + byte [] answer = cryptoInput.getCryptoData().get(ByteBuffer.wrap(e.hashToSign)); + + if (raw_digest == null || answer == null) { + // We haven't done the hash yet, so kick it off to the NFC stack + + // this secret key diverts to a OpenPGP card, throw exception with hash that will be signed + + log.add(LogType.MSG_PSE_PENDING_NFC, indent); + return new PgpSignEncryptResult(log, RequiredInputParcel.createSecurityTokenSignOperation( + signingKey.getRing().getMasterKeyId(), signingKey.getKeyId(), + e.hashToSign, e.hashAlgo, cryptoInput.getSignatureTime()), cryptoInput); + } else if (raw_digest != null) { + // We've aready done the work, replace the output stream + // from the PGP signature with just the signature as we want just + // a raw signature + + detachedByteOut = new ByteArrayOutputStream(); + detachedByteOut.write(answer, 0, answer.length); + } } } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/CachedPublicKeyRing.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/CachedPublicKeyRing.java index 604a5a027..58c3a154e 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/CachedPublicKeyRing.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/CachedPublicKeyRing.java @@ -167,6 +167,23 @@ public class CachedPublicKeyRing extends KeyRing { } } + /** Returns the key id which should be used for auth. + * + * This method returns keys which are actually available (ie. secret available, and not stripped, + * revoked, or expired), hence only works on keyrings where a secret key is available! + * + */ + public long getSecretAuthId() throws PgpKeyNotFoundException { + try { + Object data = mProviderHelper.getGenericData(mUri, + KeyRings.HAS_AUTHENTICATE, + ProviderHelper.FIELD_TYPE_INTEGER); + return (Long) data; + } catch(ProviderHelper.NotFoundException e) { + throw new PgpKeyNotFoundException(e); + } + } + @Override public int getVerified() throws PgpKeyNotFoundException { try { diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/KeychainProvider.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/KeychainProvider.java index 8a5d09d7b..8f3e4c247 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/KeychainProvider.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/KeychainProvider.java @@ -336,6 +336,8 @@ public class KeychainProvider extends ContentProvider { "kE." + Keys.KEY_ID + " AS " + KeyRings.HAS_ENCRYPT); projectionMap.put(KeyRings.HAS_SIGN, "kS." + Keys.KEY_ID + " AS " + KeyRings.HAS_SIGN); + projectionMap.put(KeyRings.HAS_AUTHENTICATE, + "kA." + Keys.KEY_ID + " AS " + KeyRings.HAS_AUTHENTICATE); projectionMap.put(KeyRings.HAS_CERTIFY, "kC." + Keys.KEY_ID + " AS " + KeyRings.HAS_CERTIFY); projectionMap.put(KeyRings.IS_EXPIRED, diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/OpenPgpService.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/OpenPgpService.java index c85774ead..c5cbcbb71 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/OpenPgpService.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/OpenPgpService.java @@ -199,7 +199,8 @@ public class OpenPgpService extends Service { } private Intent signImpl(Intent data, InputStream inputStream, - OutputStream outputStream, boolean cleartextSign) { + OutputStream outputStream, boolean cleartextSign, + boolean sshAuth) { try { boolean asciiArmor = cleartextSign || data.getBooleanExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true); @@ -209,6 +210,7 @@ public class OpenPgpService extends Service { .setCleartextSignature(cleartextSign) .setDetachedSignature(!cleartextSign) .setVersionHeader(null) + .setSshAuth(sshAuth) .setSignatureHashAlgorithm(PgpSecurityConstants.OpenKeychainHashAlgorithmTags.USE_DEFAULT); @@ -227,9 +229,15 @@ public class OpenPgpService extends Service { // get first usable subkey capable of signing try { - long signSubKeyId = mProviderHelper.getCachedPublicKeyRing( + long subKeyId; + if (sshAuth) { + subKeyId = mProviderHelper.getCachedPublicKeyRing( + pgpData.getSignatureMasterKeyId()).getSecretAuthId(); + } else { + subKeyId = mProviderHelper.getCachedPublicKeyRing( pgpData.getSignatureMasterKeyId()).getSecretSignId(); - pgpData.setSignatureSubKeyId(signSubKeyId); + } + pgpData.setSignatureSubKeyId(subKeyId); } catch (PgpKeyNotFoundException e) { throw new Exception("signing subkey not found!", e); } @@ -941,15 +949,18 @@ public class OpenPgpService extends Service { return checkPermissionImpl(data); } case OpenPgpApi.ACTION_CLEARTEXT_SIGN: { - return signImpl(data, inputStream, outputStream, true); + return signImpl(data, inputStream, outputStream, true, false); } case OpenPgpApi.ACTION_SIGN: { // DEPRECATED: same as ACTION_CLEARTEXT_SIGN Log.w(Constants.TAG, "You are using a deprecated API call, please use ACTION_CLEARTEXT_SIGN instead of ACTION_SIGN!"); - return signImpl(data, inputStream, outputStream, true); + return signImpl(data, inputStream, outputStream, true, false); } case OpenPgpApi.ACTION_DETACHED_SIGN: { - return signImpl(data, inputStream, outputStream, false); + return signImpl(data, inputStream, outputStream, false, false); + } + case OpenPgpApi.ACTION_SSH_AUTH: { + return signImpl(data, inputStream, outputStream, false, true); } case OpenPgpApi.ACTION_ENCRYPT: { return encryptAndSignImpl(data, inputStream, outputStream, false); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/securitytoken/SecurityTokenHelper.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/securitytoken/SecurityTokenHelper.java index bc1c42f7f..deee6366f 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/securitytoken/SecurityTokenHelper.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/securitytoken/SecurityTokenHelper.java @@ -513,9 +513,11 @@ public class SecurityTokenHelper { * @param hash the hash for signing * @return a big integer representing the MPI for the given hash */ - public byte[] calculateSignature(byte[] hash, int hashAlgo) throws IOException { + public byte[] calculateSignature(byte[] hash, int hashAlgo, boolean useAuthKey) throws IOException { if (!mPw1ValidatedForSignature) { - verifyPin(0x81); // (Verify PW1 with mode 81 for signing) + // (Verify PW1 with mode 81 for signing) + // (Verify PW1 with mode 82 for auth) + verifyPin(useAuthKey ? 0x82 : 0x81); } // dsi, including Lc @@ -525,7 +527,7 @@ public class SecurityTokenHelper { switch (hashAlgo) { case HashAlgorithmTags.SHA1: if (hash.length != 20) { - throw new IOException("Bad hash length (" + hash.length + ", expected 10!"); + throw new IOException("Bad hash length (" + hash.length + ", expected 20!"); } dsi = "23" // Lc + "3021" // Tag/Length of Sequence, the 0x21 includes all following 33 bytes @@ -568,11 +570,24 @@ public class SecurityTokenHelper { throw new IOException("Not supported hash algo!"); } - // Command APDU for PERFORM SECURITY OPERATION: COMPUTE DIGITAL SIGNATURE (page 37) - String apdu = - "002A9E9A" // CLA, INS, P1, P2 - + dsi // digital signature input - + "00"; // Le + String apdu; + + if (!useAuthKey) { + // Command APDU for PERFORM SECURITY OPERATION: COMPUTE DIGITAL SIGNATURE (page 37) + apdu = + "002A9E9A" // CLA, INS, P1, P2 + + dsi // digital signature input + + "00"; // Le + + } else { + // Command APDU for INTERNAL AUTHENTICATE (page 55) + // This command doesn't take / + apdu = + "00880000" // CLA, INS, P1, P2 + + dsi // digital signature input, card does PKCS#1 + + "00"; // Le + + } String response = communicate(apdu); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SecurityTokenOperationActivity.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SecurityTokenOperationActivity.java index 4d07025e6..4e7c06b69 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SecurityTokenOperationActivity.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SecurityTokenOperationActivity.java @@ -200,10 +200,16 @@ public class SecurityTokenOperationActivity extends BaseSecurityTokenActivity { break; } case SECURITY_TOKEN_SIGN: { - long tokenKeyId = KeyFormattingUtils.getKeyIdFromFingerprint( + long tokenSignKeyId = KeyFormattingUtils.getKeyIdFromFingerprint( mSecurityTokenHelper.getKeyFingerprint(KeyType.SIGN)); - if (tokenKeyId != mRequiredInput.getSubKeyId()) { + long tokenAuthKeyId = KeyFormattingUtils.getKeyIdFromFingerprint( + mSecurityTokenHelper.getKeyFingerprint(KeyType.AUTH)); + + long requiredKey = mRequiredInput.getSubKeyId(); + + + if ((tokenSignKeyId != requiredKey) && (tokenAuthKeyId != requiredKey)) { throw new IOException(getString(R.string.error_wrong_security_token)); } @@ -212,7 +218,7 @@ public class SecurityTokenOperationActivity extends BaseSecurityTokenActivity { for (int i = 0; i < mRequiredInput.mInputData.length; i++) { byte[] hash = mRequiredInput.mInputData[i]; int algo = mRequiredInput.mSignAlgos[i]; - byte[] signedHash = mSecurityTokenHelper.calculateSignature(hash, algo); + byte[] signedHash = mSecurityTokenHelper.calculateSignature(hash, algo, requiredKey == tokenAuthKeyId); mInputParcel.addCryptoData(hash, signedHash); } break; |