notes-cli/main.go

package main

import (
	// "database/sql"
	"bufio"
	"crypto/aes"
	"crypto/cipher"
	"crypto/pbkdf2"
	"crypto/sha256"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"log"
	"net/http"
	"net/url"
	"os/signal"
	"syscall"

	"os"

	"golang.org/x/term"
	_ "modernc.org/sqlite"
)

var (
	serverAddress string
	username      string
	password      string
	dataDir       string
	dataPath      string
	cachePath     string
	scanner       bufio.Scanner
)

func check(err error, format string, a ...any) bool {
	if err != nil {
		log.Fatalf(format, a, err)
		return false
	}
	return true
}

func ReadPassword() (string, error) {
	stdin := int(syscall.Stdin)
	oldState, err := term.GetState(stdin)
	if err != nil {
		return "", err
	}
	defer term.Restore(stdin, oldState)

	sigch := make(chan os.Signal, 1)
	signal.Notify(sigch, os.Interrupt)

	go func() {
		<-sigch
		term.Restore(stdin, oldState)
		os.Exit(1)
	}()

	password, err := term.ReadPassword(stdin)
	if err != nil {
		return "", err
	}

	return string(password), nil
}

func main() {
	scanner = *bufio.NewScanner(os.Stdin)
	home := os.Getenv("HOME")
	dataPath = os.Getenv("XDG_DATA_HOME")
	cachePath = os.Getenv("XDG_CACHE_HOME")
	if len(dataPath) < 1 {
		dataPath = home + "/.local/share"
	}
	if len(cachePath) < 1 {
		cachePath = home + "/.cache"
	}
	cachePath += "/notes/notes.db"
	dataDir = dataPath + "/notes"
	dataPath += "/notes/userinfo.json"

	// db, err := sql.Open("sqlite", cachePath)
	// if err != nil {
	// 	log.Fatal("Error opening sqlite database for notes cache at ", cachePath, ": ", err)
	// }
	args := os.Args[1:]
	var command string
	if len(args) < 1 {
		command = ""
	} else {
		command = args[0]
	}
	switch command {
	case "l", "ls", "list", "search", "find":
		userDataBytes, err := os.ReadFile(dataPath)
		if errors.Is(err, fs.ErrNotExist) {
			login()
		}
		check(err, "Error reading user data at '%s': %s", dataPath)
		var userData []string
		err = json.Unmarshal(userDataBytes, &userData)
		check(err, "Error unmarshalling user data: %s")

		serverAddress, username, password = userData[0], userData[1], userData[2]

		response, err := http.Get(fmt.Sprintf("https://%s/get?user=%s", serverAddress, url.QueryEscape(username)))
		check(err, "Error getting notes from '%s' as '%s': %s", serverAddress, username)
		defer response.Body.Close()
		body, err := io.ReadAll(response.Body)
		check(err, "Error reading response body while getting notes: %s")
		var jsonBody [][2]string
		err = json.Unmarshal(body, &jsonBody)
		check(err, "Error unmarshalling response body: %s")

		decryptedBody := make([]string, len(jsonBody))
		for i := range len(jsonBody) {
			decryptedBody[i] = decrypt(jsonBody[i][1], password)
			jsonDecryptedBody := json.Marshal(decryptedBody)
			decryptedBody[i]
		}
		fmt.Println(decryptedBody)

	default:
		login()
	}
}

func login() {
	fmt.Println("Welcome to Notes! To get started, choose your server and user.")
	fmt.Print("Server Address [notes.miningtcup.me]: ")
	_, err := fmt.Scanln(&serverAddress)
	if err != nil {
		serverAddress = "notes.miningtcup.me"
	}

	fmt.Print("Username: ")
	scanner.Scan()
	username = scanner.Text()

	fmt.Print("Password: ")
	passwordBytes, err := ReadPassword()
	password = string(passwordBytes)
	check(err, "Error reading user input (password): %s")

	jsonData, err := json.Marshal([]string{serverAddress, username, password})
	check(err, "Error marshalling server address and credentials: %s")
	err = os.Mkdir(dataDir, 0700)
	if !errors.Is(err, fs.ErrExist) {
		check(err, "Error creating data directory at '%s': %s", dataDir)
	}
	err = os.WriteFile(dataPath, jsonData, 0600)
	check(err, "Error writing to '%s': ", dataPath)

	fmt.Println("\nAwesome! To get started, run 'notes add' or 'notes list'")
}

func decrypt(data string, password string) string {
	dataBytes, err := base64.StdEncoding.DecodeString(data)
	check(err, "Error decoding base64 data: %s")

	if len(dataBytes) < 32 {
		fmt.Printf("Not enough data (got %d bytes, expected at least 32)\n", len(dataBytes))
		return ""
	}

	iv := dataBytes[0:16]
	salt := dataBytes[16:32]
	ciphertext := dataBytes[32:]

	if len(ciphertext)%aes.BlockSize != 0 {
		fmt.Printf("Ciphertext length %d is not a multiple of block size %d\n", len(ciphertext), aes.BlockSize)
		return ""
	}

	key, err := pbkdf2.Key(sha256.New, password, salt, 65536, 32)
	check(err, "Error deriving pbkdf2-sha256 key from password: %s")
	block, err := aes.NewCipher(key)
	mode := cipher.NewCBCDecrypter(block, iv)

	plaintext := make([]byte, len(ciphertext))
	mode.CryptBlocks(plaintext, ciphertext)
	return string(plaintext)
}