@basmilius/apple-companion-link 0.0.1

package/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "@basmilius/apple-companion-link",
+    "description": "Implementation of Apple's Companion Link",
+    "version": "0.0.1",
+    "type": "module",
+    "license": "MIT",
+    "author": {
+        "name": "Bas Milius",
+        "email": "bas@mili.us",
+        "url": "https://bas.dev"
+    },
+    "keywords": [
+        "apple",
+        "airplay",
+        "tv",
+        "apple tv",
+        "homekit"
+    ],
+    "files": [
+        "dist",
+        "src",
+        "CODEOWNERS",
+        "LICENSE"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "scripts": {
+        "build": "bun -b build.ts"
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "typings": "./dist/index.d.ts",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        }
+    },
+    "dependencies": {
+        "@noble/curves": "^2.0.1",
+        "@plist/binary.parse": "^1.1.0",
+        "@plist/binary.serialize": "^1.1.0",
+        "chacha": "^2.1.0",
+        "fast-srp-hap": "^2.0.4",
+        "node-dns-sd": "^1.0.1",
+        "tweetnacl": "^1.0.3",
+        "uuid": "^13.0.0"
+    },
+    "devDependencies": {
+        "@basmilius/tools": "^2.13.0",
+        "@types/bun": "^1.3.1"
+    }
+}

package/src/cli.ts

