Java SessionRecord.archiveCurrentState方法代码示例

import org.whispersystems.libaxolotl.state.SessionRecord; //导入方法依赖的package包/类
private Optional<Integer> processV3(SessionRecord sessionRecord, PreKeyWhisperMessage message)
    throws UntrustedIdentityException, InvalidKeyIdException, InvalidKeyException
{

  if (sessionRecord.hasSessionState(message.getMessageVersion(), message.getBaseKey().serialize())) {
    Log.w(TAG, "We've already setup a session for this V3 message, letting bundled message fall through...");
    return Optional.absent();
  }

  ECKeyPair ourSignedPreKey = signedPreKeyStore.loadSignedPreKey(message.getSignedPreKeyId()).getKeyPair();

  BobAxolotlParameters.Builder parameters = BobAxolotlParameters.newBuilder();

  parameters.setTheirBaseKey(message.getBaseKey())
            .setTheirIdentityKey(message.getIdentityKey())
            .setOurIdentityKey(identityKeyStore.getIdentityKeyPair())
            .setOurSignedPreKey(ourSignedPreKey)
            .setOurRatchetKey(ourSignedPreKey);

  if (message.getPreKeyId().isPresent()) {
    parameters.setOurOneTimePreKey(Optional.of(preKeyStore.loadPreKey(message.getPreKeyId().get()).getKeyPair()));
  } else {
    parameters.setOurOneTimePreKey(Optional.<ECKeyPair>absent());
  }

  if (!sessionRecord.isFresh()) sessionRecord.archiveCurrentState();

  RatchetingSession.initializeSession(sessionRecord.getSessionState(), message.getMessageVersion(), parameters.create());

  sessionRecord.getSessionState().setLocalRegistrationId(identityKeyStore.getLocalRegistrationId());
  sessionRecord.getSessionState().setRemoteRegistrationId(message.getRegistrationId());
  sessionRecord.getSessionState().setAliceBaseKey(message.getBaseKey().serialize());

  if (message.getPreKeyId().isPresent() && message.getPreKeyId().get() != Medium.MAX_VALUE) {
    return message.getPreKeyId();
  } else {
    return Optional.absent();
  }
}
 

import org.whispersystems.libaxolotl.state.SessionRecord; //导入方法依赖的package包/类
private Optional<Integer> processV2(SessionRecord sessionRecord, PreKeyWhisperMessage message)
    throws UntrustedIdentityException, InvalidKeyIdException, InvalidKeyException
{
  if (!message.getPreKeyId().isPresent()) {
    throw new InvalidKeyIdException("V2 message requires one time prekey id!");
  }

  if (!preKeyStore.containsPreKey(message.getPreKeyId().get()) &&
      sessionStore.containsSession(recipientId, deviceId))
  {
    Log.w(TAG, "We've already processed the prekey part of this V2 session, letting bundled message fall through...");
    return Optional.absent();
  }

  ECKeyPair ourPreKey = preKeyStore.loadPreKey(message.getPreKeyId().get()).getKeyPair();

  BobAxolotlParameters.Builder parameters = BobAxolotlParameters.newBuilder();

  parameters.setOurIdentityKey(identityKeyStore.getIdentityKeyPair())
            .setOurSignedPreKey(ourPreKey)
            .setOurRatchetKey(ourPreKey)
            .setOurOneTimePreKey(Optional.<ECKeyPair>absent())
            .setTheirIdentityKey(message.getIdentityKey())
            .setTheirBaseKey(message.getBaseKey());

  if (!sessionRecord.isFresh()) sessionRecord.archiveCurrentState();

  RatchetingSession.initializeSession(sessionRecord.getSessionState(), message.getMessageVersion(), parameters.create());

  sessionRecord.getSessionState().setLocalRegistrationId(identityKeyStore.getLocalRegistrationId());
  sessionRecord.getSessionState().setRemoteRegistrationId(message.getRegistrationId());
  sessionRecord.getSessionState().setAliceBaseKey(message.getBaseKey().serialize());

  if (message.getPreKeyId().get() != Medium.MAX_VALUE) {
    return message.getPreKeyId();
  } else {
    return Optional.absent();
  }
}
 

