HMM

go/go.mod

@@ -0,0 +1,5 @@
+module P2FA
+
+go 1.23.2
+
+require github.com/creachadair/otp v0.5.0

go/go.sum

@@ -0,0 +1,4 @@
+github.com/creachadair/mds v0.21.3 h1:RRgEAPIb52cU0q7UxGyN+13QlCVTZIL4slRr0cYYQfA=
+github.com/creachadair/mds v0.21.3/go.mod h1:1ltMWZd9yXhaHEoZwBialMaviWVUpRPvMwVP7saFAzM=
+github.com/creachadair/otp v0.5.0 h1:q3Th7CXm2zlmCdBjw5tEPFOj4oWJMnVL5HXlq0sNKS0=
+github.com/creachadair/otp v0.5.0/go.mod h1:0kceI87EnYFNYSTL121goJVAnk3eJhaed9H0nMuJUkA=

go/main.go

@@ -0,0 +1,151 @@
+package main
+
+import (
+	"crypto/hmac"
+	"crypto/sha1"
+	"crypto/sha256"
+	"crypto/sha512"
+	"github.com/creachadair/otp"
+	"hash"
+	"log"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var token string
+
+var configs map[string]otp.Config
+
+func getSha1() func() hash.Hash { return sha1.New }
+
+func loadConfigs() {
+	var homeDir string
+
+	osVar := runtime.GOOS
+	if osVar == "windows" {
+		homeDir = os.Getenv("USERPROFILE")
+	} else {
+		homeDir = os.Getenv("HOME")
+	}
+
+	configs = make(map[string]otp.Config)
+
+	files, err := os.ReadDir(homeDir + "/.totp")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, fileEntry := range files {
+		fileBytes, err := os.ReadFile(homeDir + "/.totp/" + fileEntry.Name())
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		fileStr := string(fileBytes)
+		lineSplt := strings.Split(fileStr, "\n")
+
+		var key string
+		var hashVar func() hash.Hash
+		var timeStep func() uint64
+		var counter uint64
+		var digits int
+		var format func(hash []byte, length int) string
+
+		for _, line := range lineSplt {
+			kv := strings.Split(line, ":")
+			if len(kv) < 2 {
+				continue
+			}
+			kv[1] = strings.TrimSpace(kv[1])
+
+			switch strings.ToLower(kv[0]) {
+			case "key":
+				key = kv[1]
+			case "hash":
+				{
+					switch kv[1] {
+					case "sha1":
+						hashVar = getSha1()
+					case "sha256":
+						hashVar = func() hash.Hash { return sha256.New() }
+					case "sha512":
+						hashVar = func() hash.Hash { return sha512.New() }
+					case "hmac":
+						{
+							keyBytes, err := otp.ParseKey(key)
+							if err != nil {
+								log.Fatal(err)
+							}
+							hashVar = func() hash.Hash { return hmac.New(getSha1(), keyBytes) } // Probably not proper implementation but who uses HMAC anyway
+						}
+					}
+				}
+			case "timestep":
+				{
+					ts, err := strconv.Atoi(kv[1])
+					if err != nil {
+						log.Fatal(err)
+					}
+					timeStep = otp.TimeWindow(ts)
+				}
+			case "counter":
+				{
+					cNum, err := strconv.ParseUint(kv[1], 10, 0)
+					if err != nil {
+						log.Fatal(err)
+					}
+					if cNum < 6 || cNum > 10 {
+						log.Fatal("Counter not in range 6-10")
+					}
+					counter = cNum
+				}
+			case "format":
+				{
+				} //TODO implement
+			}
+		}
+
+		config := otp.Config{
+			Key:      key,
+			Hash:     hashVar,
+			TimeStep: timeStep,
+			Counter:  counter,
+			Digits:   digits,
+			Format:   format,
+		}
+
+		configs[fileEntry.Name()] = config
+	}
+}
+
+func refreshTokenVar() {
+	token, _ = otp.DefaultTOTP("alksjdfhalksjdbf")
+}
+
+func getTimeRemaining(n int) uint64 {
+	return uint64(n) - (uint64(time.Now().Unix()) % uint64(n))
+}
+
+func main() {
+	//loadConfigs()
+
+	startUI()
+
+	//refreshTokenVar()
+	//
+	//getTimeRemaining(30)
+	//
+	//for i := 0; i < 5; i++ {
+	//	refreshTokenVar()
+	//	fmt.Printf("TOTP: %s\n", token)
+	//	for getTimeRemaining(30) > 1 {
+	//		time.Sleep(1 * time.Second)
+	//		fmt.Printf("\rTime Remaining: %ds", getTimeRemaining(30))
+	//	}
+	//	time.Sleep(1 * time.Second)
+	//	fmt.Print("\n")
+	//}
+}

go/ui.go

@@ -0,0 +1,36 @@
+package main
+
+/*
+#cgo CFLAGS: -I.
+#cgo LDFLAGS: -L. -llibp2fa -lSDL2 -lSDL2main
+
+#include "../c/libs/include/SDL2/SDL.h"
+#include "../c/p2fa.h"
+*/
+import "C"
+
+import (
+	"time"
+	"unsafe"
+)
+
+func startUI() {
+	if C.SDL_Init(C.SDL_INIT_VIDEO) != 0 {
+		panic("Failed to initialize SDL")
+	}
+	defer C.SDL_Quit()
+
+	window := C.createWindow()
+	if window == nil {
+		panic("Error creating window")
+	}
+
+	renderer := C.createRenderer((*C.SDL_Window)(unsafe.Pointer(window)))
+	if renderer == nil {
+		panic("Error creating renderer")
+	}
+	C.draw(renderer)
+
+	time.Sleep(10 * time.Second)
+	C.destroy(renderer, window)
+}