@oxyhq/core 12.7.0 → 12.9.0

package/src/crypto/__tests__/keyManager.cacheSafety.test.ts

@@ -0,0 +1,175 @@
+/**
+ * Cache-poisoning safety: a thrown read must never be cached as "no identity",
+ * and the create/import overwrite guards must read storage DIRECTLY (+ the
+ * marker), never a stale/poisoned cache — so a transient failure can never let
+ * onboarding silently overwrite a real identity.
+ */
+
+import { setPlatformOS } from '../../utils/platform';
+
+jest.mock(
+  'expo-secure-store',
+  () => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { createSecureStoreMock } = require('./identityMocks');
+    return createSecureStoreMock();
+  },
+  { virtual: true },
+);
+
+jest.mock(
+  'expo-crypto',
+  () => ({
+    __esModule: true,
+    getRandomBytes: (length: number) => {
+      const out = new Uint8Array(length);
+      for (let i = 0; i < length; i++) out[i] = (Math.random() * 256) & 0xff;
+      return out;
+    },
+    digestStringAsync: async () => '0'.repeat(64),
+    CryptoDigestAlgorithm: { SHA256: 'SHA-256' },
+  }),
+  { virtual: true },
+);
+
+jest.mock('@oxyhq/protocol', () => {
+  const actual = jest.requireActual('@oxyhq/protocol');
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { createAsyncStorageMock } = require('./identityMocks');
+  const asyncStorage = createAsyncStorageMock();
+  return {
+    __esModule: true,
+    ...actual,
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    loadExpoCrypto: async () => require('expo-crypto'),
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    loadSecureStore: async () => require('expo-secure-store'),
+    loadAsyncStorage: async () => ({ default: asyncStorage }),
+    loadSharedIdentityBridge: async () => null,
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    loadNodeCrypto: async () => require('crypto'),
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    getRandomBytesRN: (n: number) => require('expo-crypto').getRandomBytes(n),
+  };
+});
+
+const PRIMARY_SVC = 'oxy_identity';
+const V2_PRIV = 'oxy_identity_private_key_v2';
+const V2_PUB = 'oxy_identity_public_key_v2';
+
+interface SecureStoreTestHandle {
+  __resetStore__: () => void;
+  __getRaw__: (key: string, service?: string) => string | null;
+  __simulateKeystoreDeath__: (service: string) => void;
+  __failPlan__: { failKey?: string; failOp?: 'set' | 'get'; failTimes?: number; failService?: string };
+}
+
+describe('KeyManager cache-poisoning safety', () => {
+  let KeyManager: typeof import('../keyManager').KeyManager;
+  let IdentityAlreadyExistsError: typeof import('../keyManager').IdentityAlreadyExistsError;
+  let ss: SecureStoreTestHandle;
+
+  const km = () =>
+    KeyManager as unknown as {
+      cachedPublicKey: unknown;
+      cachedHasIdentity: unknown;
+      cachedPublicKeyResolved: unknown;
+    };
+  const resetCaches = () => {
+    km().cachedPublicKey = null;
+    km().cachedHasIdentity = null;
+    km().cachedPublicKeyResolved = false;
+  };
+
+  beforeAll(() => {
+    setPlatformOS('ios');
+    (globalThis as unknown as { navigator: unknown }).navigator = { product: 'ReactNative' };
+  });
+
+  beforeEach(async () => {
+    jest.resetModules();
+    setPlatformOS('ios');
+    ss = (await import('expo-secure-store' as string)) as unknown as SecureStoreTestHandle;
+    ss.__resetStore__();
+    const mod = await import('../keyManager');
+    KeyManager = mod.KeyManager;
+    IdentityAlreadyExistsError = mod.IdentityAlreadyExistsError;
+    resetCaches();
+  });
+
+  it('getPublicKey does NOT cache null when the read throws (a later read still succeeds)', async () => {
+    const pub = await KeyManager.createIdentity();
+    resetCaches();
+
+    ss.__failPlan__.failOp = 'get';
+    ss.__failPlan__.failKey = V2_PUB;
+    ss.__failPlan__.failService = PRIMARY_SVC;
+    await expect(KeyManager.getPublicKey()).rejects.toMatchObject({ name: 'IdentityUnavailableError' });
+
+    // Cache must NOT hold a null verdict — clearing the fault returns the key.
+    ss.__failPlan__.failKey = undefined;
+    ss.__failPlan__.failOp = undefined;
+    ss.__failPlan__.failService = undefined;
+    expect(await KeyManager.getPublicKey()).toBe(pub.toLowerCase());
+  });
+
+  it('getPublicKey caches a genuine-absent (successful empty) read as null', async () => {
+    // Fresh device: read succeeds empty → null, cacheable.
+    expect(await KeyManager.getPublicKey()).toBeNull();
+    // The resolved-null flag is set (distinct from a thrown read).
+    expect(km().cachedPublicKeyResolved).toBe(true);
+  });
+
+  it('createIdentity overwrite guard refuses over a POISONED cache (direct read finds the identity)', async () => {
+    await KeyManager.createIdentity();
+    // Poison the read cache as if a prior transient failure had "resolved null".
+    resetCaches();
+    km().cachedPublicKeyResolved = true; // getPublicKey would now claim "no identity"
+
+    await expect(KeyManager.createIdentity()).rejects.toBeInstanceOf(IdentityAlreadyExistsError);
+  });
+
+  it('createIdentity overwrite guard refuses (IdentityUnavailableError) when storage throws — never writes blind', async () => {
+    const pub = await KeyManager.createIdentity();
+    resetCaches();
+    ss.__failPlan__.failOp = 'get';
+    ss.__failPlan__.failKey = V2_PRIV;
+    ss.__failPlan__.failService = PRIMARY_SVC;
+
+    await expect(KeyManager.createIdentity()).rejects.toMatchObject({ name: 'IdentityUnavailableError' });
+
+    // The identity was untouched (no blind overwrite).
+    ss.__failPlan__.failKey = undefined;
+    ss.__failPlan__.failOp = undefined;
+    ss.__failPlan__.failService = undefined;
+    resetCaches();
+    expect(await KeyManager.getPublicKey()).toBe(pub.toLowerCase());
+  });
+
+  it('createIdentity refuses over a LOST identity (marker present, keys gone) — routes to recovery, not create', async () => {
+    await KeyManager.createIdentity();
+    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
+    resetCaches();
+
+    // Even with keys gone, the marker records an identity → refuse a blind create.
+    await expect(KeyManager.createIdentity()).rejects.toBeInstanceOf(IdentityAlreadyExistsError);
+  });
+
+  it('importKeyPair refuses a DIFFERENT key in the lost state, but ALLOWS re-importing the same (recovery)', async () => {
+    const pub = await KeyManager.createIdentity();
+    const originalPriv = await KeyManager.getPrivateKey();
+    if (!originalPriv) throw new Error('expected private key');
+    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
+    resetCaches();
+
+    // A different key over a lost identity → refuse.
+    const otherPriv = (await KeyManager.generateKeyPair()).privateKey;
+    await expect(KeyManager.importKeyPair(otherPriv)).rejects.toBeInstanceOf(IdentityAlreadyExistsError);
+
+    // The SAME key (recovery-by-phrase into the lost state) → allowed.
+    resetCaches();
+    const restored = await KeyManager.importKeyPair(originalPriv);
+    expect(restored).toBe(pub.toLowerCase());
+    expect(await KeyManager.getPublicKey()).toBe(pub.toLowerCase());
+  });
+});

