@basmilius/apple-companion-link 0.0.2 → 0.0.4

package/src/protocol/api/companionLink.ts

@@ -1,353 +0,0 @@
-import { randomInt } from 'node:crypto';
-import { debug, waitFor } from '@/cli';
-import { opackFloat, parseBinaryPlist } from '@/encoding';
-import { CompanionLinkFrameType, CompanionLinkMessageType, type CompanionLinkSocket } from '@/socket';
-import type CompanionLink from '../companionLink';
-
-export default class Api {
-    readonly #protocol: CompanionLink;
-    readonly #socket: CompanionLinkSocket;
-
-    constructor(protocol: CompanionLink, socket: CompanionLinkSocket) {
-        this.#protocol = protocol;
-        this.#socket = socket;
-    }
-
-    async fetchMediaControlStatus(): Promise<void> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: 'FetchMediaControlStatus',
-            _t: CompanionLinkMessageType.Request,
-            _c: {}
-        });
-    }
-
-    async fetchNowPlayingInfo(): Promise<void> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: 'FetchCurrentNowPlayingInfoEvent',
-            _t: CompanionLinkMessageType.Request,
-            _c: {}
-        });
-    }
-
-    async fetchSupportedActions(): Promise<void> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: 'FetchSupportedActionsEvent',
-            _t: CompanionLinkMessageType.Request,
-            _c: {}
-        });
-    }
-
-    async getAttentionState(): Promise<AttentionState> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: 'FetchAttentionState',
-            _t: CompanionLinkMessageType.Request,
-            _c: {}
-        });
-
-        const {_c} = objectOrFail<AttentionStateResponse>(payload);
-
-        switch (_c.state) {
-            case 0x01:
-                return 'asleep';
-
-            case 0x02:
-                return 'screensaver';
-
-            case 0x03:
-                return 'awake';
-
-            case 0x04:
-                return 'idle';
-
-            default:
-                return 'unknown';
-        }
-    }
-
-    async getLaunchableApps(): Promise<LaunchableApp[]> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: 'FetchLaunchableApplicationssEvent',
-            _t: CompanionLinkMessageType.Request,
-            _c: {}
-        });
-
-        const {_c} = objectOrFail<LaunchableAppsResponse>(payload);
-
-        return Object.entries(_c).map(([bundleId, name]) => ({
-            bundleId,
-            name
-        }));
-    }
-
-    async getSiriRemoteInfo(): Promise<any> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: 'FetchSiriRemoteInfo',
-            _t: CompanionLinkMessageType.Request,
-            _c: {}
-        });
-
-        return parseBinaryPlist(Buffer.from(payload['_c']['SiriRemoteInfoKey']).buffer);
-    }
-
-    async getUserAccounts(): Promise<UserAccount[]> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: 'FetchUserAccountsEvent',
-            _t: CompanionLinkMessageType.Request,
-            _c: {}
-        });
-
-        const {_c} = objectOrFail<UserAccountsResponse>(payload);
-
-        return Object.entries(_c).map(([accountId, name]) => ({
-            accountId,
-            name
-        }));
-    }
-
-    async hidCommand(command: keyof typeof HidCommand, down = false): Promise<void> {
-        await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: '_hidC',
-            _t: CompanionLinkMessageType.Request,
-            _c: {
-                _hBtS: down ? 1 : 2,
-                _hidC: HidCommand[command]
-            }
-        });
-    }
-
-    async launchApp(bundleId: string): Promise<void> {
-        await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: '_launchApp',
-            _t: CompanionLinkMessageType.Request,
-            _c: {
-                _bundleID: bundleId
-            }
-        });
-    }
-
-    async launchUrl(url: string): Promise<void> {
-        await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: '_launchApp',
-            _t: CompanionLinkMessageType.Request,
-            _c: {
-                _urlS: url
-            }
-        });
-    }
-
-    async mediaControlCommand(command: keyof typeof MediaControlCommand, content?: object): Promise<object> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: '_mcc',
-            _t: CompanionLinkMessageType.Request,
-            _c: {
-                _mcc: MediaControlCommand[command],
-                ...(content || {})
-            }
-        });
-
-        return objectOrFail(payload);
-    }
-
-    async pressButton(command: keyof typeof HidCommand, type: ButtonPressType = 'SingleTap', holdDelayMs = 500): Promise<void> {
-        switch (type) {
-            case 'DoubleTap':
-                await this.hidCommand(command, true);
-                await this.hidCommand(command, false);
-
-                await this.hidCommand(command, true);
-                await this.hidCommand(command, false);
-                break;
-
-            case 'Hold':
-                await this.hidCommand(command, true);
-                await waitFor(holdDelayMs);
-                await this.hidCommand(command, false);
-                break;
-
-            case 'SingleTap':
-                await this.hidCommand(command, true);
-                await this.hidCommand(command, false);
-                break;
-        }
-    }
-
-    async switchUserAccount(accountId: string): Promise<void> {
-        await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: 'SwitchUserAccountEvent',
-            _t: CompanionLinkMessageType.Request,
-            _c: {
-                SwitchAccountID: accountId
-            }
-        });
-    }
-
-    async _subscribe(event: string, fn: EventListener): Promise<void> {
-        this.#socket.addEventListener(event, fn);
-
-        await this.#socket.send(CompanionLinkFrameType.E_OPACK, {
-            _i: '_interest',
-            _t: CompanionLinkMessageType.Event,
-            _c: {
-                _regEvents: [event]
-            }
-        });
-    }
-
-    async _unsubscribe(event: string, fn?: EventListener): Promise<void> {
-        if (fn) {
-            this.#socket.removeEventListener(event, fn);
-        }
-
-        await this.#socket.send(CompanionLinkFrameType.E_OPACK, {
-            _i: '_interest',
-            _t: CompanionLinkMessageType.Event,
-            _c: {
-                _deregEvents: [event]
-            }
-        });
-    }
-
-    async _sessionStart(): Promise<object> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: '_sessionStart',
-            _t: CompanionLinkMessageType.Request,
-            _c: {
-                _srvT: 'com.apple.tvremoteservices',
-                _sid: randomInt(0, 2 ** 32 - 1)
-            }
-        });
-
-        return objectOrFail(payload);
-    }
-
-    async _systemInfo(pairingId: Buffer): Promise<object> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: '_systemInfo',
-            _t: CompanionLinkMessageType.Request,
-            _c: {
-                _bf: 0,
-                _cf: 512,
-                _clFl: 128,
-                _i: 'cafecafecafe',
-                _idsID: pairingId.toString(),
-                _pubID: 'FF:70:79:61:74:76',
-                _sf: 256,
-                _sv: '170.18',
-                model: 'iPhone10,6',
-                name: 'Bas Companion Link'
-            }
-        });
-
-        return objectOrFail(payload);
-    }
-
-    async _touchStart(): Promise<object> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: '_touchStart',
-            _t: CompanionLinkMessageType.Request,
-            _c: {
-                _height: opackFloat(1000.0),
-                _tFl: 0,
-                _width: opackFloat(1000.0)
-            }
-        });
-
-        return objectOrFail(payload);
-    }
-
-    async _tvrcSessionStart(): Promise<object> {
-        const [, payload] = await this.#socket.exchange(CompanionLinkFrameType.E_OPACK, {
-            _i: 'TVRCSessionStart',
-            _t: CompanionLinkMessageType.Request,
-            _btHP: false,
-            _inUseProc: 'tvremoted',
-            _c: {}
-        });
-
-        return objectOrFail(payload);
-    }
-}
-
-const HidCommand = {
-    Up: 1,
-    Down: 2,
-    Left: 3,
-    Right: 4,
-    Menu: 5,
-    Select: 6,
-    Home: 7,
-    VolumeUp: 8,
-    VolumeDown: 9,
-    Siri: 10,
-    Screensaver: 11,
-    Sleep: 12,
-    Wake: 13,
-    PlayPause: 14,
-    ChannelIncrement: 15,
-    ChannelDecrement: 16,
-    Guide: 17,
-    PageUp: 18,
-    PageDown: 19
-} as const;
-
-const MediaControlCommand = {
-    Play: 1,
-    Pause: 2,
-    NextTrack: 3,
-    PreviousTrack: 4,
-    GetVolume: 5,
-    SetVolume: 6,
-    SkipBy: 7,
-    FastForwardBegin: 8,
-    FastForwardEnd: 9,
-    RewindBegin: 10,
-    RewindEnd: 11,
-    GetCaptionSettings: 12,
-    SetCaptionSettings: 13
-} as const;
-
-type ButtonPressType =
-    | 'DoubleTap'
-    | 'Hold'
-    | 'SingleTap';
-
-function objectOrFail<T = object>(obj: unknown): T {
-    if (typeof obj === 'object') {
-        return obj as T;
-    }
-
-    debug('Expected an object.', {obj});
-
-    throw new Error('Expected an object.');
-}
-
-type AttentionState =
-    | 'unknown'
-    | 'asleep'
-    | 'screensaver'
-    | 'awake'
-    | 'idle';
-
-type AttentionStateResponse = {
-    readonly _c: {
-        readonly state: number;
-    };
-};
-
-type LaunchableApp = {
-    readonly bundleId: string;
-    readonly name: string;
-};
-
-type LaunchableAppsResponse = {
-    readonly _c: Record<string, string>;
-};
-
-type UserAccount = {
-    readonly accountId: string;
-    readonly name: string;
-};
-
-type UserAccountsResponse = {
-    readonly _c: Record<string, string>;
-};

