@ciphore/radiocli 0.2.4 → 0.2.6

package/vendor/node-airtunes2/UPSTREAM.json

@@ -0,0 +1,50 @@
+{
+  "url": "https://registry.npmjs.org/node-airtunes2/-/node-airtunes2-2.5.0.tgz",
+  "integrity": "sha512-OMbxDCTwakRwTEZ/PKA6HJOOHD1FiqYnw98RtGx/X3lFsNXyKPUMLyR43t9lQArRCYGsGgLuPwDv9Ehkw4mhHQ==",
+  "sha256": "2cee1d86fcd2e5fb4f56f12e23fd1abbdbd0b71a9bc5e1ffe1dcbb885cec1d71",
+  "unmodifiedFiles": {
+    ".editorconfig": "4e40c0a34e2c5d50eeaeb682bb5fd3f72f79e5cbd744729d309bf3bc5f1a7742",
+    ".nvmrc": "f14b4987904bcb5814e4459a057ed4d20f58a633152288a761214dcd28780b56",
+    "LICENSE": "2c0434c24a2fd80ef3c0dcca3c12a7618f3b0194b6bf9dc545695be86dc6c8e0",
+    "README.md": "230de9b984355778dcd8524725abd408bd3981ff6d419372135e6eab9a765a00",
+    "binding.gyp": "53cb9eb3fb6ccf3d35f0db61446dbe549d38a592644ba671c25b247a047f2a38",
+    "eslint.config.mjs": "b737b0a39d662188d2183fd06588821a996ddd920bce57d7fed758d52a6dd2e2",
+    "example_execlient.js": "950d83e8069032fbec39ddc6cd5d1ac8a5241dd5742e44b797f46d40fe95d3d0",
+    "lib/ap2_test.js": "9d902c2ccf7ec6ba45800ddf2db46fe5e8c2ad959d60aed2feb151c6fe4f6804",
+    "lib/atv.js": "a46235ad8b4b02a4d3b8abca64eba6d36af00e1b7d66f3669f34c65efa2f5ddd",
+    "lib/audio_out.js": "0481f988ec3e76ce33a5fe771eeb20107183850e22310325a7cb4799b72f8cc6",
+    "lib/circular_buffer.js": "e5521fc371be58bf6aa61b0bbdb906a48da4fd90c012e6db45ce4979a85c7719",
+    "lib/config.js": "18a2e5bcc6c41804945c28af3c14ed3a306e19c48aad4f4624ff30a7c9e14e49",
+    "lib/device_airtunes.js": "4782a671f6fa0924e8a48119a69b6ff93764d2265aedb6e293f284c773261a9a",
+    "lib/devices.js": "90b40223384c81f5635bad7b27bbe0d2061a2653c70053aed53ba6ecb4be6852",
+    "lib/homekit/credentials.js": "aa74c977d9831f064164ef30a8a12fd2a9eb06ce4d787fc28d8a2c57bfc2c1a7",
+    "lib/homekit/encryption.js": "e1ce0ef009309797d91b70d5f27f8234ef9fda1bb325ecb78a6fd296d87e03db",
+    "lib/homekit/number.js": "fd34215e79e61f75fefab06188ff3041982b933d4c406c7638ccb90630f1c6cf",
+    "lib/homekit/tlv.js": "447d1544d6befbe2281d50027a419cdecf4c2c9ee9e226ba216161046545e678",
+    "lib/http.js": "c7c32939c30e214c6e64de5f63eb0f3764122e988a76d85e606b72d86492effa",
+    "lib/index.d.ts": "365cc6d2375896b8141c1f68b76d3e0940ede807f34b3dcbd428e4f45674d674",
+    "lib/index.js": "b1c112d4e7b8e378b9ec9fa21cf4b5147cd773f887c99062f54a6a2afb410e63",
+    "lib/ntp.js": "208491f53fb4dc9e872eec1953d13aebf7f3c6d042a32020faf402a92008a8df",
+    "lib/num_util.js": "6a9585f05cd0fdb709dfb7eb63d554de377831e8f37425cd01028f8fa1d85f13",
+    "lib/packet_pool.js": "aef0dc8c9fe4be88a212134b2703f3e6551454e991c8e04d869f3a2cddbb2960",
+    "lib/rtsp.js": "99f5fa32e4cb29817ee57d79dd103f8f3bee34217a8032e92df3b5c8b3daa3ca",
+    "lib/srp.js": "878ca193826b216edaff1f428cd7645d85bcc0d2a8c10de4e5145454a0f0d631",
+    "lib/udp_servers.js": "fcd41ba9ba2b25db8aa74cdb3606f8a8f0201c99cb6c26bbc30a344ade36380d",
+    "lib/util.js": "6aeffbe069d052157079bc4fd508ab616de80e08b219dff2a6f30ac4c8303c65",
+    "src/CADebugMacros.h": "bc139e5ceb89790191b71ce61038f532f755707608f123a8f4783eb6f98e6872",
+    "src/CAHostTimeBase.cpp": "e3db4379731e39ae6d5699aa9625dcf286cfc9ffacafa769c87b746d663186ce",
+    "src/CAHostTimeBase.h": "27d74cbf90e7b4e74f44b5dda11b18ebed962a77cc530c6a4eb4456cdad0fda2",
+    "src/aes_utils.c": "2d72155b2d9319abc1d4db695fdabfbbdbbaad157286df75a0500653352053ad",
+    "src/aes_utils.h": "500146ef43ea263263e15e39c91330deb979db13c85bb0c809f2c1b7243f08f0",
+    "src/base64.c": "79d33c06704f52ce09062deb4c9659a98f826db43625f5f1840a1d8250f16d9d",
+    "src/base64.h": "ed283d2c2b5e6593d683a97621c8a7994e590529ec6576811da39eaa9ee02146",
+    "src/bindings.cc": "38da78b95543422006a1d7c87118ee966cc970b2c353d24d751c43d0d44e0090",
+    "src/codec.cc": "ba2f0ab6071e09410daed8aa6ee4fcec20ed23c627b4b46cd7078ee70b74f109",
+    "src/coreaudio.cc": "487fcf7e7430be3faf30a9338080cc9147014c1c64c7e6debd3bede117e2a615"
+  },
+  "excludedFiles": [
+    "build/",
+    "SECURITY.md",
+    "exe_api.md"
+  ]
+}

