@libp2p/webrtc 5.0.26-d8f003e6e → 5.0.27-2e35b6055

package/src/private-to-public/utils/connect.ts

@@ -0,0 +1,192 @@
+import { noise } from '@chainsafe/libp2p-noise'
+import { raceEvent } from 'race-event'
+import { WebRTCTransportError } from '../../error.js'
+import { WebRTCMultiaddrConnection } from '../../maconn.js'
+import { DataChannelMuxerFactory } from '../../muxer.js'
+import { createStream } from '../../stream.js'
+import { isFirefox } from '../../util.js'
+import { generateNoisePrologue } from './generate-noise-prologue.js'
+import * as sdp from './sdp.js'
+import type { DirectRTCPeerConnection } from './get-rtcpeerconnection.js'
+import type { DataChannelOptions } from '../../index.js'
+import type { ComponentLogger, Connection, CounterGroup, Logger, Metrics, PeerId, PrivateKey, Upgrader } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export interface ConnectOptions {
+  log: Logger
+  logger: ComponentLogger
+  metrics?: Metrics
+  events?: CounterGroup
+  remoteAddr: Multiaddr
+  role: 'client' | 'server'
+  dataChannel?: DataChannelOptions
+  upgrader: Upgrader
+  peerId: PeerId
+  remotePeerId?: PeerId
+  signal: AbortSignal
+  privateKey: PrivateKey
+}
+
+export interface ClientOptions extends ConnectOptions {
+  role: 'client'
+}
+
+export interface ServerOptions extends ConnectOptions {
+  role: 'server'
+}
+
+const CONNECTION_STATE_CHANGE_EVENT = isFirefox ? 'iceconnectionstatechange' : 'connectionstatechange'
+
+export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: string, options: ClientOptions): Promise<Connection>
+export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: string, options: ServerOptions): Promise<void>
+export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: string, options: ConnectOptions): Promise<any> {
+  // create data channel for running the noise handshake. Once the data
+  // channel is opened, the remote will initiate the noise handshake. This
+  // is used to confirm the identity of the peer.
+  const handshakeDataChannel = peerConnection.createDataChannel('', { negotiated: true, id: 0 })
+
+  if (options.role === 'client') {
+    // the client has to set the local offer before the remote answer
+
+    // Create offer and munge sdp with ufrag == pwd. This allows the remote to
+    // respond to STUN messages without performing an actual SDP exchange.
+    // This is because it can infer the passwd field by reading the USERNAME
+    // attribute of the STUN message.
+    options.log.trace('client creating local offer')
+    const offerSdp = await peerConnection.createOffer()
+    options.log.trace('client created local offer %s', offerSdp.sdp)
+    const mungedOfferSdp = sdp.munge(offerSdp, ufrag)
+    options.log.trace('client setting local offer %s', mungedOfferSdp.sdp)
+    await peerConnection.setLocalDescription(mungedOfferSdp)
+
+    const answerSdp = sdp.serverAnswerFromMultiaddr(options.remoteAddr, ufrag)
+    options.log.trace('client setting server description %s', answerSdp.sdp)
+    await peerConnection.setRemoteDescription(answerSdp)
+  } else {
+    // the server has to set the remote offer before the local answer
+    const offerSdp = sdp.clientOfferFromMultiAddr(options.remoteAddr, ufrag)
+    options.log.trace('server setting client %s %s', offerSdp.type, offerSdp.sdp)
+    await peerConnection.setRemoteDescription(offerSdp)
+
+    // Create offer and munge sdp with ufrag == pwd. This allows the remote to
+    // respond to STUN messages without performing an actual SDP exchange.
+    // This is because it can infer the passwd field by reading the USERNAME
+    // attribute of the STUN message.
+    options.log.trace('server creating local answer')
+    const answerSdp = await peerConnection.createAnswer()
+    options.log.trace('server created local answer')
+    const mungedAnswerSdp = sdp.munge(answerSdp, ufrag)
+    options.log.trace('server setting local description %s', answerSdp.sdp)
+    await peerConnection.setLocalDescription(mungedAnswerSdp)
+  }
+
+  options.log.trace('%s wait for handshake channel to open', options.role)
+  await raceEvent(handshakeDataChannel, 'open', options.signal)
+
+  options.log.trace('%s handshake channel opened', options.role)
+
+  if (options.role === 'server') {
+    // now that the connection has been opened, add the remote's certhash to
+    // it's multiaddr so we can complete the noise handshake
+    const remoteFingerprint = peerConnection.remoteFingerprint()?.value ?? ''
+    options.remoteAddr = options.remoteAddr.encapsulate(sdp.fingerprint2Ma(remoteFingerprint))
+  }
+
+  // Do noise handshake.
+  // Set the Noise Prologue to libp2p-webrtc-noise:<FINGERPRINTS> before
+  // starting the actual Noise handshake.
+  // <FINGERPRINTS> is the concatenation of the of the two TLS fingerprints
+  // of A (responder) and B (initiator) in their byte representation.
+  const localFingerprint = sdp.getFingerprintFromSdp(peerConnection.localDescription?.sdp)
+
+  if (localFingerprint == null) {
+    throw new WebRTCTransportError('Could not get fingerprint from local description sdp')
+  }
+
+  options.log.trace('%s performing noise handshake', options.role)
+  const noisePrologue = generateNoisePrologue(localFingerprint, options.remoteAddr, options.role)
+
+  // Since we use the default crypto interface and do not use a static key
+  // or early data, we pass in undefined for these parameters.
+  const connectionEncrypter = noise({ prologueBytes: noisePrologue })(options)
+
+  const wrappedChannel = createStream({
+    channel: handshakeDataChannel,
+    direction: 'inbound',
+    logger: options.logger,
+    ...(options.dataChannel ?? {})
+  })
+  const wrappedDuplex = {
+    ...wrappedChannel,
+    sink: wrappedChannel.sink.bind(wrappedChannel),
+    source: (async function * () {
+      for await (const list of wrappedChannel.source) {
+        for (const buf of list) {
+          yield buf
+        }
+      }
+    }())
+  }
+
+  // Creating the connection before completion of the noise
+  // handshake ensures that the stream opening callback is set up
+  const maConn = new WebRTCMultiaddrConnection(options, {
+    peerConnection,
+    remoteAddr: options.remoteAddr,
+    timeline: {
+      open: Date.now()
+    },
+    metrics: options.events
+  })
+
+  peerConnection.addEventListener(CONNECTION_STATE_CHANGE_EVENT, () => {
+    switch (peerConnection.connectionState) {
+      case 'failed':
+      case 'disconnected':
+      case 'closed':
+        maConn.close().catch((err) => {
+          options.log.error('error closing connection', err)
+        })
+        break
+      default:
+        break
+    }
+  })
+
+  // Track opened peer connection
+  options.events?.increment({ peer_connection: true })
+
+  const muxerFactory = new DataChannelMuxerFactory(options, {
+    peerConnection,
+    metrics: options.events,
+    dataChannelOptions: options.dataChannel
+  })
+
+  if (options.role === 'client') {
+    // For outbound connections, the remote is expected to start the noise handshake.
+    // Therefore, we need to secure an inbound noise connection from the remote.
+    options.log.trace('%s secure inbound', options.role)
+    await connectionEncrypter.secureInbound(wrappedDuplex, {
+      remotePeer: options.remotePeerId
+    })
+
+    options.log.trace('%s upgrade outbound', options.role)
+    return options.upgrader.upgradeOutbound(maConn, { skipProtection: true, skipEncryption: true, muxerFactory })
+  }
+
+  // For inbound connections, we are expected to start the noise handshake.
+  // Therefore, we need to secure an outbound noise connection from the remote.
+  options.log.trace('%s secure outbound', options.role)
+  const result = await connectionEncrypter.secureOutbound(wrappedDuplex, {
+    remotePeer: options.remotePeerId
+  })
+  maConn.remoteAddr = maConn.remoteAddr.encapsulate(`/p2p/${result.remotePeer}`)
+
+  options.log.trace('%s upgrade inbound', options.role)
+
+  await options.upgrader.upgradeInbound(maConn, {
+    skipProtection: true,
+    skipEncryption: true,
+    muxerFactory
+  })
+}

