@ciphore/radiocli 0.2.4 → 0.2.5

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

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

@@ -0,0 +1,133 @@
+const Stream = require('stream')
+const util = require('util')
+const PacketPool = require('./packet_pool')
+
+const WAITING = 0
+const FILLING = 1
+const NORMAL = 2
+const DRAINING = 3
+const ENDING = 4
+const ENDED = 5
+
+function CircularBuffer(packetsInBuffer, packetSize) {
+  Stream.call(this)
+
+  this.packetPool = new PacketPool()
+  this.maxSize = packetsInBuffer * packetSize
+  this.packetSize = packetSize
+  this.writable = true
+  this.muted = false
+  this.buffers = []
+  this.currentSize = 0
+  this.status = WAITING
+}
+
+util.inherits(CircularBuffer, Stream)
+
+CircularBuffer.prototype.write = function (chunk) {
+  this.buffers.push(chunk)
+  this.currentSize += chunk.length
+
+  if (this.status === ENDING || this.status === ENDED)
+    throw new Error('Cannot write in buffer after closing it')
+
+  if (this.status === WAITING) {
+    // notify when we receive the first chunk
+    this.emit('status', 'buffering')
+    this.status = FILLING
+  }
+
+  if (this.status === FILLING && this.currentSize > this.maxSize / 2) {
+    this.status = NORMAL
+    this.emit('status', 'playing')
+  }
+
+  if (this.currentSize >= this.maxSize) {
+    this.status = DRAINING
+    return false
+  }
+  else {
+    return true
+  }
+}
+
+CircularBuffer.prototype.readPacket = function () {
+  var packet = this.packetPool.getPacket()
+
+  // play silence until buffer is filled enough
+  if (this.status !== ENDING && this.status !== ENDED
+    && (this.status === FILLING || this.currentSize < this.packetSize)) {
+    packet.pcm.fill(0)
+
+    if (this.status !== FILLING && this.status !== WAITING) {
+      this.status = FILLING
+      this.emit('status', 'buffering')
+    }
+  }
+  else {
+    var offset = 0, remaining = this.packetSize
+
+    // fill a whole packet with data
+    while (remaining > 0) {
+      // pad packet with silence if buffer is empty
+      if (this.buffers.length === 0) {
+        packet.pcm.fill(0, offset)
+        remaining = 0
+        break
+      }
+
+      var first = this.buffers[0]
+
+      if (first.length <= remaining) {
+        // pop the whole buffer from the queue
+        first.copy(packet.pcm, offset)
+        offset += first.length
+        remaining -= first.length
+        this.buffers.shift()
+      }
+      else {
+        // first buffer contains enough data to fill a packet: slice it
+        first.copy(packet.pcm, offset, 0, remaining)
+        this.buffers[0] = first.slice(remaining)
+        offset += remaining
+        remaining = 0
+      }
+    }
+
+    this.currentSize -= this.packetSize
+
+    // emit 'end' only once
+    if (this.status === ENDING && this.currentSize <= 0) {
+      this.status = ENDED
+      this.currentSize = 0
+      this.emit('status', 'end')
+    }
+
+    // notify that the buffer now has enough room if needed
+    if (this.status === DRAINING && this.currentSize < this.maxSize / 2) {
+      this.status = NORMAL
+      this.emit('drain')
+    }
+  }
+
+  if (this.muted)
+    packet.pcm.fill(0)
+
+  return packet
+}
+
+CircularBuffer.prototype.end = function () {
+  // flush the buffer if it was filling
+  if (this.status === FILLING)
+    this.emit('status', 'playing')
+
+  this.status = ENDING
+}
+
+CircularBuffer.prototype.reset = function () {
+  this.buffers = []
+  this.currentSize = 0
+  this.status = WAITING
+}
+
+module.exports = CircularBuffer

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

@@ -0,0 +1,26 @@
+const nu = require('./num_util')
+
+const Config = {
+  user_agent: 'iTunes/11.3.1 (Windows; Microsoft Windows 10 x64 (Build 19044); x64) (dt:2)',
+  udp_default_port: 54621, // preferred starting port in AirTunes v2
+  frames_per_packet: 352, // samples per frames in ALAC packets
+  channels_per_frame: 2, // always stereo in AirTunes v2
+  bits_per_channel: 16, // -> 2 bytes per channel
+  packet_size: 352 * 2 * 2, // frames*channels*bytes
+  packets_in_buffer: 200, // increase this buffer protects against network issues
+  coreaudio_min_level: 5, // if CoreAudio's internal buffer drops too much, inject some silence to raise it
+  coreaudio_check_period: 2000, // CoreAudio buffer level check period
+  coreaudio_preload: 352 * 2 * 2 * 50, // ~0.5s of silence pushed to CoreAudio to avoid draining AudioQueue
+  sampling_rate: 44100, // fixed by AirTunes v2
+  sync_period: 126, // UDP sync packets are sent to all AirTunes devices regularly
+  stream_latency: 100, // audio UDP packets are flushed in bursts periodically
+  rtsp_timeout: 2147483647, // RTSP servers are considered gone if no reply is received before the timeout
+  rtsp_heartbeat: 15000, // some RTSP (like HomePod) servers requires heartbeat. Recommanded value: 60000 (1 minute). Set to 0 if you want to disable it.
+  rtp_time_ref: 0,
+  device_magic: nu.randomInt(9),
+  ntp_epoch: 0x83aa7e80,
+  iv_base64: 'ePRBLI0XN5ArFaaz7ncNZw',
+  rsa_aeskey_base64: 'VjVbxWcmYgbBbhwBNlCh3K0CMNtWoB844BuiHGUJT51zQS7SDpMnlbBIobsKbfEJ3SCgWHRXjYWf7VQWRYtEcfx7ejA8xDIk5PSBYTvXP5dU2QoGrSBv0leDS6uxlEWuxBq3lIxCxpWO2YswHYKJBt06Uz9P2Fq2hDUwl3qOQ8oXb0OateTKtfXEwHJMprkhsJsGDrIc5W5NJFMAo6zCiM9bGSDeH2nvTlyW6bfI/Q0v0cDGUNeY3ut6fsoafRkfpCwYId+bg3diJh+uzw5htHDyZ2sN+BFYHzEfo8iv4KDxzeya9llqg6fRNQ8d5YjpvTnoeEQ9ye9ivjkBjcAfVw',
+}
+
+module.exports = Config