package/vendor/node-airtunes2/binding.gyp

@@ -0,0 +1,41 @@
+{
+    'targets': [
+        {
+            'target_name': 'airtunes',
+            'sources': [
+                'src/codec.cc', 'src/bindings.cc',
+                'src/aes_utils.c', 'src/base64.c',
+            ],
+            'conditions': [
+                ['OS=="mac"', {
+                    'include_dirs':
+                    ['/System/Library/Frameworks/Kernel.framework/Versions/A/Headers/sys'
+                     ],
+
+                    'sources': [
+                    ],
+                    'xcode_settings': {
+                        'CLANG_CXX_LANGUAGE_STANDARD': 'c++20'
+                    }
+                }],
+                ['OS=="linux"', {
+                    'sources': [
+                    ],
+                    'cflags_cc': [
+                      "-std=c++20"
+                    ]
+                }],
+                ['OS=="win"', {
+                    'include_dirs': ['C:\\Program Files\\OpenSSL-Win64\\include\\'],
+                    "msbuild_settings": {
+                          "ClCompile": {
+                              "LanguageStandard": "stdcpp20"
+                           }
+                    },
+                    'sources': [
+                    ],
+                }],
+            ]
+        }
+    ]
+}

package/vendor/node-airtunes2/lib/ap2_test.js

@@ -0,0 +1,4 @@
+const number = require('./homekit/number').default
+
+const u = number.UInt16toBufferBE(287)
+console.log(Buffer.concat([u.slice(1), u.slice(0, 1)]))