import org.whispersystems.libaxolotl.state.SessionRecord; //导入方法依赖的package包/类
/**
 * Build a new session from a {@link org.whispersystems.libaxolotl.state.PreKeyBundle} retrieved from
 * a server.
 *
 * @param preKey A PreKey for the destination recipient, retrieved from a server.
 * @throws InvalidKeyException when the {@link org.whispersystems.libaxolotl.state.PreKeyBundle} is
 *                             badly formatted.
 * @throws org.whispersystems.libaxolotl.UntrustedIdentityException when the sender's
 *                                                                  {@link IdentityKey} is not
 *                                                                  trusted.
 */
public void process(PreKeyBundle preKey) throws InvalidKeyException, UntrustedIdentityException {
  synchronized (SessionCipher.SESSION_LOCK) {
    if (!identityKeyStore.isTrustedIdentity(recipientId, preKey.getIdentityKey())) {
      throw new UntrustedIdentityException();
    }

    if (preKey.getSignedPreKey() != null &&
        !Curve.verifySignature(preKey.getIdentityKey().getPublicKey(),
                               preKey.getSignedPreKey().serialize(),
                               preKey.getSignedPreKeySignature()))
    {
      throw new InvalidKeyException("Invalid signature on device key!");
    }

    if (preKey.getSignedPreKey() == null && preKey.getPreKey() == null) {
      throw new InvalidKeyException("Both signed and unsigned prekeys are absent!");
    }

    boolean               supportsV3           = preKey.getSignedPreKey() != null;
    SessionRecord         sessionRecord        = sessionStore.loadSession(recipientId, deviceId);
    ECKeyPair             ourBaseKey           = Curve.generateKeyPair();
    ECPublicKey           theirSignedPreKey    = supportsV3 ? preKey.getSignedPreKey() : preKey.getPreKey();
    Optional<ECPublicKey> theirOneTimePreKey   = Optional.fromNullable(preKey.getPreKey());
    Optional<Integer>     theirOneTimePreKeyId = theirOneTimePreKey.isPresent() ? Optional.of(preKey.getPreKeyId()) :
                                                                                  Optional.<Integer>absent();

    AliceAxolotlParameters.Builder parameters = AliceAxolotlParameters.newBuilder();

    parameters.setOurBaseKey(ourBaseKey)
              .setOurIdentityKey(identityKeyStore.getIdentityKeyPair())
              .setTheirIdentityKey(preKey.getIdentityKey())
              .setTheirSignedPreKey(theirSignedPreKey)
              .setTheirRatchetKey(theirSignedPreKey)
              .setTheirOneTimePreKey(supportsV3 ? theirOneTimePreKey : Optional.<ECPublicKey>absent());

    if (!sessionRecord.isFresh()) sessionRecord.archiveCurrentState();

    RatchetingSession.initializeSession(sessionRecord.getSessionState(),
                                        supportsV3 ? 3 : 2,
                                        parameters.create());

    sessionRecord.getSessionState().setUnacknowledgedPreKeyMessage(theirOneTimePreKeyId, preKey.getSignedPreKeyId(), ourBaseKey.getPublicKey());
    sessionRecord.getSessionState().setLocalRegistrationId(identityKeyStore.getLocalRegistrationId());
    sessionRecord.getSessionState().setRemoteRegistrationId(preKey.getRegistrationId());
    sessionRecord.getSessionState().setAliceBaseKey(ourBaseKey.getPublicKey().serialize());

    sessionStore.storeSession(recipientId, deviceId, sessionRecord);
    identityKeyStore.saveIdentity(recipientId, preKey.getIdentityKey());
  }
}
 

