PassPractice/main.go

package main

import (
	"bufio"
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"math"
	"os"
	"strings"
	"syscall"
	"time"

	"golang.org/x/crypto/argon2"
	"golang.org/x/crypto/ssh/terminal"
	"golang.org/x/term"
)

const (
	version  = "1.0.0"
	helpText = `Usage: PassPractice [options]
Options:
    -s, --store      Enter Store Mode to store a new password
    -v, --version    Display version information
    -h, --help       Display this help text
Run without options to enter Verify Mode.`
	filename = "password.argon2"
)

func main() {
	storeFlag := flag.Bool("store", false, "Enter Store Mode to store a new password")
	storeFlagShort := flag.Bool("s", false, "Enter Store Mode to store a new password (short)")
	versionFlag := flag.Bool("version", false, "Display version information")
	versionFlagShort := flag.Bool("v", false, "Display version information (short)")
	helpFlag := flag.Bool("help", false, "Display help text")
	helpFlagShort := flag.Bool("h", false, "Display help text (short)")

	flag.Parse()

	if *versionFlag || *versionFlagShort {
		fmt.Println("Version:", version)
		return
	}

	if *helpFlag || *helpFlagShort {
		fmt.Println(helpText)
		return
	}

	if *storeFlag || *storeFlagShort {
		storeMode()
	} else {
		verifyMode()
	}
}

func getPasswordFromUser(prompt string) string {
	fmt.Print(prompt)

	// Read the password securely without echoing
	password, err := terminal.ReadPassword(int(syscall.Stdin))
	if err != nil {
		log.Fatal(err)
	}

	// Print a new line after user input
	fmt.Println()

	// Convert byte slice to string
	passwordString := strings.TrimSpace(string(password))

	return passwordString
}

func storeMode() {
	password := getPasswordFromUser("Enter password to store: ")

	hash := argon2.IDKey([]byte(password), []byte("somesalt"), 1, 64*1024, 4, 32)
	err := ioutil.WriteFile(filename, hash, 0644)
	if err != nil {
		fmt.Println("Error saving password:", err)
		return
	}
	fmt.Println("Password stored successfully.")
}

func verifyMode() {
	hash, err := ioutil.ReadFile(filename)
	if err != nil {
		fmt.Println("Error reading stored password:", err)
		return
	}

	streak := 0

	for {

		password, elapsedTime := getPasswordFromUserAndTimeIt("Enter password to verify (or press enter to exit): ")

		// Check if the password is empty and exit the program
		if len(strings.TrimSpace(password)) == 0 {
			fmt.Println("Exiting PassPractice.")
			break
		}

		charsPerSecond := float64(len(password)) / elapsedTime.Seconds()

		// Round the time and charsPerSecond to two decimal places
		roundedTime := math.Round(elapsedTime.Seconds()*100) / 100
		roundedCharsPerSecond := math.Round(charsPerSecond*100) / 100

		hashedInput := argon2.IDKey([]byte(password), []byte("somesalt"), 1, 64*1024, 4, 32)

		if string(hashedInput) == string(hash) {
			streak++
			fmt.Printf("Correct! Streak: %d | Time taken: %.2fs | Chars/sec: %.2f\n", streak, roundedTime, roundedCharsPerSecond)
		} else {
			streak = 0
			fmt.Printf("Incorrect. Streak reset to 0. | Time taken: %.2fs | Chars/sec: %.2f\n", roundedTime, roundedCharsPerSecond)
		}
	}
}

// getPasswordFromUser reads password input character by character
// Returns the entered password and the time taken to type it
func getPasswordFromUserAndTimeIt(prompt string) (string, time.Duration) {
	fmt.Print(prompt)

	state, err := term.MakeRaw(int(os.Stdin.Fd()))
	if err != nil {
		log.Fatal(err)
	}
	defer term.Restore(int(os.Stdin.Fd()), state)

	reader := bufio.NewReader(os.Stdin)

	var startTime time.Time
	var password []rune
	firstChar := true

	for {
		char, _, err := reader.ReadRune()
		if err != nil {
			log.Fatal(err)
		}

		// Start the timer on the first character entered
		if firstChar {
			startTime = time.Now()
			firstChar = false
		}

		// Enter key pressed
		if char == '\r' || char == '\n' {
			break
		}

		// Check for Ctrl+C or Ctrl+D
		if char == 3 || char == 4 { // Ctrl+C or Ctrl+D
			fmt.Println("\r")
			return "", 0.0
		}

		// Backspace or delete key pressed
		if char == '\b' || char == 0x7F {
			if len(password) > 0 {
				password = password[:len(password)-1]
			}
			continue
		}

		password = append(password, char)
	}
	fmt.Println("\r")

	return string(password), time.Since(startTime)
}