Having git to use that could be a great opportunity to standardize on a de facto hash function encoding standard.
What would be the best way to suggest that (if it hasn't been already, though I am guessing it likely has).
Having git to use that could be a great opportunity to standardize on a de facto hash function encoding standard.
What would be the best way to suggest that (if it hasn't been already, though I am guessing it likely has).
"This is a good idea, but it doesn't solve the underlying problem: attackers control the choice of algorithm" ?
Here's another quote from the Wireguard paper[1]:
"Finally, WireGuard is cryptographically opinionated. It intentionally lacks cipher and protocol agility. If holes are found in the underlying primitives, all endpoints will be required to update"
https://github.com/multiformats/multihash/blob/master/README...
You don’t actually have to.
I really don't like given this a new name ("multihash"). We have a name already: algorithm agility. We should use that name.
I also don't like this idea of having a standard for algorithm agility for hash functions (and another for encryption algorithms, and...).
It's also not obvious that making every hash/MAC/public key payload carry an algorithm ID is the right design for every protocol (it's not), though for git it is.
Generally, and this is just my gut feeling, I think that for any hash code written to disk or stored in some way having an identifier for the hashing algorithm used is such a common bite you in the ass later thing that it makes sense to always just do it from day one. To that end it’s easier to do day one if everyone agrees to a standard set of numeric codes.
Multihash is the standard set of numeric codes for different algorithms I am aware of.
Unifying here might allow git objects to be served natively over IPFS.
Yes, that's the basic idea of all multiformats: "it's never gonna change" is considered harmful.
> Unifying here might allow git objects to be served natively over IPFS.
IPFS can already do that thanks to the CID format: https://github.com/ipld/cid
There's no good examples for Git specifically yet, but there's a good bunch of working code for transporting e.g. Ethereum and Zcash transaction blobs over IPFS. For Git it's in principle the same: import the raw object into IPFS, and starts addressing it with /ipfs/<git-cid><original-git-hash>
Which uses our new plugin system: https://github.com/ipfs/go-ipfs/blob/master/docs/plugins.md
1. Define a new protocol with multihash somewhere in it.
2. Import a super convenient multihash library.
3. Verify all hashes with a simple library function.
That sounds super natural and convenient to me, but if it means that you support MD4 by default, then you've introduced a downgrade attack into your protocol.
1) many if not most implementations will support lots of algorithms by default, and
2) as a result, approximately zero users will lock it down