@@ -0,0 +1,19 @@
+import { createInterface } from 'node:readline';
+import { styleText } from 'node:util';
+
+const stdin = createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+export function debug(...data: any[]): void {
+    console.debug(styleText('cyan', '[debug]'), ...data);
+}
+
+export async function prompt(message: string): Promise<string> {
+    return await new Promise<string>(resolve => stdin.question(`${message}: `, resolve));
+}
+
+export async function waitFor(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/const.ts

@@ -0,0 +1,7 @@
+export const AIRPLAY_TRANSIENT_PIN = '3939';
+
+export const HTTP_TIMEOUT = 15000;
+
+export const AIRPLAY_SERVICE = '_airplay._tcp.local';
+export const COMPANION_LINK_SERVICE = '_companion-link._tcp.local';
+export const RAOP_SERVICE = '_raop._tcp.local';

package/src/crypto/chacha20.ts

@@ -0,0 +1,95 @@
+import { createCipher, createDecipher } from 'chacha';
+
+const AUTH_TAG_LENGTH = 16;
+const NONCE_LENGTH = 12;
+
+export function decrypt(key: Buffer, nonce: Buffer, add: Buffer | null, ciphertext: Buffer, authTag: Buffer): Buffer {
+    nonce = padNonce(nonce);
+
+    const decipher = createDecipher(key, nonce);
+    add && decipher.setAAD(add);
+    decipher.setAuthTag(authTag);
+
+    const plaintext = decipher._update(ciphertext);
+    decipher._final();
+
+    return plaintext;
+}
+
+export function encrypt(key: Buffer, nonce: Buffer, aad: Buffer | null, plaintext: Buffer): EncryptedData {
+    nonce = padNonce(nonce);
+
+    const cipher = createCipher(key, nonce);
+    aad && cipher.setAAD(aad);
+
+    const ciphertext = cipher._update(plaintext);
+    cipher._final();
+
+    const authTag = cipher.getAuthTag();
+
+    return {
+        ciphertext: ciphertext,
+        authTag: authTag
+    };
+}
+
+export function padNonce(nonce: Buffer): Buffer {
+    if (nonce.length >= NONCE_LENGTH) {
+        return nonce;
+    }
+
+    return Buffer.concat([
+        Buffer.alloc(NONCE_LENGTH - nonce.length, 0),
+        nonce
+    ]);
+}
+
+// NOTE
+// Uncomment when Bun supports chacha20-poly1305 out of box.
+//
+// import { createCipheriv, createDecipheriv } from 'node:crypto';
+//
+// export function decrypt(key: Buffer, nonce: Buffer, aad: Buffer | null, ciphertext: Buffer, authTag: Buffer): Buffer {
+//     if (nonce.length < NONCE_LENGTH) {
+//         nonce = Buffer.concat([
+//             Buffer.alloc(NONCE_LENGTH - nonce.length, 0),
+//             nonce
+//         ]);
+//     }
+//
+//     const decipher = createDecipheriv('chacha20-poly1305', key, nonce, {authTagLength: AUTH_TAG_LENGTH});
+//     aad && decipher.setAAD(aad, {plaintextLength: ciphertext.length});
+//     decipher.setAuthTag(authTag);
+//
+//     const plaintext = decipher.update(ciphertext);
+//     decipher.final();
+//
+//     return plaintext;
+// }
+//
+// export function encrypt(key: Buffer, nonce: Buffer, aad: Buffer | null, plaintext: Buffer): EncryptedData {
+//     if (nonce.length < NONCE_LENGTH) {
+//         nonce = Buffer.concat([
+//             Buffer.alloc(NONCE_LENGTH - nonce.length, 0),
+//             nonce
+//         ]);
+//     }
+//
+//     const cipher = createCipheriv('chacha20-poly1305', key, nonce, {authTagLength: AUTH_TAG_LENGTH});
+//     aad && cipher.setAAD(aad, {plaintextLength: plaintext.length});
+//
+//     const ciphertext = cipher.update(plaintext);
+//     cipher.final();
+//
+//     const authTag = cipher.getAuthTag();
+//
+//     return {
+//         ciphertext: ciphertext,
+//         authTag: authTag
+//     };
+// }
+
+export type EncryptedData = {
+    readonly ciphertext: Buffer;
+    readonly authTag: Buffer;
+};

package/src/crypto/curve25519.ts

@@ -0,0 +1,21 @@
+import { randomBytes } from 'node:crypto';
+import { x25519 } from '@noble/curves/ed25519.js';
+
+export function generateKeyPair(): KeyPair {
+    const secretKey = randomBytes(32);
+    const publicKey = x25519.getPublicKey(secretKey);
+
+    return {
+        publicKey,
+        secretKey
+    };
+}
+
+export function generateSharedSecKey(priKey: Uint8Array, pubKey: Uint8Array): Uint8Array {
+    return x25519.getSharedSecret(priKey, pubKey);
+}
+
+interface KeyPair {
+    readonly publicKey: Uint8Array;
+    readonly secretKey: Uint8Array;
+}

package/src/crypto/hkdf.ts

@@ -0,0 +1,13 @@
+import { hkdfSync } from 'node:crypto';
+
+export default function (options: HKDFOptions): Buffer {
+    return Buffer.from(hkdfSync(options.hash, options.key, options.salt, options.info, options.length));
+}
+
+export type HKDFOptions = {
+    readonly hash: string;
+    readonly key: Buffer;
+    readonly length: number;
+    readonly salt: Buffer;
+    readonly info: Buffer;
+};

package/src/crypto/index.ts

@@ -0,0 +1,13 @@
+export {
+    decrypt as decryptChacha20,
+    encrypt as encryptChacha20
+} from './chacha20';
+
+export {
+    generateKeyPair as generateCurve25519KeyPair,
+    generateSharedSecKey as generateCurve25519SharedSecKey
+} from './curve25519'
+
+export {
+    default as hkdf
+} from './hkdf';

package/src/discovery/discovery.ts

@@ -0,0 +1,52 @@
+import mdns, { Result } from 'node-dns-sd';
+import { waitFor } from '@/cli';
+import { AIRPLAY_SERVICE, COMPANION_LINK_SERVICE, RAOP_SERVICE } from '@/const';
+
+export default class Discovery {
+    readonly #service: string;
+
+    constructor(service: string) {
+        this.#service = service;
+    }
+
+    async find(): Promise<Result[]> {
+        return await mdns.discover({
+            name: this.#service
+        });
+    }
+
+    async findUntil(fqdn: string, tries: number = 10, timeout: number = 1000): Promise<Result> {
+        while (tries > 0) {
+            const devices = await this.find();
+            const device = devices.find(device => device.fqdn === fqdn);
+
+            if (device) {
+                return device;
+            }
+
+            console.log();
+            console.log(`Device not found, retrying in ${timeout}ms...`);
+            console.log(devices.map(d => ` ● ${d.fqdn}`).join('\n'));
+
+            tries--;
+
+            if (tries === 0) {
+                throw new Error('Device not found after serveral tries, aborting.');
+            }
+
+            await waitFor(timeout);
+        }
+    }
+
+    static airplay(): Discovery {
+        return new Discovery(AIRPLAY_SERVICE);
+    }
+
+    static companionLink(): Discovery {
+        return new Discovery(COMPANION_LINK_SERVICE);
+    }
+
+    static raop(): Discovery {
+        return new Discovery(RAOP_SERVICE);
+    }
+}

package/src/discovery/index.ts

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

package/src/encoding/index.ts

@@ -0,0 +1,22 @@
+export {
+    unpack as decodeOPack,
+    pack as encodeOPack,
+    float as opackFloat,
+    int as opackInt,
+    sizedInt as opackSizedInt
+} from './opack';
+
+export {
+    parse as parseBinaryPlist,
+    serialize as serializeBinaryPlist
+} from './plist';
+
+export {
+    bail as bailTlv,
+    decode as decodeTlv,
+    encode as encodeTlv,
+    Flags as TlvFlags,
+    Method as TlvMethod,
+    State as TlvState,
+    Value as TlvValue
+} from './tlv8';

package/src/encoding/opack.ts

@@ -0,0 +1,293 @@
+type Packed = Uint8Array;
+type ObjectList = Packed[];
+
+class SizedInt extends Number {
+    size: number;
+
+    constructor(value: number, size: number) {
+        super(value);
+        this.size = size;
+    }
+}
+
+const _SIZED_INT_TYPES: Record<number, typeof SizedInt> = {};
+
+export function sizedInt(value: number, size: number): SizedInt {
+    return new SizedInt(value, size);
+}
+
+class OPACKFloat {
+    value: number;
+
+    constructor(value: number) {
+        this.value = value;
+    }
+}
+
+export function float(value: number) {
+    return new OPACKFloat(value);
+}
+
+class OPACKInt {
+    value: number;
+
+    constructor(value: number) {
+        this.value = value;
+    }
+}
+
+export function int(value: number) {
+    return new OPACKInt(value);
+}
+
+function concat(arr: Uint8Array[]): Uint8Array {
+    const total = arr.reduce((s, a) => s + a.length, 0);
+    const out = new Uint8Array(total);
+    let off = 0;
+    for (const a of arr) {
+        out.set(a, off);
+        off += a.length;
+    }
+    return out;
+}
+
+function u8(b: number) {
+    return Uint8Array.of(b);
+}
+
+function uintToLEBytes(value: number | bigint, byteLen: number): Uint8Array {
+    const out = new Uint8Array(byteLen);
+    let v = BigInt(value);
+    for (let i = 0; i < byteLen; i++) {
+        out[i] = Number(v & 0xffn);
+        v >>= 8n;
+    }
+    return out;
+}
+
+function concatUint8Arrays(arrays: Uint8Array[]): Uint8Array {
+    const total = arrays.reduce((sum, a) => sum + a.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const a of arrays) {
+        out.set(a, offset);
+        offset += a.length;
+    }
+    return out;
+}
+
+export function pack(data: any): Uint8Array {
+    return _pack(data, []);
+}
+
+function _pack(data: any, objectList: ObjectList): Uint8Array {
+    let packed: Uint8Array | null = null;
+
+    if (data === null || data === undefined) packed = u8(0x04);
+    else if (typeof data === 'boolean') packed = u8(data ? 0x01 : 0x02);
+    else if (data instanceof OPACKFloat) {
+        const buf = new ArrayBuffer(8);
+        new DataView(buf).setFloat64(0, data.value, true);
+        packed = concat([u8(0x36), new Uint8Array(buf)]);
+    } else if (data instanceof OPACKInt) {
+        const val = data.value;
+        if (val < 0x28) packed = u8(0x08 + val);
+        else if (val <= 0xff) packed = concatUint8Arrays([u8(0x30), uintToLEBytes(val, 1)]);
+        else if (val <= 0xffff) packed = concatUint8Arrays([u8(0x31), uintToLEBytes(val, 2)]);
+        else if (val <= 0xffffffff) packed = concatUint8Arrays([u8(0x32), uintToLEBytes(val, 4)]);
+        else packed = concatUint8Arrays([u8(0x33), uintToLEBytes(val, 8)]);
+    } else if (typeof data === 'number') {
+        if (!Number.isInteger(data)) {
+            const buf = new ArrayBuffer(8);
+            new DataView(buf).setFloat64(0, data, true);
+            packed = concat([u8(0x36), new Uint8Array(buf)]);
+        } else {
+            if (data < 0x28) packed = u8(0x08 + data);
+            else if (data <= 0xff) packed = concat([u8(0x30), uintToLEBytes(data, 1)]);
+            else if (data <= 0xffff) packed = concat([u8(0x31), uintToLEBytes(data, 2)]);
+            else if (data <= 0xffffffff) packed = concat([u8(0x32), uintToLEBytes(data, 4)]);
+            else packed = concat([u8(0x33), uintToLEBytes(data, 8)]);
+        }
+    } else if (data instanceof SizedInt) {
+        packed = concat([u8(0x30 + Math.log2(data.size)), uintToLEBytes(data.valueOf(), data.size)]);
+    } else if (typeof data === 'string') {
+        const b = new TextEncoder().encode(data);
+        const len = b.length;
+        if (len <= 0x20) packed = concat([u8(0x40 + len), b]);
+        else if (len <= 0xff) packed = concat([u8(0x61), uintToLEBytes(len, 1), b]);
+        else if (len <= 0xffff) packed = concat([u8(0x62), uintToLEBytes(len, 2), b]);
+        else if (len <= 0xffffff) packed = concat([u8(0x63), uintToLEBytes(len, 3), b]);
+        else packed = concat([u8(0x64), uintToLEBytes(len, 4), b]);
+    } else if (data instanceof Uint8Array || Buffer.isBuffer(data)) {
+        const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+        const len = bytes.length;
+        if (len <= 0x20) packed = concat([u8(0x70 + len), bytes]);
+        else if (len <= 0xff) packed = concat([u8(0x91), uintToLEBytes(len, 1), bytes]);
+        else if (len <= 0xffff) packed = concat([u8(0x92), uintToLEBytes(len, 2), bytes]);
+        else packed = concat([u8(0x93), uintToLEBytes(len, 4), bytes]);
+    } else if (Array.isArray(data)) {
+        const body = concat(data.map(d => _pack(d, objectList)));
+        const len = data.length;
+        if (len <= 0x0f) {
+            packed = concat([u8(0xd0 + len), body]);
+            if (len >= 0x0f) packed = concat([packed, u8(0x03)]);
+        } else packed = concat([u8(0xdf), body, u8(0x03)]);
+    } else if (typeof data === 'object') {
+        const keys = Object.keys(data);
+        const len = keys.length;
+        const pairs: Uint8Array[] = [];
+        for (const k of keys) {
+            pairs.push(_pack(k, objectList));
+            pairs.push(_pack((data as any)[k], objectList));
+        }
+        let header: Uint8Array;
+        if (len <= 0x0f) {
+            header = u8(0xE0 + len);
+        } else {
+            header = u8(0xEF);
+        }
+        packed = concatUint8Arrays([header, concatUint8Arrays(pairs)]);
+        // terminator
+        if (len >= 0x0f || objectList.some(v => v === packed)) {
+            packed = concatUint8Arrays([packed, u8(0x81)]);
+        }
+    } else throw new TypeError(typeof data + '');
+
+    // Object reuse
+    const idx = objectList.findIndex(v => v.length === packed!.length && v.every((x, i) => x === packed![i]));
+    if (idx >= 0) {
+        if (idx < 0x21) packed = u8(0xA0 + idx);
+        else if (idx <= 0xff) packed = concat([u8(0xC1), uintToLEBytes(idx, 1)]);
+        else if (idx <= 0xffff) packed = concat([u8(0xC2), uintToLEBytes(idx, 2)]);
+        else if (idx <= 0xffffffff) packed = concat([u8(0xC3), uintToLEBytes(idx, 4)]);
+        else packed = concat([u8(0xC4), uintToLEBytes(idx, 8)]);
+    } else if (packed!.length > 1) objectList.push(packed!);
+
+    return packed!;
+}
+
+/* UNPACK */
+export function unpack(data: Uint8Array): [any, Uint8Array] {
+    return _unpack(data, []);
+}
+
+function _unpack(data: Uint8Array, objectList: ObjectList): [any, Uint8Array] {
+    if (data.length === 0) throw new TypeError('No data to unpack');
+    let addToObjectList = true;
+    const tag = data[0];
+
+    // simple tokens
+    if (tag === 0x01) return [true, data.subarray(1)];
+    if (tag === 0x02) return [false, data.subarray(1)];
+    if (tag === 0x04) return [null, data.subarray(1)];
+    if (tag === 0x05) {
+        const uuidBytes = data.subarray(1, 17);
+        return [uuidBytes, data.subarray(17)];
+    }
+    if (tag === 0x06) {
+        // pyatv: dummy parse as integer (little-endian 8 bytes)
+        const val = readLittleEndian(data, 1, 8);
+        return [val, data.subarray(9)];
+    }
+    if (tag >= 0x08 && tag <= 0x2f) return [tag - 8, data.subarray(1)];
+    if (tag === 0x35) {
+        const view = new DataView(data.buffer, data.byteOffset + 1, 4);
+        return [view.getFloat32(0, true), data.subarray(5)];
+    }
+    if (tag === 0x36) {
+        const view = new DataView(data.buffer, data.byteOffset + 1, 8);
+        return [view.getFloat64(0, true), data.subarray(9)];
+    }
+    if ((tag & 0xF0) === 0x30) {
+        const noOfBytes = 2 ** (tag & 0xF);
+        const val = readLittleEndian(data, 1, noOfBytes);
+        const sized = sizedInt(val, noOfBytes);
+        return [sized, data.subarray(1 + noOfBytes)];
+    }
+    if (tag >= 0x40 && tag <= 0x60) {
+        const length = tag - 0x40;
+        const str = new TextDecoder().decode(data.subarray(1, 1 + length));
+        return [str, data.subarray(1 + length)];
+    }
+    if (tag >= 0x61 && tag <= 0x64) {
+        const lenBytes = tag & 0xF;
+        const length = readLittleEndian(data, 1, lenBytes);
+        const str = new TextDecoder().decode(data.subarray(1 + lenBytes, 1 + lenBytes + length));
+        return [str, data.subarray(1 + lenBytes + length)];
+    }
+    if (tag >= 0x70 && tag <= 0x90) {
+        const length = tag - 0x70;
+        const bytes = data.subarray(1, 1 + length);
+        return [bytes, data.subarray(1 + length)];
+    }
+    if (tag >= 0x91 && tag <= 0x94) {
+        // number of length bytes = 1 << ((tag & 0xF) - 1)
+        const noOfBytes = 1 << ((tag & 0xF) - 1);
+        const length = readLittleEndian(data, 1, noOfBytes);
+        const start = 1 + noOfBytes;
+        return [data.subarray(start, start + length), data.subarray(start + length)];
+    }
+    if ((tag & 0xF0) === 0xD0) {
+        const count = tag & 0xF;
+        let ptr = data.subarray(1);
+        const output: any[] = [];
+        if (count === 0xF) {
+            // endless list
+            while (ptr[0] !== 0x03) {
+                const [val, rem] = _unpack(ptr, objectList);
+                output.push(val);
+                ptr = rem;
+            }
+            ptr = ptr.subarray(1); // skip terminator
+        } else {
+            for (let i = 0; i < count; i++) {
+                const [val, rem] = _unpack(ptr, objectList);
+                output.push(val);
+                ptr = rem;
+            }
+        }
+        addToObjectList = false;
+        return [output, ptr];
+    }
+    if ((tag & 0xE0) === 0xE0) {
+        const count = tag & 0xF;
+        let ptr = data.subarray(1);
+        const output: Record<string, any> = {};
+        if (count === 0xF) {
+            // endless dict
+            while (ptr[0] !== 0x03) {
+                const [key, rem1] = _unpack(ptr, objectList);
+                const [val, rem2] = _unpack(rem1, objectList);
+                output[key] = val;
+                ptr = rem2;
+            }
+            ptr = ptr.subarray(1);
+        } else {
+            for (let i = 0; i < count; i++) {
+                const [key, rem1] = _unpack(ptr, objectList);
+                const [val, rem2] = _unpack(rem1, objectList);
+                output[key] = val;
+                ptr = rem2;
+            }
+        }
+        addToObjectList = false;
+        return [output, ptr];
+    }
+    if (tag >= 0xA0 && tag <= 0xC0) {
+        const idx = tag - 0xA0;
+        return [objectList[idx], data.subarray(1)];
+    }
+    if (tag >= 0xC1 && tag <= 0xC4) {
+        const len = tag - 0xC0;
+        const uid = readLittleEndian(data, 1, len);
+        return [objectList[uid], data.subarray(1 + len)];
+    }
+
+    throw new TypeError(`Unknown tag 0x${tag.toString(16)}`);
+}
+
+function readLittleEndian(buf: Uint8Array, offset: number, len: number) {
+    let v = 0n;
+    for (let i = len - 1; i >= 0; i--) v = (v << 8n) | BigInt(buf[offset + i]);
+    return Number(v);
+}

package/src/encoding/plist.ts

@@ -0,0 +1,2 @@
+export { parse } from '@plist/binary.parse';
+export { serialize } from '@plist/binary.serialize';