package/src/private-to-public/utils/generate-certificates.browser.ts

@@ -0,0 +1,3 @@
+export async function generateWebTransportCertificate (): Promise<any> {
+  throw new Error('Not implemented')
+}

package/src/private-to-public/utils/generate-certificates.ts

@@ -0,0 +1,51 @@
+import { Crypto } from '@peculiar/webcrypto'
+import * as x509 from '@peculiar/x509'
+import { base64url } from 'multiformats/bases/base64'
+import { sha256 } from 'multiformats/hashes/sha2'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import type { TransportCertificate } from '../..'
+
+const crypto = new Crypto()
+x509.cryptoProvider.set(crypto)
+
+const ONE_DAY_MS = 86400000
+
+export interface GenerateTransportCertificateOptions {
+  days: number
+  start?: Date
+  extensions?: any[]
+}
+
+export async function generateTransportCertificate (keyPair: CryptoKeyPair, options: GenerateTransportCertificateOptions): Promise<TransportCertificate> {
+  const notBefore = options.start ?? new Date()
+  notBefore.setMilliseconds(0)
+  const notAfter = new Date(notBefore.getTime() + (options.days * ONE_DAY_MS))
+  notAfter.setMilliseconds(0)
+
+  const cert = await x509.X509CertificateGenerator.createSelfSigned({
+    serialNumber: (BigInt(Math.random().toString().replace('.', '')) * 100000n).toString(16),
+    name: 'CN=ca.com, C=US, L=CA, O=example, ST=CA',
+    notBefore,
+    notAfter,
+    signingAlgorithm: {
+      name: 'ECDSA'
+    },
+    keys: keyPair,
+    extensions: [
+      new x509.BasicConstraintsExtension(false, undefined, true)
+    ]
+  })
+
+  const exported = await crypto.subtle.exportKey('pkcs8', keyPair.privateKey)
+  const privateKeyPem = [
+    '-----BEGIN PRIVATE KEY-----',
+    ...uint8ArrayToString(new Uint8Array(exported), 'base64pad').split(/(.{64})/).filter(Boolean),
+    '-----END PRIVATE KEY-----'
+  ].join('\n')
+
+  return {
+    privateKey: privateKeyPem,
+    pem: cert.toString('pem'),
+    certhash: base64url.encode((await sha256.digest(new Uint8Array(cert.rawData))).bytes)
+  }
+}

