Ockam VS flapigen-rs

https://github.com/build-trust/ockam/blob/develop/examples/a...

disclosure: I work at Ockam.

The Portals for Mac app is an example of the type of thing you could build using the open source stack of protocols. The README (linked by parent) links out to all of the relevant parts of the protocol documentation to explain how these work together. The NAT Traversal (https://github.com/build-trust/ockam/blob/develop/examples/a...) part of the README is probably the best explanation of why the free relay you get via Ockam Orchestrator is a useful part of this demo.

As for why would anyone trust this: The protocols are designed so you absolutely don't have to trust the relay. Trust is pushed out to the edges that you control and so you're not susceptible to a MITM attack if something like a relay is compromised. The protocol design for all of this is open and documented, and was independently audited by (IMO) some of the best in the business, Trail of Bits: https://docs.ockam.io/reference/protocols.

We’ve been working on something (https://github.com/build-trust/ockam) that enables exactly this, among a whole host of other use cases. If you check out some of the code examples in the docs you’ll see how to setup a tunnel using the CLI.

For other use cases there’s also the programming libraries (only Rust atm, though I was spiking a TypeScript/Node PoC this week) which might provide more flexibility. Personally I’m excited by the idea of being able to move this kind of secure by design connectivity all the way into the application layer though.

Hacktoberfest - No Code - Try Ockam Command (CLI) and give user experience feedback #3631

https://github.com/build-trust/ockam/blob/develop/documentat...

Give it a try. Would love to know if that fits what you're going for.

UDP hole puncturing is in development right now. However there is extensive research that shows it in only successful in making connections in 60 to 80% of real world networks. This is why Signal does relays for example. Relays provide a highly reliable strategy. So we knew we'll want to support both and give devs and option to choose what is right for their application. Or failover from one to the other.

In addition, relays also allow store and forward and integration to other enterprise systems like Kafka. This is how we're able to to move end-to-end encrypted data through Kafka https://github.com/build-trust/ockam/tree/develop/documentat...

Store and forward as a first class feature is in development.

Scatter/Gather is a much harder problem since it involves group key agreement and challenges that come with doing that safely. This is in our long term roadmap, but we've not done any development for this yet.

Ockam crates implement a collection of messaging and cryptographic protocols that provide end-to-end application layer trust in data. We believe that, in order to have a realistically manageable vulnerability surface, all modern applications need end-to-end guarantees of data integrity and authenticity. The only way to build secure and private applications is to remove unnecessary implicit trust in network boundaries, intermediaries and infrastructure.

use flapigen to define how our Rust structs will go across the FFI.

Yes, it's possible to generate Java and C++ bindings for Rust library using https://github.com/Dushistov/flapigen-rs .

Is there anything like flapigen-rs, but for Go?