133 lines
2.7 KiB
Go
133 lines
2.7 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto"
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/url"
|
|
"os"
|
|
|
|
"crispbyte.dev/sig-auth/client"
|
|
"crispbyte.dev/sig-auth/keydirectory"
|
|
"crispbyte.dev/sig-auth/server"
|
|
"golang.org/x/crypto/ssh"
|
|
)
|
|
|
|
func main() {
|
|
useClient := flag.Bool("c", false, "Run client")
|
|
keyId := flag.String("id", "", "The key id to pass")
|
|
register := flag.Bool("r", false, "Register a key")
|
|
user := flag.String("user", "", "Username to register")
|
|
keyPath := flag.String("key", "", "Path to the private key (client mode) or public key (registration mode) to use")
|
|
baseUrlString := flag.String("base-url", "http://localhost:8080", "Base URL of the server")
|
|
simulateCaddy := flag.Bool("caddy", false, "Simulate caddy reverse proxy")
|
|
useTempDb := flag.Bool("temp-db", false, "Use a temporary in-memory database")
|
|
dbPath := flag.String("db", "", "Path to the sqlite database file")
|
|
|
|
flag.Parse()
|
|
|
|
baseUrl, err := url.Parse(*baseUrlString)
|
|
|
|
if err != nil {
|
|
flag.PrintDefaults()
|
|
return
|
|
}
|
|
|
|
if *useClient {
|
|
if *keyPath == "" || *keyId == "" {
|
|
flag.PrintDefaults()
|
|
return
|
|
}
|
|
|
|
runClient(baseUrl, *keyPath, *keyId, *simulateCaddy)
|
|
} else if *register {
|
|
if *keyPath == "" || *user == "" {
|
|
flag.PrintDefaults()
|
|
return
|
|
}
|
|
|
|
registerKey(baseUrl, *keyPath, *user)
|
|
} else {
|
|
if !*useTempDb && *dbPath == "" {
|
|
flag.PrintDefaults()
|
|
return
|
|
}
|
|
|
|
runServer(*simulateCaddy, *useTempDb, *dbPath)
|
|
}
|
|
}
|
|
|
|
func runClient(baseUrl *url.URL, keyFile string, keyId string, simulateCaddy bool) {
|
|
testData := map[string]string{"hello": "world"}
|
|
json_data, _ := json.Marshal(testData)
|
|
|
|
key, err := loadPrivateKey(keyFile)
|
|
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
resp, err := client.Post(baseUrl, key, keyId, json_data, simulateCaddy)
|
|
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
|
|
out, err := io.ReadAll(resp.Body)
|
|
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
fmt.Println(resp.StatusCode)
|
|
fmt.Println(resp.Header)
|
|
fmt.Println(string(out[:]))
|
|
}
|
|
|
|
func loadPrivateKey(keyFile string) (crypto.PrivateKey, error) {
|
|
keyBytes, err := os.ReadFile(keyFile)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ssh.ParseRawPrivateKey(keyBytes)
|
|
}
|
|
|
|
func registerKey(baseUrl *url.URL, keyFile string, userId string) {
|
|
keyBytes, err := os.ReadFile(keyFile)
|
|
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
keyText := string(keyBytes)
|
|
|
|
err = client.RegisterKey(baseUrl, keyText, userId)
|
|
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func runServer(simulateCaddy bool, useTempDb bool, dbPath string) {
|
|
var keyDir keydirectory.RegistrationDirectory
|
|
|
|
if useTempDb {
|
|
keyDir = keydirectory.CreateMemoryDirectory()
|
|
} else {
|
|
var err error
|
|
keyDir, err = keydirectory.InitSqlite(dbPath)
|
|
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
server.Start(simulateCaddy, keyDir)
|
|
}
|