97 lines
2.3 KiB
Go
97 lines
2.3 KiB
Go
// Package keys is a set of helpers for generating and converting public/secret
|
|
// keys to hex and back to binary.
|
|
package keys
|
|
|
|
import (
|
|
"bytes"
|
|
|
|
"realy.lol/chk"
|
|
"realy.lol/ec/schnorr"
|
|
"realy.lol/hex"
|
|
"realy.lol/p256k"
|
|
)
|
|
|
|
// GeneratePrivateKey - deprecated, use GenerateSecretKeyHex
|
|
var GeneratePrivateKey = func() string { return GenerateSecretKeyHex() }
|
|
|
|
// GenerateSecretKey creates a new secret key and returns the bytes of the secret.
|
|
func GenerateSecretKey() (skb []byte, err error) {
|
|
signer := &p256k.Signer{}
|
|
if err = signer.Generate(); chk.E(err) {
|
|
return
|
|
}
|
|
skb = signer.Sec()
|
|
return
|
|
}
|
|
|
|
// GenerateSecretKeyHex generates a secret key and encodes the bytes as hex.
|
|
func GenerateSecretKeyHex() (sks string) {
|
|
skb, err := GenerateSecretKey()
|
|
if chk.E(err) {
|
|
return
|
|
}
|
|
return hex.Enc(skb)
|
|
}
|
|
|
|
// GetPublicKeyHex generates a public key from a hex encoded secret key.
|
|
func GetPublicKeyHex(sk string) (pk string, err error) {
|
|
var b []byte
|
|
if b, err = hex.Dec(sk); chk.E(err) {
|
|
return
|
|
}
|
|
signer := &p256k.Signer{}
|
|
if err = signer.InitSec(b); chk.E(err) {
|
|
return
|
|
}
|
|
|
|
return hex.Enc(signer.Pub()), nil
|
|
}
|
|
|
|
// SecretBytesToPubKeyHex generates a public key from secret key bytes.
|
|
func SecretBytesToPubKeyHex(skb []byte) (pk string, err error) {
|
|
signer := &p256k.Signer{}
|
|
if err = signer.InitSec(skb); chk.E(err) {
|
|
return
|
|
}
|
|
return hex.Enc(signer.Pub()), nil
|
|
}
|
|
|
|
// IsValid32ByteHex checks that a hex string is a valid 32 bytes lower case hex encoded value as
|
|
// per nostr NIP-01 spec.
|
|
func IsValid32ByteHex[V []byte | string](pk V) bool {
|
|
pkBytes := []byte(pk)
|
|
|
|
// Check if the input is lowercase
|
|
if !bytes.Equal(bytes.ToLower(pkBytes), pkBytes) {
|
|
return false
|
|
}
|
|
|
|
// Check if the input length is exactly 64 characters (32 bytes * 2)
|
|
if len(pkBytes) != 64 {
|
|
return false
|
|
}
|
|
|
|
// Try to decode the hex string
|
|
var err error
|
|
if _, err = hex.Dec(string(pkBytes)); err != nil {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// IsValidPublicKey checks that a hex encoded public key is a valid BIP-340 public key.
|
|
func IsValidPublicKey[V []byte | string](pk V) bool {
|
|
v, err := hex.Dec(string(pk))
|
|
if err != nil {
|
|
return false
|
|
}
|
|
_, err = schnorr.ParsePubKey(v)
|
|
return err == nil
|
|
}
|
|
|
|
// HexPubkeyToBytes decodes a pubkey from hex encoded string/bytes.
|
|
func HexPubkeyToBytes[V []byte | string](hpk V) (pkb []byte, err error) {
|
|
return hex.DecAppend(nil, []byte(hpk))
|
|
}
|