HNHacker News
TopNewBestAskShowJobs

brendoncarroll

195 karma · joined January 4, 2020

https://www.brendoncarroll.net

My email is on my website.

[ my public key: https://keybase.io/brendoncarroll; my proof: https://keybase.io/brendoncarroll/sigs/fYaonvrG14Nua37nuEegQ1J9jl0b0RYIc3PyBRtwbjE ]

submissionscomments
brendoncarroll··on CDC File Transfer
FastCDC is the same chunking algorithm used in Got.

https://github.com/gotvc/got

brendoncarroll··on Ask HN: What are you working on this year?
I'm working on INET256, an API for secure identity based networking. The reference implementation, mesh256 is a mesh network using a distributed routing algorithm. There is also diet256, which is a centrally coordinated network with direct connections using QUIC over The Internet.

https://github.com/inet256/inet256

https://github.com/inet256/diet256

brendoncarroll··on Show HN: Encrypted Git hosting should be easy
I work on a project which solves a similar use case.

https://github.com/gotvc/got

Got also does E2E encryption, but it can additionally encrypt branch names from remote servers. It also handles syncing large files and directories better thanks to an improved data structure.

brendoncarroll··on Ask HN: Is there a good reason for disallowing some characters from a password?
I can think of a few reasons to exclude a character:

- Requires quoting or escaping in the shell or some other programming environment

- Hard to type on mobile keyboard.

- Not in a given person's touch-typing repertoire.

The correct way to think about password security is as randomly generating a binary string of the desired security strength/length and then encoding it. If you generate 16 random bytes, that's 128 bits of security whether you encode it with hex, base32 or base64.

Required characters also do little to improve security, since there is usually only 1 of each kind of required character, and it's often at the beginning or end. They don't cause the user to select a random string from a meaningfully larger space.

brendoncarroll··on What comes after Git
I've been working on a project "Got". Which deals with the LFS problem, mentioned in the post.

https://github.com/gotvc/got

Got isn't really trying to do software version control better than Git. It's trying to make general purpose file versioning practical, with a workflow similar to Git's.

brendoncarroll··on Let's build an end-to-end encrypted data store
In the same space is the key-value store underlying Got: GotKV. https://github.com/gotvc/got/tree/master/pkg/gotkv

It stores encrypted blobs in any content-addressed store, and provides a copy-on-write key-value store API.

brendoncarroll··on Show HN: Diet256 Is a Centrally Coordinated INET256 Network
Author here, happy to answer any questions.

Diet256 is a centrally coordinated, densely connected overlay network, implementing the INET256 spec. It's the same simple INET256 API, but without any of the peering or routing configuration to manage. Diet256 makes all its connections over The Internet using QUIC and uses a central server to discover the IP address of peers.

Diet256 can be run as a daemon, providing a INET256 API over gRPC compatible with the reference implementation and tools. It can also be used as a Go library directly.

brendoncarroll··on Ask HN: Who wants to collaborate?
I'm working on INET256, a 256 bit network address space for easily and securely connecting applications.

https://github.com/inet256/inet256

- The API is focused around sending and receiving messages to addresses derived from public keys.

- Each application can have its own stable address.

- Runs as a daemon process which is configured with peering information. Additional network nodes can be spawned through the API.

- Can easily support arbitrary routing algorithms through a well defined interface.

- A TUN device (similar to CJDNS or Yggdrasil) is included as a separate application. (The IP6 Portal)

brendoncarroll··on Ask HN: Who wants to collaborate?
I am working on INET256, an API and address standard + reference implementation for secure network communication.

https://github.com/inet256/inet256

Developers, applications, and end-users are under-served by the network layer. INET256 provides necessary features (stable addresses, encryption) to client applications, which usually have to reimplement those features themselves.

brendoncarroll··on Show HN: Got is like Git, but with an 'o'
There is an interface for address discovery [1] (finding transport addresses for peers you know about) and autopeering [2] (peering with peers you didn't know about beforehand). There is an unfinished branch for LAN broadcast discovery/autopeering. Contributions are definitely welcome here.

I had played around with a STUN transport, but the easiest way to connect has been to stand up a cloud VM with a static IP.

INET256 addresses use the same public key serialization as TLS, but they intentionally avoid the rest of the certificate infrastructure complexity. They make great leaves in a web of trust. You can sign them, or stick them in DNS records. And if you don't want to deal with any of that, fine, just swap addresses and you can communicate securely.

[1] https://github.com/inet256/inet256/blob/master/pkg/discovery...

[2] https://github.com/inet256/inet256/blob/master/pkg/autopeeri...

brendoncarroll··on Show HN: Got is like Git, but with an 'o'
The "ideas from WebFS" that are mentioned in the README are just building a filesystem on top of 2 well defined primitives: compare-and-swap cells and content-addressed storage. Those primitives are general enough to deal with the network and encryption. WebFS tried to allow specifications for cells and stores to live as files in the filesystem, so that submounts could be set up recursively. Got takes the approach of just creating a namespace for branches where each branch contains a cell and store.

Got is an INET256[1] application. Got uses the go-p2p library on top of INET256 to get a reliable request-response layer, since INET256 only provides the same guarantees as DTLS. Each repo has an address on the network which is used to identify remote branches and for access control. You have to configure peering/port-forwarding once for INET256 and then Got should just work.

[1] https://github.com/inet256/inet256

brendoncarroll··on Spork: Peer-to-peer socket magic in the air
> To me, this is the future. I wish we had a set of APIs to allow connecting to a public key instead of an IP address

INET256 is working on exactly that. It's a set of APIs for connecting to addresses derived from public keys.

https://github.com/inet256/inet256

brendoncarroll··on Ask HN: What are some tools / libraries you built yourself?
A message based p2p library. https://github.com/brendoncarroll/go-p2p

There is a single abstraction (the Swarm) which is capable of modeling communication, NAT, and identity. And you can layer them (Swarms) to provide whatever functionality you need. For the most part, you communicate using tell or ask methods.

The big name in this space is lib-p2p. It doesn’t have a UDP transport (it exists but is incomplete), and the examples were focused on manipulating streams so it wasn’t clear how to model message based communication from reading the docs. You also have to buy into many other abstractions when you use it e.g. multiaddrs.

brendoncarroll··on The Pinecone Overlay Network
I have been working on a similar project here: https://github.com/inet256/inet256 The focus is more on establishing an upward facing API, to develop p2p applications against. You can write your p2p app in whatever language and just connect to the INET256 service. It makes it pretty easy to experiment with a new routing algorithm, and eliminates much of the peering and transport security boilerplate.

Is Pinecone intended as a Go library, or will it eventually run as a separate process like Yggdrasil? How will this be exposed to the other matrix applications, which AFAIK are not written in Go?

brendoncarroll··on Webfs: A Filesystem Built on Top of the Web
I was not aware of Plan 9's WebFS. It looks like it presents websites in the local file system. IPFS can do something very similar with its content. I have used that before.

The name here comes from using web resources (referred to by url) as building blocks for a file system. I guess "Web for FS" rather than "Web as FS".

brendoncarroll··on Webfs: A Filesystem Built on Top of the Web
A WebDAV file could be used as a WebFS Cell. The locking would allow emulation of the compare-and-swap functionality. The reference HTTP Cell: client and server are way less complicated than WebDAV though, as many here have alluded to.
brendoncarroll··on Webfs: A Filesystem Built on Top of the Web
Yes, you could use the HTTP Store over Tor. I think you would have to configure the proxy environment variables for Go's HTTP client.
brendoncarroll··on Webfs: A Filesystem Built on Top of the Web
Encryption keys are derived from a secret and the hash of the data. The secrets are set per Volume. An empty secret would be a convergent encryption strategy, maybe suitable for public data. If the secret is set then the keys will be convergent with other keys generated with the same secret. This amounts to deduplication within a Volume, and privacy.

All a storage provider sees are many small encrypted blobs, so the size of large files is not leaked either.

brendoncarroll··on Webfs: A Filesystem Built on Top of the Web
Just to clarify: All data is encrypted on the client, going after a server backing a Store will get you encrypted blobs. Encryption keys would not exist on the server in plaintext.
brendoncarroll··on Webfs: A Filesystem Built on Top of the Web
This is a legitimate concern. WebFS is designed for the p2p storage use case. Persisting data with p2p storage means that it can live forever. All the secrets in WebFS are randomly generated and there are no user supplied (potentially weak) passwords.

w.r.t. quantum computing: it is possible for WebFS to use symmetric cryptography for all remote data. Although, many Cell implementations in the near term will likely use elliptic curves or RSA.

brendoncarroll··on Webfs: A Filesystem Built on Top of the Web
WebFS stores data in things it calls "Stores". Stores can be anything that takes data and gives back a key to retrieve the data. Right now we have an IPFS and HTTP store built. An FTP server could also work as a store.

If you or a friend run the HTTP or FTP server then it will persist the data for you. IPFS doesn't incentivize data persistence so if WebFS is working on top of IPFS it inherits that problem. You could run WebFS on top of one of the storage networks and persisting your blobs would be incentivized.

WebFS is storage layer agnostic. Give it a Store, and it will give you a file system.

brendoncarroll··on Webfs: A Filesystem Built on Top of the Web
Yes. WebFS doesn't actually use any of the file/directory functionality provided by IPFS, or any encryption features. We only use the get/put block functionality. Everything is encrypted in WebFS before being posted to a Store.

The data encryption keys are generated using a secret and the hash of the data being encrypted. That key is stored in the reference to that data. This continues recursively to the superblock which is not encrypted.

brendoncarroll··on Webfs: A Filesystem Built on Top of the Web
Hey everyone, I'm the author of WebFS. Happy to answer any questions.
← PreviousPage 2 of 2