Account switching: prototype findings and test plan

static void startAuthorization(Activity activity, Account account)
        throws Exception {
  String state = randomUrlSafe(12);
  String verifier = randomUrlSafe(64);
  String challenge = base64Url(
      MessageDigest.getInstance("SHA-256")
          .digest(verifier.getBytes(US_ASCII)));

  boolean saved = pending.edit()
      .putString(KEY_ACCOUNT_ID, account.id)
      .putString(KEY_STATE, state)
      .putString(KEY_VERIFIER, verifier)
      .putLong(KEY_CREATED_AT, now())
      .commit();
  if (!saved) throw new IllegalStateException("pending state");

  setCallbackEnabled(activity, true);
  activity.startActivity(browserIntent(
      authorizationUri(state, challenge)));
}

static CallbackResult consumeCallback(Context context, Uri callback) {
  String expectedState = pending.getString(KEY_STATE, null);
  String returnedState = first(callback, "state");
  long createdAt = pending.getLong(KEY_CREATED_AT, 0);

  if (now() - createdAt > MAX_PENDING_AGE_MS) {
    pending.edit().clear().commit();
    return failure("sign-in expired");
  }
  if (!constantTimeEquals(expectedState, returnedState)) {
    return failure("OAuth state mismatch");
  }

  pending.edit().clear().commit();
  return success(accountId, code, verifier);
}

void put(String recordId, String plaintext) throws Exception {
  Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
  cipher.init(Cipher.ENCRYPT_MODE, getOrCreateKey());

  byte[] ciphertext = cipher.doFinal(plaintext.getBytes(UTF_8));
  byte[] iv = cipher.getIV();
  ByteBuffer packed = ByteBuffer.allocate(1 + iv.length + ciphertext.length);
  packed.put((byte) iv.length).put(iv).put(ciphertext);

  preferences.edit()
      .putString(recordId, Base64.encodeToString(packed.array(), NO_WRAP))
      .commit();
}

Result switchAndRelaunch(Account account) {
  boolean prepared = false;
  String stage = "prepare";
  try {
    String credential = secureStore.get(recordFor(account));
    if (credential == null) return failure("credential-missing");

    credential = refreshCredential(credential);
    prepared = installer.prepare(credential);
    if (!prepared) return failure(installer.getLastError());

    stage = "startup-check";
    if (!rootBridge.coldStartPokemonGo()) {
      installer.rollback();
      return failure(stage);
    }

    installer.commit();
    accounts.setSelectedId(account.id);
    return success("ready");
  } catch (Exception error) {
    if (prepared) installer.rollback();
    return failure(stage);
  }
}

switchAccount(target):
  acquire device switch lock
  stop Pokémon GO or abort
  persist stage = "stopped"
  preserve and verify previous session or abort
  apply and verify target session
  launch Pokémon GO
  wait for runtime readiness
  observed = read active account identity

  if observed matches expected:
      persist stage = "verified"
      remove temporary backup
      report verified switch success
  else:
      stop Pokémon GO
      restore and verify previous session
      record rollback result
      keep switch result unresolved

run_id
device_model
android_version
pokemon_go_version
controller_version

source_account_id_hash
target_account_id_hash
expected_identity_hash
observed_identity_hash

transaction_stage
switch_started_at
game_launched_at
identity_checked_at
switch_duration_ms

result
failure_code
rollback_attempted
rollback_succeeded
switch_reported_success
wrong_account_detected
identity_unknown
session_corruption_detected