package/src/protocol/companionLink.ts

@@ -1,41 +0,0 @@
-import { Result } from 'node-dns-sd';
-import { CompanionLinkSocket } from '@/socket';
-import Api from './api/companionLink';
-import Pairing from './pairing/companionLink';
-import Verify from './verify/companionLink';
-
-export default class CompanionLink {
-    get api(): Api {
-        return this.#api;
-    }
-
-    get socket(): CompanionLinkSocket {
-        return this.#socket;
-    }
-
-    get pairing(): Pairing {
-        return this.#pairing;
-    }
-
-    get verify(): Verify {
-        return this.#verify;
-    }
-
-    readonly #api: Api;
-    readonly #device: Result;
-    readonly #socket: CompanionLinkSocket;
-    readonly #pairing: Pairing;
-    readonly #verify: Verify;
-
-    constructor(device: Result) {
-        this.#device = device;
-        this.#socket = new CompanionLinkSocket(device.address, device.service.port);
-        this.#api = new Api(this, this.#socket);
-        this.#pairing = new Pairing(this, this.#socket);
-        this.#verify = new Verify(this, this.#socket);
-    }
-
-    async connect(): Promise<void> {
-        await this.#socket.connect();
-    }
-}

package/src/protocol/index.ts

@@ -1 +0,0 @@
-export { default as CompanionLink } from './companionLink';

