conversations-classic/src/main/java/eu/siacs/conversations/ui/TrustKeysActivity.java

458 lines
17 KiB
Java
Raw Normal View History

package eu.siacs.conversations.ui;
import android.app.AlertDialog;
import android.content.Intent;
2018-02-17 19:41:46 +00:00
import android.databinding.DataBindingUtil;
import android.os.Bundle;
import android.support.v7.app.ActionBar;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.Gravity;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Toast;
import org.whispersystems.libsignal.IdentityKey;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
2016-11-17 19:09:42 +00:00
import eu.siacs.conversations.Config;
import eu.siacs.conversations.R;
import eu.siacs.conversations.crypto.OmemoSetting;
import eu.siacs.conversations.crypto.axolotl.AxolotlService;
import eu.siacs.conversations.crypto.axolotl.FingerprintStatus;
2018-02-17 19:41:46 +00:00
import eu.siacs.conversations.databinding.ActivityTrustKeysBinding;
import eu.siacs.conversations.databinding.KeysCardBinding;
import eu.siacs.conversations.entities.Account;
import eu.siacs.conversations.entities.Contact;
import eu.siacs.conversations.entities.Conversation;
import eu.siacs.conversations.entities.Message;
import eu.siacs.conversations.utils.CryptoHelper;
import eu.siacs.conversations.utils.IrregularUnicodeDetector;
import eu.siacs.conversations.utils.XmppUri;
import eu.siacs.conversations.xmpp.OnKeyStatusUpdated;
2018-03-05 17:30:40 +00:00
import rocks.xmpp.addr.Jid;
2018-02-17 19:41:46 +00:00
2016-11-15 19:00:52 +00:00
public class TrustKeysActivity extends OmemoActivity implements OnKeyStatusUpdated {
private final Map<String, Boolean> ownKeysToTrust = new HashMap<>();
private final Map<Jid, Map<String, Boolean>> foreignKeysToTrust = new HashMap<>();
private final OnClickListener mCancelButtonListener = v -> {
setResult(RESULT_CANCELED);
finish();
};
private List<Jid> contactJids;
private Account mAccount;
private Conversation mConversation;
private final OnClickListener mSaveButtonListener = v -> {
commitTrusts();
finishOk(false);
};
private AtomicBoolean mUseCameraHintShown = new AtomicBoolean(false);
private AxolotlService.FetchStatus lastFetchReport = AxolotlService.FetchStatus.SUCCESS;
private Toast mUseCameraHintToast = null;
2018-02-17 19:41:46 +00:00
private ActivityTrustKeysBinding binding;
@Override
protected void refreshUiReal() {
invalidateOptionsMenu();
populateView();
}
@Override
protected void onCreate(final Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
this.binding = DataBindingUtil.setContentView(this, R.layout.activity_trust_keys);
this.contactJids = new ArrayList<>();
for (String jid : getIntent().getStringArrayExtra("contacts")) {
try {
2018-03-05 17:30:40 +00:00
this.contactJids.add(Jid.of(jid));
} catch (IllegalArgumentException e) {
e.printStackTrace();
}
}
2018-02-17 19:41:46 +00:00
binding.cancelButton.setOnClickListener(mCancelButtonListener);
binding.saveButton.setOnClickListener(mSaveButtonListener);
setSupportActionBar((Toolbar) binding.toolbar);
configureActionBar(getSupportActionBar());
if (savedInstanceState != null) {
mUseCameraHintShown.set(savedInstanceState.getBoolean("camera_hint_shown", false));
}
}
@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
savedInstanceState.putBoolean("camera_hint_shown", mUseCameraHintShown.get());
super.onSaveInstanceState(savedInstanceState);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.trust_keys, menu);
MenuItem scanQrCode = menu.findItem(R.id.action_scan_qr_code);
2018-03-14 07:21:49 +00:00
scanQrCode.setVisible((ownKeysToTrust.size() > 0 || foreignActuallyHasKeys()) && isCameraFeatureAvailable());
return super.onCreateOptionsMenu(menu);
}
private void showCameraToast() {
mUseCameraHintToast = Toast.makeText(this, R.string.use_camera_icon_to_scan_barcode, Toast.LENGTH_LONG);
ActionBar actionBar = getSupportActionBar();
mUseCameraHintToast.setGravity(Gravity.TOP | Gravity.END, 0, actionBar == null ? 0 : actionBar.getHeight());
mUseCameraHintToast.show();
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.action_scan_qr_code:
if (hasPendingKeyFetches()) {
Toast.makeText(this, R.string.please_wait_for_keys_to_be_fetched, Toast.LENGTH_SHORT).show();
} else {
2018-02-26 11:44:03 +00:00
ScanActivity.scan(this);
//new IntentIntegrator(this).initiateScan(Arrays.asList("AZTEC","QR_CODE"));
return true;
}
}
return super.onOptionsItemSelected(item);
}
@Override
protected void onStop() {
super.onStop();
if (mUseCameraHintToast != null) {
mUseCameraHintToast.cancel();
}
}
@Override
protected void processFingerprintVerification(XmppUri uri) {
if (mConversation != null
&& mAccount != null
&& uri.hasFingerprints()
&& mAccount.getAxolotlService().getCryptoTargets(mConversation).contains(uri.getJid())) {
boolean performedVerification = xmppConnectionService.verifyFingerprints(mAccount.getRoster().getContact(uri.getJid()), uri.getFingerprints());
boolean keys = reloadFingerprints();
if (performedVerification && !keys && !hasNoOtherTrustedKeys() && !hasPendingKeyFetches()) {
Toast.makeText(this, R.string.all_omemo_keys_have_been_verified, Toast.LENGTH_SHORT).show();
finishOk(false);
return;
} else if (performedVerification) {
Toast.makeText(this, R.string.verified_fingerprints, Toast.LENGTH_SHORT).show();
}
} else {
reloadFingerprints();
Log.d(Config.LOGTAG, "xmpp uri was: " + uri.getJid() + " has Fingerprints: " + Boolean.toString(uri.hasFingerprints()));
Toast.makeText(this, R.string.barcode_does_not_contain_fingerprints_for_this_conversation, Toast.LENGTH_SHORT).show();
}
populateView();
}
private void populateView() {
2015-08-08 11:29:21 +00:00
setTitle(getString(R.string.trust_omemo_fingerprints));
2018-02-17 19:41:46 +00:00
binding.ownKeysDetails.removeAllViews();
binding.foreignKeys.removeAllViews();
boolean hasOwnKeys = false;
boolean hasForeignKeys = false;
for (final String fingerprint : ownKeysToTrust.keySet()) {
hasOwnKeys = true;
2018-02-17 19:41:46 +00:00
addFingerprintRowWithListeners(binding.ownKeysDetails, mAccount, fingerprint, false,
2016-11-15 19:00:52 +00:00
FingerprintStatus.createActive(ownKeysToTrust.get(fingerprint)), false, false,
(buttonView, isChecked) -> {
ownKeysToTrust.put(fingerprint, isChecked);
// own fingerprints have no impact on locked status.
2016-11-15 19:00:52 +00:00
}
);
}
synchronized (this.foreignKeysToTrust) {
for (Map.Entry<Jid, Map<String, Boolean>> entry : foreignKeysToTrust.entrySet()) {
hasForeignKeys = true;
KeysCardBinding keysCardBinding = DataBindingUtil.inflate(getLayoutInflater(), R.layout.keys_card, binding.foreignKeys, false);
final Jid jid = entry.getKey();
keysCardBinding.foreignKeysTitle.setText(IrregularUnicodeDetector.style(this, jid));
2018-02-17 19:41:46 +00:00
keysCardBinding.foreignKeysTitle.setOnClickListener(v -> switchToContactDetails(mAccount.getRoster().getContact(jid)));
final Map<String, Boolean> fingerprints = entry.getValue();
for (final String fingerprint : fingerprints.keySet()) {
2018-02-17 19:41:46 +00:00
addFingerprintRowWithListeners(keysCardBinding.foreignKeysDetails, mAccount, fingerprint, false,
2016-11-15 19:00:52 +00:00
FingerprintStatus.createActive(fingerprints.get(fingerprint)), false, false,
2018-02-17 19:41:46 +00:00
(buttonView, isChecked) -> {
fingerprints.put(fingerprint, isChecked);
lockOrUnlockAsNeeded();
2016-11-15 19:00:52 +00:00
}
);
}
if (fingerprints.size() == 0) {
2018-02-17 19:41:46 +00:00
keysCardBinding.noKeysToAccept.setVisibility(View.VISIBLE);
if (hasNoOtherTrustedKeys(jid)) {
if (!mAccount.getRoster().getContact(jid).mutualPresenceSubscription()) {
2018-02-17 19:41:46 +00:00
keysCardBinding.noKeysToAccept.setText(R.string.error_no_keys_to_trust_presence);
} else {
2018-02-17 19:41:46 +00:00
keysCardBinding.noKeysToAccept.setText(R.string.error_no_keys_to_trust_server_error);
}
} else {
2018-02-17 19:41:46 +00:00
keysCardBinding.noKeysToAccept.setText(getString(R.string.no_keys_just_confirm, mAccount.getRoster().getContact(jid).getDisplayName()));
}
} else {
2018-02-17 19:41:46 +00:00
keysCardBinding.noKeysToAccept.setVisibility(View.GONE);
}
2018-02-17 19:41:46 +00:00
binding.foreignKeys.addView(keysCardBinding.foreignKeysCard);
}
}
if ((hasOwnKeys || foreignActuallyHasKeys()) && isCameraFeatureAvailable() && mUseCameraHintShown.compareAndSet(false, true)) {
showCameraToast();
}
2018-03-05 17:30:40 +00:00
binding.ownKeysTitle.setText(mAccount.getJid().asBareJid().toString());
2018-02-17 19:41:46 +00:00
binding.ownKeysCard.setVisibility(hasOwnKeys ? View.VISIBLE : View.GONE);
binding.foreignKeys.setVisibility(hasForeignKeys ? View.VISIBLE : View.GONE);
if (hasPendingKeyFetches()) {
setFetching();
lock();
} else {
if (!hasForeignKeys && hasNoOtherTrustedKeys()) {
2018-02-17 19:41:46 +00:00
binding.keyErrorMessageCard.setVisibility(View.VISIBLE);
boolean lastReportWasError = lastFetchReport == AxolotlService.FetchStatus.ERROR;
boolean errorFetchingBundle = mAccount.getAxolotlService().fetchMapHasErrors(contactJids);
boolean errorFetchingDeviceList = mAccount.getAxolotlService().hasErrorFetchingDeviceList(contactJids);
boolean anyWithoutMutualPresenceSubscription = anyWithoutMutualPresenceSubscription(contactJids);
if (errorFetchingDeviceList) {
binding.keyErrorMessage.setVisibility(View.VISIBLE);
binding.keyErrorMessage.setText(R.string.error_trustkey_device_list);
} else if (errorFetchingBundle || lastReportWasError) {
binding.keyErrorMessage.setVisibility(View.VISIBLE);
binding.keyErrorMessage.setText(R.string.error_trustkey_bundle);
} else {
binding.keyErrorMessage.setVisibility(View.GONE);
}
this.binding.keyErrorHintMutual.setVisibility(anyWithoutMutualPresenceSubscription ? View.VISIBLE : View.GONE);
Contact contact = mAccount.getRoster().getContact(contactJids.get(0));
binding.keyErrorGeneral.setText(getString(R.string.error_trustkey_general, contact.getDisplayName()));
2018-02-17 19:41:46 +00:00
binding.ownKeysDetails.removeAllViews();
if (OmemoSetting.isAlways()) {
binding.disableButton.setVisibility(View.GONE);
} else {
binding.disableButton.setVisibility(View.VISIBLE);
binding.disableButton.setOnClickListener(this::disableEncryptionDialog);
}
2018-02-17 19:41:46 +00:00
binding.ownKeysCard.setVisibility(View.GONE);
binding.foreignKeys.removeAllViews();
binding.foreignKeys.setVisibility(View.GONE);
}
lockOrUnlockAsNeeded();
setDone();
}
}
private void disableEncryptionDialog(View view) {
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle(R.string.disable_encryption);
builder.setMessage(R.string.disable_encryption_message);
builder.setPositiveButton(R.string.disable_now, (dialog, which) -> {
mConversation.setNextEncryption(Message.ENCRYPTION_NONE);
xmppConnectionService.updateConversation(mConversation);
finishOk(true);
});
builder.setNegativeButton(R.string.cancel, null);
builder.create().show();
}
private boolean anyWithoutMutualPresenceSubscription(List<Jid> contactJids) {
for (Jid jid : contactJids) {
if (!mAccount.getRoster().getContact(jid).mutualPresenceSubscription()) {
return true;
}
}
return false;
}
private boolean foreignActuallyHasKeys() {
synchronized (this.foreignKeysToTrust) {
for (Map.Entry<Jid, Map<String, Boolean>> entry : foreignKeysToTrust.entrySet()) {
if (entry.getValue().size() > 0) {
return true;
}
}
}
return false;
}
private boolean reloadFingerprints() {
List<Jid> acceptedTargets = mConversation == null ? new ArrayList<>() : mConversation.getAcceptedCryptoTargets();
ownKeysToTrust.clear();
if (this.mAccount == null) {
return false;
}
AxolotlService service = this.mAccount.getAxolotlService();
Set<IdentityKey> ownKeysSet = service.getKeysWithTrust(FingerprintStatus.createActiveUndecided());
for (final IdentityKey identityKey : ownKeysSet) {
final String fingerprint = CryptoHelper.bytesToHex(identityKey.getPublicKey().serialize());
if (!ownKeysToTrust.containsKey(fingerprint)) {
ownKeysToTrust.put(fingerprint, false);
}
}
synchronized (this.foreignKeysToTrust) {
foreignKeysToTrust.clear();
for (Jid jid : contactJids) {
Set<IdentityKey> foreignKeysSet = service.getKeysWithTrust(FingerprintStatus.createActiveUndecided(), jid);
if (hasNoOtherTrustedKeys(jid) && ownKeysSet.size() == 0) {
foreignKeysSet.addAll(service.getKeysWithTrust(FingerprintStatus.createActive(false), jid));
}
Map<String, Boolean> foreignFingerprints = new HashMap<>();
for (final IdentityKey identityKey : foreignKeysSet) {
final String fingerprint = CryptoHelper.bytesToHex(identityKey.getPublicKey().serialize());
if (!foreignFingerprints.containsKey(fingerprint)) {
foreignFingerprints.put(fingerprint, false);
}
}
if (foreignFingerprints.size() > 0 || !acceptedTargets.contains(jid)) {
foreignKeysToTrust.put(jid, foreignFingerprints);
}
}
}
return ownKeysSet.size() + foreignKeysToTrust.size() > 0;
}
public void onBackendConnected() {
Intent intent = getIntent();
this.mAccount = extractAccount(intent);
if (this.mAccount != null && intent != null) {
String uuid = intent.getStringExtra("conversation");
this.mConversation = xmppConnectionService.findConversationByUuid(uuid);
if (this.mPendingFingerprintVerificationUri != null) {
processFingerprintVerification(this.mPendingFingerprintVerificationUri);
this.mPendingFingerprintVerificationUri = null;
} else {
final boolean keysToTrust = reloadFingerprints();
if (keysToTrust || hasPendingKeyFetches() || hasNoOtherTrustedKeys()) {
populateView();
invalidateOptionsMenu();
} else {
finishOk(false);
}
}
}
}
private boolean hasNoOtherTrustedKeys() {
return mAccount == null || mAccount.getAxolotlService().anyTargetHasNoTrustedKeys(contactJids);
}
private boolean hasNoOtherTrustedKeys(Jid contact) {
return mAccount == null || mAccount.getAxolotlService().getNumTrustedKeys(contact) == 0;
}
private boolean hasPendingKeyFetches() {
return mAccount != null && mAccount.getAxolotlService().hasPendingKeyFetches(contactJids);
}
@Override
public void onKeyStatusUpdated(final AxolotlService.FetchStatus report) {
final boolean keysToTrust = reloadFingerprints();
if (report != null) {
lastFetchReport = report;
runOnUiThread(() -> {
if (mUseCameraHintToast != null && !keysToTrust) {
mUseCameraHintToast.cancel();
}
switch (report) {
case ERROR:
Toast.makeText(TrustKeysActivity.this, R.string.error_fetching_omemo_key, Toast.LENGTH_SHORT).show();
break;
case SUCCESS_TRUSTED:
Toast.makeText(TrustKeysActivity.this, R.string.blindly_trusted_omemo_keys, Toast.LENGTH_LONG).show();
break;
case SUCCESS_VERIFIED:
Toast.makeText(TrustKeysActivity.this,
Config.X509_VERIFICATION ? R.string.verified_omemo_key_with_certificate : R.string.all_omemo_keys_have_been_verified,
Toast.LENGTH_LONG).show();
break;
}
});
}
if (keysToTrust || hasPendingKeyFetches() || hasNoOtherTrustedKeys()) {
refreshUi();
} else {
runOnUiThread(() -> finishOk(false));
}
}
private void finishOk(boolean disabled) {
Intent data = new Intent();
data.putExtra("choice", getIntent().getIntExtra("choice", ConversationFragment.ATTACHMENT_CHOICE_INVALID));
data.putExtra("disabled", disabled);
setResult(RESULT_OK, data);
finish();
}
private void commitTrusts() {
for (final String fingerprint : ownKeysToTrust.keySet()) {
mAccount.getAxolotlService().setFingerprintTrust(
fingerprint,
FingerprintStatus.createActive(ownKeysToTrust.get(fingerprint)));
}
2018-03-08 13:02:48 +00:00
List<Jid> acceptedTargets = mConversation == null ? new ArrayList<>() : mConversation.getAcceptedCryptoTargets();
synchronized (this.foreignKeysToTrust) {
for (Map.Entry<Jid, Map<String, Boolean>> entry : foreignKeysToTrust.entrySet()) {
Jid jid = entry.getKey();
Map<String, Boolean> value = entry.getValue();
if (!acceptedTargets.contains(jid)) {
acceptedTargets.add(jid);
}
for (final String fingerprint : value.keySet()) {
mAccount.getAxolotlService().setFingerprintTrust(
fingerprint,
FingerprintStatus.createActive(value.get(fingerprint)));
}
}
}
if (mConversation != null && mConversation.getMode() == Conversation.MODE_MULTI) {
mConversation.setAcceptedCryptoTargets(acceptedTargets);
xmppConnectionService.updateConversation(mConversation);
}
}
private void unlock() {
2018-02-17 19:41:46 +00:00
binding.saveButton.setEnabled(true);
}
private void lock() {
2018-02-17 19:41:46 +00:00
binding.saveButton.setEnabled(false);
}
private void lockOrUnlockAsNeeded() {
synchronized (this.foreignKeysToTrust) {
for (Jid jid : contactJids) {
Map<String, Boolean> fingerprints = foreignKeysToTrust.get(jid);
if (hasNoOtherTrustedKeys(jid) && (fingerprints == null || !fingerprints.values().contains(true))) {
lock();
return;
}
}
}
unlock();
}
private void setDone() {
2018-02-17 19:41:46 +00:00
binding.saveButton.setText(getString(R.string.done));
}
private void setFetching() {
2018-02-17 19:41:46 +00:00
binding.saveButton.setText(getString(R.string.fetching_keys));
}
}