import { Database } from 'bun:sqlite' import { afterEach, beforeEach, describe, expect, spyOn, it } from 'bun:test' import { createCipheriv, pbkdf2Sync } from 'node:crypto' import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs' import { homedir, tmpdir } from 'node:os' import { join } from 'node:path' import * as linuxKeyring from '@/shared/utils/linux-keyring' import { TeamsTokenExtractor } from './token-extractor' function encryptAESCBC(value: string, key: Buffer, prefix = 'v11'): Buffer { const iv = Buffer.alloc(16, 0x20) const cipher = createCipheriv('aes-128-cbc', key, iv) const ciphertext = Buffer.concat([cipher.update(value, 'utf8'), cipher.final()]) return Buffer.concat([Buffer.from(prefix), ciphertext]) } const unteamsPaths = (appDataBase: string) => ['Unteams', 'Unteams Debug', 'Unteams Dev'].flatMap((name) => [ { path: join(appDataBase, name, 'Cookies'), accountType: 'work' as const, accountTypeKnown: false }, { path: join(appDataBase, name, 'Network', 'Cookies'), accountType: 'work' as const, accountTypeKnown: false }, ]) describe('TeamsTokenExtractor', () => { let extractor: TeamsTokenExtractor beforeEach(() => { extractor = new TeamsTokenExtractor() }) describe('getDesktopCookiesPaths', () => { it('returns darwin desktop paths on macOS', () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const paths = darwinExtractor.getDesktopCookiesPaths() const darwinEbWebView = join( homedir(), 'Library', 'Containers', 'com.microsoft.teams2', 'Data', 'Library', 'Application Support', 'Microsoft', 'MSTeams', 'EBWebView', ) expect(paths).toEqual([ { path: join(darwinEbWebView, 'WV2Profile_tfw', 'Cookies'), accountType: 'work', accountTypeKnown: true }, { path: join(darwinEbWebView, 'WV2Profile_tfw', 'Network', 'Cookies'), accountType: 'work', accountTypeKnown: true, }, { path: join(darwinEbWebView, 'WV2Profile_tfl', 'Cookies'), accountType: 'personal', accountTypeKnown: true, }, { path: join(darwinEbWebView, 'WV2Profile_tfl', 'Network', 'Cookies'), accountType: 'personal', accountTypeKnown: true, }, { path: join(darwinEbWebView, 'Default', 'Cookies'), accountType: 'work', accountTypeKnown: false }, { path: join(darwinEbWebView, 'Default', 'Network', 'Cookies'), accountType: 'work', accountTypeKnown: false }, { path: join(homedir(), 'Library', 'Application Support', 'Microsoft', 'Teams', 'Cookies'), accountType: 'work', accountTypeKnown: false, }, ...unteamsPaths(join(homedir(), 'Library', 'Application Support')), ]) }) it('returns linux desktop path on Linux', () => { const linuxExtractor = new TeamsTokenExtractor('linux') const paths = linuxExtractor.getDesktopCookiesPaths() expect(paths).toEqual([ { path: join(homedir(), '.config', 'Microsoft', 'Microsoft Teams', 'Cookies'), accountType: 'work', accountTypeKnown: false, }, ...unteamsPaths(join(homedir(), '.config')), ]) }) it('returns win32 desktop paths on Windows', () => { const winExtractor = new TeamsTokenExtractor('win32') const paths = winExtractor.getDesktopCookiesPaths() const localAppData = process.env.LOCALAPPDATA || join(homedir(), 'AppData', 'Local') const appdata = process.env.APPDATA || join(homedir(), 'AppData', 'Roaming') const winEbWebView = join( localAppData, 'Packages', 'MSTeams_8wekyb3d8bbwe', 'LocalCache', 'Microsoft', 'MSTeams', 'EBWebView', ) expect(paths).toEqual([ { path: join(winEbWebView, 'WV2Profile_tfw', 'Cookies'), accountType: 'work', accountTypeKnown: true }, { path: join(winEbWebView, 'WV2Profile_tfw', 'Network', 'Cookies'), accountType: 'work', accountTypeKnown: true, }, { path: join(winEbWebView, 'WV2Profile_tfl', 'Cookies'), accountType: 'personal', accountTypeKnown: true }, { path: join(winEbWebView, 'WV2Profile_tfl', 'Network', 'Cookies'), accountType: 'personal', accountTypeKnown: true, }, { path: join(winEbWebView, 'Default', 'Cookies'), accountType: 'work', accountTypeKnown: false }, { path: join(winEbWebView, 'Default', 'Network', 'Cookies'), accountType: 'work', accountTypeKnown: false }, { path: join(appdata, 'Microsoft', 'Teams', 'Cookies'), accountType: 'work', accountTypeKnown: false }, ...unteamsPaths(appdata), ]) }) it('returns empty array for unsupported platform', () => { const unsupportedExtractor = new TeamsTokenExtractor('freebsd' as NodeJS.Platform) expect(unsupportedExtractor.getDesktopCookiesPaths()).toEqual([]) }) }) describe('getUnteamsCookiesPaths', () => { it('returns Unteams Electron cookie paths on macOS with accountTypeKnown=false', () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const paths = darwinExtractor.getUnteamsCookiesPaths() const appSupport = join(homedir(), 'Library', 'Application Support') expect(paths).toEqual(unteamsPaths(appSupport)) expect(paths.every((p) => p.accountTypeKnown === false)).toBe(true) }) it('returns Unteams cookie paths on Linux under ~/.config when XDG_CONFIG_HOME is unset', () => { const previous = process.env.XDG_CONFIG_HOME delete process.env.XDG_CONFIG_HOME try { const linuxExtractor = new TeamsTokenExtractor('linux') expect(linuxExtractor.getUnteamsCookiesPaths()).toEqual(unteamsPaths(join(homedir(), '.config'))) } finally { if (previous !== undefined) process.env.XDG_CONFIG_HOME = previous } }) it('honors XDG_CONFIG_HOME for Unteams cookie paths on Linux', () => { const previous = process.env.XDG_CONFIG_HOME process.env.XDG_CONFIG_HOME = '/custom/xdg/config' try { const linuxExtractor = new TeamsTokenExtractor('linux') expect(linuxExtractor.getUnteamsCookiesPaths()).toEqual(unteamsPaths('/custom/xdg/config')) } finally { if (previous === undefined) delete process.env.XDG_CONFIG_HOME else process.env.XDG_CONFIG_HOME = previous } }) it('returns Unteams cookie paths on Windows (roaming AppData)', () => { const winExtractor = new TeamsTokenExtractor('win32') const appdata = process.env.APPDATA || join(homedir(), 'AppData', 'Roaming') expect(winExtractor.getUnteamsCookiesPaths()).toEqual(unteamsPaths(appdata)) }) it('returns empty array for unsupported platform', () => { const unsupportedExtractor = new TeamsTokenExtractor('freebsd' as NodeJS.Platform) expect(unsupportedExtractor.getUnteamsCookiesPaths()).toEqual([]) }) }) describe('getBrowserCookiesPaths', () => { it('returns browser cookie paths on macOS (at least Default profile per browser)', () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const paths = darwinExtractor.getBrowserCookiesPaths() const chromeBase = join(homedir(), 'Library', 'Application Support', 'Google', 'Chrome') expect(paths).toContainEqual({ path: join(chromeBase, 'Default', 'Cookies'), accountType: 'work', accountTypeKnown: false, }) expect(paths).toContainEqual({ path: join(chromeBase, 'Default', 'Network', 'Cookies'), accountType: 'work', accountTypeKnown: false, }) }) it('returns browser cookie paths on Linux', () => { const linuxExtractor = new TeamsTokenExtractor('linux') const paths = linuxExtractor.getBrowserCookiesPaths() const chromeBase = join(homedir(), '.config', 'google-chrome') expect(paths).toContainEqual({ path: join(chromeBase, 'Default', 'Cookies'), accountType: 'work', accountTypeKnown: false, }) }) it('returns browser cookie paths on Windows', () => { const winExtractor = new TeamsTokenExtractor('win32') const paths = winExtractor.getBrowserCookiesPaths() const localAppData = process.env.LOCALAPPDATA || join(homedir(), 'AppData', 'Local') const chromeBase = join(localAppData, 'Google', 'Chrome', 'User Data') expect(paths).toContainEqual({ path: join(chromeBase, 'Default', 'Cookies'), accountType: 'work', accountTypeKnown: false, }) }) it('returns empty array for unsupported platform', () => { const unsupportedExtractor = new TeamsTokenExtractor('freebsd' as NodeJS.Platform) expect(unsupportedExtractor.getBrowserCookiesPaths()).toEqual([]) }) // Regression for #163: browser paths must not assert accountType confidently because // Chromium profile paths don't encode work vs personal. Desktop WV2Profile_tfw/_tfl // paths are authoritative; browsers must be probed at validation time. it('browser paths have accountTypeKnown=false so they get probed at validation', () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const paths = darwinExtractor.getBrowserCookiesPaths() expect(paths.length).toBeGreaterThan(0) expect(paths.every((p) => p.accountTypeKnown === false)).toBe(true) }) }) describe('getTeamsCookiesPaths', () => { it('returns darwin paths on macOS with desktop paths first', () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const paths = darwinExtractor.getTeamsCookiesPaths() const desktopPaths = darwinExtractor.getDesktopCookiesPaths() expect(paths.slice(0, desktopPaths.length)).toEqual(desktopPaths) }) it('browser paths come after desktop paths on macOS', () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const paths = darwinExtractor.getTeamsCookiesPaths() const desktopPaths = darwinExtractor.getDesktopCookiesPaths() const browserPaths = darwinExtractor.getBrowserCookiesPaths() expect(paths.length).toBe(desktopPaths.length + browserPaths.length) expect(paths.slice(desktopPaths.length)).toEqual(browserPaths) }) it('returns linux paths with desktop first then browser paths', () => { const linuxExtractor = new TeamsTokenExtractor('linux') const paths = linuxExtractor.getTeamsCookiesPaths() const desktopPaths = linuxExtractor.getDesktopCookiesPaths() expect(paths.slice(0, 1)).toEqual([ { path: join(homedir(), '.config', 'Microsoft', 'Microsoft Teams', 'Cookies'), accountType: 'work', accountTypeKnown: false, }, ]) expect(paths.length).toBeGreaterThan(desktopPaths.length) }) it('returns win32 paths with desktop first then browser paths', () => { const winExtractor = new TeamsTokenExtractor('win32') const paths = winExtractor.getTeamsCookiesPaths() const desktopPaths = winExtractor.getDesktopCookiesPaths() expect(paths.slice(0, desktopPaths.length)).toEqual(desktopPaths) expect(paths.length).toBeGreaterThan(desktopPaths.length) }) it('returns empty array for unsupported platform', () => { const unsupportedExtractor = new TeamsTokenExtractor('freebsd' as NodeJS.Platform) const paths = unsupportedExtractor.getTeamsCookiesPaths() expect(paths).toEqual([]) }) }) describe('getLocalStatePath', () => { it('returns darwin Local State path on macOS', () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const path = darwinExtractor.getLocalStatePath() expect(path).toBe(join(homedir(), 'Library', 'Application Support', 'Microsoft', 'Teams', 'Local State')) }) it('returns linux Local State path on Linux', () => { const linuxExtractor = new TeamsTokenExtractor('linux') const path = linuxExtractor.getLocalStatePath() expect(path).toBe(join(homedir(), '.config', 'Microsoft', 'Microsoft Teams', 'Local State')) }) it('returns win32 Local State path on Windows', () => { const winExtractor = new TeamsTokenExtractor('win32') const path = winExtractor.getLocalStatePath() const appdata = process.env.APPDATA || join(homedir(), 'AppData', 'Roaming') expect(path).toBe(join(appdata, 'Microsoft', 'Teams', 'Local State')) }) }) describe('getKeychainVariants', () => { it('includes Teams-specific keychain entries', () => { const macExtractor = new TeamsTokenExtractor('darwin') const variants = macExtractor.getKeychainVariants() expect(variants).toContainEqual({ service: 'Microsoft Teams Safe Storage', account: 'Microsoft Teams' }) expect(variants).toContainEqual({ service: 'Microsoft Teams (work or school) Safe Storage', account: 'Microsoft Teams (work or school)', }) expect(variants).toContainEqual({ service: 'Microsoft Edge Safe Storage', account: 'Microsoft Edge' }) expect(variants).toContainEqual({ service: 'Teams Safe Storage', account: 'Teams' }) expect(variants).toContainEqual({ service: 'Unteams Safe Storage', account: 'Unteams' }) expect(variants).toContainEqual({ service: 'Unteams Debug Safe Storage', account: 'Unteams Debug' }) }) it('includes browser keychain entries appended after Teams entries', () => { const macExtractor = new TeamsTokenExtractor('darwin') const variants = macExtractor.getKeychainVariants() expect(variants).toContainEqual({ service: 'Chrome Safe Storage', account: 'Chrome' }) expect(variants).toContainEqual({ service: 'Chrome Canary Safe Storage', account: 'Chrome Canary' }) expect(variants).toContainEqual({ service: 'Arc Safe Storage', account: 'Arc' }) expect(variants).toContainEqual({ service: 'Brave Safe Storage', account: 'Brave' }) expect(variants).toContainEqual({ service: 'Vivaldi Safe Storage', account: 'Vivaldi' }) expect(variants).toContainEqual({ service: 'Chromium Safe Storage', account: 'Chromium' }) }) it('Teams entries come before browser entries', () => { const macExtractor = new TeamsTokenExtractor('darwin') const variants = macExtractor.getKeychainVariants() const teamsIdx = variants.findIndex((v) => v.service === 'Microsoft Teams Safe Storage') const chromeIdx = variants.findIndex((v) => v.service === 'Chrome Safe Storage') expect(teamsIdx).toBeLessThan(chromeIdx) }) }) describe('Linux v11 keyring decryption', () => { it('decrypts a v11 Unteams cookie using the secret-store key instead of the peanuts fallback', () => { // given: a v11 cookie encrypted with the key derived from the Unteams keyring secret const keyringPassword = 'unteams-secret-store-password' const key = pbkdf2Sync(keyringPassword, 'saltysalt', 1, 16, 'sha1') const encrypted = encryptAESCBC('eyJhbGciOiJSUzI1NiJ9.unteams-skypetoken', key) const spy = spyOn(linuxKeyring, 'lookupLinuxKeyringPassword').mockImplementation(() => keyringPassword) const linuxExtractor = new TeamsTokenExtractor('linux') // when const decrypted = (linuxExtractor as any).decryptor.decryptCookieRaw(encrypted) as Buffer | null // then expect(spy).toHaveBeenCalledWith('Unteams') expect(decrypted?.toString('utf8')).toBe('eyJhbGciOiJSUzI1NiJ9.unteams-skypetoken') spy.mockRestore() }) }) describe('isValidSkypeToken', () => { it('validates JWT-like skype token format', () => { const validToken = 'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.signature' expect(extractor.isValidSkypeToken(validToken)).toBe(true) }) it('validates long base64 token format', () => { const validToken = 'a'.repeat(100) expect(extractor.isValidSkypeToken(validToken)).toBe(true) }) it('rejects empty tokens', () => { expect(extractor.isValidSkypeToken('')).toBe(false) }) it('rejects short tokens', () => { expect(extractor.isValidSkypeToken('short')).toBe(false) }) it('rejects null/undefined', () => { expect(extractor.isValidSkypeToken(null as unknown as string)).toBe(false) expect(extractor.isValidSkypeToken(undefined as unknown as string)).toBe(false) }) // Regression for #156: PowerShell CLIXML leaks into DPAPI output on Windows. it('rejects CLIXML progress-stream contamination', () => { // given: the exact shape of the leak reported in #156 const clixml = '#< CLIXML\r\n' + 'System.Management.Automation.PSCustomObject' + 'System.Object1' // then expect(extractor.isValidSkypeToken(clixml)).toBe(false) }) it('rejects anything containing angle brackets or whitespace', () => { expect(extractor.isValidSkypeToken('a'.repeat(60) + '
')).toBe(false) expect(extractor.isValidSkypeToken('a'.repeat(40) + ' ' + 'b'.repeat(40))).toBe(false) expect(extractor.isValidSkypeToken('a'.repeat(40) + '\n' + 'b'.repeat(40))).toBe(false) }) it('rejects a bare 36-char UUID', () => { expect(extractor.isValidSkypeToken('12345678-1234-1234-1234-123456789012')).toBe(false) }) }) describe('isEncryptedValue', () => { it('detects v10 encrypted values', () => { const encrypted = Buffer.from('v10encrypted_data') expect(extractor.isEncryptedValue(encrypted)).toBe(true) }) it('detects v11 encrypted values', () => { const encrypted = Buffer.from('v11encrypted_data') expect(extractor.isEncryptedValue(encrypted)).toBe(true) }) it('rejects non-encrypted values', () => { const plain = Buffer.from('plain_text') expect(extractor.isEncryptedValue(plain)).toBe(false) }) it('rejects empty buffers', () => { const empty = Buffer.alloc(0) expect(extractor.isEncryptedValue(empty)).toBe(false) }) it('rejects short buffers', () => { const short = Buffer.from('v1') expect(extractor.isEncryptedValue(short)).toBe(false) }) }) describe('extract', () => { it('returns null when cookies path does not exist', async () => { const linuxExtractor = new TeamsTokenExtractor('linux') const extractFromCookiesDBSpy = spyOn(linuxExtractor as any, 'extractFromCookiesDB').mockResolvedValue([]) const result = await linuxExtractor.extract() expect(result).toEqual([]) extractFromCookiesDBSpy.mockRestore() }) it('extracts token from cookies database when available', async () => { const mockToken = 'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.signature_here' const linuxExtractor = new TeamsTokenExtractor('linux') const extractFromCookiesDBSpy = spyOn(linuxExtractor as any, 'extractFromCookiesDB').mockResolvedValue([ { token: mockToken, accountType: 'work', accountTypeKnown: true }, ]) const result = await linuxExtractor.extract() expect(result).toHaveLength(1) expect(result[0].token).toBe(mockToken) extractFromCookiesDBSpy.mockRestore() }) it('returns null when extraction fails', async () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const extractFromCookiesDBSpy = spyOn(darwinExtractor as any, 'extractFromCookiesDB').mockResolvedValue([]) const result = await darwinExtractor.extract() expect(result).toEqual([]) extractFromCookiesDBSpy.mockRestore() }) }) describe('current Teams cookies', () => { const token = 'eyJhbGciOiJSUzI1NiJ9.eyJhdWQiOiJodHRwczovL2ljMy50ZWFtcy5vZmZpY2UuY29tIn0.signature' let workDir: string beforeEach(() => { workDir = mkdtempSync(join(tmpdir(), 'teams-cookie-test-')) }) afterEach(() => { rmSync(workDir, { recursive: true, force: true }) }) it.each([ ['skypetoken_asm', 'plaintext'], ['authtoken_asm', 'plaintext'], ['authtoken_asm_urlp', 'plaintext'], ['authtoken_asm', 'encrypted'], ])('extracts the %s messaging cookie stored as %s', async (name, storage) => { // given: a signed-in web profile with only its current messaging cookie const cookiesPath = join(workDir, 'Cookies') const value = name === 'skypetoken_asm' ? token : encodeURIComponent(`Bearer ${token}`) const encrypted = storage === 'encrypted' const key = pbkdf2Sync('peanuts', 'saltysalt', 1, 16, 'sha1') const db = new Database(cookiesPath) db.run('CREATE TABLE cookies (host_key TEXT, name TEXT, value TEXT, encrypted_value BLOB)') db.run('INSERT INTO cookies VALUES (?, ?, ?, ?)', [ '.asyncgw.teams.microsoft.com', name, encrypted ? '' : value, encrypted ? encryptAESCBC('\0'.repeat(32) + value, key, 'v10') : Buffer.alloc(0), ]) db.close() const linuxExtractor = new TeamsTokenExtractor('linux') const paths = spyOn(linuxExtractor, 'getTeamsCookiesPaths').mockReturnValue([ { path: cookiesPath, accountType: 'work', accountTypeKnown: false }, ]) try { // when const results = await linuxExtractor.extract() // then expect(results).toEqual([{ token, accountType: 'work', accountTypeKnown: false }]) } finally { paths.mockRestore() } }) it('extracts the real-time bearer from the current Teams cloud domain', async () => { // given: Teams stores its URL-encoded real-time token on teams.cloud.microsoft const cookiesPath = join(workDir, 'Cookies') const bearer = 'header.encrypted-key.iv.ciphertext.authentication-tag' const db = new Database(cookiesPath) db.run('CREATE TABLE cookies (host_key TEXT, name TEXT, value TEXT, encrypted_value BLOB)') db.run('INSERT INTO cookies VALUES (?, ?, ?, ?)', [ 'teams.cloud.microsoft', 'authtoken', encodeURIComponent(`Bearer=${bearer}`), Buffer.alloc(0), ]) db.close() const linuxExtractor = new TeamsTokenExtractor('linux') const desktopPaths = spyOn(linuxExtractor, 'getDesktopCookiesPaths').mockReturnValue([ { path: cookiesPath, accountType: 'work', accountTypeKnown: false }, ]) const browserPaths = spyOn(linuxExtractor, 'getBrowserCookiesPaths').mockReturnValue([]) try { // when const result = await linuxExtractor.extractIdToken() // then expect(result).toBe(bearer) } finally { desktopPaths.mockRestore() browserPaths.mockRestore() } }) it('preserves the current cookie when a legacy token also needs validation', async () => { // given: an expired but well-shaped legacy token alongside the current OAuth cookie const legacy = 'eyJhbGciOiJSUzI1NiJ9.eyJleHAiOjEsInNreXBlaWQiOiJ0ZXN0In0.signature' const cookiesPath = join(workDir, 'Cookies') const db = new Database(cookiesPath) db.run('CREATE TABLE cookies (host_key TEXT, name TEXT, value TEXT, encrypted_value BLOB)') for (const [name, value] of [ ['skypetoken_asm', legacy], ['authtoken_asm', encodeURIComponent(`Bearer ${token}`)], ['authtoken_asm_urlp', 'Bearer%invalid' + 'x'.repeat(60)], ]) { db.run('INSERT INTO cookies VALUES (?, ?, ?, ?)', [ '.asyncgw.teams.microsoft.com', name, value, Buffer.alloc(0), ]) } db.close() const linuxExtractor = new TeamsTokenExtractor('linux') const paths = spyOn(linuxExtractor, 'getTeamsCookiesPaths').mockReturnValue([ { path: cookiesPath, accountType: 'work', accountTypeKnown: false }, ]) try { // when const results = await linuxExtractor.extract() // then: API validation can reject the old token without losing the current one expect(results.map(({ token }) => token)).toEqual([legacy, token]) } finally { paths.mockRestore() } }) }) describe('extractFromCookiesDB (Network/Cookies fallback)', () => { const mockToken = 'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.signature_here' let workDir: string beforeEach(() => { workDir = mkdtempSync(join(tmpdir(), 'teams-extractor-test-')) }) const cleanup = () => rmSync(workDir, { recursive: true, force: true }) // Regression for #156: if only Network/Cookies exists, missing sibling must not poison accountType. it('falls through to Network/Cookies when Cookies is missing', async () => { // given: only Network/Cookies exists on disk for WV2Profile_tfl const profileDir = join(workDir, 'WV2Profile_tfl') const networkDir = join(profileDir, 'Network') mkdirSync(networkDir, { recursive: true }) const cookiesPath = join(profileDir, 'Cookies') const networkCookiesPath = join(networkDir, 'Cookies') writeFileSync(networkCookiesPath, '') const winExtractor = new TeamsTokenExtractor('win32') const getPathsSpy = spyOn(winExtractor, 'getTeamsCookiesPaths').mockReturnValue([ { path: cookiesPath, accountType: 'personal', accountTypeKnown: true }, { path: networkCookiesPath, accountType: 'personal', accountTypeKnown: true }, ]) const tried: string[] = [] const copyAndExtractSpy = spyOn(winExtractor as any, 'copyAndExtract').mockImplementation(async (...args) => { const path = args[0] as string tried.push(path) return [mockToken] }) // when const results = await (winExtractor as any).extractFromCookiesDB() // then: the Cookies path was skipped (never passed to copyAndExtract), // the Network/Cookies sibling was tried, and the token was returned. expect(tried).toEqual([networkCookiesPath]) expect(results).toEqual([{ token: mockToken, accountType: 'personal', accountTypeKnown: true }]) getPathsSpy.mockRestore() copyAndExtractSpy.mockRestore() cleanup() }) // Regression for #156: CLIXML-contaminated decrypt output must not short-circuit // the work account, leaving other valid paths unvisited. it('does not mark accountType seen when the first path yields CLIXML garbage', async () => { // given: first work path returns CLIXML garbage, second work path returns a real token const clixmlGarbage = '#< CLIXML\r\n' + 'Progress\r\n' + 'a'.repeat(80) const realToken = 'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.signature_here' const winExtractor = new TeamsTokenExtractor('win32') const firstPath = join(workDir, 'WV2Profile_tfw', 'Cookies') const secondPath = join(workDir, 'Default', 'Network', 'Cookies') const getPathsSpy = spyOn(winExtractor, 'getTeamsCookiesPaths').mockReturnValue([ { path: firstPath, accountType: 'work', accountTypeKnown: true }, { path: secondPath, accountType: 'work', accountTypeKnown: true }, ]) mkdirSync(join(workDir, 'WV2Profile_tfw'), { recursive: true }) mkdirSync(join(workDir, 'Default', 'Network'), { recursive: true }) writeFileSync(firstPath, '') writeFileSync(secondPath, '') const copyAndExtractSpy = spyOn(winExtractor as any, 'copyAndExtract') .mockResolvedValueOnce([clixmlGarbage]) .mockResolvedValueOnce([realToken]) // when const results = await (winExtractor as any).extractFromCookiesDB() // then: garbage was rejected, loop continued to the real token expect(copyAndExtractSpy).toHaveBeenCalledTimes(2) expect(results).toEqual([{ token: realToken, accountType: 'work', accountTypeKnown: true }]) getPathsSpy.mockRestore() copyAndExtractSpy.mockRestore() cleanup() }) // Regression for #163: browser-sourced tokens carry accountTypeKnown=false so that // the auth command can probe both endpoints. The extraction loop must preserve the // flag and must not dedupe an unknown-type browser token by its guessed accountType. it('propagates accountTypeKnown=false for browser-sourced tokens', async () => { // given: a browser Cookies path returning a valid token, guessed as work const browserPath = join(workDir, 'Chrome', 'Default', 'Cookies') mkdirSync(join(workDir, 'Chrome', 'Default'), { recursive: true }) writeFileSync(browserPath, '') const winExtractor = new TeamsTokenExtractor('win32') const getPathsSpy = spyOn(winExtractor, 'getTeamsCookiesPaths').mockReturnValue([ { path: browserPath, accountType: 'work', accountTypeKnown: false }, ]) const copyAndExtractSpy = spyOn(winExtractor as any, 'copyAndExtract').mockResolvedValue([mockToken]) // when const results = await (winExtractor as any).extractFromCookiesDB() // then: the flag is passed through so callers can probe expect(results).toEqual([{ token: mockToken, accountType: 'work', accountTypeKnown: false }]) getPathsSpy.mockRestore() copyAndExtractSpy.mockRestore() cleanup() }) // Regression for #163: when a desktop path (known=true) for 'work' already succeeded, // a subsequent browser path (known=false) guessed as 'work' must still be explored — // it might be a personal account misguessed as work. The dedup only kicks in for // confidently labeled paths. it('does not skip unknown-type path just because a known-type same-label succeeded', async () => { const desktopPath = join(workDir, 'WV2Profile_tfw', 'Network', 'Cookies') const browserPath = join(workDir, 'Chrome', 'Default', 'Cookies') mkdirSync(join(workDir, 'WV2Profile_tfw', 'Network'), { recursive: true }) mkdirSync(join(workDir, 'Chrome', 'Default'), { recursive: true }) writeFileSync(desktopPath, '') writeFileSync(browserPath, '') const desktopToken = mockToken const browserToken = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJicm93c2VyIn0.different_signature_here_abc' const winExtractor = new TeamsTokenExtractor('win32') const getPathsSpy = spyOn(winExtractor, 'getTeamsCookiesPaths').mockReturnValue([ { path: desktopPath, accountType: 'work', accountTypeKnown: true }, { path: browserPath, accountType: 'work', accountTypeKnown: false }, ]) const copyAndExtractSpy = spyOn(winExtractor as any, 'copyAndExtract') .mockResolvedValueOnce([desktopToken]) .mockResolvedValueOnce([browserToken]) // when const results = await (winExtractor as any).extractFromCookiesDB() // then: both tokens returned; browser token keeps accountTypeKnown=false for probing expect(results).toEqual([ { token: desktopToken, accountType: 'work', accountTypeKnown: true }, { token: browserToken, accountType: 'work', accountTypeKnown: false }, ]) getPathsSpy.mockRestore() copyAndExtractSpy.mockRestore() cleanup() }) it('dedupes identical tokens extracted from multiple paths', async () => { const path1 = join(workDir, 'Chrome', 'Default', 'Cookies') const path2 = join(workDir, 'Edge', 'Default', 'Cookies') mkdirSync(join(workDir, 'Chrome', 'Default'), { recursive: true }) mkdirSync(join(workDir, 'Edge', 'Default'), { recursive: true }) writeFileSync(path1, '') writeFileSync(path2, '') const winExtractor = new TeamsTokenExtractor('win32') const getPathsSpy = spyOn(winExtractor, 'getTeamsCookiesPaths').mockReturnValue([ { path: path1, accountType: 'work', accountTypeKnown: false }, { path: path2, accountType: 'work', accountTypeKnown: false }, ]) const copyAndExtractSpy = spyOn(winExtractor as any, 'copyAndExtract').mockResolvedValue([mockToken]) // when const results = await (winExtractor as any).extractFromCookiesDB() // then: only one result despite two paths returning the same token expect(results).toHaveLength(1) expect(results[0].token).toBe(mockToken) getPathsSpy.mockRestore() copyAndExtractSpy.mockRestore() cleanup() }) it('a missing path does not mark the account type as seen', async () => { // given: work account has Cookies missing but Network/Cookies present const workProfile = join(workDir, 'WV2Profile_tfw') const workNetworkDir = join(workProfile, 'Network') mkdirSync(workNetworkDir, { recursive: true }) const workCookies = join(workProfile, 'Cookies') const workNetworkCookies = join(workNetworkDir, 'Cookies') writeFileSync(workNetworkCookies, '') const winExtractor = new TeamsTokenExtractor('win32') const getPathsSpy = spyOn(winExtractor, 'getTeamsCookiesPaths').mockReturnValue([ { path: workCookies, accountType: 'work', accountTypeKnown: true }, { path: workNetworkCookies, accountType: 'work', accountTypeKnown: true }, ]) const copyAndExtractSpy = spyOn(winExtractor as any, 'copyAndExtract').mockResolvedValue([mockToken]) // when const results = await (winExtractor as any).extractFromCookiesDB() // then: missing first path did not block the sibling; work token extracted expect(results).toHaveLength(1) expect(results[0].accountType).toBe('work') expect(copyAndExtractSpy).toHaveBeenCalledTimes(1) expect(copyAndExtractSpy).toHaveBeenCalledWith(workNetworkCookies) getPathsSpy.mockRestore() copyAndExtractSpy.mockRestore() cleanup() }) }) describe('copyAndExtract', () => { it('attempts to copy database to temp location', async () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const copyFileSpy = spyOn(darwinExtractor as any, 'copyDatabaseToTemp').mockReturnValue('/tmp/test-cookies') const extractSpy = spyOn(darwinExtractor as any, 'extractFromSQLite').mockResolvedValue(['test_token']) const cleanupSpy = spyOn(darwinExtractor as any, 'cleanupTempFile').mockImplementation(() => {}) const result = await (darwinExtractor as any).copyAndExtract('/path/to/Cookies') expect(copyFileSpy).toHaveBeenCalled() expect(extractSpy).toHaveBeenCalled() expect(cleanupSpy).toHaveBeenCalled() expect(result).toEqual(['test_token']) copyFileSpy.mockRestore() extractSpy.mockRestore() cleanupSpy.mockRestore() }) it('returns no tokens when copy fails (file locked)', async () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const copyFileSpy = spyOn(darwinExtractor as any, 'copyDatabaseToTemp').mockImplementation(() => { throw new Error('EBUSY: resource busy or locked') }) const result = await (darwinExtractor as any).copyAndExtract('/path/to/Cookies') expect(result).toEqual([]) copyFileSpy.mockRestore() }) }) describe('decryption', () => { describe('decryptAESGCM', () => { it('returns null for invalid encrypted data', () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const invalidData = Buffer.from('too_short') const key = Buffer.alloc(32, 0) const result = (darwinExtractor as any).decryptAESGCM(invalidData, key) expect(result).toBeNull() }) it('returns null when decryption fails', () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const fakeEncrypted = Buffer.concat([ Buffer.from('v10'), Buffer.alloc(12, 1), Buffer.alloc(20, 2), Buffer.alloc(16, 3), ]) const key = Buffer.alloc(32, 0) const result = (darwinExtractor as any).decryptAESGCM(fakeEncrypted, key) expect(result).toBeNull() }) }) describe('getKeychainPassword (macOS)', () => { it('tries multiple keychain variants', async () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const execSyncSpy = spyOn(darwinExtractor as any, 'execSecurityCommand') .mockReturnValueOnce(null) .mockReturnValueOnce('test_password') const result = (darwinExtractor as any).getKeychainPassword() expect(execSyncSpy).toHaveBeenCalledTimes(2) expect(result).toBe('test_password') execSyncSpy.mockRestore() }) it('returns null when all keychain variants fail', async () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const execSyncSpy = spyOn(darwinExtractor as any, 'execSecurityCommand').mockReturnValue(null) const result = (darwinExtractor as any).getKeychainPassword() expect(result).toBeNull() execSyncSpy.mockRestore() }) }) }) describe('process management', () => { describe('isTeamsRunning', () => { it('returns true when Teams process is found', async () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const checkProcessRunningSpy = spyOn(darwinExtractor as any, 'checkProcessRunning').mockReturnValue(true) const result = await darwinExtractor.isTeamsRunning() expect(result).toBe(true) checkProcessRunningSpy.mockRestore() }) it('returns false when no Teams process is found', async () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const checkProcessRunningSpy = spyOn(darwinExtractor as any, 'checkProcessRunning').mockReturnValue(false) const result = await darwinExtractor.isTeamsRunning() expect(result).toBe(false) checkProcessRunningSpy.mockRestore() }) }) describe('getProcessName', () => { it('returns correct process name for macOS', () => { const darwinExtractor = new TeamsTokenExtractor('darwin') expect((darwinExtractor as any).getProcessName()).toBe('Microsoft Teams') }) it('returns correct process name for Windows', () => { const winExtractor = new TeamsTokenExtractor('win32') expect((winExtractor as any).getProcessName()).toBe('Teams.exe') }) it('returns correct process name for Linux', () => { const linuxExtractor = new TeamsTokenExtractor('linux') expect((linuxExtractor as any).getProcessName()).toBe('teams') }) }) }) describe('SQLite extraction', () => { it('returns no tokens when database path does not exist', async () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const result = await (darwinExtractor as any).extractFromSQLite('/nonexistent/path') expect(result).toEqual([]) }) it('returns no tokens when extraction throws', async () => { const darwinExtractor = new TeamsTokenExtractor('darwin') const result = await (darwinExtractor as any).extractFromSQLite('/dev/null') expect(result).toEqual([]) }) }) })