package/vendor/node-airtunes2/lib/atv.js

@@ -0,0 +1,307 @@
+const crypto = require('crypto')
+const fs = require('fs')
+const bplistCreator = require('bplist-creator')
+const bplistParser = require('bplist-parser')
+const SRP = require('./srp')
+const ATVAuthenticator = require('./atvAuthenticator')
+const httpClientFactory = require('./http')
+
+// ...
+// Configuration.
+const loadConfig = configFilePath => !fs.existsSync(configFilePath) ? null : JSON.parse(fs.readFileSync(configFilePath))
+const saveConfig = (configFilePath, config) => fs.writeFileSync(configFilePath, JSON.stringify(config, null, '\t'))
+
+// ...
+
+class ATV {
+  constructor(addr, port) {
+    this.addr = addr
+    this.port = port || 7000
+
+    this.httpClient = httpClientFactory()
+    this.auth_secret = null
+  }
+
+  // ...
+
+  auth(configFilePath, authenticator) {
+    async function auth(owner) {
+      await owner.httpClient.connect(owner.addr, owner.port)
+
+      let conf = loadConfig(configFilePath)
+      if (!conf || !conf['auth_secret']) {
+        // a pairing does not exist and must be performed.
+
+        // ...
+        // SRP parameters.
+        const srp = new SRP(2048)
+
+        let I = '366B4165DD64AD3A'
+        let P
+        let s
+        let B
+        let a
+        let A
+        let M1
+
+        await owner.httpClient.request('POST', '/pair-pin-start')
+          .then(() => authenticator())
+          .then((pin) => {
+            P = pin
+
+            return owner.httpClient.request(
+              'POST',
+              '/pair-setup-pin',
+              {
+                'Content-Type': 'application/x-apple-binary-plist',
+              },
+              bplistCreator({
+                user: '366B4165DD64AD3A',
+                method: 'pin',
+              }),
+            )
+          })
+          .then((res) => {
+            const { pk, salt } = bplistParser.parseBuffer(res.body)[0]
+
+            s = salt.toString('hex')
+            B = pk.toString('hex')
+
+            // SRP: Generate random auth_secret, 'a'; if pairing is successful, it'll be utilized in
+            // subsequent session authentication(s).
+            a = crypto.randomBytes(32).toString('hex')
+
+            // SRP: Compute A and M1.
+            A = srp.A(a)
+            M1 = srp.M1(I, P, s, a, B)
+
+            return owner.httpClient.request(
+              'POST',
+              '/pair-setup-pin',
+              {
+                'Content-Type': 'application/x-apple-binary-plist',
+              },
+              bplistCreator({
+                pk: Buffer.from(A, 'hex'),
+                proof: Buffer.from(M1, 'hex'),
+              }),
+            )
+          })
+          .then(() => {
+            // confirm the auth secret (a).
+            const { epk, authTag } = ATVAuthenticator.confirm(a, srp.K(I, P, s, a, B))
+
+            // complete pair-setup-pin by registering the auth secret with the target device.
+            return owner.httpClient.request(
+              'POST',
+              '/pair-setup-pin',
+              {
+                'Content-Type': 'application/x-apple-binary-plist',
+              },
+              bplistCreator({
+                epk: Buffer.from(epk, 'hex'),
+                authTag: Buffer.from(authTag, 'hex'),
+              }),
+            )
+          })
+          .then(() => {
+            // save the auth secret for subsequent session authentication(s).
+            !conf && (conf = {})
+            conf['auth_secret'] = a
+            saveConfig(configFilePath, conf)
+          })
+      }
+
+      // ...
+      // Authenticate session with the target device using existing pairing information.
+      const verifier = ATVAuthenticator.verifier(conf['auth_secret'])
+
+      return owner.httpClient.request(
+        'POST',
+        '/pair-verify',
+        {
+          'Content-Type': 'application/octet-stream',
+        },
+        verifier.verifierBody,
+      )
+        .then((res) => {
+          const atv_pub = res.body.slice(0, 32).toString('hex')
+          const atv_data = res.body.slice(32).toString('hex')
+
+          const shared = ATVAuthenticator.shared(verifier.v_pri, atv_pub)
+          const signed = ATVAuthenticator.signed(conf['auth_secret'], verifier.v_pub, atv_pub)
+          const signature = Buffer.from(
+            Buffer.from([0x00, 0x00, 0x00, 0x00]).toString('hex')
+            + ATVAuthenticator.signature(shared, atv_data, signed),
+            'hex',
+          )
+
+          return owner.httpClient.request(
+            'POST',
+            '/pair-verify',
+            {
+              'Content-Type': 'application/octet-stream',
+            },
+            signature,
+          )
+        })
+    };
+
+    return auth(this)
+  }
+
+  authSecret() {
+    return this.auth_secret
+  }
+
+  authSimple(authenticator) {
+    async function auth(owner) {
+      await owner.httpClient.connect(owner.addr, owner.port)
+
+      let conf = null
+      if (!conf || !conf['auth_secret']) {
+        // a pairing does not exist and must be performed.
+
+        // ...
+        // SRP parameters.
+        const srp = new SRP(2048)
+
+        let I = '366B4165DD64AD3A'
+        let P
+        let s
+        let B
+        let a
+        let A
+        let M1
+
+        await owner.httpClient.request('POST', '/pair-pin-start')
+          .then(() => authenticator())
+          .then((pin) => {
+            P = pin
+
+            return owner.httpClient.request(
+              'POST',
+              '/pair-setup-pin',
+              {
+                'Content-Type': 'application/x-apple-binary-plist',
+              },
+              bplistCreator({
+                user: '366B4165DD64AD3A',
+                method: 'pin',
+              }),
+            )
+          })
+          .then((res) => {
+            const { pk, salt } = bplistParser.parseBuffer(res.body)[0]
+
+            s = salt.toString('hex')
+            B = pk.toString('hex')
+
+            // SRP: Generate random auth_secret, 'a'; if pairing is successful, it'll be utilized in
+            // subsequent session authentication(s).
+            a = crypto.randomBytes(32).toString('hex')
+
+            // SRP: Compute A and M1.
+            A = srp.A(a)
+            M1 = srp.M1(I, P, s, a, B)
+
+            return owner.httpClient.request(
+              'POST',
+              '/pair-setup-pin',
+              {
+                'Content-Type': 'application/x-apple-binary-plist',
+              },
+              bplistCreator({
+                pk: Buffer.from(A, 'hex'),
+                proof: Buffer.from(M1, 'hex'),
+              }),
+            )
+          }).then(() => {
+            // confirm the auth secret (a).
+            const { epk, authTag } = ATVAuthenticator.confirm(a, srp.K(I, P, s, a, B))
+
+            // complete pair-setup-pin by registering the auth secret with the target device.
+            return owner.httpClient.request(
+              'POST',
+              '/pair-setup-pin',
+              {
+                'Content-Type': 'application/x-apple-binary-plist',
+              },
+              bplistCreator({
+                epk: Buffer.from(epk, 'hex'),
+                authTag: Buffer.from(authTag, 'hex'),
+              }),
+            )
+          })
+          .then(() => {
+            // save the auth secret for subsequent session authentication(s).
+            console.log(a)
+            owner.auth_secret = a
+          })
+      }
+    }
+    return auth(this)
+  }
+
+  verifySimple(secret) {
+    // ...
+    // Authenticate session with the target device using existing pairing information.
+    const verifier = ATVAuthenticator.verifier(secret)
+
+    return owner.httpClient.request(
+      'POST',
+      '/pair-verify',
+      {
+        'Content-Type': 'application/octet-stream',
+      },
+      verifier.verifierBody,
+    )
+      .then((res) => {
+        const atv_pub = res.body.slice(0, 32).toString('hex')
+        const atv_data = res.body.slice(32).toString('hex')
+
+        const shared = ATVAuthenticator.shared(verifier.v_pri, atv_pub)
+        const signed = ATVAuthenticator.signed(secret, verifier.v_pub, atv_pub)
+        const signature = Buffer.from(
+          Buffer.from([0x00, 0x00, 0x00, 0x00]).toString('hex')
+          + ATVAuthenticator.signature(shared, atv_data, signed),
+          'hex',
+        )
+
+        return owner.httpClient.request(
+          'POST',
+          '/pair-verify',
+          {
+            'Content-Type': 'application/octet-stream',
+          },
+          signature,
+        )
+      })
+  }
+
+  play(videoUrl) {
+    return this.httpClient.request(
+      'POST',
+      '/play',
+      {
+        'Content-Type': 'application/x-apple-binary-plist',
+      },
+      bplistCreator({
+        'Content-Location': videoUrl,
+        'Start-Location': 0,
+      }),
+    )
+  }
+
+  stop() {
+    return this.httpClient.request('POST', '/stop')
+  }
+
+  close() {
+    this.httpClient.close()
+  }
+}
+
+// ...
+
+module.exports = ATV