package/src/private-to-public/utils/generate-noise-prologue.ts

@@ -0,0 +1,26 @@
+import * as Digest from 'multiformats/hashes/digest'
+import { sha256 } from 'multiformats/hashes/sha2'
+import { concat } from 'uint8arrays/concat'
+import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
+import * as sdp from './sdp.js'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+const PREFIX = uint8arrayFromString('libp2p-webrtc-noise:')
+
+/**
+ * Generate a noise prologue from the peer connection's certificate.
+ * noise prologue = bytes('libp2p-webrtc-noise:') + noise-server fingerprint + noise-client fingerprint
+ */
+export function generateNoisePrologue (localFingerprint: string, remoteAddr: Multiaddr, role: 'client' | 'server'): Uint8Array {
+  const localFpString = localFingerprint.trim().toLowerCase().replaceAll(':', '')
+  const localFpArray = uint8arrayFromString(localFpString, 'hex')
+  const local = Digest.create(sha256.code, localFpArray)
+  const remote: Uint8Array = sdp.mbdecoder.decode(sdp.certhash(remoteAddr))
+  const byteLength = PREFIX.byteLength + local.bytes.byteLength + remote.byteLength
+
+  if (role === 'server') {
+    return concat([PREFIX, remote, local.bytes], byteLength)
+  }
+
+  return concat([PREFIX, local.bytes, remote], byteLength)
+}