import org.whispersystems.libaxolotl.state.SessionRecord; //导入方法依赖的package包/类
private KeyExchangeMessage processInitiate(KeyExchangeMessage message) throws InvalidKeyException {
  int           flags         = KeyExchangeMessage.RESPONSE_FLAG;
  SessionRecord sessionRecord = sessionStore.loadSession(recipientId, deviceId);

  if (message.getVersion() >= 3 &&
      !Curve.verifySignature(message.getIdentityKey().getPublicKey(),
                             message.getBaseKey().serialize(),
                             message.getBaseKeySignature()))
  {
    throw new InvalidKeyException("Bad signature!");
  }

  SymmetricAxolotlParameters.Builder builder = SymmetricAxolotlParameters.newBuilder();

  if (!sessionRecord.getSessionState().hasPendingKeyExchange()) {
    builder.setOurIdentityKey(identityKeyStore.getIdentityKeyPair())
           .setOurBaseKey(Curve.generateKeyPair())
           .setOurRatchetKey(Curve.generateKeyPair());
  } else {
    builder.setOurIdentityKey(sessionRecord.getSessionState().getPendingKeyExchangeIdentityKey())
           .setOurBaseKey(sessionRecord.getSessionState().getPendingKeyExchangeBaseKey())
           .setOurRatchetKey(sessionRecord.getSessionState().getPendingKeyExchangeRatchetKey());
    flags |= KeyExchangeMessage.SIMULTAENOUS_INITIATE_FLAG;
  }

  builder.setTheirBaseKey(message.getBaseKey())
         .setTheirRatchetKey(message.getRatchetKey())
         .setTheirIdentityKey(message.getIdentityKey());

  SymmetricAxolotlParameters parameters = builder.create();

  if (!sessionRecord.isFresh()) sessionRecord.archiveCurrentState();

  RatchetingSession.initializeSession(sessionRecord.getSessionState(),
                                      Math.min(message.getMaxVersion(), CiphertextMessage.CURRENT_VERSION),
                                      parameters);

  sessionStore.storeSession(recipientId, deviceId, sessionRecord);
  identityKeyStore.saveIdentity(recipientId, message.getIdentityKey());

  byte[] baseKeySignature = Curve.calculateSignature(parameters.getOurIdentityKey().getPrivateKey(),
                                                     parameters.getOurBaseKey().getPublicKey().serialize());

  return new KeyExchangeMessage(sessionRecord.getSessionState().getSessionVersion(),
                                message.getSequence(), flags,
                                parameters.getOurBaseKey().getPublicKey(),
                                baseKeySignature, parameters.getOurRatchetKey().getPublicKey(),
                                parameters.getOurIdentityKey().getPublicKey());
}
 

import org.whispersystems.libaxolotl.state.SessionRecord; //导入方法依赖的package包/类
private void processResponse(KeyExchangeMessage message)
    throws StaleKeyExchangeException, InvalidKeyException
{
  SessionRecord sessionRecord                  = sessionStore.loadSession(recipientId, deviceId);
  SessionState  sessionState                   = sessionRecord.getSessionState();
  boolean       hasPendingKeyExchange          = sessionState.hasPendingKeyExchange();
  boolean       isSimultaneousInitiateResponse = message.isResponseForSimultaneousInitiate();

  if (!hasPendingKeyExchange || sessionState.getPendingKeyExchangeSequence() != message.getSequence()) {
    Log.w(TAG, "No matching sequence for response. Is simultaneous initiate response: " + isSimultaneousInitiateResponse);
    if (!isSimultaneousInitiateResponse) throw new StaleKeyExchangeException();
    else                                 return;
  }

  SymmetricAxolotlParameters.Builder parameters = SymmetricAxolotlParameters.newBuilder();

  parameters.setOurBaseKey(sessionRecord.getSessionState().getPendingKeyExchangeBaseKey())
            .setOurRatchetKey(sessionRecord.getSessionState().getPendingKeyExchangeRatchetKey())
            .setOurIdentityKey(sessionRecord.getSessionState().getPendingKeyExchangeIdentityKey())
            .setTheirBaseKey(message.getBaseKey())
            .setTheirRatchetKey(message.getRatchetKey())
            .setTheirIdentityKey(message.getIdentityKey());

  if (!sessionRecord.isFresh()) sessionRecord.archiveCurrentState();

  RatchetingSession.initializeSession(sessionRecord.getSessionState(),
                                      Math.min(message.getMaxVersion(), CiphertextMessage.CURRENT_VERSION),
                                      parameters.create());

  if (sessionRecord.getSessionState().getSessionVersion() >= 3 &&
      !Curve.verifySignature(message.getIdentityKey().getPublicKey(),
                             message.getBaseKey().serialize(),
                             message.getBaseKeySignature()))
  {
    throw new InvalidKeyException("Base key signature doesn't match!");
  }

  sessionStore.storeSession(recipientId, deviceId, sessionRecord);
  identityKeyStore.saveIdentity(recipientId, message.getIdentityKey());

}