package/vendor/node-airtunes2/lib/atvAuthenticator.js

@@ -0,0 +1,136 @@
+// RadioCLI modification, 2026-10-16: replace elliptic with native Ed25519.
+// Distributed under the accompanying AGPLv3; pairing formats remain unchanged.
+const ed25519 = require('./ed25519')
+const crypto = require('crypto')
+const axlsign = require('axlsign')
+const { hexString2ArrayBuffer, buf2hex } = require('./util')
+
+// ...
+// Note: All functions expect parameters to be hex strings.
+
+function pair_setup_aes_key(K) {
+  return crypto.createHash('sha512')
+    .update('Pair-Setup-AES-Key')
+    .update(hexString2ArrayBuffer(K))
+    .digest('hex')
+    .substring(0, 32)
+}
+
+function pair_setup_aes_iv(K) {
+  let ab = crypto.createHash('sha512')
+    .update('Pair-Setup-AES-IV')
+    .update(hexString2ArrayBuffer(K))
+    .digest()
+
+  ab = ab.slice(0, 16)
+  ab[ab.length - 1] += 0x01
+
+  return buf2hex(ab)
+}
+
+function pair_verify_aes_key(shared) {
+  return buf2hex(
+    crypto.createHash('sha512')
+      .update('Pair-Verify-AES-Key')
+      .update(hexString2ArrayBuffer(shared))
+      .digest()
+      .slice(0, 16),
+  )
+}
+
+function pair_verify_aes_iv(shared) {
+  return buf2hex(
+    crypto.createHash('sha512')
+      .update('Pair-Verify-AES-IV')
+      .update(hexString2ArrayBuffer(shared))
+      .digest()
+      .slice(0, 16),
+  )
+}
+
+// ...
+// Public.
+
+function a_pub(a) {
+  return ed25519.publicKey(a)
+}
+
+function confirm(a, K) {
+  const key = pair_setup_aes_key(K)
+  const iv = pair_setup_aes_iv(K)
+
+  const cipher = crypto.createCipheriv(
+    'aes-128-gcm',
+    hexString2ArrayBuffer(key),
+    hexString2ArrayBuffer(iv),
+  )
+
+  let encrypted = cipher.update(hexString2ArrayBuffer(a_pub(a)), null, 'hex')
+  encrypted += cipher.final('hex')
+
+  return {
+    epk: encrypted,
+    authTag: buf2hex(cipher.getAuthTag()),
+  }
+}
+
+function verifier(a) {
+  const keyPair = axlsign.generateKeyPair(crypto.randomBytes(32))
+  const v_pri = buf2hex(keyPair.private)
+  const v_pub = buf2hex(keyPair.public)
+
+  const header = Buffer.from([0x01, 0x00, 0x00, 0x00])
+  const a_pub_buf = Buffer.from(a_pub(a), 'hex')
+
+  return {
+    verifierBody: Buffer.concat(
+      [header, keyPair.public, a_pub_buf],
+      header.byteLength + keyPair.public.byteLength + a_pub_buf.byteLength,
+    ),
+    v_pri,
+    v_pub,
+  }
+}
+
+function shared(v_pri, atv_pub) {
+  return buf2hex(
+    axlsign.sharedKey(
+      hexString2ArrayBuffer(v_pri),
+      hexString2ArrayBuffer(atv_pub),
+    ),
+  )
+}
+
+function signed(a, v_pub, atv_pub) {
+  return ed25519.sign(a, v_pub + atv_pub)
+}
+
+function signature(shared, atv_data, signed) {
+  const cipher = crypto.createCipheriv(
+    'aes-128-ctr',
+    hexString2ArrayBuffer(pair_verify_aes_key(shared)),
+    hexString2ArrayBuffer(pair_verify_aes_iv(shared)),
+  )
+
+  // discard the result of encrypting atv_data.
+  cipher.update(hexString2ArrayBuffer(atv_data))
+
+  let encrypted = cipher.update(Buffer.from(signed, 'hex'), null, 'hex')
+  encrypted += cipher.final('hex')
+
+  return encrypted
+}
+
+module.exports = {
+  pair_setup_aes_key,
+  pair_setup_aes_iv,
+  pair_verify_aes_key,
+  pair_verify_aes_iv,
+
+  a_pub,
+  confirm,
+  verifier,
+  shared,
+  signed,
+  signature,
+}

