195 karma · joined January 4, 2020
My email is on my website.
[ my public key: https://keybase.io/brendoncarroll; my proof: https://keybase.io/brendoncarroll/sigs/fYaonvrG14Nua37nuEegQ1J9jl0b0RYIc3PyBRtwbjE ]
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.
- 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.
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.
It stores encrypted blobs in any content-addressed store, and provides a copy-on-write key-value store API.
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.
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)
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.
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...
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.
INET256 is working on exactly that. It's a set of APIs for connecting to addresses derived from public keys.
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.
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?
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".
All a storage provider sees are many small encrypted blobs, so the size of large files is not leaked either.
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.
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.
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.