2023-10-20 19:57:29 -04:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
2023-11-07 15:57:43 -05:00
|
|
|
"bufio"
|
|
|
|
"context"
|
2024-01-29 07:47:26 -05:00
|
|
|
"encoding/hex"
|
2023-10-20 20:01:11 -04:00
|
|
|
"fmt"
|
|
|
|
"net/url"
|
2023-10-20 19:57:29 -04:00
|
|
|
"os"
|
2023-10-23 07:04:28 -04:00
|
|
|
"strings"
|
2023-10-20 19:57:29 -04:00
|
|
|
|
2024-01-29 07:47:26 -05:00
|
|
|
"github.com/chzyer/readline"
|
|
|
|
"github.com/fatih/color"
|
2023-11-13 12:57:35 -05:00
|
|
|
"github.com/nbd-wtf/go-nostr"
|
2023-12-02 10:18:55 -05:00
|
|
|
"github.com/nbd-wtf/go-nostr/nip19"
|
2024-02-05 22:58:26 -05:00
|
|
|
"github.com/nbd-wtf/go-nostr/nip46"
|
2024-01-29 07:47:26 -05:00
|
|
|
"github.com/nbd-wtf/go-nostr/nip49"
|
2023-10-20 19:57:29 -04:00
|
|
|
"github.com/urfave/cli/v2"
|
|
|
|
)
|
|
|
|
|
2023-11-07 15:57:43 -05:00
|
|
|
const (
|
|
|
|
LINE_PROCESSING_ERROR = iota
|
2023-12-02 10:18:55 -05:00
|
|
|
|
|
|
|
BOLD_ON = "\033[1m"
|
|
|
|
BOLD_OFF = "\033[21m"
|
2023-11-07 15:57:43 -05:00
|
|
|
)
|
|
|
|
|
2023-11-13 13:03:27 -05:00
|
|
|
var log = func(msg string, args ...any) {
|
|
|
|
fmt.Fprintf(os.Stderr, msg, args...)
|
|
|
|
}
|
|
|
|
|
2024-01-24 20:38:51 -05:00
|
|
|
var stdout = fmt.Println
|
|
|
|
|
2023-11-08 12:26:25 -05:00
|
|
|
func isPiped() bool {
|
|
|
|
stat, _ := os.Stdin.Stat()
|
|
|
|
return stat.Mode()&os.ModeCharDevice == 0
|
|
|
|
}
|
|
|
|
|
2023-11-07 15:57:43 -05:00
|
|
|
func getStdinLinesOrBlank() chan string {
|
2023-11-08 10:50:36 -05:00
|
|
|
multi := make(chan string)
|
|
|
|
if hasStdinLines := writeStdinLinesOrNothing(multi); !hasStdinLines {
|
|
|
|
single := make(chan string, 1)
|
|
|
|
single <- ""
|
|
|
|
close(single)
|
|
|
|
return single
|
|
|
|
} else {
|
|
|
|
return multi
|
|
|
|
}
|
2023-11-07 15:57:43 -05:00
|
|
|
}
|
|
|
|
|
2024-02-03 08:03:32 -05:00
|
|
|
func getStdinLinesOrFirstArgument(arg string) chan string {
|
2023-11-07 15:57:43 -05:00
|
|
|
// try the first argument
|
2024-02-03 08:03:32 -05:00
|
|
|
if arg != "" {
|
2023-11-08 10:50:36 -05:00
|
|
|
single := make(chan string, 1)
|
2024-02-03 08:03:32 -05:00
|
|
|
single <- arg
|
2023-11-08 20:54:52 -05:00
|
|
|
close(single)
|
2023-11-08 10:50:36 -05:00
|
|
|
return single
|
2023-11-07 15:57:43 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// try the stdin
|
2023-11-08 10:50:36 -05:00
|
|
|
multi := make(chan string)
|
|
|
|
writeStdinLinesOrNothing(multi)
|
|
|
|
return multi
|
|
|
|
}
|
|
|
|
|
|
|
|
func writeStdinLinesOrNothing(ch chan string) (hasStdinLines bool) {
|
2023-11-08 12:26:25 -05:00
|
|
|
if isPiped() {
|
2023-11-08 10:50:36 -05:00
|
|
|
// piped
|
|
|
|
go func() {
|
|
|
|
scanner := bufio.NewScanner(os.Stdin)
|
2024-01-11 19:48:54 -05:00
|
|
|
scanner.Buffer(make([]byte, 16*1024), 256*1024)
|
2023-11-08 10:50:36 -05:00
|
|
|
for scanner.Scan() {
|
|
|
|
ch <- strings.TrimSpace(scanner.Text())
|
|
|
|
}
|
|
|
|
close(ch)
|
|
|
|
}()
|
|
|
|
return true
|
|
|
|
} else {
|
|
|
|
// not piped
|
|
|
|
return false
|
2023-10-20 19:57:29 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-10-20 20:01:11 -04:00
|
|
|
func validateRelayURLs(wsurls []string) error {
|
|
|
|
for _, wsurl := range wsurls {
|
|
|
|
u, err := url.Parse(wsurl)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("invalid relay url '%s': %s", wsurl, err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if u.Scheme != "ws" && u.Scheme != "wss" {
|
|
|
|
return fmt.Errorf("relay url must use wss:// or ws:// schemes, got '%s'", wsurl)
|
|
|
|
}
|
|
|
|
|
|
|
|
if u.Host == "" {
|
|
|
|
return fmt.Errorf("relay url '%s' is missing the hostname", wsurl)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2023-11-07 15:57:43 -05:00
|
|
|
|
2023-12-09 14:32:04 -05:00
|
|
|
func connectToAllRelays(
|
|
|
|
ctx context.Context,
|
|
|
|
relayUrls []string,
|
|
|
|
opts ...nostr.PoolOption,
|
|
|
|
) (*nostr.SimplePool, []*nostr.Relay) {
|
2023-11-13 12:57:35 -05:00
|
|
|
relays := make([]*nostr.Relay, 0, len(relayUrls))
|
2023-12-09 14:32:04 -05:00
|
|
|
pool := nostr.NewSimplePool(ctx, opts...)
|
2023-11-13 12:57:35 -05:00
|
|
|
for _, url := range relayUrls {
|
2023-11-13 13:03:27 -05:00
|
|
|
log("connecting to %s... ", url)
|
2023-11-13 12:57:35 -05:00
|
|
|
if relay, err := pool.EnsureRelay(url); err == nil {
|
|
|
|
relays = append(relays, relay)
|
2023-11-13 13:03:27 -05:00
|
|
|
log("ok.\n")
|
2023-11-13 12:57:35 -05:00
|
|
|
} else {
|
2023-11-13 13:03:27 -05:00
|
|
|
log(err.Error() + "\n")
|
2023-11-13 12:57:35 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return pool, relays
|
|
|
|
}
|
|
|
|
|
2023-11-07 15:57:43 -05:00
|
|
|
func lineProcessingError(c *cli.Context, msg string, args ...any) {
|
|
|
|
c.Context = context.WithValue(c.Context, LINE_PROCESSING_ERROR, true)
|
2023-11-13 13:03:27 -05:00
|
|
|
log(msg+"\n", args...)
|
2023-11-07 15:57:43 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
func exitIfLineProcessingError(c *cli.Context) {
|
|
|
|
if val := c.Context.Value(LINE_PROCESSING_ERROR); val != nil && val.(bool) {
|
|
|
|
os.Exit(123)
|
|
|
|
}
|
|
|
|
}
|
2023-12-02 10:18:55 -05:00
|
|
|
|
2024-02-05 22:58:26 -05:00
|
|
|
func gatherSecretKeyOrBunkerFromArguments(c *cli.Context) (string, *nip46.BunkerClient, error) {
|
2024-01-29 07:47:26 -05:00
|
|
|
var err error
|
2024-02-05 22:58:26 -05:00
|
|
|
|
|
|
|
if bunkerURL := c.String("connect"); bunkerURL != "" {
|
2024-02-06 10:47:46 -05:00
|
|
|
clientKey := c.String("connect-as")
|
|
|
|
if clientKey != "" {
|
|
|
|
clientKey = strings.Repeat("0", 64-len(clientKey)) + clientKey
|
|
|
|
} else {
|
|
|
|
clientKey = nostr.GeneratePrivateKey()
|
|
|
|
}
|
2024-02-05 22:58:26 -05:00
|
|
|
bunker, err := nip46.ConnectBunker(c.Context, clientKey, bunkerURL, nil)
|
|
|
|
return "", bunker, err
|
|
|
|
}
|
2023-12-02 10:18:55 -05:00
|
|
|
sec := c.String("sec")
|
|
|
|
if c.Bool("prompt-sec") {
|
|
|
|
if isPiped() {
|
2024-02-05 22:58:26 -05:00
|
|
|
return "", nil, fmt.Errorf("can't prompt for a secret key when processing data from a pipe, try again without --prompt-sec")
|
2023-12-02 10:18:55 -05:00
|
|
|
}
|
2024-01-29 07:47:26 -05:00
|
|
|
sec, err = askPassword("type your secret key as ncryptsec, nsec or hex: ", nil)
|
2023-12-02 10:18:55 -05:00
|
|
|
if err != nil {
|
2024-02-05 22:58:26 -05:00
|
|
|
return "", nil, fmt.Errorf("failed to get secret key: %w", err)
|
2023-12-02 10:18:55 -05:00
|
|
|
}
|
|
|
|
}
|
2024-01-29 07:47:26 -05:00
|
|
|
if strings.HasPrefix(sec, "ncryptsec1") {
|
|
|
|
sec, err = promptDecrypt(sec)
|
2023-12-02 10:18:55 -05:00
|
|
|
if err != nil {
|
2024-02-05 22:58:26 -05:00
|
|
|
return "", nil, fmt.Errorf("failed to decrypt: %w", err)
|
2023-12-02 10:18:55 -05:00
|
|
|
}
|
2024-02-02 12:11:58 -05:00
|
|
|
} else if bsec, err := hex.DecodeString(strings.Repeat("0", 64-len(sec)) + sec); err == nil {
|
|
|
|
sec = hex.EncodeToString(bsec)
|
2024-01-29 07:47:26 -05:00
|
|
|
} else if prefix, hexvalue, err := nip19.Decode(sec); err != nil {
|
2024-02-05 22:58:26 -05:00
|
|
|
return "", nil, fmt.Errorf("invalid nsec: %w", err)
|
2024-01-29 07:47:26 -05:00
|
|
|
} else if prefix == "nsec" {
|
|
|
|
sec = hexvalue.(string)
|
2023-12-02 10:18:55 -05:00
|
|
|
}
|
2024-01-29 07:47:26 -05:00
|
|
|
|
2024-01-21 05:45:22 -05:00
|
|
|
if ok := nostr.IsValid32ByteHex(sec); !ok {
|
2024-02-05 22:58:26 -05:00
|
|
|
return "", nil, fmt.Errorf("invalid secret key")
|
2023-12-02 10:18:55 -05:00
|
|
|
}
|
2024-02-05 22:58:26 -05:00
|
|
|
return sec, nil, nil
|
2023-12-02 10:18:55 -05:00
|
|
|
}
|
2024-01-29 07:47:26 -05:00
|
|
|
|
|
|
|
func promptDecrypt(ncryptsec1 string) (string, error) {
|
|
|
|
for i := 1; i < 4; i++ {
|
|
|
|
var attemptStr string
|
|
|
|
if i > 1 {
|
|
|
|
attemptStr = fmt.Sprintf(" [%d/3]", i)
|
|
|
|
}
|
|
|
|
password, err := askPassword("type the password to decrypt your secret key"+attemptStr+": ", nil)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
sec, err := nip49.Decrypt(ncryptsec1, password)
|
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
return sec, nil
|
|
|
|
}
|
|
|
|
return "", fmt.Errorf("couldn't decrypt private key")
|
|
|
|
}
|
|
|
|
|
|
|
|
func ask(msg string, defaultValue string, shouldAskAgain func(answer string) bool) (string, error) {
|
|
|
|
return _ask(&readline.Config{
|
2024-02-02 12:13:11 -05:00
|
|
|
Stdout: os.Stderr,
|
2024-01-29 07:47:26 -05:00
|
|
|
Prompt: color.YellowString(msg),
|
|
|
|
InterruptPrompt: "^C",
|
|
|
|
DisableAutoSaveHistory: true,
|
|
|
|
}, msg, defaultValue, shouldAskAgain)
|
|
|
|
}
|
|
|
|
|
|
|
|
func askPassword(msg string, shouldAskAgain func(answer string) bool) (string, error) {
|
|
|
|
config := &readline.Config{
|
2024-02-02 12:13:11 -05:00
|
|
|
Stdout: os.Stderr,
|
2024-01-29 07:47:26 -05:00
|
|
|
Prompt: color.YellowString(msg),
|
|
|
|
InterruptPrompt: "^C",
|
|
|
|
DisableAutoSaveHistory: true,
|
|
|
|
EnableMask: true,
|
|
|
|
MaskRune: '*',
|
|
|
|
}
|
|
|
|
return _ask(config, msg, "", shouldAskAgain)
|
|
|
|
}
|
|
|
|
|
|
|
|
func _ask(config *readline.Config, msg string, defaultValue string, shouldAskAgain func(answer string) bool) (string, error) {
|
|
|
|
rl, err := readline.NewEx(config)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
rl.WriteStdin([]byte(defaultValue))
|
|
|
|
for {
|
|
|
|
answer, err := rl.Readline()
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
answer = strings.TrimSpace(strings.ToLower(answer))
|
|
|
|
if shouldAskAgain != nil && shouldAskAgain(answer) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
return answer, err
|
|
|
|
}
|
|
|
|
}
|