package/src/private-to-public/utils/get-rtcpeerconnection.browser.ts

@@ -0,0 +1,22 @@
+export async function createDialerRTCPeerConnection (role: 'client' | 'server', ufrag: string, rtcConfiguration?: RTCConfiguration | (() => RTCConfiguration | Promise<RTCConfiguration>), certificate?: RTCCertificate): Promise<RTCPeerConnection> {
+  if (certificate == null) {
+    // ECDSA is preferred over RSA here. From our testing we find that P-256 elliptic
+    // curve is supported by Pion, webrtc-rs, as well as Chromium (P-228 and P-384
+    // was not supported in Chromium). We use the same hash function as found in the
+    // multiaddr if it is supported.
+    certificate = await RTCPeerConnection.generateCertificate({
+      name: 'ECDSA',
+
+      // @ts-expect-error missing from lib.dom.d.ts but required by chrome
+      namedCurve: 'P-256'
+      // hash: sdp.toSupportedHashFunction(hashName)
+    })
+  }
+
+  const rtcConfig = typeof rtcConfiguration === 'function' ? await rtcConfiguration() : rtcConfiguration
+
+  return new RTCPeerConnection({
+    ...(rtcConfig ?? {}),
+    certificates: [certificate]
+  })
+}

package/src/private-to-public/utils/get-rtcpeerconnection.ts

@@ -0,0 +1,108 @@
+import { PeerConnection } from '@ipshipyard/node-datachannel'
+import { RTCPeerConnection } from '@ipshipyard/node-datachannel/polyfill'
+import { Crypto } from '@peculiar/webcrypto'
+import { DEFAULT_ICE_SERVERS } from '../../constants.js'
+import { MAX_MESSAGE_SIZE } from '../../stream.js'
+import { generateTransportCertificate } from './generate-certificates.js'
+import type { TransportCertificate } from '../../index.js'
+import type { CertificateFingerprint } from '@ipshipyard/node-datachannel'
+
+const crypto = new Crypto()
+
+interface DirectRTCPeerConnectionInit extends RTCConfiguration {
+  ufrag: string
+  peerConnection: PeerConnection
+}
+
+export class DirectRTCPeerConnection extends RTCPeerConnection {
+  private readonly peerConnection: PeerConnection
+  private readonly ufrag: string
+
+  constructor (init: DirectRTCPeerConnectionInit) {
+    super(init)
+
+    this.peerConnection = init.peerConnection
+    this.ufrag = init.ufrag
+  }
+
+  async createOffer (): Promise<globalThis.RTCSessionDescriptionInit | any> {
+    // have to set ufrag before creating offer
+    if (this.connectionState === 'new') {
+      this.peerConnection?.setLocalDescription('offer', {
+        iceUfrag: this.ufrag,
+        icePwd: this.ufrag
+      })
+    }
+
+    return super.createOffer()
+  }
+
+  async createAnswer (): Promise<globalThis.RTCSessionDescriptionInit | any> {
+    // have to set ufrag before creating answer
+    if (this.connectionState === 'new') {
+      this.peerConnection?.setLocalDescription('answer', {
+        iceUfrag: this.ufrag,
+        icePwd: this.ufrag
+      })
+    }
+
+    return super.createAnswer()
+  }
+
+  remoteFingerprint (): CertificateFingerprint {
+    if (this.peerConnection == null) {
+      throw new Error('Invalid state: peer connection not set')
+    }
+
+    return this.peerConnection.remoteFingerprint()
+  }
+}
+
+function mapIceServers (iceServers?: RTCIceServer[]): string[] {
+  return iceServers
+    ?.map((server) => {
+      const urls = Array.isArray(server.urls) ? server.urls : [server.urls]
+
+      return urls.map((url) => {
+        if (server.username != null && server.credential != null) {
+          const [protocol, rest] = url.split(/:(.*)/)
+          return `${protocol}:${server.username}:${server.credential}@${rest}`
+        }
+        return url
+      })
+    })
+    .flat() ?? []
+}
+
+export async function createDialerRTCPeerConnection (role: 'client' | 'server', ufrag: string, rtcConfiguration?: RTCConfiguration | (() => RTCConfiguration | Promise<RTCConfiguration>), certificate?: TransportCertificate): Promise<DirectRTCPeerConnection> {
+  if (certificate == null) {
+    // ECDSA is preferred over RSA here. From our testing we find that P-256
+    // elliptic curve is supported by Pion, webrtc-rs, as well as Chromium
+    // (P-228 and P-384 was not supported in Chromium). We use the same hash
+    // function as found in the multiaddr if it is supported.
+    const keyPair = await crypto.subtle.generateKey({
+      name: 'ECDSA',
+      namedCurve: 'P-256'
+    }, true, ['sign', 'verify'])
+
+    certificate = await generateTransportCertificate(keyPair, {
+      days: 365
+    })
+  }
+
+  const rtcConfig = typeof rtcConfiguration === 'function' ? await rtcConfiguration() : rtcConfiguration
+
+  return new DirectRTCPeerConnection({
+    ...rtcConfig,
+    ufrag,
+    peerConnection: new PeerConnection(`${role}-${Date.now()}`, {
+      disableFingerprintVerification: true,
+      disableAutoNegotiation: true,
+      certificatePemFile: certificate.pem,
+      keyPemFile: certificate.privateKey,
+      enableIceUdpMux: role === 'server',
+      maxMessageSize: MAX_MESSAGE_SIZE,
+      iceServers: mapIceServers(rtcConfig?.iceServers ?? DEFAULT_ICE_SERVERS.map(urls => ({ urls })))
+    })
+  })
+}

