428 lines
18 KiB
Java
428 lines
18 KiB
Java
/*
|
|
* Copyright (C) 2017 Christian Hagau <ach@hagau.se>
|
|
*
|
|
* 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.remote;
|
|
|
|
import android.app.PendingIntent;
|
|
import android.app.Service;
|
|
import android.content.Intent;
|
|
import android.os.IBinder;
|
|
import android.util.Log;
|
|
import org.bouncycastle.bcpg.HashAlgorithmTags;
|
|
import org.bouncycastle.bcpg.PublicKeyAlgorithmTags;
|
|
import org.openintents.ssh.authentication.ISshAuthenticationService;
|
|
import org.openintents.ssh.authentication.SshAuthenticationApi;
|
|
import org.openintents.ssh.authentication.SshAuthenticationApiError;
|
|
import org.openintents.ssh.authentication.response.KeySelectionResponse;
|
|
import org.openintents.ssh.authentication.response.PublicKeyResponse;
|
|
import org.openintents.ssh.authentication.response.SigningResponse;
|
|
import org.openintents.ssh.authentication.response.SshPublicKeyResponse;
|
|
import org.sufficientlysecure.keychain.Constants;
|
|
import org.sufficientlysecure.keychain.operations.results.OperationResult.LogEntryParcel;
|
|
import org.sufficientlysecure.keychain.pgp.CanonicalizedPublicKey;
|
|
import org.sufficientlysecure.keychain.pgp.SshPublicKey;
|
|
import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
|
|
import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException;
|
|
import org.sufficientlysecure.keychain.provider.ApiDataAccessObject;
|
|
import org.sufficientlysecure.keychain.provider.CachedPublicKeyRing;
|
|
import org.sufficientlysecure.keychain.provider.KeyRepository;
|
|
import org.sufficientlysecure.keychain.provider.KeychainContract;
|
|
import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
|
|
import org.sufficientlysecure.keychain.service.input.RequiredInputParcel;
|
|
import org.sufficientlysecure.keychain.ssh.AuthenticationData;
|
|
import org.sufficientlysecure.keychain.ssh.AuthenticationOperation;
|
|
import org.sufficientlysecure.keychain.ssh.AuthenticationParcel;
|
|
import org.sufficientlysecure.keychain.ssh.AuthenticationResult;
|
|
import org.sufficientlysecure.keychain.ssh.signature.SshSignatureConverter;
|
|
|
|
import java.security.NoSuchAlgorithmException;
|
|
import java.security.PublicKey;
|
|
import java.util.Collections;
|
|
import java.util.Date;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
|
|
|
|
public class SshAuthenticationService extends Service {
|
|
private static final String TAG = "SshAuthService";
|
|
|
|
private ApiPermissionHelper mApiPermissionHelper;
|
|
private KeyRepository mKeyRepository;
|
|
private ApiDataAccessObject mApiDao;
|
|
private ApiPendingIntentFactory mApiPendingIntentFactory;
|
|
|
|
private static final List<Integer> SUPPORTED_VERSIONS = Collections.unmodifiableList(Collections.singletonList(1));
|
|
private static final int INVALID_API_VERSION = -1;
|
|
|
|
private static final int HASHALGORITHM_NONE = SshAuthenticationApiError.INVALID_HASH_ALGORITHM;
|
|
|
|
@Override
|
|
public void onCreate() {
|
|
super.onCreate();
|
|
mApiPermissionHelper = new ApiPermissionHelper(this, new ApiDataAccessObject(this));
|
|
mKeyRepository = KeyRepository.create(this);
|
|
mApiDao = new ApiDataAccessObject(this);
|
|
|
|
mApiPendingIntentFactory = new ApiPendingIntentFactory(getBaseContext());
|
|
}
|
|
|
|
private final ISshAuthenticationService.Stub mSSHAgent = new ISshAuthenticationService.Stub() {
|
|
@Override
|
|
public Intent execute(Intent intent) {
|
|
return checkIntent(intent);
|
|
}
|
|
|
|
};
|
|
|
|
@Override
|
|
public IBinder onBind(Intent intent) {
|
|
return mSSHAgent;
|
|
}
|
|
|
|
private Intent checkIntent(Intent intent) {
|
|
Intent errorResult = checkRequirements(intent);
|
|
if (errorResult == null) {
|
|
return executeInternal(intent);
|
|
} else {
|
|
return errorResult;
|
|
}
|
|
}
|
|
|
|
private Intent executeInternal(Intent intent) {
|
|
switch (intent.getAction()) {
|
|
case SshAuthenticationApi.ACTION_SIGN:
|
|
return authenticate(intent);
|
|
case SshAuthenticationApi.ACTION_SELECT_KEY:
|
|
return getAuthenticationKey(intent);
|
|
case SshAuthenticationApi.ACTION_GET_PUBLIC_KEY:
|
|
return getAuthenticationPublicKey(intent, false);
|
|
case SshAuthenticationApi.ACTION_GET_SSH_PUBLIC_KEY:
|
|
return getAuthenticationPublicKey(intent, true);
|
|
default:
|
|
return createErrorResult(SshAuthenticationApiError.UNKNOWN_ACTION, "Unknown action");
|
|
}
|
|
}
|
|
|
|
private Intent authenticate(Intent data) {
|
|
Intent errorIntent = checkForKeyId(data);
|
|
if (errorIntent != null) {
|
|
return errorIntent;
|
|
}
|
|
|
|
// keyid == masterkeyid -> authkeyid
|
|
// keyId is the pgp master keyId, the keyId used will be the first authentication
|
|
// key in the keyring designated by the master keyId
|
|
String keyIdString = data.getStringExtra(SshAuthenticationApi.EXTRA_KEY_ID);
|
|
long masterKeyId = Long.valueOf(keyIdString);
|
|
|
|
int hashAlgorithmTag = getHashAlgorithm(data);
|
|
if (hashAlgorithmTag == HASHALGORITHM_NONE) {
|
|
return createErrorResult(SshAuthenticationApiError.GENERIC_ERROR, "No valid hash algorithm!");
|
|
}
|
|
|
|
byte[] challenge = data.getByteArrayExtra(SshAuthenticationApi.EXTRA_CHALLENGE);
|
|
if (challenge == null || challenge.length == 0) {
|
|
return createErrorResult(SshAuthenticationApiError.GENERIC_ERROR, "No challenge given");
|
|
}
|
|
|
|
// carries the metadata necessary for authentication
|
|
AuthenticationData.Builder authData = AuthenticationData.builder();
|
|
authData.setAuthenticationMasterKeyId(masterKeyId);
|
|
|
|
CachedPublicKeyRing cachedPublicKeyRing = mKeyRepository.getCachedPublicKeyRing(masterKeyId);
|
|
|
|
long authSubKeyId;
|
|
int authSubKeyAlgorithm;
|
|
String authSubKeyCurveOid = null;
|
|
try {
|
|
// get first usable subkey capable of authentication
|
|
authSubKeyId = cachedPublicKeyRing.getSecretAuthenticationId();
|
|
// needed for encoding the resulting signature
|
|
authSubKeyAlgorithm = getPublicKey(masterKeyId).getAlgorithm();
|
|
if (authSubKeyAlgorithm == PublicKeyAlgorithmTags.ECDSA) {
|
|
authSubKeyCurveOid = getPublicKey(masterKeyId).getCurveOid();
|
|
}
|
|
} catch (PgpKeyNotFoundException e) {
|
|
return createExceptionErrorResult(SshAuthenticationApiError.NO_AUTH_KEY,
|
|
"authentication key for master key id not found in keychain", e);
|
|
} catch (KeyRepository.NotFoundException e) {
|
|
return createExceptionErrorResult(SshAuthenticationApiError.NO_SUCH_KEY,
|
|
"Key for master key id not found", e);
|
|
}
|
|
|
|
authData.setAuthenticationSubKeyId(authSubKeyId);
|
|
|
|
authData.setAllowedAuthenticationKeyIds(getAllowedKeyIds());
|
|
|
|
authData.setHashAlgorithm(hashAlgorithmTag);
|
|
|
|
CryptoInputParcel inputParcel = CryptoInputParcelCacheService.getCryptoInputParcel(this, data);
|
|
if (inputParcel == null) {
|
|
// fresh request, assign UUID
|
|
inputParcel = CryptoInputParcel.createCryptoInputParcel(new Date());
|
|
}
|
|
|
|
AuthenticationParcel authParcel = AuthenticationParcel
|
|
.createAuthenticationParcel(authData.build(), challenge);
|
|
|
|
// execute authentication operation!
|
|
AuthenticationOperation authOperation = new AuthenticationOperation(this, mKeyRepository);
|
|
AuthenticationResult authResult = authOperation.execute(authData.build(), inputParcel, authParcel);
|
|
|
|
if (authResult.isPending()) {
|
|
RequiredInputParcel requiredInput = authResult.getRequiredInputParcel();
|
|
PendingIntent pi = mApiPendingIntentFactory.requiredInputPi(data, requiredInput,
|
|
authResult.mCryptoInputParcel);
|
|
// return PendingIntent to be executed by client
|
|
return packagePendingIntent(pi);
|
|
} else if (authResult.success()) {
|
|
byte[] rawSignature = authResult.getSignature();
|
|
byte[] sshSignature;
|
|
try {
|
|
if (authSubKeyAlgorithm == PublicKeyAlgorithmTags.ECDSA) {
|
|
sshSignature = SshSignatureConverter.getSshSignatureEcDsa(rawSignature, authSubKeyCurveOid);
|
|
} else {
|
|
sshSignature = SshSignatureConverter.getSshSignature(rawSignature, authSubKeyAlgorithm);
|
|
}
|
|
} catch (NoSuchAlgorithmException e) {
|
|
return createExceptionErrorResult(SshAuthenticationApiError.INTERNAL_ERROR,
|
|
"Error converting signature", e);
|
|
}
|
|
return new SigningResponse(sshSignature).toIntent();
|
|
} else {
|
|
LogEntryParcel errorMsg = authResult.getLog().getLast();
|
|
return createErrorResult(SshAuthenticationApiError.INTERNAL_ERROR, getString(errorMsg.mType.getMsgId()));
|
|
}
|
|
}
|
|
|
|
private Intent checkForKeyId(Intent data) {
|
|
long authMasterKeyId = getKeyId(data);
|
|
if (authMasterKeyId == Constants.key.none) {
|
|
return createErrorResult(SshAuthenticationApiError.NO_KEY_ID,
|
|
"No key id in request");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private long getKeyId(Intent data) {
|
|
String keyIdString = data.getStringExtra(SshAuthenticationApi.EXTRA_KEY_ID);
|
|
long authMasterKeyId = Constants.key.none;
|
|
if (keyIdString != null) {
|
|
try {
|
|
authMasterKeyId = Long.valueOf(keyIdString);
|
|
} catch (NumberFormatException e) {
|
|
return Constants.key.none;
|
|
}
|
|
}
|
|
return authMasterKeyId;
|
|
}
|
|
|
|
private int getHashAlgorithm(Intent data) {
|
|
int hashAlgorithm = data.getIntExtra(SshAuthenticationApi.EXTRA_HASH_ALGORITHM, HASHALGORITHM_NONE);
|
|
|
|
switch (hashAlgorithm) {
|
|
case SshAuthenticationApi.SHA1:
|
|
return HashAlgorithmTags.SHA1;
|
|
case SshAuthenticationApi.RIPEMD160:
|
|
return HashAlgorithmTags.RIPEMD160;
|
|
case SshAuthenticationApi.SHA224:
|
|
return HashAlgorithmTags.SHA224;
|
|
case SshAuthenticationApi.SHA256:
|
|
return HashAlgorithmTags.SHA256;
|
|
case SshAuthenticationApi.SHA384:
|
|
return HashAlgorithmTags.SHA384;
|
|
case SshAuthenticationApi.SHA512:
|
|
return HashAlgorithmTags.SHA512;
|
|
default:
|
|
return HASHALGORITHM_NONE;
|
|
}
|
|
}
|
|
|
|
private Intent getAuthenticationKey(Intent data) {
|
|
long masterKeyId = getKeyId(data);
|
|
if (masterKeyId != Constants.key.none) {
|
|
String description;
|
|
|
|
try {
|
|
description = getDescription(masterKeyId);
|
|
} catch (PgpKeyNotFoundException e) {
|
|
return createExceptionErrorResult(SshAuthenticationApiError.NO_SUCH_KEY,
|
|
"Could not create description", e);
|
|
}
|
|
|
|
return new KeySelectionResponse(String.valueOf(masterKeyId), description).toIntent();
|
|
} else {
|
|
return redirectToKeySelection(data);
|
|
}
|
|
}
|
|
|
|
private Intent redirectToKeySelection(Intent data) {
|
|
String currentPkg = mApiPermissionHelper.getCurrentCallingPackage();
|
|
PendingIntent pi = mApiPendingIntentFactory.createSelectAuthenticationKeyIdPendingIntent(data, currentPkg);
|
|
return packagePendingIntent(pi);
|
|
}
|
|
|
|
private Intent packagePendingIntent(PendingIntent pi) {
|
|
Intent result = new Intent();
|
|
result.putExtra(SshAuthenticationApi.EXTRA_RESULT_CODE,
|
|
SshAuthenticationApi.RESULT_CODE_USER_INTERACTION_REQUIRED);
|
|
result.putExtra(SshAuthenticationApi.EXTRA_PENDING_INTENT, pi);
|
|
return result;
|
|
}
|
|
|
|
private Intent getAuthenticationPublicKey(Intent data, boolean asSshKey) {
|
|
long masterKeyId = getKeyId(data);
|
|
if (masterKeyId != Constants.key.none) {
|
|
try {
|
|
if (asSshKey) {
|
|
return getSSHPublicKey(masterKeyId);
|
|
} else {
|
|
return getX509PublicKey(masterKeyId);
|
|
}
|
|
} catch (KeyRepository.NotFoundException e) {
|
|
return createExceptionErrorResult(SshAuthenticationApiError.NO_SUCH_KEY,
|
|
"Key for master key id not found", e);
|
|
} catch (PgpKeyNotFoundException e) {
|
|
return createExceptionErrorResult(SshAuthenticationApiError.NO_AUTH_KEY,
|
|
"Authentication key for master key id not found in keychain", e);
|
|
} catch (NoSuchAlgorithmException e) {
|
|
return createExceptionErrorResult(SshAuthenticationApiError.INVALID_ALGORITHM,
|
|
"Algorithm not supported", e);
|
|
}
|
|
} else {
|
|
return createErrorResult(SshAuthenticationApiError.NO_KEY_ID,
|
|
"No key id in request");
|
|
}
|
|
}
|
|
|
|
private Intent getX509PublicKey(long masterKeyId) throws KeyRepository.NotFoundException, PgpKeyNotFoundException, NoSuchAlgorithmException {
|
|
byte[] encodedPublicKey;
|
|
int algorithm;
|
|
|
|
PublicKey publicKey;
|
|
try {
|
|
publicKey = getPublicKey(masterKeyId).getJcaPublicKey();
|
|
} catch (PgpGeneralException e) { // this should probably never happen
|
|
return createExceptionErrorResult(SshAuthenticationApiError.GENERIC_ERROR,
|
|
"Error converting public key", e);
|
|
}
|
|
|
|
encodedPublicKey = publicKey.getEncoded();
|
|
algorithm = translateAlgorithm(publicKey.getAlgorithm());
|
|
|
|
return new PublicKeyResponse(encodedPublicKey, algorithm).toIntent();
|
|
}
|
|
|
|
private int translateAlgorithm(String algorithm) throws NoSuchAlgorithmException {
|
|
switch (algorithm) {
|
|
case "RSA":
|
|
return SshAuthenticationApi.RSA;
|
|
case "ECDSA":
|
|
return SshAuthenticationApi.ECDSA;
|
|
case "EdDSA":
|
|
return SshAuthenticationApi.EDDSA;
|
|
case "DSA":
|
|
return SshAuthenticationApi.DSA;
|
|
default:
|
|
throw new NoSuchAlgorithmException("Error matching key algorithm to API supported algorithm: "
|
|
+ algorithm);
|
|
}
|
|
}
|
|
|
|
private Intent getSSHPublicKey(long masterKeyId) throws KeyRepository.NotFoundException, PgpKeyNotFoundException {
|
|
String sshPublicKeyBlob;
|
|
|
|
CanonicalizedPublicKey publicKey = getPublicKey(masterKeyId);
|
|
|
|
SshPublicKey sshPublicKey = new SshPublicKey(publicKey);
|
|
try {
|
|
sshPublicKeyBlob = sshPublicKey.getEncodedKey();
|
|
} catch (PgpGeneralException | NoSuchAlgorithmException e) {
|
|
return createExceptionErrorResult(SshAuthenticationApiError.GENERIC_ERROR,
|
|
"Error converting public key to SSH format", e);
|
|
}
|
|
|
|
return new SshPublicKeyResponse(sshPublicKeyBlob).toIntent();
|
|
}
|
|
|
|
private CanonicalizedPublicKey getPublicKey(long masterKeyId)
|
|
throws PgpKeyNotFoundException, KeyRepository.NotFoundException {
|
|
KeyRepository keyRepository = KeyRepository.create(getApplicationContext());
|
|
long authSubKeyId = keyRepository.getCachedPublicKeyRing(masterKeyId)
|
|
.getSecretAuthenticationId();
|
|
return keyRepository.getCanonicalizedPublicKeyRing(masterKeyId)
|
|
.getPublicKey(authSubKeyId);
|
|
}
|
|
|
|
private String getDescription(long masterKeyId) throws PgpKeyNotFoundException {
|
|
CachedPublicKeyRing cachedPublicKeyRing = mKeyRepository.getCachedPublicKeyRing(masterKeyId);
|
|
|
|
String description = "";
|
|
long authSubKeyId = cachedPublicKeyRing.getSecretAuthenticationId();
|
|
description += cachedPublicKeyRing.getPrimaryUserId();
|
|
description += " (" + Long.toHexString(authSubKeyId) + ")";
|
|
|
|
return description;
|
|
}
|
|
|
|
private HashSet<Long> getAllowedKeyIds() {
|
|
String currentPkg = mApiPermissionHelper.getCurrentCallingPackage();
|
|
return mApiDao.getAllowedKeyIdsForApp(KeychainContract.ApiAllowedKeys.buildBaseUri(currentPkg));
|
|
}
|
|
|
|
/**
|
|
* @return null if basic requirements are met
|
|
*/
|
|
private Intent checkRequirements(Intent data) {
|
|
if (data == null) {
|
|
return createErrorResult(SshAuthenticationApiError.GENERIC_ERROR, "No parameter bundle");
|
|
}
|
|
|
|
// check version
|
|
int apiVersion = data.getIntExtra(SshAuthenticationApi.EXTRA_API_VERSION, INVALID_API_VERSION);
|
|
if (!SUPPORTED_VERSIONS.contains(apiVersion)) {
|
|
String errorMsg = "Incompatible API versions:\n"
|
|
+ "used : " + data.getIntExtra(SshAuthenticationApi.EXTRA_API_VERSION, INVALID_API_VERSION) + "\n"
|
|
+ "supported : " + SUPPORTED_VERSIONS;
|
|
|
|
return createErrorResult(SshAuthenticationApiError.INCOMPATIBLE_API_VERSIONS, errorMsg);
|
|
}
|
|
|
|
// check if caller is allowed to access OpenKeychain
|
|
Intent result = mApiPermissionHelper.isAllowedOrReturnIntent(data);
|
|
if (result != null) {
|
|
return result; // disallowed, redirect to registration
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private Intent createErrorResult(int errorCode, String errorMessage) {
|
|
Log.e(TAG, errorMessage);
|
|
Intent result = new Intent();
|
|
result.putExtra(SshAuthenticationApi.EXTRA_ERROR, new SshAuthenticationApiError(errorCode, errorMessage));
|
|
result.putExtra(SshAuthenticationApi.EXTRA_RESULT_CODE, SshAuthenticationApi.RESULT_CODE_ERROR);
|
|
return result;
|
|
}
|
|
|
|
private Intent createExceptionErrorResult(int errorCode, String errorMessage, Exception e) {
|
|
String message = errorMessage + " : " + e.getMessage();
|
|
return createErrorResult(errorCode, message);
|
|
}
|
|
|
|
}
|