Java IdentityKey类代码示例

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
public void setMismatchedIdentity(long messageId, final long recipientId, final IdentityKey identityKey) {
  List<IdentityKeyMismatch> items = new ArrayList<IdentityKeyMismatch>() {{
    add(new IdentityKeyMismatch(recipientId, identityKey));
  }};

  IdentityKeyMismatchList document = new IdentityKeyMismatchList(items);

  SQLiteDatabase database = databaseHelper.getWritableDatabase();
  database.beginTransaction();

  try {
    setDocument(database, messageId, MISMATCHED_IDENTITIES, document);

    database.setTransactionSuccessful();
  } catch (IOException ioe) {
    Log.w(TAG, ioe);
  } finally {
    database.endTransaction();
  }
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
@Override
public boolean isTrustedIdentity(SignalProtocolAddress address, IdentityKey identityKey) {
  long    recipientId = RecipientFactory.getRecipientsFromString(context, address.getName(), true).getPrimaryRecipient().getRecipientId();
  boolean trusted     = DatabaseFactory.getIdentityDatabase(context)
                                       .isValidIdentity(recipientId, identityKey);

  if (trusted) {
    return true;
  } else if (!TextSecurePreferences.isBlockingIdentityUpdates(context)) {
    saveIdentity(address, identityKey);
    new TextSecureSessionStore(context).deleteAllSessions(address.getName());

    ApplicationContext.getInstance(context)
                      .getJobManager()
                      .add(new IdentityUpdateJob(context, recipientId));

    return true;
  } else {
    return false;
  }
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
public void setUntrustedIdentity(Recipient personInfo, IdentityKey untrustedIdentity) {
  String          name            = recipient.toShortString();
  String          introduction    = String.format(getContext().getString(R.string.WebRtcCallScreen_new_safety_numbers), name, name);
  SpannableString spannableString = new SpannableString(introduction + " " + getContext().getString(R.string.WebRtcCallScreen_you_may_wish_to_verify_this_contact));

  spannableString.setSpan(new VerifySpan(getContext(), personInfo.getRecipientId(), untrustedIdentity),
                          introduction.length()+1, spannableString.length(),
                          Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);

  setPersonInfo(personInfo);

  this.incomingCallOverlay.setActiveCall();
  this.status.setText(R.string.WebRtcCallScreen_new_safety_number_title);
  this.untrustedIdentityContainer.setVisibility(View.VISIBLE);
  this.untrustedIdentityExplanation.setText(spannableString);
  this.untrustedIdentityExplanation.setMovementMethod(LinkMovementMethod.getInstance());

  this.endCallButton.setVisibility(View.INVISIBLE);
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
public void registerPreKeys(IdentityKey identityKey,
                            PreKeyRecord lastResortKey,
                            SignedPreKeyRecord signedPreKey,
                            List<PreKeyRecord> records)
    throws IOException
{
  List<PreKeyEntity> entities = new LinkedList<>();

  for (PreKeyRecord record : records) {
    PreKeyEntity entity = new PreKeyEntity(record.getId(),
                                           record.getKeyPair().getPublicKey());

    entities.add(entity);
  }

  PreKeyEntity lastResortEntity = new PreKeyEntity(lastResortKey.getId(),
                                                   lastResortKey.getKeyPair().getPublicKey());

  SignedPreKeyEntity signedPreKeyEntity = new SignedPreKeyEntity(signedPreKey.getId(),
                                                                 signedPreKey.getKeyPair().getPublicKey(),
                                                                 signedPreKey.getSignature());

  makeRequest(String.format(PREKEY_PATH, ""), "PUT",
              JsonUtil.toJson(new PreKeyState(entities, lastResortEntity,
                                              signedPreKeyEntity, identityKey)));
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
public void saveIdentity(long recipientId, IdentityKey identityKey, VerifiedStatus verifiedStatus,
                         boolean firstUse, long timestamp, boolean nonBlockingApproval)
{
  SQLiteDatabase database          = databaseHelper.getWritableDatabase();
  String         identityKeyString = Base64.encodeBytes(identityKey.serialize());

  ContentValues contentValues = new ContentValues();
  contentValues.put(RECIPIENT, recipientId);
  contentValues.put(IDENTITY_KEY, identityKeyString);
  contentValues.put(TIMESTAMP, timestamp);
  contentValues.put(VERIFIED, verifiedStatus.toInt());
  contentValues.put(NONBLOCKING_APPROVAL, nonBlockingApproval ? 1 : 0);
  contentValues.put(FIRST_USE, firstUse ? 1 : 0);

  database.replace(TABLE_NAME, null, contentValues);

  EventBus.getDefault().post(new IdentityRecord(recipientId, identityKey, verifiedStatus,
                                                firstUse, timestamp, nonBlockingApproval));
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
@Override
public boolean isTrustedIdentity(SignalProtocolAddress address, IdentityKey identityKey, Direction direction) {
  synchronized (LOCK) {
    IdentityDatabase identityDatabase = DatabaseFactory.getIdentityDatabase(context);
    long             recipientId      = RecipientFactory.getRecipientsFromString(context, address.getName(), true).getPrimaryRecipient().getRecipientId();
    String           ourNumber        = TextSecurePreferences.getLocalNumber(context);
    long             ourRecipientId   = RecipientFactory.getRecipientsFromString(context, ourNumber, true).getPrimaryRecipient().getRecipientId();

    if (ourRecipientId == recipientId || ourNumber.equals(address.getName())) {
      return identityKey.equals(IdentityKeyUtil.getIdentityKey(context));
    }

    switch (direction) {
      case SENDING:   return isTrustedForSending(identityKey, identityDatabase.getIdentity(recipientId));
      case RECEIVING: return true;
      default:        throw new AssertionError("Unknown direction: " + direction);
    }
  }
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
private boolean isTrustedForSending(IdentityKey identityKey, Optional<IdentityRecord> identityRecord) {
  if (!identityRecord.isPresent()) {
    Log.w(TAG, "Nothing here, returning true...");
    return true;
  }

  if (!identityKey.equals(identityRecord.get().getIdentityKey())) {
    Log.w(TAG, "Identity keys don't match...");
    return false;
  }

  if (identityRecord.get().getVerifiedStatus() == VerifiedStatus.UNVERIFIED) {
    Log.w(TAG, "Needs unverified approval!");
    return false;
  }

  if (isNonBlockingApprovalRequired(identityRecord.get())) {
    Log.w(TAG, "Needs non-blocking approval!");
    return false;
  }

  return true;
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
public static void saveIdentity(Context context, String number, IdentityKey identityKey) {
  synchronized (SESSION_LOCK) {
    IdentityKeyStore      identityKeyStore = new TextSecureIdentityKeyStore(context);
    SessionStore          sessionStore     = new TextSecureSessionStore(context);
    SignalProtocolAddress address          = new SignalProtocolAddress(number, 1);

    if (identityKeyStore.saveIdentity(address, identityKey)) {
      if (sessionStore.containsSession(address)) {
        SessionRecord sessionRecord = sessionStore.loadSession(address);
        sessionRecord.archiveCurrentState();

        sessionStore.storeSession(address, sessionRecord);
      }
    }
  }
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
@Override
public void onRun() throws IOException, UntrustedIdentityException {
  try {
    if (!TextSecurePreferences.isMultiDevice(context)) {
      Log.w(TAG, "Not multi device...");
      return;
    }

    if (destination == null) {
      Log.w(TAG, "No destination...");
      return;
    }

    String                        canonicalDestination = Util.canonicalizeNumber(context, destination);
    VerifiedMessage.VerifiedState verifiedState        = getVerifiedState(verifiedStatus);
    SignalServiceMessageSender    messageSender        = messageSenderFactory.create();
    VerifiedMessage               verifiedMessage      = new VerifiedMessage(canonicalDestination, new IdentityKey(identityKey, 0), verifiedState, timestamp);

    messageSender.sendMessage(SignalServiceSyncMessage.forVerified(verifiedMessage));
  } catch (InvalidNumberException | InvalidKeyException e) {
    throw new IOException(e);
  }
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
private Optional<VerifiedMessage> getVerifiedMessage(Recipient recipient, Optional<IdentityDatabase.IdentityRecord> identity) throws InvalidNumberException {
  if (!identity.isPresent()) return Optional.absent();

  String      destination = Util.canonicalizeNumber(context, recipient.getNumber());
  IdentityKey identityKey = identity.get().getIdentityKey();

  VerifiedMessage.VerifiedState state;

  switch (identity.get().getVerifiedStatus()) {
    case VERIFIED:   state = VerifiedMessage.VerifiedState.VERIFIED;   break;
    case UNVERIFIED: state = VerifiedMessage.VerifiedState.UNVERIFIED; break;
    case DEFAULT:    state = VerifiedMessage.VerifiedState.DEFAULT;    break;
    default: throw new AssertionError("Unknown state: " + identity.get().getVerifiedStatus());
  }

  return Optional.of(new VerifiedMessage(destination, identityKey, state, System.currentTimeMillis()));
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
private void handleIndividualRecipient(Recipient recipient)
    throws IOException, InvalidKeyException, InvalidNumberException
{
  String               number  = Util.canonicalizeNumber(context, recipient.getNumber());
  SignalServiceProfile profile = retrieveProfile(number);

  if (TextUtils.isEmpty(profile.getIdentityKey())) {
    Log.w(TAG, "Identity key is missing on profile!");
    return;
  }

  IdentityKey identityKey = new IdentityKey(Base64.decode(profile.getIdentityKey()), 0);

  if (!DatabaseFactory.getIdentityDatabase(context)
                      .getIdentity(recipient.getRecipientId())
                      .isPresent())
  {
    Log.w(TAG, "Still first use...");
    return;
  }

  IdentityUtil.saveIdentity(context, number, identityKey);
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
public IqPacket publishBundles(final SignedPreKeyRecord signedPreKeyRecord, final IdentityKey identityKey,
							   final Set<PreKeyRecord> preKeyRecords, final int deviceId, Bundle publishOptions) {
	final Element item = new Element("item");
	final Element bundle = item.addChild("bundle", AxolotlService.PEP_PREFIX);
	final Element signedPreKeyPublic = bundle.addChild("signedPreKeyPublic");
	signedPreKeyPublic.setAttribute("signedPreKeyId", signedPreKeyRecord.getId());
	ECPublicKey publicKey = signedPreKeyRecord.getKeyPair().getPublicKey();
	signedPreKeyPublic.setContent(Base64.encodeToString(publicKey.serialize(),Base64.DEFAULT));
	final Element signedPreKeySignature = bundle.addChild("signedPreKeySignature");
	signedPreKeySignature.setContent(Base64.encodeToString(signedPreKeyRecord.getSignature(),Base64.DEFAULT));
	final Element identityKeyElement = bundle.addChild("identityKey");
	identityKeyElement.setContent(Base64.encodeToString(identityKey.serialize(), Base64.DEFAULT));

	final Element prekeys = bundle.addChild("prekeys", AxolotlService.PEP_PREFIX);
	for(PreKeyRecord preKeyRecord:preKeyRecords) {
		final Element prekey = prekeys.addChild("preKeyPublic");
		prekey.setAttribute("preKeyId", preKeyRecord.getId());
		prekey.setContent(Base64.encodeToString(preKeyRecord.getKeyPair().getPublicKey().serialize(), Base64.DEFAULT));
	}

	return publish(AxolotlService.PEP_BUNDLES+":"+deviceId, item, publishOptions);
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
public Set<IdentityKey> loadIdentityKeys(Account account, String name, FingerprintStatus status) {
	Set<IdentityKey> identityKeys = new HashSet<>();
	Cursor cursor = getIdentityKeyCursor(account, name, false);

	while (cursor.moveToNext()) {
		if (status != null && !FingerprintStatus.fromCursor(cursor).equals(status)) {
			continue;
		}
		try {
			String key = cursor.getString(cursor.getColumnIndex(SQLiteAxolotlStore.KEY));
			if (key != null) {
				identityKeys.add(new IdentityKey(Base64.decode(key, Base64.DEFAULT), 0));
			} else {
				Log.d(Config.LOGTAG, AxolotlService.getLogprefix(account) + "Missing key (possibly preverified) in database for account" + account.getJid().toBareJid() + ", address: " + name);
			}
		} catch (InvalidKeyException e) {
			Log.d(Config.LOGTAG, AxolotlService.getLogprefix(account) + "Encountered invalid IdentityKey in database for account" + account.getJid().toBareJid() + ", address: " + name);
		}
	}
	cursor.close();

	return identityKeys;
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
private void putDevicesForJid(String bareJid, List<Integer> deviceIds, SQLiteAxolotlStore store) {
	for (Integer deviceId : deviceIds) {
		SignalProtocolAddress axolotlAddress = new SignalProtocolAddress(bareJid, deviceId);
		IdentityKey identityKey = store.loadSession(axolotlAddress).getSessionState().getRemoteIdentityKey();
		if(Config.X509_VERIFICATION) {
			X509Certificate certificate = store.getFingerprintCertificate(CryptoHelper.bytesToHex(identityKey.getPublicKey().serialize()));
			if (certificate != null) {
				Bundle information = CryptoHelper.extractCertificateInformation(certificate);
				try {
					final String cn = information.getString("subject_cn");
					final Jid jid = Jid.fromString(bareJid);
					Log.d(Config.LOGTAG,"setting common name for "+jid+" to "+cn);
					account.getRoster().getContact(jid).setCommonName(cn);
				} catch (final InvalidJidException ignored) {
					//ignored
				}
			}
		}
		this.put(axolotlAddress, new XmppAxolotlSession(account, store, axolotlAddress, identityKey));
	}
}
 

import org.whispersystems.libsignal.IdentityKey; //导入依赖的package包/类
/**
 * Save a remote client's identity key
 * <p/>
 * Store a remote client's identity key as trusted.
 *
 * @param address     The address of the remote client.
 * @param identityKey The remote client's identity key.
 * @return true on success
 */
@Override
public boolean saveIdentity(SignalProtocolAddress address, IdentityKey identityKey) {
	if (!mXmppConnectionService.databaseBackend.loadIdentityKeys(account, address.getName()).contains(identityKey)) {
		String fingerprint = CryptoHelper.bytesToHex(identityKey.getPublicKey().serialize());
		FingerprintStatus status = getFingerprintStatus(fingerprint);
		if (status == null) {
			if (mXmppConnectionService.blindTrustBeforeVerification() && !account.getAxolotlService().hasVerifiedKeys(address.getName())) {
				Log.d(Config.LOGTAG,account.getJid().toBareJid()+": blindly trusted "+fingerprint+" of "+address.getName());
				status = FingerprintStatus.createActiveTrusted();
			} else {
				status = FingerprintStatus.createActiveUndecided();
			}
		} else {
			status = status.toActive();
		}
		mXmppConnectionService.databaseBackend.storeIdentityKey(account, address.getName(), identityKey, status);
		trustCache.remove(fingerprint);
	}
	return true;
}