package/src/crypto/__tests__/keyManager.identityStatus.test.ts

@@ -0,0 +1,217 @@
+/**
+ * getIdentityStatus tri-state (+ unavailable) verdict, the marker lifecycle, and
+ * the honest-typed-throw semantics of hasIdentity — the corruption-vs-fresh
+ * disambiguation that routing keys off of.
+ */
+
+import { setPlatformOS } from '../../utils/platform';
+
+jest.mock(
+  'expo-secure-store',
+  () => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { createSecureStoreMock } = require('./identityMocks');
+    return createSecureStoreMock();
+  },
+  { virtual: true },
+);
+
+jest.mock(
+  'expo-crypto',
+  () => ({
+    __esModule: true,
+    getRandomBytes: (length: number) => {
+      const out = new Uint8Array(length);
+      for (let i = 0; i < length; i++) out[i] = (Math.random() * 256) & 0xff;
+      return out;
+    },
+    digestStringAsync: async () => '0'.repeat(64),
+    CryptoDigestAlgorithm: { SHA256: 'SHA-256' },
+  }),
+  { virtual: true },
+);
+
+jest.mock('@oxyhq/protocol', () => {
+  const actual = jest.requireActual('@oxyhq/protocol');
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { createAsyncStorageMock } = require('./identityMocks');
+  const asyncStorage = createAsyncStorageMock();
+  return {
+    __esModule: true,
+    ...actual,
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    loadExpoCrypto: async () => require('expo-crypto'),
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    loadSecureStore: async () => require('expo-secure-store'),
+    loadAsyncStorage: async () => ({ default: asyncStorage }),
+    loadSharedIdentityBridge: async () => null,
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    loadNodeCrypto: async () => require('crypto'),
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    getRandomBytesRN: (n: number) => require('expo-crypto').getRandomBytes(n),
+  };
+});
+
+const PRIMARY_SVC = 'oxy_identity';
+const BACKUP_SVC = 'oxy_identity_backup';
+const V2_PRIV = 'oxy_identity_private_key_v2';
+const V2_PUB = 'oxy_identity_public_key_v2';
+
+interface SecureStoreTestHandle {
+  __resetStore__: () => void;
+  __getRaw__: (key: string, service?: string) => string | null;
+  __setRaw__: (key: string, value: string, service?: string) => void;
+  __simulateKeystoreDeath__: (service: string) => void;
+  __failPlan__: { failKey?: string; failOp?: 'set' | 'get'; failTimes?: number; failService?: string };
+}
+
+describe('KeyManager.getIdentityStatus + marker lifecycle', () => {
+  let KeyManager: typeof import('../keyManager').KeyManager;
+  let readIdentityMarker: typeof import('../identityMarker').readIdentityMarker;
+  let clearIdentityMarker: typeof import('../identityMarker').clearIdentityMarker;
+  let ss: SecureStoreTestHandle;
+
+  const resetCaches = () => {
+    const km = KeyManager as unknown as {
+      cachedPublicKey: unknown;
+      cachedHasIdentity: unknown;
+      cachedPublicKeyResolved: unknown;
+    };
+    km.cachedPublicKey = null;
+    km.cachedHasIdentity = null;
+    km.cachedPublicKeyResolved = false;
+  };
+
+  beforeAll(() => {
+    setPlatformOS('ios');
+    (globalThis as unknown as { navigator: unknown }).navigator = { product: 'ReactNative' };
+  });
+
+  beforeEach(async () => {
+    jest.resetModules();
+    setPlatformOS('ios');
+    ss = (await import('expo-secure-store' as string)) as unknown as SecureStoreTestHandle;
+    ss.__resetStore__();
+    const km = await import('../keyManager');
+    KeyManager = km.KeyManager;
+    // Dynamically import the marker module AFTER resetModules so it shares the
+    // SAME (post-reset) AsyncStorage instance KeyManager writes markers to.
+    const marker = await import('../identityMarker');
+    readIdentityMarker = marker.readIdentityMarker;
+    clearIdentityMarker = marker.clearIdentityMarker;
+    resetCaches();
+  });
+
+  it('reports absent on a genuinely fresh device (no keys, no marker)', async () => {
+    const status = await KeyManager.getIdentityStatus();
+    expect(status.state).toBe('absent');
+  });
+
+  it('reports present and writes a marker for a healthy identity', async () => {
+    const pub = await KeyManager.createIdentity();
+    const status = await KeyManager.getIdentityStatus();
+    expect(status).toEqual({ state: 'present', publicKey: pub.toLowerCase() });
+    const marker = await readIdentityMarker();
+    expect(marker?.publicKey.toLowerCase()).toBe(pub.toLowerCase());
+  });
+
+  it('backfills a MISSING marker on the first healthy read (origin: backfill)', async () => {
+    const pub = await KeyManager.createIdentity();
+    // Simulate a device whose loss/creation predated markers: drop the marker.
+    await clearIdentityMarker();
+    expect(await readIdentityMarker()).toBeNull();
+
+    const status = await KeyManager.getIdentityStatus();
+    expect(status.state).toBe('present');
+    const marker = await readIdentityMarker();
+    expect(marker?.publicKey.toLowerCase()).toBe(pub.toLowerCase());
+    expect(marker?.origin).toBe('backfill');
+  });
+
+  it('reports LOST when the keys are gone (keystore death) but the marker survives', async () => {
+    const pub = await KeyManager.createIdentity();
+    // Kill the primary keychain service — the marker in AsyncStorage survives.
+    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
+    resetCaches();
+
+    const status = await KeyManager.getIdentityStatus();
+    expect(status.state).toBe('lost');
+    if (status.state === 'lost') {
+      expect(status.marker.publicKey.toLowerCase()).toBe(pub.toLowerCase());
+    }
+  });
+
+  it('reports UNAVAILABLE on a storage throw and NEVER caches that verdict', async () => {
+    await KeyManager.createIdentity();
+    resetCaches();
+
+    // Make the primary read throw (migration already resolved to v2 above).
+    ss.__failPlan__.failOp = 'get';
+    ss.__failPlan__.failKey = V2_PUB;
+    ss.__failPlan__.failService = PRIMARY_SVC;
+    const unavailable = await KeyManager.getIdentityStatus();
+    expect(unavailable.state).toBe('unavailable');
+
+    // Clearing the fault yields a fresh, CORRECT verdict — proof it was not cached.
+    ss.__failPlan__.failKey = undefined;
+    ss.__failPlan__.failOp = undefined;
+    ss.__failPlan__.failService = undefined;
+    const present = await KeyManager.getIdentityStatus();
+    expect(present.state).toBe('present');
+  });
+
+  it('hasIdentity throws IdentityUnavailableError (not false) on a storage throw', async () => {
+    await KeyManager.createIdentity();
+    resetCaches();
+    ss.__failPlan__.failOp = 'get';
+    ss.__failPlan__.failKey = V2_PRIV;
+    ss.__failPlan__.failService = PRIMARY_SVC;
+    await expect(KeyManager.hasIdentity()).rejects.toMatchObject({ name: 'IdentityUnavailableError' });
+  });
+
+  describe('marker lifecycle', () => {
+    it('writes a create-origin marker on createIdentity', async () => {
+      const pub = await KeyManager.createIdentity();
+      const marker = await readIdentityMarker();
+      expect(marker?.publicKey.toLowerCase()).toBe(pub.toLowerCase());
+      expect(marker?.origin).toBe('create');
+    });
+
+    it('leaves the marker untouched when a persist rolls back', async () => {
+      const original = await KeyManager.createIdentity();
+      resetCaches();
+      // Fail the overwrite's primary write → rollback (marker must not change).
+      ss.__failPlan__.failOp = 'set';
+      ss.__failPlan__.failKey = V2_PRIV;
+      ss.__failPlan__.failService = PRIMARY_SVC;
+      await expect(KeyManager.createIdentity({ overwrite: true })).rejects.toBeDefined();
+
+      const marker = await readIdentityMarker();
+      expect(marker?.publicKey.toLowerCase()).toBe(original.toLowerCase());
+      expect(marker?.origin).toBe('create');
+    });
+
+    it('clears the marker on force deleteIdentity', async () => {
+      await KeyManager.createIdentity();
+      expect(await readIdentityMarker()).not.toBeNull();
+      await KeyManager.deleteIdentity(true, true, true);
+      expect(await readIdentityMarker()).toBeNull();
+    });
+
+    it('preserves onboardingComplete + createdAt across a same-identity re-persist', async () => {
+      const pub = await KeyManager.createIdentity();
+      const marker = await import('../identityMarker');
+      await marker.updateIdentityMarker({ onboardingComplete: true });
+      const before = await readIdentityMarker();
+      resetCaches();
+      // Re-import the same identity (idempotent refresh).
+      const priv = await KeyManager.getPrivateKey();
+      if (!priv) throw new Error('expected private key');
+      await KeyManager.importKeyPair(priv);
+      const after = await readIdentityMarker();
+      expect(after?.publicKey.toLowerCase()).toBe(pub.toLowerCase());
+      expect(after?.onboardingComplete).toBe(true);
+      expect(after?.createdAt).toBe(before?.createdAt);
+    });
+  });
+});