package/src/private-to-public/utils/sdp.ts

@@ -0,0 +1,174 @@
+import { InvalidParametersError } from '@libp2p/interface'
+import { multiaddr } from '@multiformats/multiaddr'
+import { base64url } from 'multiformats/bases/base64'
+import { bases, digest } from 'multiformats/basics'
+import * as Digest from 'multiformats/hashes/digest'
+import { sha256 } from 'multiformats/hashes/sha2'
+import { InvalidFingerprintError, UnsupportedHashAlgorithmError } from '../../error.js'
+import { MAX_MESSAGE_SIZE } from '../../stream.js'
+import { CERTHASH_CODE } from '../transport.js'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { MultihashDigest } from 'multiformats/hashes/interface'
+
+/**
+ * Get base2 | identity decoders
+ */
+// @ts-expect-error - Not easy to combine these types.
+export const mbdecoder: any = Object.values(bases).map(b => b.decoder).reduce((d, b) => d.or(b))
+
+const fingerprintRegex = /^a=fingerprint:(?:\w+-[0-9]+)\s(?<fingerprint>(:?[0-9a-fA-F]{2})+)$/m
+export function getFingerprintFromSdp (sdp: string | undefined): string | undefined {
+  if (sdp == null) {
+    return undefined
+  }
+
+  const searchResult = sdp.match(fingerprintRegex)
+  return searchResult?.groups?.fingerprint
+}
+
+// Extract the certhash from a multiaddr
+export function certhash (ma: Multiaddr): string {
+  const tups = ma.stringTuples()
+  const certhash = tups.filter((tup) => tup[0] === CERTHASH_CODE).map((tup) => tup[1])[0]
+
+  if (certhash === undefined || certhash === '') {
+    throw new InvalidParametersError(`Couldn't find a certhash component of multiaddr: ${ma.toString()}`)
+  }
+
+  return certhash
+}
+
+/**
+ * Convert a certhash into a multihash
+ */
+export function decodeCerthash (certhash: string): MultihashDigest {
+  return digest.decode(mbdecoder.decode(certhash))
+}
+
+export function certhashToFingerprint (certhash: string): string {
+  const mbdecoded = decodeCerthash(certhash)
+
+  return new Array(mbdecoded.bytes.length)
+    .fill(0)
+    .map((val, index) => {
+      return mbdecoded.digest[index].toString(16).padStart(2, '0').toUpperCase()
+    })
+    .join(':')
+}
+
+/**
+ * Extract the fingerprint from a multiaddr
+ */
+export function ma2Fingerprint (ma: Multiaddr): string {
+  const mhdecoded = decodeCerthash(certhash(ma))
+  const prefix = toSupportedHashFunction(mhdecoded.code)
+  const fingerprint = mhdecoded.digest.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '')
+  const sdp = fingerprint.match(/.{1,2}/g)
+
+  if (sdp == null) {
+    throw new InvalidFingerprintError(fingerprint, ma.toString())
+  }
+
+  return `${prefix} ${sdp.join(':').toUpperCase()}`
+}
+
+export function fingerprint2Ma (fingerprint: string): Multiaddr {
+  const output = fingerprint.split(':').map(str => parseInt(str, 16))
+  const encoded = Uint8Array.from(output)
+  const digest = Digest.create(sha256.code, encoded)
+
+  return multiaddr(`/certhash/${base64url.encode(digest.bytes)}`)
+}
+
+/**
+ * Normalize the hash name from a given multihash has name
+ */
+export function toSupportedHashFunction (code: number): 'sha-1' | 'sha-256' | 'sha-512' {
+  switch (code) {
+    case 0x11:
+      return 'sha-1'
+    case 0x12:
+      return 'sha-256'
+    case 0x13:
+      return 'sha-512'
+    default:
+      throw new UnsupportedHashAlgorithmError(code)
+  }
+}
+
+/**
+ * Create an answer SDP message from a multiaddr - the server always operates in
+ * ice-lite mode and DTLS active mode.
+ */
+export function serverAnswerFromMultiaddr (ma: Multiaddr, ufrag: string): RTCSessionDescriptionInit {
+  const { host, port, family } = ma.toOptions()
+  const fingerprint = ma2Fingerprint(ma)
+  const sdp = `v=0
+o=- 0 0 IN IP${family} ${host}
+s=-
+t=0 0
+a=ice-lite
+m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
+c=IN IP${family} ${host}
+a=mid:0
+a=ice-options:ice2
+a=ice-ufrag:${ufrag}
+a=ice-pwd:${ufrag}
+a=fingerprint:${fingerprint}
+a=setup:passive
+a=sctp-port:5000
+a=max-message-size:${MAX_MESSAGE_SIZE}
+a=candidate:1467250027 1 UDP 1467250027 ${host} ${port} typ host
+a=end-of-candidates
+`
+
+  return {
+    type: 'answer',
+    sdp
+  }
+}
+
+/**
+ * Create an offer SDP message from a multiaddr
+ */
+export function clientOfferFromMultiAddr (ma: Multiaddr, ufrag: string): RTCSessionDescriptionInit {
+  const { host, port, family } = ma.toOptions()
+  const sdp = `v=0
+o=- 0 0 IN IP${family} ${host}
+s=-
+c=IN IP${family} ${host}
+t=0 0
+a=ice-options:ice2,trickle
+m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
+a=mid:0
+a=setup:active
+a=ice-ufrag:${ufrag}
+a=ice-pwd:${ufrag}
+a=fingerprint:sha-256 00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00
+a=sctp-port:5000
+a=max-message-size:${MAX_MESSAGE_SIZE}
+a=candidate:1467250027 1 UDP 1467250027 ${host} ${port} typ host
+a=end-of-candidates
+`
+
+  return {
+    type: 'offer',
+    sdp
+  }
+}
+
+/**
+ * Replace (munge) the ufrag and password values in a SDP
+ */
+export function munge (desc: RTCSessionDescriptionInit, ufrag: string): RTCSessionDescriptionInit {
+  if (desc.sdp === undefined) {
+    throw new InvalidParametersError("Can't munge a missing SDP")
+  }
+
+  const lineBreak = desc.sdp.includes('\r\n') ? '\r\n' : '\n'
+
+  desc.sdp = desc.sdp
+    .replace(/\na=ice-ufrag:[^\n]*\n/, '\na=ice-ufrag:' + ufrag + lineBreak)
+    .replace(/\na=ice-pwd:[^\n]*\n/, '\na=ice-pwd:' + ufrag + lineBreak)
+  return desc
+}

