@libp2p/webrtc 6.0.32 → 6.0.33-183116ba0

package/src/constants.ts

@@ -24,7 +24,8 @@ export const UFRAG_ALPHABET = Array.from('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL
 /**
  * Used to detect the version of the WebRTC Direct connection protocol in use
  */
-export const UFRAG_PREFIX = 'libp2p+webrtc+v1/'
+export const UFRAG_PREFIX_V1 = 'libp2p+webrtc+v1/'
+export const UFRAG_PREFIX_V2 = 'libp2p+webrtc+v2/'
 
 /**
  * How much can be buffered to the DataChannel at once

package/src/index.ts

@@ -15,7 +15,7 @@
  *
  * The WebRTC transport uses libp2p [Circuit Relay](https://libp2p.io/docs/circuit-relay/)s to forward SDP messages. Once a direct connection is formed the relay plays no further part in the exchange.
  *
- * WebRTC Direct uses a technique known as [SDP munging](https://webrtchacks.com/not-a-guide-to-sdp-munging/) to skip the handshake step, instead encoding enough information in the connection request that the responder can derive what would have been in the handshake messages and so requires no third parties to establish a connection.
+ * WebRTC Direct skips the handshake step, instead encoding enough information in the connection request that the responder can derive what would have been in the handshake messages and so requires no third parties to establish a connection. Version 1 of the protocol does this with a technique known as [SDP munging](https://webrtchacks.com/not-a-guide-to-sdp-munging/); version 2 avoids munging, which browsers are removing support for. See WebRTC Direct versions below.
  *
  * A WebRTC Direct multiaddr also includes a certhash of the target peer - this is used to allow opening a connection to the remote, which would otherwise be denied due to use of a self-signed certificate.
  *
@@ -197,6 +197,27 @@
  * })
  * ```
  *
+ * ## WebRTC Direct versions
+ *
+ * There are two versions of the WebRTC Direct connection flow. Both use the
+ * same `/webrtc-direct` multiaddr and certificate hash; they differ in how the
+ * client's ICE credentials reach the server.
+ *
+ * Version 1 munges the client's SDP offer so that the server can predict the
+ * client's ICE credentials. Browsers are removing the ability to do this, so
+ * v1 will stop working for browser clients.
+ *
+ * Version 2 leaves the local SDP offer untouched and instead carries the
+ * client's ICE password in the ICE username fragment of the synthetic server
+ * answer, where the server reads it back from the incoming STUN request.
+ *
+ * No configuration is needed for either version. Listeners accept both on the
+ * same port and select the version from the incoming username fragment prefix.
+ * The first dial tries v1 and, if the runtime does not apply the munged ICE
+ * credentials, continues as v2; later dials then start at v2. The
+ * `dialerVersion` option skips this and forces one version, for example `2`
+ * for a server known to support it (go-libp2p does from v0.49.0).
+ *
  * ## WebRTC Direct certificate hashes
  *
  * WebRTC Direct listeners publish the hash of their TLS certificate as part of

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

@@ -156,10 +156,10 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
             this.log.trace('listening on free port %d', port)
           }
 
-          return stunListener(host, port, this.log, (ufrag, remoteHost, remotePort) => {
+          return stunListener(host, port, this.log, (serverUfrag, clientUfrag, clientPwd, remoteHost, remotePort) => {
             const signal = this.components.upgrader.createInboundAbortSignal(this.shutdownController.signal)
 
-            this.incomingConnection(ufrag, remoteHost, remotePort, signal)
+            this.incomingConnection(serverUfrag, clientUfrag, clientPwd, remoteHost, remotePort, signal)
               .catch(err => {
                 this.log.error('error processing incoming STUN request - %e', err)
               })
@@ -171,8 +171,8 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     }
   }
 
-  private async incomingConnection (ufrag: string, remoteHost: string, remotePort: number, signal: AbortSignal): Promise<void> {
-    const key = `${remoteHost}:${remotePort}:${ufrag}`
+  private async incomingConnection (serverUfrag: string, clientUfrag: string, clientPwd: string | undefined, remoteHost: string, remotePort: number, signal: AbortSignal): Promise<void> {
+    const key = `${remoteHost}:${remotePort}:${serverUfrag}:${clientUfrag}`
     let peerConnection = this.connections.get(key)
 
     if (peerConnection != null) {
@@ -185,8 +185,8 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     // do not create RTCPeerConnection objects if the signal has aborted already
     signal.throwIfAborted()
 
-    // https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md#browser-to-public-server
-    const results = await createDialerRTCPeerConnection('server', ufrag, {
+    // https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md
+    const results = await createDialerRTCPeerConnection('server', serverUfrag, {
       rtcConfiguration: this.init.rtcConfiguration,
       certificate: this.certificate,
       events: this.metrics?.listenerEvents,
@@ -211,12 +211,14 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     })
 
     try {
-      await connect(peerConnection, results.muxerFactory, ufrag, {
+      await connect(peerConnection, results.muxerFactory, serverUfrag, {
         role: 'server',
         log: this.log,
         logger: this.components.logger,
         events: this.metrics?.listenerEvents,
         signal,
+        remoteUfrag: clientUfrag,
+        remotePwd: clientPwd,
         remoteAddr: multiaddr(`/ip${isIPv4(remoteHost) ? 4 : 6}/${remoteHost}/udp/${remotePort}/webrtc-direct`),
         dataChannel: this.init.dataChannel,
         upgrader: this.init.upgrader,

package/src/private-to-public/transport.browser.ts

@@ -1,7 +1,8 @@
-import { serviceCapabilities, transportSymbol } from '@libp2p/interface'
+import { InvalidParametersError, serviceCapabilities, transportSymbol } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { CODE_P2P } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
+import { UFRAG_PREFIX_V1 } from '../constants.ts'
 import { UnimplementedError } from '../error.ts'
 import { genUfrag } from '../util.ts'
 import { connect } from './utils/connect.ts'
@@ -30,6 +31,15 @@ export interface WebRTCMetrics {
 }
 
 export interface WebRTCTransportDirectInit {
+  /**
+   * Force the version of the WebRTC Direct connection flow to dial with. When
+   * not set, the first dial tries v1 and continues as v2 if the runtime does
+   * not apply the munged ICE credentials in the local SDP offer, and later
+   * dials start at whichever version that showed the runtime supports. The
+   * server must support the version in use, listeners accept both.
+   */
+  dialerVersion?: 1 | 2
+
   /**
    * The default configuration used by all created RTCPeerConnections
    */
@@ -54,12 +64,19 @@ export class WebRTCDirectTransport implements Transport {
   protected readonly metrics?: WebRTCMetrics
   protected readonly components: WebRTCDirectTransportComponents
   protected readonly init: WebRTCTransportDirectInit
+  private mungeable?: boolean
 
   constructor (components: WebRTCDirectTransportComponents, init: WebRTCTransportDirectInit = {}) {
     this.log = components.logger.forComponent('libp2p:webrtc-direct')
     this.components = components
     this.init = init
 
+    const dialerVersion: unknown = init.dialerVersion
+
+    if (dialerVersion != null && dialerVersion !== 1 && dialerVersion !== 2) {
+      throw new InvalidParametersError(`Unknown WebRTC Direct dialer version "${String(dialerVersion)}"`)
+    }
+
     if (components.metrics != null) {
       this.metrics = {
         dialerEvents: components.metrics.registerCounterGroup('libp2p_webrtc-direct_dialer_events_total', {
@@ -92,9 +109,20 @@ export class WebRTCDirectTransport implements Transport {
       theirPeerId = peerIdFromString(remotePeerString)
     }
 
-    const ufrag = genUfrag()
+    // an explicit dialer version is always used, otherwise start at v1 until a
+    // dial shows this runtime does not apply munged ICE credentials
+    const version = this.init.dialerVersion ?? (this.mungeable === false ? 2 : 1)
+    const ufrag = version === 2
+      ? genUfrag(32, '')
+      : genUfrag(32, UFRAG_PREFIX_V1)
+    const pwd = version === 2 ? genUfrag(22, '') : ufrag
+
+    // the version actually dialed, v1 may continue as v2
+    let dialedVersion = version
 
-    // https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md#browser-to-public-server
+    this.log('dial %a starting as WebRTC Direct v%d', ma, version)
+
+    // https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md
     const {
       peerConnection,
       muxerFactory
@@ -103,16 +131,28 @@ export class WebRTCDirectTransport implements Transport {
       events: this.metrics?.dialerEvents,
       log: this.log,
       dataChannel: this.init.dataChannel,
-      maxEarlyStreams: this.init.maxEarlyStreams
+      maxEarlyStreams: this.init.maxEarlyStreams,
+      pwd
     })
 
     try {
-      return await connect(peerConnection, muxerFactory, ufrag, {
+      const connection = await connect(peerConnection, muxerFactory, ufrag, {
         role: 'client',
         log: this.log,
         logger: this.components.logger,
         events: this.metrics?.dialerEvents,
         signal: options.signal,
+        version,
+        fallback: this.init.dialerVersion == null,
+        onMungeable: (mungeable) => {
+          // munging support belongs to the runtime, not the remote, so it is
+          // remembered even if this dial fails
+          this.mungeable ??= mungeable
+
+          if (!mungeable && this.init.dialerVersion == null) {
+            dialedVersion = 2
+          }
+        },
         remoteAddr: ma,
         dataChannel: this.init.dataChannel,
         upgrader: options.upgrader,
@@ -120,7 +160,10 @@ export class WebRTCDirectTransport implements Transport {
         remotePeer: theirPeerId,
         privateKey: this.components.privateKey
       })
+
+      return connection
     } catch (err) {
+      this.log('dial %a failed as WebRTC Direct v%d - %e', ma, dialedVersion, err)
       peerConnection.close()
       throw err
     }

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

@@ -6,6 +6,7 @@ import { toMultiaddrConnection } from '../../rtcpeerconnection-to-conn.ts'
 import { createStream } from '../../stream.ts'
 import { generateNoisePrologue } from './generate-noise-prologue.ts'
 import * as sdp from './sdp.ts'
+import { isIcePwd, isIceUfrag, serverUfragV2 } from './stun.ts'
 import type { DirectRTCPeerConnection } from './get-rtcpeerconnection.ts'
 import type { DataChannelOptions } from '../../index.ts'
 import type { ComponentLogger, Connection, CounterGroup, Logger, PeerId, PrivateKey, Upgrader } from '@libp2p/interface'
@@ -23,10 +24,29 @@ export interface ConnectOptions {
   remotePeer?: PeerId
   signal: AbortSignal
   privateKey: PrivateKey
+  remoteUfrag?: string
+  remotePwd?: string
 }
 
 export interface ClientOptions extends ConnectOptions {
   role: 'client'
+
+  /**
+   * Which version of the connection flow to dial with
+   */
+  version: 1 | 2
+
+  /**
+   * Continue as v2 when the runtime does not apply the munged ICE credentials
+   * a v1 dial needs
+   */
+  fallback?: boolean
+
+  /**
+   * Called once a v1 attempt shows whether the runtime applies munged ICE
+   * credentials, even if the dial later fails
+   */
+  onMungeable?(mungeable: boolean): void
 }
 
 export interface ServerOptions extends ConnectOptions {
@@ -37,6 +57,86 @@ function isServer (options: ClientOptions | ServerOptions, peerConnection: any):
   return options.role === 'server'
 }
 
+/**
+ * Set `offer` as the local description with its ICE ufrag and password munged
+ * to `ufrag`, as WebRTC Direct v1 requires, and report whether the runtime
+ * applied them. Browsers are removing support for this, in which case
+ * setLocalDescription either rejects the offer with an InvalidModificationError
+ * or keeps the generated credentials.
+ */
+async function setMungedLocalOffer (peerConnection: RTCPeerConnection | DirectRTCPeerConnection, offer: RTCSessionDescriptionInit, ufrag: string, log: Logger): Promise<boolean> {
+  const mungedOffer = sdp.munge({ type: offer.type, sdp: offer.sdp }, ufrag)
+
+  try {
+    log.trace('client setting munged local offer %s', mungedOffer.sdp)
+    await peerConnection.setLocalDescription(mungedOffer)
+  } catch (err: any) {
+    // any other rejection is a real failure, not the runtime refusing the munge
+    if (err.name !== 'InvalidModificationError') {
+      throw err
+    }
+
+    log('runtime rejected the munged local offer - %e', err)
+    return false
+  }
+
+  const localSdp = peerConnection.localDescription?.sdp
+
+  return sdp.getIceUfragFromSdp(localSdp) === ufrag && sdp.getIcePwdFromSdp(localSdp) === ufrag
+}
+
+/**
+ * Set the local offer for the requested version and return the ufrag for the
+ * synthetic server answer.
+ *
+ * v1 munges the offer so ice-ufrag and ice-pwd both equal `ufrag`, letting the
+ * server infer the client's credentials from the STUN USERNAME alone. v2 keeps
+ * the credentials the runtime generated and carries the client's ICE password
+ * in the server ufrag instead. When a v1 attempt does not stick and fallback
+ * is allowed, the dial continues as v2.
+ */
+async function setClientOffer (peerConnection: RTCPeerConnection | DirectRTCPeerConnection, offer: RTCSessionDescriptionInit, ufrag: string, options: ClientOptions): Promise<string> {
+  if (options.version === 1) {
+    const mungeable = await setMungedLocalOffer(peerConnection, offer, ufrag, options.log)
+    options.onMungeable?.(mungeable)
+
+    if (mungeable) {
+      return ufrag
+    }
+
+    if (options.fallback !== true) {
+      throw new WebRTCTransportError('SDP munging is not available in this runtime so WebRTC Direct v1 cannot be used')
+    }
+
+    options.log('SDP munging is not available in this runtime, continuing as WebRTC Direct v2')
+  }
+
+  // a rejected munged offer leaves no local description, an ignored one leaves
+  // the runtime's own credentials in place, which is what v2 needs
+  if (peerConnection.localDescription == null) {
+    options.log.trace('client setting local offer %s', offer.sdp)
+    await peerConnection.setLocalDescription(offer)
+  }
+
+  // encode the client's ICE password in the synthetic server ufrag
+  const localPwd = sdp.getIcePwdFromSdp(peerConnection.localDescription?.sdp)
+
+  if (localPwd == null || !isIcePwd(localPwd)) {
+    // without a valid local ICE password we cannot build a valid v2 server
+    // ufrag; fail loudly instead of dialing with a ufrag the server would reject
+    throw new WebRTCTransportError('Could not read a valid local ICE password from local description for v2 dial')
+  }
+
+  const serverUfrag = serverUfragV2(localPwd)
+
+  if (!isIceUfrag(serverUfrag)) {
+    // the prefix counts towards the 256 character ufrag limit
+    throw new WebRTCTransportError('Local ICE password is too long to encode in a v2 server ufrag')
+  }
+
+  return serverUfrag
+}
+
 export async function connect (peerConnection: RTCPeerConnection, muxerFactory: DataChannelMuxerFactory, ufrag: string, options: ClientOptions): Promise<Connection>
 export async function connect (peerConnection: DirectRTCPeerConnection, muxerFactory: DataChannelMuxerFactory, ufrag: string, options: ServerOptions): Promise<void>
 export async function connect (peerConnection: RTCPeerConnection | DirectRTCPeerConnection, muxerFactory: DataChannelMuxerFactory, ufrag: string, options: ClientOptions | ServerOptions): Promise<any> {
@@ -48,37 +148,30 @@ export async function connect (peerConnection: RTCPeerConnection | DirectRTCPeer
   try {
     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)
+      const serverUfrag = await setClientOffer(peerConnection, offerSdp, ufrag, options)
+      const answerSdp = sdp.serverAnswerFromMultiaddr(options.remoteAddr, serverUfrag)
       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)
+      const remoteUfrag = options.remoteUfrag ?? ufrag
+      const remotePwd = options.remotePwd ?? remoteUfrag
+      const offerSdp = sdp.clientOfferFromMultiAddr(options.remoteAddr, remoteUfrag, remotePwd)
       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)
+
+      // the answer credentials were pinned to the server ufrag when the peer
+      // connection was created, so it needs no munging for either version
       options.log.trace('server setting local description %s', answerSdp.sdp)
-      await peerConnection.setLocalDescription(mungedAnswerSdp)
+      await peerConnection.setLocalDescription(answerSdp)
     }
 
     if (handshakeDataChannel.readyState !== 'open') {
@@ -162,13 +255,15 @@ export async function connect (peerConnection: RTCPeerConnection | DirectRTCPeer
       })
 
       options.log.trace('%s upgrade outbound', options.role)
-      return await options.upgrader.upgradeOutbound(maConn, {
+      const connection = await options.upgrader.upgradeOutbound(maConn, {
         skipProtection: true,
         skipEncryption: true,
         remotePeer: result.remotePeer,
         muxerFactory,
         signal: options.signal
       })
+
+      return connection
     }
 
     // For inbound connections, the server is are expected to start the noise

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

@@ -4,8 +4,8 @@ import { PeerConnection } from 'node-datachannel'
 import { RTCPeerConnection } from 'node-datachannel/polyfill'
 import { DEFAULT_ICE_SERVERS, MAX_MESSAGE_SIZE } from '../../constants.ts'
 import { DataChannelMuxerFactory } from '../../muxer.ts'
-import { isValidUfrag } from '../../util.ts'
 import { generateTransportCertificate } from './generate-certificates.ts'
+import { isIcePwd, isIceUfrag } from './stun.ts'
 import type { DataChannelOptions, TransportCertificate } from '../../index.ts'
 import type { CounterGroup, Logger } from '@libp2p/interface'
 import type { CertificateFingerprint } from 'node-datachannel'
@@ -14,18 +14,21 @@ const crypto = new Crypto()
 
 interface DirectRTCPeerConnectionInit extends RTCConfiguration {
   ufrag: string
+  pwd: string
   peerConnection: PeerConnection
 }
 
 export class DirectRTCPeerConnection extends RTCPeerConnection {
   private peerConnection: PeerConnection
   private readonly ufrag: string
+  private readonly pwd: string
 
   constructor (init: DirectRTCPeerConnectionInit) {
     super(init)
 
     this.peerConnection = init.peerConnection
     this.ufrag = init.ufrag
+    this.pwd = init.pwd
 
     // make sure C++ peer connection is garbage collected
     // https://github.com/murat-dogan/node-datachannel/issues/366#issuecomment-3228453155
@@ -41,33 +44,36 @@ export class DirectRTCPeerConnection extends RTCPeerConnection {
   }
 
   async createOffer (): Promise<globalThis.RTCSessionDescriptionInit | any> {
-    // have to set ufrag before creating offer
-    this.setLocalUfrag('offer')
+    // have to set the ICE credentials before creating the offer
+    this.setLocalCredentials('offer')
 
     return super.createOffer()
   }
 
   async createAnswer (): Promise<globalThis.RTCSessionDescriptionInit | any> {
-    // have to set ufrag before creating answer
-    this.setLocalUfrag('answer')
+    // have to set the ICE credentials before creating the answer
+    this.setLocalCredentials('answer')
 
     return super.createAnswer()
   }
 
-  // this.ufrag is reused as the ICE password; an invalid value aborts the process
-  // inside the native ICE stack, so reject it with a recoverable error first
-  private setLocalUfrag (type: 'offer' | 'answer'): void {
+  // node-datachannel needs the ICE credentials set before the description is
+  // created. On the server they come from an attacker-controlled STUN username
+  // and an invalid value aborts the process inside the native ICE stack, so
+  // reject it with a recoverable error first. The browser path uses a native
+  // RTCPeerConnection and never reaches this class.
+  private setLocalCredentials (type: 'offer' | 'answer'): void {
     if (this.connectionState !== 'new') {
       return
     }
 
-    if (!isValidUfrag(this.ufrag)) {
-      throw new InvalidParametersError('ufrag is not a valid ICE credential')
+    if (!isIceUfrag(this.ufrag) || !isIcePwd(this.pwd)) {
+      throw new InvalidParametersError('ufrag or pwd is not a valid ICE credential')
     }
 
     this.peerConnection?.setLocalDescription(type, {
       iceUfrag: this.ufrag,
-      icePwd: this.ufrag
+      icePwd: this.pwd
     })
   }
 
@@ -103,6 +109,7 @@ export interface CreateDialerRTCPeerConnectionOptions {
   log?: Logger
   dataChannel?: DataChannelOptions
   maxEarlyStreams?: number
+  pwd?: string
 }
 
 export async function createDialerRTCPeerConnection (role: 'client', ufrag: string, options?: CreateDialerRTCPeerConnectionOptions): Promise<{ peerConnection: globalThis.RTCPeerConnection, muxerFactory: DataChannelMuxerFactory }>
@@ -124,10 +131,12 @@ export async function createDialerRTCPeerConnection (role: 'client' | 'server',
   }
 
   const rtcConfig = typeof options.rtcConfiguration === 'function' ? await options.rtcConfiguration() : options.rtcConfiguration
+  const pwd = options.pwd ?? ufrag
 
   const peerConnection = new DirectRTCPeerConnection({
     ...rtcConfig,
     ufrag,
+    pwd,
     peerConnection: new PeerConnection(`${role}-${Date.now()}`, {
       disableFingerprintVerification: true,
       disableAutoNegotiation: true,

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

@@ -17,6 +17,9 @@ import type { MultihashDigest } from 'multiformats/hashes/interface'
 export const multibaseDecoder: 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
+const iceUfragRegex = /^a=ice-ufrag:(?<ufrag>[^\r\n]+)$/m
+const icePwdRegex = /^a=ice-pwd:(?<pwd>[^\r\n]+)$/m
+
 export function getFingerprintFromSdp (sdp: string | undefined): string | undefined {
   if (sdp == null) {
     return undefined
@@ -26,6 +29,22 @@ export function getFingerprintFromSdp (sdp: string | undefined): string | undefi
   return searchResult?.groups?.fingerprint
 }
 
+export function getIceUfragFromSdp (sdp: string | undefined): string | undefined {
+  if (sdp == null) {
+    return undefined
+  }
+
+  return sdp.match(iceUfragRegex)?.groups?.ufrag
+}
+
+export function getIcePwdFromSdp (sdp: string | undefined): string | undefined {
+  if (sdp == null) {
+    return undefined
+  }
+
+  return sdp.match(icePwdRegex)?.groups?.pwd
+}
+
 // Extract the certhash from a multiaddr
 export function certhash (ma: Multiaddr): string {
   const components = ma.getComponents()
@@ -136,7 +155,7 @@ a=end-of-candidates
 /**
  * Create an offer SDP message from a multiaddr
  */
-export function clientOfferFromMultiAddr (ma: Multiaddr, ufrag: string): RTCSessionDescriptionInit {
+export function clientOfferFromMultiAddr (ma: Multiaddr, ufrag: string, pwd: string = ufrag): RTCSessionDescriptionInit {
   const { host, port, type } = getNetConfig(ma)
 
   if (type !== 'ip4' && type !== 'ip6') {
@@ -153,7 +172,7 @@ m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
 a=mid:0
 a=setup:active
 a=ice-ufrag:${ufrag}
-a=ice-pwd:${ufrag}
+a=ice-pwd:${pwd}
 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}

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

@@ -0,0 +1,14 @@
+import { UnimplementedError } from '../../error.ts'
+import type { StunRequestCallback } from './stun.ts'
+import type { Logger } from '@libp2p/interface'
+
+export { parseStunUsernameUfrags } from './stun.ts'
+
+export interface StunServer {
+  close(): Promise<void>
+  address(): never
+}
+
+export async function stunListener (host: string, port: number, log: Logger, cb: StunRequestCallback): Promise<StunServer> {
+  throw new UnimplementedError('stunListener')
+}

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

@@ -1,6 +1,7 @@
 import { isIPv4 } from '@chainsafe/is-ip'
 import { IceUdpMuxListener } from 'node-datachannel'
-import { handleStunRequest } from '../../util.ts'
+import { handleStunRequest } from './stun.ts'
+import type { StunRequestCallback } from './stun.ts'
 import type { Logger } from '@libp2p/interface'
 import type { AddressInfo } from 'node:net'
 
@@ -9,14 +10,15 @@ export interface StunServer {
   address(): AddressInfo
 }
 
-export interface Callback {
-  (ufrag: string, remoteHost: string, remotePort: number): void
-}
-
-export async function stunListener (host: string, port: number, log: Logger, cb: Callback): Promise<StunServer> {
+export async function stunListener (host: string, port: number, log: Logger, cb: StunRequestCallback): Promise<StunServer> {
   const listener = new IceUdpMuxListener(port, host)
   listener.onUnhandledStunRequest(request => {
-    handleStunRequest(request, log, cb)
+    // this runs inside a native callback where a throw would crash the process
+    try {
+      handleStunRequest(request, log, cb)
+    } catch (err) {
+      log.error('error handling STUN request from %s:%d - %e', request.host, request.port, err)
+    }
   })
 
   return {