package/src/protocol/pairing/companionLink.ts

@@ -1,286 +0,0 @@
-import { CompanionLinkFrameType, type CompanionLinkSocket } from '@/socket';
-import { SRP, SrpClient } from 'fast-srp-hap';
-import { v4 as uuid } from 'uuid';
-import tweetnacl from 'tweetnacl';
-import { debug } from '@/cli';
-import { AIRPLAY_TRANSIENT_PIN } from '@/const';
-import { decryptChacha20, encryptChacha20, hkdf } from '@/crypto';
-import { bailTlv, decodeTlv, encodeOPack, encodeTlv, TlvFlags, TlvMethod, TlvState, TlvValue } from '@/encoding';
-import CompanionLink from '../companionLink';
-
-export default class {
-    get name(): string {
-        return this.#name;
-    }
-
-    get pairingId(): Buffer {
-        return this.#pairingId;
-    }
-
-    readonly #name: string;
-    readonly #pairingId: Buffer;
-    readonly #protocol: CompanionLink;
-    readonly #socket: CompanionLinkSocket;
-    #publicKey: Buffer;
-    #secretKey: Buffer;
-    #srp: SrpClient;
-
-    constructor(protocol: CompanionLink, socket: CompanionLinkSocket) {
-        this.#protocol = protocol;
-        this.#socket = socket;
-
-        this.#name = 'Bas Companion Link';
-        this.#pairingId = Buffer.from(uuid().toUpperCase());
-    }
-
-    async start(): Promise<void> {
-        const keyPair = tweetnacl.sign.keyPair();
-        this.#publicKey = Buffer.from(keyPair.publicKey);
-        this.#secretKey = Buffer.from(keyPair.secretKey);
-    }
-
-    async pin(askPin: () => Promise<string>): Promise<PairingCredentials> {
-        const m1 = await this.m1();
-        const m2 = await this.m2(m1, await askPin());
-        const m3 = await this.m3(m2);
-        const m4 = await this.m4(m3);
-        const m5 = await this.m5(m4);
-        const m6 = await this.m6(m4, m5);
-
-        if (!m6) {
-            throw new Error('Pairing failed, could not get accessory keys.');
-        }
-
-        return m6;
-    }
-
-    async transient(): Promise<TransientPairingCredentials> {
-        const m1 = await this.m1([[TlvValue.Flags, TlvFlags.TransientPairing]]);
-        const m2 = await this.m2(m1);
-        const m3 = await this.m3(m2);
-        const m4 = await this.m4(m3);
-
-        const accessoryToControllerKey = hkdf({
-            hash: 'sha512',
-            key: m4.sharedSecret,
-            length: 32,
-            salt: Buffer.from('Control-Salt'),
-            info: Buffer.from('Control-Read-Encryption-Key')
-        });
-
-        const controllerToAccessoryKey = hkdf({
-            hash: 'sha512',
-            key: m4.sharedSecret,
-            length: 32,
-            salt: Buffer.from('Control-Salt'),
-            info: Buffer.from('Control-Write-Encryption-Key')
-        });
-
-        return {
-            pairingId: this.#pairingId,
-            sharedSecret: m4.sharedSecret,
-            accessoryToControllerKey,
-            controllerToAccessoryKey
-        };
-    }
-
-    async m1(additionalTlv: [number, number | Buffer][] = []): Promise<M1> {
-        const [, response] = await this.#socket.exchange(CompanionLinkFrameType.PS_Start, {
-            _pd: encodeTlv([
-                [TlvValue.Method, TlvMethod.PairSetup],
-                [TlvValue.State, TlvState.M1],
-                ...additionalTlv
-            ]),
-            _pwTy: 1
-        });
-
-        const data = this.#tlv(response);
-        const publicKey = data.get(TlvValue.PublicKey);
-        const salt = data.get(TlvValue.Salt);
-
-        return {publicKey, salt};
-    }
-
-    async m2(m1: M1, pin: string = AIRPLAY_TRANSIENT_PIN): Promise<M2> {
-        const srpKey = await SRP.genKey(32);
-
-        this.#srp = new SrpClient(SRP.params.hap, m1.salt, Buffer.from('Pair-Setup'), Buffer.from(pin), srpKey, true);
-        this.#srp.setB(m1.publicKey);
-
-        const publicKey = this.#srp.computeA();
-        const proof = this.#srp.computeM1();
-
-        return {publicKey, proof};
-    }
-
-    async m3(m2: M2): Promise<M3> {
-        const [, response] = await this.#socket.exchange(CompanionLinkFrameType.PS_Next, {
-            _pd: encodeTlv([
-                [TlvValue.State, TlvState.M3],
-                [TlvValue.PublicKey, m2.publicKey],
-                [TlvValue.Proof, m2.proof]
-            ]),
-            _pwTy: 1
-        });
-
-        const data = this.#tlv(response);
-        const serverProof = data.get(TlvValue.Proof);
-
-        return {serverProof};
-    }
-
-    async m4(m3: M3): Promise<M4> {
-        this.#srp.checkM2(m3.serverProof);
-
-        const sharedSecret = this.#srp.computeK();
-
-        return {sharedSecret};
-    }
-
-    async m5(m4: M4): Promise<M5> {
-        const iosDeviceX = hkdf({
-            hash: 'sha512',
-            key: m4.sharedSecret,
-            length: 32,
-            salt: Buffer.from('Pair-Setup-Controller-Sign-Salt', 'utf8'),
-            info: Buffer.from('Pair-Setup-Controller-Sign-Info', 'utf8')
-        });
-
-        const sessionKey = hkdf({
-            hash: 'sha512',
-            key: m4.sharedSecret,
-            length: 32,
-            salt: Buffer.from('Pair-Setup-Encrypt-Salt', 'utf8'),
-            info: Buffer.from('Pair-Setup-Encrypt-Info', 'utf8')
-        });
-
-        const deviceInfo = Buffer.concat([
-            iosDeviceX,
-            this.#pairingId,
-            this.#publicKey
-        ]);
-
-        const signature = tweetnacl.sign.detached(deviceInfo, this.#secretKey);
-
-        const innerTlv = encodeTlv([
-            [TlvValue.Identifier, this.#pairingId],
-            [TlvValue.PublicKey, this.#publicKey],
-            [TlvValue.Signature, Buffer.from(signature)],
-            [TlvValue.Name, Buffer.from(encodeOPack({
-                name: this.#name
-            }))]
-        ]);
-
-        const {authTag, ciphertext} = encryptChacha20(sessionKey, Buffer.from('PS-Msg05'), null, innerTlv);
-        const encrypted = Buffer.concat([ciphertext, authTag]);
-
-        const [, response] = await this.#socket.exchange(CompanionLinkFrameType.PS_Next, {
-            _pd: encodeTlv([
-                [TlvValue.State, TlvState.M5],
-                [TlvValue.EncryptedData, encrypted]
-            ]),
-            _pwTy: 1
-        });
-
-        const data = this.#tlv(response);
-        const encryptedDataRaw = data.get(TlvValue.EncryptedData);
-        const encryptedData = encryptedDataRaw.subarray(0, -16);
-        const encryptedTag = encryptedDataRaw.subarray(-16);
-
-        return {
-            authTag: encryptedTag,
-            data: encryptedData,
-            sessionKey
-        };
-    }
-
-    async m6(m4: M4, m5: M5): Promise<PairingCredentials> {
-        const data = decryptChacha20(m5.sessionKey, Buffer.from('PS-Msg06'), null, m5.data, m5.authTag);
-        const tlv = decodeTlv(data);
-
-        const accessoryIdentifier = tlv.get(TlvValue.Identifier);
-        const accessoryLongTermPublicKey = tlv.get(TlvValue.PublicKey);
-        const accessorySignature = tlv.get(TlvValue.Signature);
-
-        const accessoryX = hkdf({
-            hash: 'sha512',
-            key: m4.sharedSecret,
-            length: 32,
-            salt: Buffer.from('Pair-Setup-Accessory-Sign-Salt'),
-            info: Buffer.from('Pair-Setup-Accessory-Sign-Info')
-        });
-
-        const accessoryInfo = Buffer.concat([
-            accessoryX,
-            accessoryIdentifier,
-            accessoryLongTermPublicKey
-        ]);
-
-        if (!tweetnacl.sign.detached.verify(accessoryInfo, accessorySignature, accessoryLongTermPublicKey)) {
-            throw new Error('Invalid accessory signature.');
-        }
-
-        return {
-            accessoryIdentifier: accessoryIdentifier.toString(),
-            accessoryLongTermPublicKey: accessoryLongTermPublicKey,
-            pairingId: this.#pairingId,
-            publicKey: this.#publicKey,
-            secretKey: this.#secretKey
-        };
-    }
-
-    #tlv(response: unknown): Map<number, Buffer> {
-        if (typeof response !== 'object' || response === null) {
-            throw new Error('Invalid response from receiver.');
-        }
-
-        const data = decodeTlv(response['_pd']);
-
-        if (data.has(TlvValue.Error)) {
-            bailTlv(data);
-        }
-
-        debug('Decoded TLV', data);
-
-        return data;
-    }
-}
-
-type M1 = {
-    readonly publicKey: Buffer;
-    readonly salt: Buffer;
-}
-
-type M2 = {
-    readonly publicKey: Buffer;
-    readonly proof: Buffer;
-};
-
-type M3 = {
-    readonly serverProof: Buffer;
-};
-
-type M4 = {
-    readonly sharedSecret: Buffer;
-};
-
-type M5 = {
-    readonly authTag: Buffer;
-    readonly data: Buffer;
-    readonly sessionKey: Buffer;
-};
-
-type PairingCredentials = {
-    readonly accessoryIdentifier: string;
-    readonly accessoryLongTermPublicKey: Buffer;
-    readonly pairingId: Buffer;
-    readonly publicKey: Buffer;
-    readonly secretKey: Buffer;
-};
-
-type TransientPairingCredentials = {
-    readonly pairingId: Buffer;
-    readonly sharedSecret: Buffer;
-    readonly accessoryToControllerKey: Buffer;
-    readonly controllerToAccessoryKey: Buffer;
-};