Summary of Gordian Developer Meeting @ July 10th

[shannona]

Blockchain Commons' July Developer Meeting had updates on our two newest CLIs, Seedtool for Rust (all new!) and Envelope for Rust (now updated!) as well as a feature presentation on Gordian Sealed Transaction Protocol (GSTP)

Seedtool in Rust

Seedtool-cli is now in Rust

Available in a Blockchain Commons repo, now with a user manual.

Blockchain Commons has always felt seeds were the root of the tree for various cryptographic operations. So the new seedtool-cli-rust is one of three seedtool apps (others in C++ (deprecated) & iOS.)

The whole idea is to have a very fully featured command line tool.

• Can input & output in a variety of formats.
• Can use Envelope to include metadata with a seed.
• Can output to SSKR for backup, sharding the output.

There was some discussion of making sure inputs produce the same outputs for testing purposes. The -d deterministic flag is the main way to support that, though dice and coin flips may be used to test consistent results as well, including at Ian Coleman's site.

The Rust Seedtool is now on the leading edge of Blockchain Commons' development, but they're considering more additions, such as descriptors, attachments, and BIP-85.

Envelope in Rust

BC is updating envelope-cli-rust for new SSH functionality.

Why SSH?

Traditionally, SSH keys were just for auth, mostly for logging in to UNIX boxes.

But now they can be used for code signing, driven by work from GitHub!

• You don't have to use PGP! There's an alternative!
• We can modernize securing our code bases!
• This allows us to do more with our software supply chain.

Use of SSH keys in Envelope also demonstrates flexibility of Envelope!

Envelope-CLI-Rust Expansions

This is another Rust/cargo tool.

• It's been around for a while
• But you can now sign Envelopes with SSH keys
• Two features from old C++ seedtool not yet in: diff support and mermaid output

Schnorr is the default for signing in Envelopes

• But seedtool now also supports ecdsa and a variety of ssh signatures

There's a lot of depth, as shown in our new Signingchapter for the Envelope CLI.

• Can not only generate SSH keys, but can import then from OpenSSL-style files!
• Can both sign and verify SSH keys
• Finally, can export private or public keys or signatures or see info
• Can also use other Envelope functions, such as encryption.

Well-used libraries are the heart of the SSH code, so Blockchain Commons is inheriting any attack surfaces & any protections

Doesn't do hardware or FIDO yet, but is enough to demo SSH usage!

• And it uses the sshkey crate, which can allow expansion to these

One of the advantages of using Envelopes is that users can add additional attributes to
a key, such as an expiration date! Or precommit of future keys that are elided at the time!

Gordian Sealed Transaction Protocol (GSTP)

This project is supported by Foundation Devices, who have made advances available to the whole community.

Support for GSTP is in the bc-envelope crate in the Blockchain Commons Rust stack.

• includes many expansive features beyond core specification architecture

GSTP is built on REQUESTS and RESPONSES

• could be on any channel: internet, bluetooth, NFC, Tor, QR code
• Some of these are unreliable/insecure, GSTP makes them all secure!

Goals & Key Components:

• async communication between peers
• multimodal transactions
• unique IDs for request/response pairs
• bidirectional encryption with public-key crypto
• self-signed requests w/public keys for auth
• message-encapsulated state with self-encrypted "continuations"
• expected response ID, continuation timeout to resist replay attacks
• encourage idempotent actions

Benefits

• reduce state management
• improve fault tolerance
• improve scalability
• ensure security
• make data handling efficient

Function Layer

Requests & Responses are distributed function calls

• Functions are supported in Envelopes!
• subject is function identifier
• assertions are arguments on function identifier

Request/Response Layer

To encapsulate a function in a request, Envelope generates an apparently random ID (ARID)

• and marks it as a request with CBOR
• with function as 'body'

Same pattern with response

• ARID
• and CBOR-tagged response
• and 'result'

Authentication Layer

GSTP then adds an authentication layer

For Request:

• add a senderPublicKey
• add a senderContinuation (what we expect back!)
  • allows us to start, then continue calculation without storing state
  • encrypted by ourself!
• add a recipientContinuation if we have one
• wrap & sign whole Envelope

Encryption Layer

GSTP then adds an encryption layer

For Request:

• wrap & encrypt with symmetric key
• add a SealedMessage key, which encrypts symmetric key with recipient's public key
• recipient can use their private key and sender's public key to recover

Reversing the Process

RECIPIENT then reverse sprocess

• decrypts envelope
• verifies signature
• recovers their continuation
• runs function

RECIPIENT then reverses process again to send a response to original sender

GSTP & The Future

This is foundation for a wide variety of protocols. Depo is the first use case, but can be used with many more protocols: Git depos, supply-chain, etc.

• These protocols can use other benefits of Envelope, particularly elision
• generally, allows progressive trust, as reveal more trust over time

Lots of opportunity for advanced protocols!

There's a lot of flexibility for future

• For example, already two ways to manage "permits" on Envelopes
• currently, SSKR shares or private/public keys
• could be FROST in future or more

Trust on First Use (TOFU) Pairing

How do things get started?

The TOFO method is used by Blockchain Commons' depo.

Process starts with SERVER sending a discovery message: their open public key

• could be a QR code
• could be GET call over internet

Client now has server public key

• it sends a request

Server now has client public key

• it sends a response

Next Month

Back to First Wednesday

Presentation on BIP-85!

Demo of using SSH with Envelope & Git

If you would like to present something related to wallet interop, let us know!