libzt VS libdatachannel

BlindSPOT: https://blindspotsec.com/ Specific graphic from BlindSPOT: https://blindspotsec.com/wp-content/uploads/2021/04/Failure_Before.jpg How to Measure Anything in Cybersecurity Risk: https://www.amazon.com/dp/B01J4XYM16/ Monte Carlo simulation approach: https://embracethered.com/blog/posts/2020/red-teaming-and-monte-carlo-simulations/ D3FEND: https://d3fend.mitre.org/ ATT&CK mappings: https://github.com/center-for-threat-informed-defense/attack-control-framework-mappings ATT&CK evals: https://attackevals.mitre-engenuity.org/index.html CALDERA: https://github.com/mitre/caldera Offensive Countermeasures: https://www.amazon.com/dp/1974671690/ SPIFFE: https://spiffe.io/ SPIRE: https://github.com/spiffe/spire Zerotier: https://www.zerotier.com/ Zerotier libzt: https://github.com/zerotier/libzt

Alternatively you can use your server as a signaling server for WebRTC (Insertable Streams ("Breakout Box"), or data channels https://github.com/paullouisageneau/libdatachannel), then users (peers) can exchange data themselves and you don't need to store anything, see True End-to-End Encryption with WebRTC Insertable Streams, A complete example for a WebRTC datachannel with manual signaling.

there is also a c++ library that can be used to open a data channel connection, I think a number of SFU “servers?” use this library (I wish I had) https://libdatachannel.org/

For networking and terminating WebRTC connections from cpp libdatachannel is you easiest bet. For transcoding you can pick whatever library you like, if any. The other way would be to use the chrome WebRTC stack and modify it for server use. It can and has been done but is very involved.

Node.js node JavaScript runtime itself provides a means to interface with native applications. Plenty of people write their own WebSocket or WebRTC data channel libraries https://github.com/paullouisageneau/libdatachannel.

Fourtunately some technologies and API's are extensible enough to do whatever you want in spite of and to overcome limitations; e.g., WebRTC (particularly data channels https://github.com/paullouisageneau/libdatachannel), Native Messaging, WebTransport, fetch(), Trasnferable Streams, Media Capture Transform, File API, File System Access API, Web extensions.

To be fair, C++ has libdatachannel which I like using too.

https://github.com/paullouisageneau/libdatachannel ?

Or use something specific like libdatachannel https://libdatachannel.org/

If you’re using WebRTC data channels in a client server config then infra is no more complex than a regular setup because the server will almost certainly have an external facing IP address.

People should really try using WebRTC as well because you can get the full pipeline setup for a toy demo in a couple of slow days. I did whilst also writing my own signalling server in Go without having used Go before!

It’s certainly not any more complex than rolling all the stuff the article is talking about on top of raw UDP.

This does use a real WebRTC stack (specifically libdatachannel - https://libdatachannel.org). Under the hood this is making real WebRTC connections.

But I guess you mean why it doesn't mock using real peers in the browser where the tests are happening, using the browser's existing stack there?

There's a few reasons I've avoided that:

* Primarily: I want to do things that the browser APIs won't let you do. E.g. sending invalid data, or intentionally causing various types of errors. The browser APIs are designed to stop you doing the wrong thing, by keeping the raw data at arm's length. Very sensible for normal WebRTC usage, but bad for testing edge cases and breaking things.

Building WebRTC tends to be hell. If your use case is simple enough, it might be interesting to switch to an alternative C++ library like libdatachannel (I'm the author).