package/src/crypto/__tests__/keyManager.recoveryLadder.test.ts

@@ -0,0 +1,179 @@
+/**
+ * attemptIdentityRecovery — the ladder that restores a `lost` identity from an
+ * independent, key_v1-surviving source (backup slot, then cross-app shared slot)
+ * WITHOUT the recovery phrase. Every rung validates well-formed + derive-match +
+ * `publicKey === marker.publicKey`, so a source holding a DIFFERENT account is
+ * skipped (never a silent switch).
+ */
+
+import { setPlatformOS } from '../../utils/platform';
+
+jest.mock(
+  'expo-secure-store',
+  () => {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { createSecureStoreMock } = require('./identityMocks');
+    return createSecureStoreMock();
+  },
+  { virtual: true },
+);
+
+jest.mock(
+  'expo-crypto',
+  () => ({
+    __esModule: true,
+    getRandomBytes: (length: number) => {
+      const out = new Uint8Array(length);
+      for (let i = 0; i < length; i++) out[i] = (Math.random() * 256) & 0xff;
+      return out;
+    },
+    digestStringAsync: async () => '0'.repeat(64),
+    CryptoDigestAlgorithm: { SHA256: 'SHA-256' },
+  }),
+  { virtual: true },
+);
+
+jest.mock('@oxyhq/protocol', () => {
+  const actual = jest.requireActual('@oxyhq/protocol');
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { createAsyncStorageMock } = require('./identityMocks');
+  const asyncStorage = createAsyncStorageMock();
+  return {
+    __esModule: true,
+    ...actual,
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    loadExpoCrypto: async () => require('expo-crypto'),
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    loadSecureStore: async () => require('expo-secure-store'),
+    loadAsyncStorage: async () => ({ default: asyncStorage }),
+    loadSharedIdentityBridge: async () => null,
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    loadNodeCrypto: async () => require('crypto'),
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    getRandomBytesRN: (n: number) => require('expo-crypto').getRandomBytes(n),
+  };
+});
+
+const PRIMARY_SVC = 'oxy_identity';
+const BACKUP_SVC = 'oxy_identity_backup';
+const V2_PRIV = 'oxy_identity_private_key_v2';
+const V2_PUB = 'oxy_identity_public_key_v2';
+const V2_BPRIV = 'oxy_identity_backup_private_key_v2';
+const V2_BPUB = 'oxy_identity_backup_public_key_v2';
+
+interface SecureStoreTestHandle {
+  __resetStore__: () => void;
+  __getRaw__: (key: string, service?: string) => string | null;
+  __setRaw__: (key: string, value: string, service?: string) => void;
+  __simulateKeystoreDeath__: (service: string) => void;
+}
+
+describe('KeyManager.attemptIdentityRecovery (recovery ladder)', () => {
+  let KeyManager: typeof import('../keyManager').KeyManager;
+  let ss: SecureStoreTestHandle;
+
+  const resetCaches = () => {
+    const km = KeyManager as unknown as {
+      cachedPublicKey: unknown;
+      cachedHasIdentity: unknown;
+      cachedPublicKeyResolved: unknown;
+      cachedSharedPublicKey: unknown;
+      cachedHasSharedIdentity: unknown;
+    };
+    km.cachedPublicKey = null;
+    km.cachedHasIdentity = null;
+    km.cachedPublicKeyResolved = false;
+    km.cachedSharedPublicKey = null;
+    km.cachedHasSharedIdentity = null;
+  };
+
+  beforeAll(() => {
+    setPlatformOS('ios');
+    (globalThis as unknown as { navigator: unknown }).navigator = { product: 'ReactNative' };
+  });
+
+  beforeEach(async () => {
+    jest.resetModules();
+    setPlatformOS('ios');
+    ss = (await import('expo-secure-store' as string)) as unknown as SecureStoreTestHandle;
+    ss.__resetStore__();
+    const mod = await import('../keyManager');
+    KeyManager = mod.KeyManager;
+    resetCaches();
+  });
+
+  it('recovers from the BACKUP slot when the primary keychain key dies', async () => {
+    const pub = await KeyManager.createIdentity();
+    // Kill ONLY the primary service — the backup slot (independent key) survives.
+    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
+    resetCaches();
+
+    expect((await KeyManager.getIdentityStatus()).state).toBe('lost');
+    resetCaches();
+
+    const result = await KeyManager.attemptIdentityRecovery();
+    expect(result).toEqual({ recovered: true, source: 'backup', publicKey: pub.toLowerCase() });
+    expect((await KeyManager.getIdentityStatus()).state).toBe('present');
+    expect(ss.__getRaw__(V2_PRIV, PRIMARY_SVC)).toBe((await KeyManager.getPrivateKey()));
+  });
+
+  it('recovers from the SHARED slot when both primary and backup keys die', async () => {
+    await KeyManager.createIdentity();
+    const priv = await KeyManager.getPrivateKey();
+    if (!priv) throw new Error('expected private key');
+    const pub = KeyManager.derivePublicKey(priv);
+    // Mirror the identity into the cross-app shared slot (survives key_v1 death).
+    await KeyManager.importSharedIdentity(priv);
+
+    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
+    ss.__simulateKeystoreDeath__(BACKUP_SVC);
+    resetCaches();
+
+    expect((await KeyManager.getIdentityStatus()).state).toBe('lost');
+    resetCaches();
+
+    const result = await KeyManager.attemptIdentityRecovery();
+    expect(result).toEqual({ recovered: true, source: 'shared', publicKey: pub.toLowerCase() });
+    expect((await KeyManager.getIdentityStatus()).state).toBe('present');
+  });
+
+  it('SKIPS a source that holds a DIFFERENT account (never silently switches)', async () => {
+    await KeyManager.createIdentity();
+    // Plant a DIFFERENT identity B in both the backup and shared slots.
+    const b = await KeyManager.generateKeyPair();
+    ss.__setRaw__(V2_BPRIV, b.privateKey, BACKUP_SVC);
+    ss.__setRaw__(V2_BPUB, b.publicKey, BACKUP_SVC);
+    await KeyManager.importSharedIdentity(b.privateKey);
+
+    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
+    resetCaches();
+
+    const result = await KeyManager.attemptIdentityRecovery();
+    expect(result).toEqual({ recovered: false, reason: 'mismatch' });
+    // The primary was NOT switched to B.
+    expect(ss.__getRaw__(V2_PRIV, PRIMARY_SVC)).not.toBe(b.privateKey);
+  });
+
+  it('is a no-op when the identity is NOT lost (present)', async () => {
+    await KeyManager.createIdentity();
+    const result = await KeyManager.attemptIdentityRecovery();
+    expect(result).toEqual({ recovered: false, reason: 'not-lost' });
+  });
+
+  it('is a no-op on a genuinely absent (fresh) device', async () => {
+    const result = await KeyManager.attemptIdentityRecovery();
+    expect(result).toEqual({ recovered: false, reason: 'not-lost' });
+  });
+
+  it('reports no-sources when every recovery slot is empty or malformed', async () => {
+    await KeyManager.createIdentity();
+    // Corrupt the backup so it is not a valid candidate.
+    ss.__setRaw__(V2_BPRIV, 'zz-not-hex', BACKUP_SVC);
+    ss.__setRaw__(V2_BPUB, 'garbage', BACKUP_SVC);
+    ss.__simulateKeystoreDeath__(PRIMARY_SVC);
+    resetCaches();
+
+    const result = await KeyManager.attemptIdentityRecovery();
+    expect(result).toEqual({ recovered: false, reason: 'no-sources' });
+  });
+});