package/src/private-to-public/utils/stun-listener.ts

@@ -0,0 +1,104 @@
+import { createSocket } from 'node:dgram'
+import { isIPv4 } from '@chainsafe/is-ip'
+import { IceUdpMuxListener } from '@ipshipyard/node-datachannel'
+import { pEvent } from 'p-event'
+// @ts-expect-error no types
+import stun from 'stun'
+import { UFRAG_PREFIX } from '../../constants.js'
+import type { Logger } from '@libp2p/interface'
+import type { AddressInfo } from 'node:net'
+
+export interface StunServer {
+  close(): Promise<void>
+  address(): AddressInfo
+}
+
+export interface Callback {
+  (ufrag: string, remoteHost: string, remotePort: number): void
+}
+
+async function dgramListener (host: string, port: number, ipVersion: 4 | 6, log: Logger, cb: Callback): Promise<StunServer> {
+  const socket = createSocket({
+    type: `udp${ipVersion}`,
+    reuseAddr: true
+  })
+
+  try {
+    socket.bind(port, host)
+    await pEvent(socket, 'listening')
+  } catch (err) {
+    socket.close()
+    throw err
+  }
+
+  socket.on('message', (msg, rinfo) => {
+    // TODO: this needs to be rate limited keyed by the remote host to
+    // prevent a DOS attack
+    try {
+      log.trace('incoming STUN packet from %o', rinfo)
+      const stunMessage = stun.decode(msg)
+      const usernameAttribute = stunMessage.getAttribute(stun.constants.STUN_ATTR_USERNAME)
+      const username: string | undefined = usernameAttribute?.value?.toString()
+
+      if (username?.startsWith(UFRAG_PREFIX) !== true) {
+        log.trace('ufrag missing from incoming STUN message from %s:%s', rinfo.address, rinfo.port)
+        return
+      }
+
+      const [ufrag] = username.split(':')
+
+      cb(ufrag, rinfo.address, rinfo.port)
+    } catch (err) {
+      log.error('could not process incoming STUN data from %o', rinfo, err)
+    }
+  })
+
+  return {
+    close: async () => {
+      const p = pEvent(socket, 'close')
+      socket.close()
+      await p
+    },
+    address: () => {
+      return socket.address()
+    }
+  }
+}
+
+async function libjuiceListener (host: string, port: number, log: Logger, cb: Callback): Promise<StunServer> {
+  const listener = new IceUdpMuxListener(port, host)
+  listener.onUnhandledStunRequest(request => {
+    if (request.ufrag == null) {
+      return
+    }
+
+    log.trace('incoming STUN packet from %s:%d %s', request.host, request.port, request.ufrag)
+
+    cb(request.ufrag, request.host, request.port)
+  })
+
+  return {
+    close: async () => {
+      listener.stop()
+    },
+    address: () => {
+      return {
+        address: host,
+        family: isIPv4(host) ? 'IPv4' : 'IPv6',
+        port
+      }
+    }
+  }
+}
+
+export interface STUNListenerOptions {
+  useLibjuice?: boolean
+}
+
+export async function stunListener (host: string, port: number, ipVersion: 4 | 6, log: Logger, cb: Callback, opts: STUNListenerOptions = {}): Promise<StunServer> {
+  if (opts.useLibjuice === false) {
+    return dgramListener(host, port, ipVersion, log, cb)
+  }
+
+  return libjuiceListener(host, port, log, cb)
+}