116 lines
2.9 KiB
Go
116 lines
2.9 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"
|
|
|
|
"lol.mleku.dev/chk"
|
|
"next.orly.dev/pkg/crypto/ec/schnorr"
|
|
"next.orly.dev/pkg/interfaces/signer/p8k"
|
|
"next.orly.dev/pkg/encoders/hex"
|
|
"next.orly.dev/pkg/utils"
|
|
)
|
|
|
|
// 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) {
|
|
var signer *p8k.Signer
|
|
if signer, err = p8k.New(); chk.E(err) {
|
|
return
|
|
}
|
|
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
|
|
}
|
|
var signer *p8k.Signer
|
|
if signer, err = p8k.New(); chk.E(err) {
|
|
return
|
|
}
|
|
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) {
|
|
var signer *p8k.Signer
|
|
if signer, err = p8k.New(); chk.E(err) {
|
|
return
|
|
}
|
|
if err = signer.InitSec(skb); chk.E(err) {
|
|
return
|
|
}
|
|
return hex.Enc(signer.Pub()), nil
|
|
}
|
|
|
|
// SecretBytesToPubKeyBytes generates a public key bytes from secret key bytes.
|
|
func SecretBytesToPubKeyBytes(skb []byte) (pkb []byte, err error) {
|
|
var signer *p8k.Signer
|
|
if signer, err = p8k.New(); chk.E(err) {
|
|
return
|
|
}
|
|
if err = signer.InitSec(skb); chk.E(err) {
|
|
return
|
|
}
|
|
return signer.Pub(), nil
|
|
}
|
|
|
|
// SecretBytesToSigner creates a signer from secret key bytes.
|
|
func SecretBytesToSigner(skb []byte) (signer *p8k.Signer, err error) {
|
|
if signer, err = p8k.New(); chk.E(err) {
|
|
return
|
|
}
|
|
if err = signer.InitSec(skb); chk.E(err) {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// 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 {
|
|
if utils.FastEqual(bytes.ToLower([]byte(pk)), []byte(pk)) {
|
|
return false
|
|
}
|
|
var err error
|
|
dec := make([]byte, 32)
|
|
if _, err = hex.DecBytes(dec, []byte(pk)); chk.E(err) {
|
|
}
|
|
return len(dec) == 32
|
|
}
|
|
|
|
// IsValidPublicKey checks that a hex encoded public key is a valid BIP-340 public key.
|
|
func IsValidPublicKey[V []byte | string](pk V) bool {
|
|
v, _ := hex.Dec(string(pk))
|
|
_, 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))
|
|
}
|