ds-harness-remote-fast/packages/plugin/tests/identity-store.test.ts

1076 lines
60 KiB
TypeScript

import { spawn } from 'node:child_process'
import { createHash } from 'node:crypto'
import { once } from 'node:events'
import { chmod, link, mkdir, mkdtemp, readFile, readdir, rename, rm, stat, symlink, truncate, writeFile } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { dirname, join } from 'node:path'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { IdentityInvalidError, IdentityStore, prepareDefaultIdentityDirectory, resetDefaultIdentityRoles, serverStorageDirectory } from '../src/identity-store.js'
import { ServerCredentialStore } from '../src/server-credentials.js'
vi.mock('node:fs/promises', async importOriginal => {
const actual = await importOriginal<typeof import('node:fs/promises')>()
return { ...actual, rename: vi.fn(actual.rename) }
})
const directories: string[] = []
async function mockMoveFailure(source: string, target: string, code: string, createTarget = false): Promise<void> {
const actual = await vi.importActual<typeof import('node:fs/promises')>('node:fs/promises')
let pending = true
vi.mocked(rename).mockImplementation(async (from, to) => {
if (pending && from === source && to === target) {
pending = false
if (createTarget) await mkdir(target)
throw Object.assign(createTarget ? new IdentityInvalidError('destination appeared') : new Error('move unavailable'), { code })
}
return actual.rename(from, to)
})
}
afterEach(async () => {
await Promise.all(directories.splice(0).map(directory => rm(directory, { recursive: true, force: true })))
})
describe('IdentityStore', () => {
it('moves all Server roles without changing identities, trust or credential bytes, and serializes repeated migration', async () => {
const home = await temporaryDirectory()
const env = { DSH_HOME: home }
const source = join(home, 'remote')
const target = join(home, 'ds-harness-remote')
const records: Array<{ directory: string; identity: Awaited<ReturnType<IdentityStore['loadOrCreate']>>; peers: unknown; files: Map<string, Buffer> }> = []
for (const origin of ['https://first.example.com', 'https://second.example.com']) {
for (const role of ['host', 'client'] as const) {
const directory = serverStorageDirectory(source, origin, role)
const store = new IdentityStore({ directory })
const identity = await store.loadOrCreate('Host')
await store.trustPeer({ deviceId: identity.deviceId, name: 'Peer', platform: 'linux', publicKey: identity.publicKey })
await new ServerCredentialStore(directory).save({ serverUrl: origin, deviceId: identity.deviceId, authorizationMethod: 'owned_device', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2 })
const files = new Map<string, Buffer>()
for (const file of await readdir(directory)) files.set(file, await readFile(join(directory, file)))
records.push({ directory, identity, peers: store.listTrustedPeers(), files })
}
}
await expect(stat(target)).rejects.toMatchObject({ code: 'ENOENT' })
expect(await Promise.all(Array.from({ length: 3 }, () => prepareDefaultIdentityDirectory({ env })))).toEqual([target, target, target])
await expect(stat(source)).rejects.toMatchObject({ code: 'ENOENT' })
for (const record of records) {
const directory = record.directory.replace(source, target)
for (const [file, bytes] of record.files) expect(await readFile(join(directory, file))).toEqual(bytes)
const store = new IdentityStore({ directory })
expect(await store.loadOrCreate('Host')).toEqual(record.identity)
expect(store.listTrustedPeers()).toEqual(record.peers)
if (process.platform !== 'win32') expect((await stat(join(directory, 'device.key'))).mode & 0o777).toBe(0o600)
}
expect(new IdentityStore({ env }).directory).toBe(target)
expect(await prepareDefaultIdentityDirectory({ env })).toBe(target)
})
it('migrates interrupted peer writes for flat, host and client storage and cleans only known temporaries', async () => {
const dead = await deadPid()
for (const role of ['flat', 'host', 'client'] as const) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const directory = role === 'flat' ? source : serverStorageDirectory(source, 'https://example.com', role)
const store = new IdentityStore({ directory })
const identity = await store.loadOrCreate('Host')
await store.trustPeer({ deviceId: identity.deviceId, name: 'Peer', platform: 'linux', publicKey: identity.publicKey })
const peers = await readFile(join(directory, 'trusted-peers.json'))
const temps = [
`trusted-peers.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000001.tmp`,
`server-credentials.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000002.tmp`,
`device.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000003.tmp`,
`device.key.${dead}.01a1b6d8-e8b5-7000-8000-000000000004.tmp`,
`host-pairing.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000005.tmp`,
`pairing-host-only.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000006.tmp`,
]
for (const temp of temps) {
await writeFile(join(directory, temp), '{partial', { mode: 0o600 })
}
const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
const moved = directory.replace(source, target)
for (const temp of temps) {
expect(await readFile(join(moved, temp), 'utf8')).toBe('{partial')
}
const reopened = new IdentityStore({ directory: moved })
expect(await reopened.loadOrCreate('Host')).toEqual(identity)
expect(await readFile(join(moved, 'trusted-peers.json'))).toEqual(peers)
const remaining = await readdir(moved)
for (const temp of temps) {
expect(remaining).not.toContain(temp)
}
}
})
it('preserves in-flight credential and peer temporary files owned by a live process until rename completes', async () => {
const directory = await temporaryDirectory()
const store = new IdentityStore({ directory })
const identity = await store.loadOrCreate('Host')
const inFlightCredTemp = `server-credentials.json.${process.pid}.01a1b6d8-e8b5-7000-8000-000000000002.tmp`
const inFlightPeerTemp = `trusted-peers.json.${process.pid}.01a1b6d8-e8b5-7000-8000-000000000001.tmp`
const dead = await deadPid()
const staleCredTemp = `server-credentials.json.${dead}.01a1b6d8-e8b5-7000-8000-000000000003.tmp`
await writeFile(join(directory, inFlightCredTemp), '{"schemaVersion":1}\n', { mode: 0o600 })
await writeFile(join(directory, inFlightPeerTemp), '{"schemaVersion":1,"peers":[]}\n', { mode: 0o600 })
await writeFile(join(directory, staleCredTemp), '{partial', { mode: 0o600 })
// Concurrent loadOrCreate runs removeStaleTemporaries; live PID temps must survive so rename succeeds.
expect(await new IdentityStore({ directory }).loadOrCreate('Host')).toEqual(identity)
const afterLoad = await readdir(directory)
expect(afterLoad).toContain(inFlightCredTemp)
expect(afterLoad).toContain(inFlightPeerTemp)
expect(afterLoad).not.toContain(staleCredTemp)
await rename(join(directory, inFlightPeerTemp), join(directory, 'trusted-peers.json'))
await rename(join(directory, inFlightCredTemp), join(directory, 'server-credentials.json'))
// Migration must also refuse to move legacy storage while a live process has an unrenamed temp file.
const home = await temporaryDirectory()
const source = join(home, 'remote')
const hostIdentity = await new IdentityStore({ directory: source }).loadOrCreate('Host')
const liveMigrationTemp = join(source, inFlightCredTemp)
const validCredPayload = JSON.stringify({
schemaVersion: 1,
serverUrl: 'https://dsh.r2049.cn',
deviceId: hostIdentity.deviceId,
authorizationMethod: 'account',
account: 'host@example.com',
accessToken: 'fixture-access-token',
accessTokenExpiresAt: 1,
refreshToken: 'fixture-refresh-token',
refreshTokenExpiresAt: 2,
})
await writeFile(liveMigrationTemp, `${validCredPayload}\n`, { mode: 0o600 })
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).rejects.toMatchObject({
code: 'IDENTITY_LOCKED',
})
await rename(liveMigrationTemp, join(source, 'server-credentials.json'))
await chmod(join(source, 'server-credentials.json'), 0o600)
expect(await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).toBe(join(home, 'ds-harness-remote'))
})
it('reclaims exited-owner identity and interrupted real-hash takeover locks during migration and runtime load while preserving live lock and concurrent takeover protection', async () => {
const [deadOwner, deadContender, deadSecondContender] = await deadPids()
expect(new Set([deadOwner, deadContender, deadSecondContender]).size).toBe(3)
const lockRecord = `${deadOwner}\n`
const takeoverRecord = `${deadContender}\n`
const realTakeover = `device.lock.takeover-${createHash('sha256').update(lockRecord).digest('hex').slice(0, 16)}`
const secondTakeover = `device.lock.takeover-${createHash('sha256').update(`${realTakeover}\n${takeoverRecord}`).digest('hex').slice(0, 16)}`
const serverUrl = 'https://example.com'
for (const role of ['flat', 'host', 'client'] as const) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const directory = role === 'flat' ? source : serverStorageDirectory(source, serverUrl, role)
const store = new IdentityStore({ directory, role: role === 'flat' ? undefined : role })
const identity = await store.loadOrCreate('Host')
await store.trustPeer({ deviceId: identity.deviceId, name: 'Peer', platform: 'linux', publicKey: identity.publicKey })
const credentials = await new ServerCredentialStore(directory).save({
serverUrl,
deviceId: identity.deviceId,
authorizationMethod: 'owned_device',
accessToken: 'fixture-access-token',
accessTokenExpiresAt: 1,
refreshToken: 'fixture-refresh-token',
refreshTokenExpiresAt: 2,
})
const deviceJsonBytes = await readFile(join(directory, 'device.json'))
const deviceKeyBytes = await readFile(join(directory, 'device.key'))
const peersBytes = await readFile(join(directory, 'trusted-peers.json'))
const credentialBytes = await readFile(join(directory, 'server-credentials.json'))
await writeFile(join(directory, 'device.lock'), lockRecord, { mode: 0o600 })
await writeFile(join(directory, realTakeover), takeoverRecord, { mode: 0o600 })
await writeFile(join(directory, secondTakeover), `${deadSecondContender}\n`, { mode: 0o600 })
const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
expect(target).toBe(join(home, 'ds-harness-remote'))
const moved = directory.replace(source, target)
expect(await readdir(moved)).not.toContain('device.lock')
expect(await readdir(moved)).not.toContain(realTakeover)
expect(await readdir(moved)).not.toContain(secondTakeover)
expect(await readFile(join(moved, 'device.json'))).toEqual(deviceJsonBytes)
expect(await readFile(join(moved, 'device.key'))).toEqual(deviceKeyBytes)
expect(await readFile(join(moved, 'trusted-peers.json'))).toEqual(peersBytes)
expect(await readFile(join(moved, 'server-credentials.json'))).toEqual(credentialBytes)
// Also verify direct runtime withIdentityLock recovery when device.lock and chained real-hash takeover files remain.
await writeFile(join(moved, 'device.lock'), lockRecord, { mode: 0o600 })
await writeFile(join(moved, realTakeover), takeoverRecord, { mode: 0o600 })
await writeFile(join(moved, secondTakeover), `${deadSecondContender}\n`, { mode: 0o600 })
const reopened = new IdentityStore({ directory: moved, role: role === 'flat' ? undefined : role })
expect(await reopened.loadOrCreate('Host')).toEqual(identity)
expect(reopened.listTrustedPeers()).toEqual(store.listTrustedPeers())
expect(await new ServerCredentialStore(moved).load(serverUrl, identity.deviceId)).toEqual(credentials)
expect(await readdir(moved)).not.toContain('device.lock')
expect(await readdir(moved)).not.toContain(realTakeover)
expect(await readdir(moved)).not.toContain(secondTakeover)
expect(await readFile(join(moved, 'device.json'))).toEqual(deviceJsonBytes)
expect(await readFile(join(moved, 'device.key'))).toEqual(deviceKeyBytes)
expect(await readFile(join(moved, 'trusted-peers.json'))).toEqual(peersBytes)
expect(await readFile(join(moved, 'server-credentials.json'))).toEqual(credentialBytes)
}
// Live lock owner or live concurrent takeover contender must reject with IDENTITY_LOCKED without altering any file.
for (const liveScenario of ['live-lock-with-dead-takeover', 'dead-lock-with-live-takeover'] as const) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const hostDir = serverStorageDirectory(source, serverUrl, 'host')
const store = new IdentityStore({ directory: hostDir, role: 'host' })
const identity = await store.loadOrCreate('Host')
await store.trustPeer({ deviceId: identity.deviceId, name: 'Peer', platform: 'linux', publicKey: identity.publicKey })
await new ServerCredentialStore(hostDir).save({
serverUrl,
deviceId: identity.deviceId,
authorizationMethod: 'owned_device',
accessToken: 'fixture-access-token',
accessTokenExpiresAt: 1,
refreshToken: 'fixture-refresh-token',
refreshTokenExpiresAt: 2,
})
const activeLockRecord = liveScenario === 'live-lock-with-dead-takeover' ? `${process.pid}\n` : lockRecord
const activeTakeoverName = `device.lock.takeover-${createHash('sha256').update(activeLockRecord).digest('hex').slice(0, 16)}`
const activeTakeoverRecord = liveScenario === 'live-lock-with-dead-takeover' ? `${deadContender}\n` : `${process.pid}\n`
await writeFile(join(hostDir, 'device.lock'), activeLockRecord, { mode: 0o600 })
await writeFile(join(hostDir, activeTakeoverName), activeTakeoverRecord, { mode: 0o600 })
const beforeEntries = (await readdir(hostDir)).sort()
const beforeBytes = new Map(await Promise.all(
beforeEntries.map(async name => [name, await readFile(join(hostDir, name))] as const),
))
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), liveScenario).rejects.toMatchObject({
code: 'IDENTITY_LOCKED',
})
expect((await readdir(hostDir)).sort(), liveScenario).toEqual(beforeEntries)
for (const [name, bytes] of beforeBytes) {
expect(await readFile(join(hostDir, name)), `${liveScenario}:${name}`).toEqual(bytes)
}
await expect(stat(join(home, 'ds-harness-remote'))).rejects.toMatchObject({ code: 'ENOENT' })
}
})
it('migrates valid host storage alongside an empty client directory, rotated client credential or uncredentialed broken flat root', async () => {
const serverUrl = 'https://dsh.r2049.cn'
for (const scenario of [
'empty-client',
'rotated-client-credential',
'broken-flat-root',
'corrupt-flat-json',
'invalid-flat-schema',
'corrupt-flat-key',
] as const) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const hostDir = serverStorageDirectory(source, serverUrl, 'host')
const clientDir = serverStorageDirectory(source, serverUrl, 'client')
const hostIdentity = await new IdentityStore({ directory: hostDir, role: 'host' }).loadOrCreate('Host')
await new ServerCredentialStore(hostDir).save({
serverUrl,
deviceId: hostIdentity.deviceId,
authorizationMethod: 'account',
account: 'host@example.com',
accessToken: 'fixture-access-token',
accessTokenExpiresAt: 1,
refreshToken: 'fixture-refresh-token',
refreshTokenExpiresAt: 2,
})
const hostCredentialBytes = await readFile(join(hostDir, 'server-credentials.json'))
if (scenario === 'empty-client') {
await mkdir(clientDir, { recursive: true })
}
if (scenario === 'rotated-client-credential') {
const oldClient = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Old Client')
await new IdentityStore({ directory: clientDir, role: 'client' }).loadOrCreate('Client')
await new ServerCredentialStore(clientDir).save({
serverUrl,
deviceId: oldClient.deviceId,
authorizationMethod: 'account',
account: 'host@example.com',
accessToken: 'stale-client-access-token',
accessTokenExpiresAt: 1,
refreshToken: 'stale-client-refresh-token',
refreshTokenExpiresAt: 2,
})
}
if (scenario === 'broken-flat-root') {
const other = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Other')
await new IdentityStore({ directory: source }).loadOrCreate('Flat')
await writeFile(join(source, 'device.key'), `${other.privateKey}\n`, { mode: 0o600 })
}
if (scenario === 'corrupt-flat-json') {
await new IdentityStore({ directory: source }).loadOrCreate('Flat')
await writeFile(join(source, 'device.json'), '{corrupt-json', { mode: 0o600 })
}
if (scenario === 'invalid-flat-schema') {
await new IdentityStore({ directory: source }).loadOrCreate('Flat')
await writeFile(join(source, 'device.json'), '{"schemaVersion":99}', { mode: 0o600 })
}
if (scenario === 'corrupt-flat-key') {
await new IdentityStore({ directory: source }).loadOrCreate('Flat')
await writeFile(join(source, 'device.key'), 'not-a-32-byte-private-key\n', { mode: 0o600 })
}
const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
expect(target, scenario).toBe(join(home, 'ds-harness-remote'))
const movedHostDir = serverStorageDirectory(target, serverUrl, 'host')
expect(await new IdentityStore({ directory: movedHostDir, role: 'host' }).loadOrCreate('Host'), scenario).toEqual(hostIdentity)
expect(await readFile(join(movedHostDir, 'server-credentials.json')), scenario).toEqual(hostCredentialBytes)
if (scenario.includes('flat')) {
const healedFlat = await new IdentityStore({ directory: target }).loadOrCreate('Flat')
expect(healedFlat.publicKey, scenario).toBeDefined()
expect(await new IdentityStore({ directory: movedHostDir, role: 'host' }).loadOrCreate('Host'), scenario).toEqual(hostIdentity)
}
}
// Broken flat root without a verified scoped identity must still be rejected.
const unverifiedHome = await temporaryDirectory()
const unverifiedSource = join(unverifiedHome, 'remote')
const unverifiedClientDir = serverStorageDirectory(unverifiedSource, serverUrl, 'client')
const other = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Other')
await new IdentityStore({ directory: unverifiedSource }).loadOrCreate('Flat')
await writeFile(join(unverifiedSource, 'device.key'), `${other.privateKey}\n`, { mode: 0o600 })
await mkdir(unverifiedClientDir, { recursive: true })
await writeFile(join(unverifiedClientDir, 'device.json'), '{corrupt-client-json', { mode: 0o600 })
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: unverifiedHome } })).rejects.toMatchObject({
code: 'IDENTITY_INVALID',
})
await expect(new IdentityStore({ directory: unverifiedSource }).loadOrCreate('Flat')).rejects.toThrow(IdentityInvalidError)
// Flat root credential with mismatched deviceId must still be rejected even when a valid scoped host exists.
const mismatchHome = await temporaryDirectory()
const mismatchSource = join(mismatchHome, 'remote')
const mismatchHostDir = serverStorageDirectory(mismatchSource, serverUrl, 'host')
const validHost = await new IdentityStore({ directory: mismatchHostDir, role: 'host' }).loadOrCreate('Host')
await new IdentityStore({ directory: mismatchSource }).loadOrCreate('Flat')
await new ServerCredentialStore(mismatchSource).save({
serverUrl,
deviceId: validHost.deviceId,
authorizationMethod: 'account',
account: 'host@example.com',
accessToken: 'fixture-access-token',
accessTokenExpiresAt: 1,
refreshToken: 'fixture-refresh-token',
refreshTokenExpiresAt: 2,
})
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: mismatchHome } })).rejects.toMatchObject({
code: 'IDENTITY_INVALID',
})
// Symlinked device.json in scoped host must not authorize flat root self-heal.
const symlinkScopedRoot = await temporaryDirectory()
const externalDir = await temporaryDirectory()
const externalIdentity = await new IdentityStore({ directory: externalDir }).loadOrCreate('External')
const symlinkHostDir = serverStorageDirectory(symlinkScopedRoot, serverUrl, 'host')
await mkdir(symlinkHostDir, { recursive: true })
await writeFile(join(symlinkHostDir, 'device.key'), `${externalIdentity.privateKey}\n`, { mode: 0o600 })
await symlink(join(externalDir, 'device.json'), join(symlinkHostDir, 'device.json'))
await new IdentityStore({ directory: symlinkScopedRoot }).loadOrCreate('Flat')
const brokenFlatKey = `${other.privateKey}\n`
await writeFile(join(symlinkScopedRoot, 'device.key'), brokenFlatKey, { mode: 0o600 })
await expect(new IdentityStore({ directory: symlinkScopedRoot }).loadOrCreate('Flat')).rejects.toThrow(IdentityInvalidError)
expect(await readFile(join(symlinkScopedRoot, 'device.key'), 'utf8')).toBe(brokenFlatKey)
})
it('rejects unknown or malformed peer temporary names without deleting them', async () => {
for (const name of ['foreign.json.1.01a1b6d8-e8b5-7000-8000-000000000001.tmp', 'trusted-peers.json.other.tmp']) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
await new IdentityStore({ directory: source }).loadOrCreate('Host')
await writeFile(join(source, name), 'keep')
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).rejects.toMatchObject({ code: 'STORAGE_CONFLICT' })
await new IdentityStore({ directory: source }).loadOrCreate('Host')
expect(await readFile(join(source, name), 'utf8')).toBe('keep')
}
})
it('refuses conflicting roots, lock records and symlinks without modifying either storage tree', async () => {
for (const scenario of ['conflict', 'destination-race', 'identity-lock', 'refresh-lock', 'symlink']) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const target = join(home, 'ds-harness-remote')
const original = await new IdentityStore({ directory: source }).loadOrCreate('Host')
if (scenario === 'conflict') await mkdir(target)
if (scenario === 'destination-race') await mockMoveFailure(source, target, 'EEXIST', true)
if (scenario === 'identity-lock') await writeFile(join(source, 'device.lock'), String(process.pid))
if (scenario === 'refresh-lock') await mkdir(join(source, 'server-credentials.json.refresh-lock'))
if (scenario === 'symlink') await symlink(join(source, 'device.key'), join(source, 'linked'))
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), scenario).rejects.toBeInstanceOf(IdentityInvalidError)
expect((await readFile(join(source, 'device.key'), 'utf8')).trim()).toBe(original.privateKey)
if (!['conflict', 'destination-race'].includes(scenario)) await expect(stat(target)).rejects.toMatchObject({ code: 'ENOENT' })
}
const directory = await temporaryDirectory()
expect(await prepareDefaultIdentityDirectory({ directory })).toBe(directory)
})
it('moves an idle refresh queue marker and rejects an active queue holder', async () => {
const home = await temporaryDirectory()
const source = join(home, 'remote')
await new IdentityStore({ directory: source }).loadOrCreate('Host')
await new ServerCredentialStore(source).withRefreshLock(async () => undefined)
const marker = join(source, 'server-credentials.json.refresh-lock')
expect(await readFile(marker, 'utf8')).toBe('DSH_REFRESH_LOCK_V2\n')
const holder = `${marker}.holder-${process.pid}-00000000-0000-7000-8000-000000000000`
await writeFile(holder, `${process.pid}-00000000-0000-7000-8000-000000000000 1\n`)
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).rejects.toMatchObject({ code: 'IDENTITY_LOCKED' })
await rm(holder)
expect(await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).toBe(join(home, 'ds-harness-remote'))
expect(await readFile(join(home, 'ds-harness-remote', 'server-credentials.json.refresh-lock'), 'utf8'))
.toBe('DSH_REFRESH_LOCK_V2\n')
})
it.skipIf(process.platform !== 'linux')('moves storage after cleaning a dead holder and accepts a queue temp file', async () => {
const home = await temporaryDirectory()
const source = join(home, 'remote')
await new IdentityStore({ directory: source }).loadOrCreate('Host')
const lock = join(source, 'server-credentials.json.refresh-lock')
await writeFile(lock, 'DSH_REFRESH_LOCK_V2\n')
const owner = spawn(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { stdio: 'ignore' })
const pid = owner.pid!
owner.kill('SIGKILL')
await once(owner, 'exit')
const id = `${pid}-00000000-0000-7000-8000-000000000001`
await writeFile(`${lock}.holder-${id}`, `${id} 1\n`)
const temporary = `${lock}.holder-${id}.${pid}.00000000-0000-7000-8000-000000000002.tmp`
await writeFile(temporary, 'partial')
const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
expect(target).toBe(join(home, 'ds-harness-remote'))
expect(await readdir(target)).not.toContain(`server-credentials.json.refresh-lock.holder-${id}`)
expect(await readFile(join(target, temporary.slice(source.length + 1)), 'utf8')).toBe('partial')
})
it.skipIf(process.platform !== 'linux')('removes verified hardlink remnants from an interrupted refresh lock publication', async () => {
const home = await temporaryDirectory()
const source = join(home, 'remote')
await new IdentityStore({ directory: source }).loadOrCreate('Host')
const dead = await deadPid()
const marker = join(source, 'server-credentials.json.refresh-lock')
await writeFile(marker, 'DSH_REFRESH_LOCK_V2\n', { mode: 0o600 })
const markerTemp = `${marker}.${dead}.00000000-0000-7000-8000-000000000001.tmp`
await link(marker, markerTemp)
const id = `${dead}-00000000-0000-7000-8000-000000000002`
const holder = `${marker}.holder-${id}`
await writeFile(holder, `${id} 1\n`, { mode: 0o600 })
const holderTemp = `${holder}.${dead}.00000000-0000-7000-8000-000000000003.tmp`
await link(holder, holderTemp)
expect((await stat(marker)).nlink).toBe(2)
expect((await stat(holder)).nlink).toBe(2)
const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
expect(target).toBe(join(home, 'ds-harness-remote'))
expect(await readdir(target)).not.toContain(markerTemp.slice(source.length + 1))
expect(await readdir(target)).not.toContain(holderTemp.slice(source.length + 1))
expect(await readdir(target)).not.toContain(holder.slice(source.length + 1))
expect((await stat(join(target, 'server-credentials.json.refresh-lock'))).nlink).toBe(1)
})
it.skipIf(process.platform !== 'linux')('rejects a queue temp that does not link to its matching published file', async () => {
const home = await temporaryDirectory()
const source = join(home, 'remote')
await new IdentityStore({ directory: source }).loadOrCreate('Host')
const dead = await deadPid()
const marker = join(source, 'server-credentials.json.refresh-lock')
await writeFile(marker, 'DSH_REFRESH_LOCK_V2\n', { mode: 0o600 })
await link(marker, join(home, 'foreign-link'))
const markerTemp = `${marker}.${dead}.00000000-0000-7000-8000-000000000004.tmp`
await writeFile(markerTemp, 'DSH_REFRESH_LOCK_V2\n', { mode: 0o600 })
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })).rejects.toMatchObject({ code: 'STORAGE_CONFLICT' })
expect((await stat(marker)).nlink).toBe(2)
expect(await readFile(markerTemp, 'utf8')).toBe('DSH_REFRESH_LOCK_V2\n')
})
it('waits for an active refresh before it moves the storage directory', async () => {
const home = await temporaryDirectory()
const source = join(home, 'remote')
await new IdentityStore({ directory: source }).loadOrCreate('Host')
let entered!: () => void
let release!: () => void
const started = new Promise<void>(resolve => { entered = resolve })
const finish = new Promise<void>(resolve => { release = resolve })
const refresh = new ServerCredentialStore(source).withRefreshLock(async () => {
entered()
await finish
})
await started
const moving = prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
await new Promise(resolve => setTimeout(resolve, 100))
await expect(stat(join(home, 'ds-harness-remote'))).rejects.toMatchObject({ code: 'ENOENT' })
release()
await refresh
expect(await moving).toBe(join(home, 'ds-harness-remote'))
})
it('holds the migration gate while a default identity reset clears credentials', async () => {
const home = await temporaryDirectory()
const target = join(home, 'ds-harness-remote')
await new IdentityStore({ directory: target }).loadOrCreate('Host')
let enteredClear!: () => void
let releaseClear!: () => void
const clearing = new Promise<void>(resolve => { enteredClear = resolve })
const finishClear = new Promise<void>(resolve => { releaseClear = resolve })
const originalClear = ServerCredentialStore.prototype.clear
const clear = vi.spyOn(ServerCredentialStore.prototype, 'clear')
clear.mockImplementation(async function (this: ServerCredentialStore) {
enteredClear()
await finishClear
return originalClear.call(this)
})
try {
const reset = resetDefaultIdentityRoles(['host'], undefined, 'New Host', { env: { DSH_HOME: home } })
await clearing
let enteredRefresh = false
const refresh = new ServerCredentialStore(target).withRefreshLock(async () => { enteredRefresh = true })
await new Promise(resolve => setTimeout(resolve, 100))
expect(enteredRefresh).toBe(false)
releaseClear()
expect(await reset).toBe(target)
await refresh
expect(enteredRefresh).toBe(true)
} finally {
releaseClear()
clear.mockRestore()
}
})
it('keeps using verified legacy identities, trust and authorization when the directory move fails', async () => {
for (const code of ['EACCES', 'EPERM', 'EBUSY', 'EXDEV', 'EROFS', 'ENOSPC', 'EDQUOT']) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const env = { DSH_HOME: home }
const store = new IdentityStore({ directory: source })
const original = await store.loadOrCreate('Host')
await store.trustPeer({ deviceId: original.deviceId, name: 'Peer', platform: 'linux', publicKey: original.publicKey })
const credentials = await new ServerCredentialStore(source).save({ serverUrl: 'https://first.example.com', deviceId: original.deviceId, authorizationMethod: 'owned_device', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2 })
const bytes = await readFile(join(source, 'server-credentials.json'))
await mockMoveFailure(source, join(home, 'ds-harness-remote'), code)
expect(await prepareDefaultIdentityDirectory({ env }), code).toBe(source)
// A subsequent default-store load must adopt the fallback, without retrying
// the move or creating a replacement identity at the canonical path.
const fallback = new IdentityStore({ env })
expect(await fallback.loadOrCreate('Host'), code).toEqual(original)
expect(fallback.directory).toBe(source)
expect(fallback.listTrustedPeers()).toEqual(store.listTrustedPeers())
expect(await new ServerCredentialStore(fallback.directory).load(credentials.serverUrl, original.deviceId)).toEqual(credentials)
expect(await readFile(join(source, 'server-credentials.json'))).toEqual(bytes)
await expect(stat(join(home, 'ds-harness-remote'))).rejects.toMatchObject({ code: 'ENOENT' })
}
})
it('refuses to replace missing or changed storage after a persisted legacy fallback and preserves 64-bit NTFS inode precision', async () => {
for (const scenario of ['missing', 'replaced', 'float-pin', 'high-bit-ino']) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const original = await new IdentityStore({ directory: source }).loadOrCreate('Host')
await mockMoveFailure(source, join(home, 'ds-harness-remote'), 'EACCES')
await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
const pinPath = join(home, '.ds-harness-remote-migration', 'legacy-root.json')
if (scenario === 'float-pin') {
await writeFile(pinPath, JSON.stringify({ schemaVersion: 1, dev: 1.5, ino: 2.5 }), { mode: 0o600 })
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), scenario).rejects.toBeInstanceOf(IdentityInvalidError)
continue
}
if (scenario === 'high-bit-ino') {
const pinned = JSON.parse(await readFile(pinPath, 'utf8')) as { dev: number | string; ino: number | string }
const lowBitChanged = (BigInt(pinned.ino) ^ 1n).toString()
await writeFile(pinPath, JSON.stringify({ schemaVersion: 1, dev: String(pinned.dev), ino: lowBitChanged }), { mode: 0o600 })
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), scenario).rejects.toThrow('changed after fallback')
continue
}
const backup = join(home, 'preserved')
await rename(source, backup)
if (scenario === 'replaced') await new IdentityStore({ directory: source }).loadOrCreate('Other Host')
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), scenario).rejects.toBeInstanceOf(IdentityInvalidError)
expect((await readFile(join(backup, 'device.key'), 'utf8')).trim()).toBe(original.privateKey)
await expect(stat(join(home, 'ds-harness-remote'))).rejects.toMatchObject({ code: 'ENOENT' })
}
})
it('leaves foreign, mixed and inconsistent legacy contents untouched instead of claiming ownership', async () => {
for (const scenario of ['foreign', 'empty', 'mixed', 'wrong-key', 'bad-peers', 'wrong-device', 'wrong-scope', 'unknown-role']) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
await mkdir(source)
const env = { DSH_HOME: home }
if (scenario === 'foreign') await writeFile(join(source, 'settings.json'), '{"owner":"other-plugin"}')
if (!['foreign', 'empty'].includes(scenario)) {
const origin = 'https://first.example.com'
const directory = scenario === 'wrong-scope'
? join(source, 'servers', '0'.repeat(24), 'host')
: scenario === 'unknown-role'
? join(source, 'servers', '0'.repeat(24), 'other')
: serverStorageDirectory(source, origin, 'host')
const identity = await new IdentityStore({ directory }).loadOrCreate('Host')
if (scenario === 'mixed') await writeFile(join(directory, 'foreign.txt'), 'leave-this-alone')
if (scenario === 'wrong-key') await writeFile(join(directory, 'device.key'), 'invalid-private-key')
if (scenario === 'bad-peers') await writeFile(join(directory, 'trusted-peers.json'), '{"schemaVersion":1,"peers":[{}]}')
if (scenario === 'wrong-device' || scenario === 'wrong-scope') {
await new ServerCredentialStore(directory).save({ serverUrl: origin, deviceId: scenario === 'wrong-device' ? 'another-device' : identity.deviceId, authorizationMethod: 'owned_device', accessToken: 'fixture-access-token', accessTokenExpiresAt: 1, refreshToken: 'fixture-refresh-token', refreshTokenExpiresAt: 2 })
}
}
const snapshot = async (directory: string): Promise<unknown> => {
const values: Record<string, unknown> = {}
for (const entry of await readdir(directory, { withFileTypes: true })) {
values[entry.name] = entry.isDirectory() ? await snapshot(join(directory, entry.name)) : await readFile(join(directory, entry.name))
}
return values
}
const before = await snapshot(source)
await expect(prepareDefaultIdentityDirectory({ env }), scenario).rejects.toThrow('ownership could not be verified')
expect(await snapshot(source), scenario).toEqual(before)
await expect(stat(join(home, 'ds-harness-remote'))).rejects.toMatchObject({ code: 'ENOENT' })
}
})
it('creates and reloads one stable device identity', async () => {
const directory = await temporaryDirectory()
const first = await new IdentityStore({ directory }).loadOrCreate('Workstation')
const second = await new IdentityStore({ directory }).loadOrCreate('Renamed workstation')
expect(second).toMatchObject({ deviceId: first.deviceId, publicKey: first.publicKey, privateKey: first.privateKey, name: 'Renamed workstation' })
expect(first.deviceId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/)
if (process.platform !== 'win32') {
expect((await stat(join(directory, 'device.key'))).mode & 0o777).toBe(0o600)
}
})
it('persists trusted peers without private material', async () => {
const hostDirectory = await temporaryDirectory()
const clientDirectory = await temporaryDirectory()
const hostStore = new IdentityStore({ directory: hostDirectory })
await hostStore.loadOrCreate('Host')
const client = await new IdentityStore({ directory: clientDirectory }).loadOrCreate('Client')
await hostStore.trustPeer({ deviceId: client.deviceId, name: client.name, platform: 'linux', publicKey: client.publicKey })
const stored = await readFile(join(hostDirectory, 'trusted-peers.json'), 'utf8')
expect(stored).toContain(client.publicKey)
expect(stored).not.toContain(client.privateKey)
expect(hostStore.isTrusted(client.deviceId, client.publicKey)).toBe(true)
})
it('reloads all trusted peers after discovering more than 256 hosts', async () => {
const directory = await temporaryDirectory()
const store = new IdentityStore({ directory })
const identity = await store.loadOrCreate('Client')
for (let index = 0; index < 301; index++) {
await store.trustPeer({ deviceId: `host-${index}`, name: `Host ${index}`, platform: 'linux', publicKey: identity.publicKey })
}
const restarted = new IdentityStore({ directory })
await expect(restarted.loadOrCreate('Client')).resolves.toMatchObject({ deviceId: identity.deviceId })
expect(restarted.listTrustedPeers()).toEqual(store.listTrustedPeers())
const file = join(directory, 'trusted-peers.json')
const records = JSON.parse(await readFile(file, 'utf8'))
records.peers[300].fingerprint = 'invalid'
await writeFile(file, JSON.stringify(records), { mode: 0o600 })
await expect(new IdentityStore({ directory }).loadOrCreate('Client')).rejects.toThrow(/invalid fingerprint/)
})
it('fails closed for incomplete or overly permissive identity files', async () => {
const incomplete = await temporaryDirectory()
await writeFile(join(incomplete, 'device.json'), '{}')
await expect(new IdentityStore({ directory: incomplete }).loadOrCreate('Host')).rejects.toBeInstanceOf(IdentityInvalidError)
if (process.platform !== 'win32') {
const permissive = await temporaryDirectory()
await new IdentityStore({ directory: permissive }).loadOrCreate('Host')
await chmod(join(permissive, 'device.key'), 0o644)
await expect(new IdentityStore({ directory: permissive }).loadOrCreate('Host')).rejects.toThrow(/0600/)
}
})
it('isolates Host and Client identities by normalized Server origin', async () => {
const root = await temporaryDirectory()
const firstHost = serverStorageDirectory(root, 'https://one.example.com', 'host')
const firstClient = serverStorageDirectory(root, 'https://one.example.com', 'client')
const secondHost = serverStorageDirectory(root, 'https://two.example.com', 'host')
expect(firstHost).not.toBe(firstClient)
expect(firstHost).not.toBe(secondHost)
expect(serverStorageDirectory(root, 'https://one.example.com/', 'host')).toBe(firstHost)
})
it('serializes concurrent first-time creation onto one key pair', async () => {
const directory = await temporaryDirectory()
// Two Stores over one directory model the real incident: a Desktop restart
// overlapping the previous Host process, both reaching the "create" branch.
const stores = Array.from({ length: 6 }, () => new IdentityStore({ directory }))
const created = await Promise.all(stores.map(store => store.loadOrCreate('Workstation')))
const [first] = created
for (const identity of created) {
expect(identity).toMatchObject({ deviceId: first!.deviceId, publicKey: first!.publicKey, privateKey: first!.privateKey })
}
// The pair left on disk must still be self-consistent.
const reloaded = await new IdentityStore({ directory }).loadOrCreate('Workstation')
expect(reloaded.publicKey).toBe(first!.publicKey)
expect(reloaded.privateKey).toBe(first!.privateKey)
})
it('reports a mismatched key pair instead of silently minting a new identity', async () => {
const directory = await temporaryDirectory()
const original = await new IdentityStore({ directory }).loadOrCreate('Workstation')
// Reproduce the incident's residue: overwrite the private key with an
// unrelated one so the public key in device.json no longer matches.
const other = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Other')
await writeFile(join(directory, 'device.key'), `${other.privateKey}\n`)
// Repair stays an explicit operator action: a silent rebuild would drop the
// pinned peer trust and re-register the device without the user knowing.
await expect(new IdentityStore({ directory }).loadOrCreate('Workstation'))
.rejects.toThrow(/public and private keys do not match/)
// The original record is left intact so the operator can still back it up.
expect(JSON.parse(await readFile(join(directory, 'device.json'), 'utf8')).publicKey).toBe(original.publicKey)
})
it('keeps recovery material when the stored pair does not verify', async () => {
const directory = await temporaryDirectory()
const original = await new IdentityStore({ directory }).loadOrCreate('Workstation')
const other = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Other')
const residue = join(directory, 'device.key.57692.01a1a04a-7ced-7ffe-b382-e5a2e689f6ad.tmp')
await writeFile(residue, `${original.privateKey}\n`)
await writeFile(join(directory, 'device.key'), `${other.privateKey}\n`)
await expect(new IdentityStore({ directory }).loadOrCreate('Workstation'))
.rejects.toThrow(/public and private keys do not match/)
// That temp is the only private key still matching device.json (#276), so a
// failed verification must not delete it the way a successful one does.
await expect(readFile(residue, 'utf8')).resolves.toContain(original.privateKey)
})
it('resets onto a fresh identity without leaving lock artifacts behind', async () => {
const directory = await temporaryDirectory()
const first = await new IdentityStore({ directory }).loadOrCreate('Workstation')
const second = await new IdentityStore({ directory }).reset('Workstation')
expect(second.deviceId).not.toBe(first.deviceId)
expect((await readdir(directory)).sort()).toEqual(['device.json', 'device.key', 'trusted-peers.json'])
await expect(new IdentityStore({ directory }).loadOrCreate('Workstation')).resolves.toMatchObject({
deviceId: second.deviceId, publicKey: second.publicKey,
})
})
it('clears temporary files left behind by an interrupted write', async () => {
const directory = await temporaryDirectory()
await new IdentityStore({ directory }).loadOrCreate('Workstation')
const residue = join(directory, 'device.key.57692.01a1a04a-7ced-7ffe-b382-e5a2e689f6ad.tmp')
await writeFile(residue, 'stale\n')
await new IdentityStore({ directory }).loadOrCreate('Workstation')
const remaining = (await readdir(directory)).filter(name => name.endsWith('.tmp'))
expect(remaining).toEqual([])
})
it('self-heals uncredentialed unpeered corrupt or incomplete client identities including across legacy migration', async () => {
const first = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Client 1')
const second = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Client 2')
for (const scenario of ['mismatched', 'device-only', 'key-only', 'legacy-upgrade', 'legacy-client-only'] as const) {
if (scenario === 'legacy-client-only') {
const home = await temporaryDirectory()
const legacyRoot = join(home, 'remote')
const serverUrl = 'https://dsh.r2049.cn'
const legacyClientDir = serverStorageDirectory(legacyRoot, serverUrl, 'client')
await mkdir(legacyClientDir, { recursive: true })
await writeFile(join(legacyClientDir, 'device.json'), JSON.stringify({
schemaVersion: 1,
deviceId: first.deviceId,
name: 'Client',
publicKey: first.publicKey,
}), { mode: 0o600 })
await writeFile(join(legacyClientDir, 'device.key'), `${second.privateKey}\n`, { mode: 0o600 })
const migratedRoot = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
expect(migratedRoot).toBe(join(home, 'ds-harness-remote'))
const migratedClientDir = serverStorageDirectory(migratedRoot, serverUrl, 'client')
const healedClient = await new IdentityStore({ directory: migratedClientDir, role: 'client' }).loadOrCreate('Client')
expect(healedClient.deviceId).not.toBe(first.deviceId)
expect(await new IdentityStore({ directory: migratedClientDir, role: 'client' }).loadOrCreate('Client')).toEqual(healedClient)
continue
}
if (scenario === 'legacy-upgrade') {
const home = await temporaryDirectory()
const legacyRoot = join(home, 'remote')
const serverUrl = 'https://dsh.r2049.cn'
const legacyHostDir = serverStorageDirectory(legacyRoot, serverUrl, 'host')
const legacyClientDir = serverStorageDirectory(legacyRoot, serverUrl, 'client')
const hostIdentity = await new IdentityStore({ directory: legacyHostDir, role: 'host' }).loadOrCreate('Host')
await new ServerCredentialStore(legacyHostDir).save({
serverUrl,
deviceId: hostIdentity.deviceId,
authorizationMethod: 'account',
account: 'host@example.com',
accessToken: 'fixture-access-token',
accessTokenExpiresAt: 1,
refreshToken: 'fixture-refresh-token',
refreshTokenExpiresAt: 2,
})
const hostCredentialBytes = await readFile(join(legacyHostDir, 'server-credentials.json'))
await mkdir(legacyClientDir, { recursive: true })
await writeFile(join(legacyClientDir, 'device.json'), JSON.stringify({
schemaVersion: 1,
deviceId: first.deviceId,
name: 'Client',
publicKey: first.publicKey,
}), { mode: 0o600 })
await writeFile(join(legacyClientDir, 'device.key'), `${second.privateKey}\n`, { mode: 0o600 })
const migratedRoot = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
expect(migratedRoot).toBe(join(home, 'ds-harness-remote'))
const migratedHostDir = serverStorageDirectory(migratedRoot, serverUrl, 'host')
const migratedClientDir = serverStorageDirectory(migratedRoot, serverUrl, 'client')
expect(await new IdentityStore({ directory: migratedHostDir, role: 'host' }).loadOrCreate('Host')).toEqual(hostIdentity)
expect(await readFile(join(migratedHostDir, 'server-credentials.json'))).toEqual(hostCredentialBytes)
const healedClient = await new IdentityStore({ directory: migratedClientDir, role: 'client' }).loadOrCreate('Client')
expect(healedClient.deviceId).not.toBe(first.deviceId)
expect(await new IdentityStore({ directory: migratedClientDir, role: 'client' }).loadOrCreate('Client')).toEqual(healedClient)
continue
}
const directory = await temporaryDirectory()
if (scenario !== 'key-only') {
await writeFile(join(directory, 'device.json'), JSON.stringify({
schemaVersion: 1,
deviceId: first.deviceId,
name: 'Client',
publicKey: first.publicKey,
}))
}
if (scenario !== 'device-only') {
await writeFile(join(directory, 'device.key'), `${second.privateKey}\n`)
}
const healed = await new IdentityStore({ directory, role: 'client' }).loadOrCreate('Client')
expect(healed.publicKey, scenario).toBeDefined()
expect(healed.privateKey, scenario).toBeDefined()
const reloaded = await new IdentityStore({ directory, role: 'client' }).loadOrCreate('Client')
expect(reloaded, scenario).toEqual(healed)
}
})
it('refuses to auto-heal when credentials, trusted peers, unreadable peer records, or host role exist without altering stored bytes', async () => {
const first = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Device 1')
const second = await new IdentityStore({ directory: await temporaryDirectory() }).loadOrCreate('Device 2')
for (const scenario of ['credentials', 'trusted-peers', 'corrupt-peers', 'unknown-file', 'unexpected-servers-dir', 'host-role'] as const) {
const directory = await temporaryDirectory()
await writeFile(join(directory, 'device.json'), JSON.stringify({
schemaVersion: 1,
deviceId: first.deviceId,
name: 'Device',
publicKey: first.publicKey,
}), { mode: 0o600 })
await writeFile(join(directory, 'device.key'), `${second.privateKey}\n`, { mode: 0o600 })
if (scenario === 'credentials') {
await new ServerCredentialStore(directory).save({
serverUrl: 'https://dsh.r2049.cn',
deviceId: first.deviceId,
authorizationMethod: 'owned_device',
accessToken: 'token-access-12345',
accessTokenExpiresAt: Date.now() + 60000,
refreshToken: 'token-refresh-12345',
refreshTokenExpiresAt: Date.now() + 600000,
})
}
if (scenario === 'trusted-peers') {
await writeFile(join(directory, 'trusted-peers.json'), JSON.stringify({
schemaVersion: 1,
peers: [{
deviceId: 'peer-device-id',
name: 'Peer',
platform: 'linux',
publicKey: first.publicKey,
fingerprint: first.fingerprint,
trustedAt: Date.now(),
}],
}))
}
if (scenario === 'corrupt-peers') {
await writeFile(join(directory, 'trusted-peers.json'), '{corrupt-peers-json')
}
if (scenario === 'unknown-file') {
await writeFile(join(directory, 'foreign.bak'), 'keep-me')
}
if (scenario === 'unexpected-servers-dir') {
await mkdir(join(directory, 'servers'), { recursive: true })
}
const beforeEntries = (await readdir(directory)).sort()
const beforeBytes = new Map(await Promise.all(
beforeEntries
.filter(name => name !== 'servers')
.map(async name => [name, await readFile(join(directory, name))] as const),
))
const role = scenario === 'host-role' ? 'host' : 'client'
await expect(new IdentityStore({ directory, role }).loadOrCreate('Device'), scenario)
.rejects.toThrow(IdentityInvalidError)
const afterEntries = (await readdir(directory)).sort()
expect(afterEntries, scenario).toEqual(beforeEntries)
for (const [name, bytes] of beforeBytes) {
expect(await readFile(join(directory, name)), `${scenario}:${name}`).toEqual(bytes)
}
}
})
it.each(['.DS_Store', 'desktop.ini', 'Thumbs.db', 'DESKTOP.INI', 'THUMBS.DB'])(
'keeps plain OS metadata %s at every level and migrates identities unchanged',
async name => {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const host = serverStorageDirectory(source, 'https://example.com', 'host')
const client = serverStorageDirectory(source, 'https://example.com', 'client')
const first = await new IdentityStore({ directory: host }).loadOrCreate('Host')
const second = await new IdentityStore({ directory: client, role: 'client' }).loadOrCreate('Client')
const levels = [source, join(source, 'servers'), dirname(host), host, client]
for (const level of levels) await writeFile(join(level, name), 'metadata')
const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
expect(target).toBe(join(home, 'ds-harness-remote'))
for (const level of levels) {
expect(await readFile(join(level.replace(source, target), name), 'utf8')).toBe('metadata')
}
expect(await new IdentityStore({ directory: host.replace(source, target) }).loadOrCreate('Host')).toEqual(first)
expect(await new IdentityStore({ directory: client.replace(source, target), role: 'client' }).loadOrCreate('Client')).toEqual(second)
},
)
it('keeps plain OS metadata compatible with a flat legacy identity and client self-heal', async () => {
for (const role of ['flat', 'client'] as const) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const directory = role === 'flat' ? source : serverStorageDirectory(source, 'https://example.com', role)
await new IdentityStore({ directory, role: role === 'flat' ? 'host' : role }).loadOrCreate('Device')
await writeFile(join(directory, '.DS_Store'), 'metadata')
if (role === 'client') await rm(join(directory, 'device.key'))
const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
await expect(new IdentityStore({ directory: directory.replace(source, target), role: role === 'flat' ? 'host' : role }).loadOrCreate('Device'))
.resolves.toHaveProperty('deviceId')
}
})
it.each(['.DS_Store', 'desktop.ini', 'Thumbs.db'])(
'client self-heal only tolerates plain metadata %s and keeps stored bytes otherwise',
async name => {
for (const kind of ['file', 'directory', 'hardlink', 'oversized'] as const) {
const directory = await temporaryDirectory()
await new IdentityStore({ directory, role: 'client' }).loadOrCreate('Client')
const original = await readFile(join(directory, 'device.json'))
await rm(join(directory, 'device.key'))
const artifact = join(directory, name)
if (kind === 'directory') await mkdir(artifact)
else if (kind === 'hardlink') await link(join(directory, 'device.json'), artifact)
else {
await writeFile(artifact, 'metadata')
if (kind === 'oversized') await truncate(artifact, 16 * 1024 * 1024 + 1)
}
const loaded = new IdentityStore({ directory, role: 'client' }).loadOrCreate('Client')
if (kind === 'file') await expect(loaded).resolves.toHaveProperty('deviceId')
else {
await expect(loaded).rejects.toMatchObject({ code: 'IDENTITY_INVALID' })
expect(await readFile(join(directory, 'device.json'))).toEqual(original)
}
}
},
)
it('still rejects metadata names used by directories, links, oversized files and unknown content', async () => {
for (const level of ['root', 'servers', 'scope', 'role'] as const) {
for (const kind of ['directory', 'symlink', 'hardlink', 'oversized', 'unknown', 'appledouble'] as const) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const host = serverStorageDirectory(source, 'https://example.com', 'host')
await new IdentityStore({ directory: host }).loadOrCreate('Host')
const directory = { root: source, servers: join(source, 'servers'), scope: dirname(host), role: host }[level]
const artifact = join(directory, kind === 'unknown' ? 'foreign.txt' : kind === 'appledouble' ? '._foreign' : '.DS_Store')
if (kind === 'directory') await mkdir(artifact)
else if (kind === 'symlink') await symlink(home, artifact, process.platform === 'win32' ? 'junction' : 'dir')
else if (kind === 'hardlink') await link(join(host, 'device.json'), artifact)
else {
await writeFile(artifact, 'keep')
if (kind === 'oversized') await truncate(artifact, 16 * 1024 * 1024 + 1)
}
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), `${level}:${kind}`)
.rejects.toMatchObject({ code: 'STORAGE_CONFLICT' })
await expect(stat(source)).resolves.toBeDefined()
}
}
})
it.each([
'server-credentials.json.bak',
'server-credentials.json.bak-1793870140999',
'server-credentials.json.old',
'server-credentials.json.orig',
'server-credentials.json~',
'server-credentials.json.swp',
])('preserves known credential backups during migration: %s', async name => {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const directory = serverStorageDirectory(source, 'https://example.com', 'host')
const identity = await new IdentityStore({ directory }).loadOrCreate('Host')
await writeFile(join(directory, name), 'backup-bytes')
const target = await prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } })
const migrated = directory.replace(source, target)
expect(await readFile(join(migrated, name), 'utf8')).toBe('backup-bytes')
expect(await new IdentityStore({ directory: migrated }).loadOrCreate('Host')).toEqual(identity)
})
it('rejects unsafe known backup artifacts during migration', async () => {
for (const kind of ['directory', 'symlink', 'hardlink', 'oversized'] as const) {
const home = await temporaryDirectory()
const source = join(home, 'remote')
const directory = serverStorageDirectory(source, 'https://example.com', 'host')
await new IdentityStore({ directory }).loadOrCreate('Host')
const artifact = join(directory, 'server-credentials.json.bak')
if (kind === 'directory') await mkdir(artifact)
else if (kind === 'symlink') await symlink(home, artifact, process.platform === 'win32' ? 'junction' : 'dir')
else if (kind === 'hardlink') await link(join(directory, 'device.json'), artifact)
else {
await writeFile(artifact, 'oversized')
await truncate(artifact, 16 * 1024 * 1024 + 1)
}
await expect(prepareDefaultIdentityDirectory({ env: { DSH_HOME: home } }), kind)
.rejects.toMatchObject({ code: 'STORAGE_CONFLICT' })
await expect(stat(source)).resolves.toBeDefined()
}
})
it('allows known backups while healing an unpaired client identity', async () => {
const directory = await temporaryDirectory()
const store = new IdentityStore({ directory, role: 'client' })
const original = await store.loadOrCreate('Client')
await rm(join(directory, 'device.key'))
await writeFile(join(directory, 'device.json.bak-1793870140999'), 'backup-bytes')
const healed = await new IdentityStore({ directory, role: 'client' }).loadOrCreate('Client')
expect(healed.deviceId).not.toBe(original.deviceId)
expect(await readFile(join(directory, 'device.json.bak-1793870140999'), 'utf8')).toBe('backup-bytes')
})
})
async function temporaryDirectory(): Promise<string> {
const directory = await mkdtemp(join(tmpdir(), 'dsh-remote-plugin-'))
directories.push(directory)
return directory
}
let cachedDeadPids: Promise<[number, number, number]> | undefined
async function deadPids(): Promise<[number, number, number]> {
cachedDeadPids ??= (async () => {
const first = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 50)'], { stdio: 'ignore' })
const second = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 50)'], { stdio: 'ignore' })
const third = spawn(process.execPath, ['-e', ''], { stdio: 'ignore' })
await Promise.all([
new Promise<void>(resolve => first.once('exit', () => resolve())),
new Promise<void>(resolve => second.once('exit', () => resolve())),
new Promise<void>(resolve => third.once('exit', () => resolve())),
])
return [first.pid!, second.pid!, third.pid!]
})()
return cachedDeadPids
}
async function deadPid(): Promise<number> {
const [first] = await deadPids()
return first
}