0
0
package didkey
import (
"crypto/ed25519"
"encoding/hex"
"errors"
"fmt"
"math/big"
"strings"
"github.com/bluesky-social/indigo/atproto/atcrypto"
)
const Prefix = "did:key:"
const MultibaseBase58BTC = 'z'
var Ed25519PubMulticodec = []byte{0xed, 0x01}
var Secp256k1PubMulticodec = []byte{0xe7, 0x01}
const base58Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
var (
ErrNotDidKey = errors.New("didkey: not a did:key")
ErrNotEd25519 = errors.New("didkey: the multicodec prefix is not ed25519-pub (0xed 0x01)")
ErrNotSecp256k1 = errors.New("didkey: the multicodec prefix is not secp256k1-pub (0xe7 0x01)")
ErrBadBase58 = errors.New("didkey: not base58btc")
)
func FromEd25519(pub ed25519.PublicKey) (string, error) {
if len(pub) != ed25519.PublicKeySize {
return "", fmt.Errorf("didkey: an ed25519 public key is %d bytes, this one is %d",
ed25519.PublicKeySize, len(pub))
}
body := append(append([]byte{}, Ed25519PubMulticodec...), pub...)
return Prefix + string(MultibaseBase58BTC) + EncodeBase58(body), nil
}
func ParseEd25519(did string) (ed25519.PublicKey, error) {
rest, ok := strings.CutPrefix(did, Prefix)
if !ok {
return nil, fmt.Errorf("%w: %q", ErrNotDidKey, did)
}
if rest == "" || rest[0] != MultibaseBase58BTC {
return nil, fmt.Errorf("%w: %q is not multibase base58btc (no %q prefix)", ErrNotDidKey, did,
MultibaseBase58BTC)
}
body, err := DecodeBase58(rest[1:])
if err != nil {
return nil, err
}
if len(body) < len(Ed25519PubMulticodec) || body[0] != Ed25519PubMulticodec[0] || body[1] != Ed25519PubMulticodec[1] {
return nil, fmt.Errorf("%w: %q", ErrNotEd25519, did)
}
pub := body[len(Ed25519PubMulticodec):]
if len(pub) != ed25519.PublicKeySize {
return nil, fmt.Errorf("didkey: %q carries %d key bytes, an ed25519 public key is %d",
did, len(pub), ed25519.PublicKeySize)
}
return ed25519.PublicKey(pub), nil
}
func FromSecp256k1(pub atcrypto.PublicKey) (string, error) {
if pub == nil {
return "", errors.New("didkey: a nil secp256k1 public key")
}
k, ok := pub.(*atcrypto.PublicKeyK256)
if !ok {
return "", fmt.Errorf("%w: %T", ErrNotSecp256k1, pub)
}
return k.DIDKey(), nil
}
func ParseSecp256k1(did string) (*atcrypto.PublicKeyK256, error) {
if !strings.HasPrefix(did, Prefix) {
return nil, fmt.Errorf("%w: %q", ErrNotDidKey, did)
}
pub, err := atcrypto.ParsePublicDIDKey(did)
if err != nil {
return nil, fmt.Errorf("didkey: %q: %w", did, err)
}
k, ok := pub.(*atcrypto.PublicKeyK256)
if !ok {
return nil, fmt.Errorf("%w: %q", ErrNotSecp256k1, did)
}
return k, nil
}
func ParsePublic(did string) (atcrypto.PublicKey, error) {
if !strings.HasPrefix(did, Prefix) {
return nil, fmt.Errorf("%w: %q", ErrNotDidKey, did)
}
pub, err := atcrypto.ParsePublicDIDKey(did)
if err != nil {
return nil, fmt.Errorf("didkey: %q: %w", did, err)
}
return pub, nil
}
func Verify(did string, msg, sig []byte) error {
pub, err := ParsePublic(did)
if err != nil {
return err
}
return pub.HashAndVerify(msg, sig)
}
func EndpointID(pub ed25519.PublicKey) (string, error) {
if len(pub) != ed25519.PublicKeySize {
return "", fmt.Errorf("didkey: an iroh endpoint id is a %d byte ed25519 public key, this one is %d",
ed25519.PublicKeySize, len(pub))
}
return hex.EncodeToString(pub), nil
}
func EncodeBase58(b []byte) string {
zeros := 0
for zeros < len(b) && b[zeros] == 0 {
zeros++
}
n := new(big.Int).SetBytes(b)
radix := big.NewInt(58)
mod := new(big.Int)
var out []byte
for n.Sign() > 0 {
n.DivMod(n, radix, mod)
out = append(out, base58Alphabet[mod.Int64()])
}
for i := 0; i < zeros; i++ {
out = append(out, base58Alphabet[0])
}
for i, j := 0, len(out)-1; i < j; i, j = i+1, j-1 {
out[i], out[j] = out[j], out[i]
}
return string(out)
}
func DecodeBase58(s string) ([]byte, error) {
if s == "" {
return nil, fmt.Errorf("%w: empty", ErrBadBase58)
}
n := new(big.Int)
radix := big.NewInt(58)
for _, c := range s {
i := strings.IndexRune(base58Alphabet, c)
if i < 0 {
return nil, fmt.Errorf("%w: %q holds %q", ErrBadBase58, s, c)
}
n.Mul(n, radix)
n.Add(n, big.NewInt(int64(i)))
}
zeros := 0
for zeros < len(s) && s[zeros] == base58Alphabet[0] {
zeros++
}
return append(make([]byte, zeros), n.Bytes()...), nil
}