move key creation to the keystore lib

cmd/auth.go

@@ -1,15 +1,10 @@
 package cmd
 
 import (
- "crypto/rand"
- "errors"
  "fmt"
- "io"
- "path/filepath"
 
  "github.com/cristalhq/jwt"
  "github.com/filecoin-project/go-jsonrpc/auth"
- "github.com/mitchellh/go-homedir"
  "github.com/spf13/cobra"
  flag "github.com/spf13/pflag"
 
@@ -44,63 +39,23 @@ func newToken(cmd *cobra.Command, args []string) error {
  return err
  }
 
- token, err := Token(StorePath(cmd.Context()), permissions)
+ privKey, err := keystore.Key(StorePath(cmd.Context()), nodemod.SecretName)
  if err != nil {
  return err
  }
 
- fmt.Printf("%s", token)
- return nil
-}
-
-func Token(path string, perms []auth.Permission) (string, error) {
- expanded, err := homedir.Expand(filepath.Clean(path))
- if err != nil {
- return "", err
- }
- ks, err := keystore.NewFSKeystore(filepath.Join(expanded, "keys"), nil)
- if err != nil {
- return "", err
- }
-
- var key keystore.PrivKey
- key, err = ks.Get(nodemod.SecretName)
- if err != nil {
- if !errors.Is(err, keystore.ErrNotFound) {
- return "", err
- }
- // otherwise, generate and save new priv key
- key, err = generateNewKey(ks)
- if err != nil {
- return "", err
- }
- }
-
- signer, err := jwt.NewHS256(key.Body)
+ signer, err := jwt.NewHS256(privKey)
  if err != nil {
- return "", err
+ return err
  }
 
- token, err := authtoken.NewSignedJWT(signer, perms)
+ token, err := authtoken.NewSignedJWT(signer, permissions)
  if err != nil {
- return "", err
+ return err
  }
 
- return token, nil
-}
-
-func generateNewKey(ks keystore.Keystore) (keystore.PrivKey, error) {
- sk, err := io.ReadAll(io.LimitReader(rand.Reader, 32))
- if err != nil {
- return keystore.PrivKey{}, err
- }
- // save key
- key := keystore.PrivKey{Body: sk}
- err = ks.Put(nodemod.SecretName, key)
- if err != nil {
- return keystore.PrivKey{}, err
- }
- return key, nil
+ fmt.Printf("%s", token)
+ return nil
 }
 
 func convertToPerms(perm string) ([]auth.Permission, error) {

cmd/celestia/rpc.go

@@ -13,12 +13,15 @@ import (
  "strconv"
  "strings"
 
+ "github.com/cristalhq/jwt"
  "github.com/spf13/cobra"
 
  "github.com/celestiaorg/celestia-node/api/rpc/client"
  "github.com/celestiaorg/celestia-node/api/rpc/perms"
  "github.com/celestiaorg/celestia-node/blob"
- auth "github.com/celestiaorg/celestia-node/cmd"
+ "github.com/celestiaorg/celestia-node/libs/authtoken"
+ "github.com/celestiaorg/celestia-node/libs/keystore"
+ nodemod "github.com/celestiaorg/celestia-node/nodebuilder/node"
  "github.com/celestiaorg/celestia-node/nodebuilder/p2p"
  "github.com/celestiaorg/celestia-node/share"
  "github.com/celestiaorg/celestia-node/state"
@@ -355,16 +358,23 @@ func sendJSONRPCRequest(namespace, method string, params []interface{}) {
 
  authToken := authTokenFlag
  if authToken == "" {
- token, err := auth.Token(storePath, perms.AllPerms)
+ privKey, err := keystore.Key(storePath, nodemod.SecretName)
+ if err != nil {
+ panic(err)
+ }
+
+ signer, err := jwt.NewHS256(privKey)
  if err != nil {
  panic(err)
  }
- authToken = token
- }
 
- if authToken != "" {
- req.Header.Set("Authorization", "Bearer "+authToken)
+ token, err := authtoken.NewSignedJWT(signer, perms.AllPerms)
+ if err != nil {
+ panic(err)
+ }
+ authToken = token
  }
+ req.Header.Set("Authorization", "Bearer "+authToken)
 
  client := &http.Client{}
  resp, err := client.Do(req)

libs/keystore/fs_keystore.go

@@ -1,14 +1,17 @@
 package keystore
 
 import (
+ "crypto/rand"
  "encoding/json"
  "errors"
  "fmt"
+ "io"
  "io/fs"
  "os"
  "path/filepath"
 
  "github.com/cosmos/cosmos-sdk/crypto/keyring"
+ "github.com/mitchellh/go-homedir"
 )
 
 // ErrNotFound is returned when the key does not exist.
@@ -143,3 +146,43 @@ func checkPerms(perms os.FileMode) error {
  }
  return nil
 }
+
+func Key(path string, keyName KeyName) ([]byte, error) {
+ expanded, err := homedir.Expand(filepath.Clean(path))
+ if err != nil {
+ return nil, err
+ }
+ ks, err := NewFSKeystore(filepath.Join(expanded, "keys"), nil)
+ if err != nil {
+ return nil, err
+ }
+
+ var key PrivKey
+ key, err = ks.Get(keyName)
+ if err != nil {
+ if !errors.Is(err, ErrNotFound) {
+ return nil, err
+ }
+ // otherwise, generate and save new priv key
+ key, err = generateNewKey(ks, keyName)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ return key.Body, nil
+}
+
+func generateNewKey(ks Keystore, keyName KeyName) (PrivKey, error) {
+ sk, err := io.ReadAll(io.LimitReader(rand.Reader, 32))
+ if err != nil {
+ return PrivKey{}, err
+ }
+ // save key
+ key := PrivKey{Body: sk}
+ err = ks.Put(keyName, key)
+ if err != nil {
+ return PrivKey{}, err
+ }
+ return key, nil
+}