package/vendor/node-airtunes2/lib/audio_out.js

@@ -0,0 +1,69 @@
+const events = require('events')
+const util = require('util')
+const config = require('./config')
+const nu = require('./num_util')
+
+const SEQ_NUM_WRAP = Math.pow(2, 16)
+
+function AudioOut() {
+  events.EventEmitter.call(this)
+
+  this.lastSeq = -1
+  this.hasAirTunes = false
+}
+
+util.inherits(AudioOut, events.EventEmitter)
+
+AudioOut.prototype.init = function (devices, circularBuffer) {
+  var self = this
+  config.rtp_time_ref = new Date().getTime()
+
+  devices.on('airtunes_devices', function (hasAirTunes) {
+    self.hasAirTunes = hasAirTunes
+  })
+
+  devices.on('need_sync', function () {
+    // a sync is forced when a new remote device is added
+    self.emit('need_sync', self.lastSeq)
+  })
+
+  function sendPacket(seq) {
+    var packet = circularBuffer.readPacket()
+
+    packet.seq = seq % SEQ_NUM_WRAP
+    packet.timestamp = nu.low32(seq * config.frames_per_packet + 2 * config.sampling_rate)
+
+    if (self.hasAirTunes && seq % config.sync_period == 0)
+      self.emit('need_sync', seq)
+
+    self.emit('packet', packet)
+    packet.release()
+  }
+
+  function syncAudio() {
+    /*
+     * Each time syncAudio() runs, a burst of packet is sent.
+     * Increasing config.stream_latency lowers CPU usage but increases the size of the burst.
+     * If the burst size exceeds the UDP windows size (which we do not know), packets are lost.
+     */
+    var elapsed = new Date().getTime() - config.rtp_time_ref
+
+    /*
+     * currentSeq is the # of the packet we should be sending now. We have some packets to catch-up
+     * since syncAudio is not always running.
+     */
+    var currentSeq = Math.floor(elapsed * config.sampling_rate / (config.frames_per_packet * 1000))
+
+    for (let i = self.lastSeq + 1; i <= currentSeq; i++)
+      sendPacket(i)
+
+    self.lastSeq = currentSeq
+
+    // reschedule ourselves later
+    setTimeout(syncAudio, config.stream_latency)
+  }
+
+  syncAudio()
+}
+
+module.exports = AudioOut