hostware-vnc-proxy/main.go

167 lines
4.8 KiB
Go

package main
import (
"crypto/tls"
"encoding/json"
"fmt"
"net/http"
"net/url"
"os"
"time"
"github.com/gin-gonic/gin"
"github.com/gorilla/websocket"
_ "github.com/joho/godotenv/autoload"
ginlogrus "github.com/toorop/gin-logrus"
"jonasled.dev/jonasled/hostware-vnc-proxy/development"
"jonasled.dev/jonasled/hostware-vnc-proxy/encryption"
"jonasled.dev/jonasled/hostware-vnc-proxy/log"
"jonasled.dev/jonasled/hostware-vnc-proxy/metrics"
"jonasled.dev/jonasled/hostware-vnc-proxy/types"
)
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
CheckOrigin: func(r *http.Request) bool { return true },
}
func bridgeConnections(src, dest *websocket.Conn, done chan struct{}) {
defer close(done)
for {
messageType, message, err := src.ReadMessage()
if err != nil {
log.Log.Error("Error reading from WebSocket")
return
}
err = dest.WriteMessage(messageType, message)
if err != nil {
log.Log.Error("Error writing to WebSocket")
return
}
}
}
func removeElement(slice []string, name string) []string {
for i, v := range slice {
if v == name {
return append(slice[:i], slice[i+1:]...)
}
}
return slice
}
func main() {
currentActiveConnectionList := make(map[string][]string)
startTime := time.Now()
log.Init()
r := gin.New()
r.Use(ginlogrus.Logger(log.Log), gin.Recovery())
r.GET("/ready", func(ctx *gin.Context) {
ctx.String(http.StatusOK, "OK")
})
r.GET("/status", func(ctx *gin.Context) {
signatureKey := ctx.Query("key")
if os.Getenv("JWT_SIGN_KEY") != signatureKey {
ctx.String(http.StatusForbidden, "Forbidden")
return
}
ctx.JSON(http.StatusOK, map[string]any{
"uptime": time.Since(startTime).Seconds(),
"activeSockets": currentActiveConnectionList,
})
})
r.GET("/", func(ctx *gin.Context) {
payload := ctx.Query("payload")
if payload == "" {
log.Log.Info("Received Request with missing Payload parameter")
ctx.String(http.StatusBadRequest, "Missing payload parameter")
return
}
jwtClain, err := encryption.DecodePayload(payload)
if err != nil {
log.Log.Info("Received Request with invalid Payload parameter")
ctx.String(http.StatusBadRequest, "Invalid Payload provided")
fmt.Println(err.Error())
return
}
configuration := encryption.DecryptMessage(jwtClain.EncryptedPayload)
var vncConfig types.VncConfig
err = json.Unmarshal(configuration, &vncConfig)
if err != nil {
ctx.String(http.StatusBadRequest, "Failed decoding VNC config")
log.Log.Error("Failed decoding VNC config", err.Error())
return
}
log.Log.Info("Starting VNC Proxy for ", vncConfig.VmID, " on ", vncConfig.NodeName)
dialer := websocket.Dialer{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: os.Getenv("PVE_IGNORE_SSL") == "true", // Ignore SSL certificate verification
},
}
vncConfig.GenerateApiTicket()
header := http.Header{}
header.Add("Cookie", "PVEAuthCookie="+url.QueryEscape(vncConfig.ApiTicket)+";")
header.Add("CSRFPreventionToken", vncConfig.CSRFPreventionToken)
pveConn, resp, err := dialer.Dial(vncConfig.GetVncUrl(), header)
if err != nil {
if resp != nil {
log.Log.Error("Error connecting to PVE WebSocket:", err, " Status Message: ", resp.Status)
} else {
log.Log.Error("Error connecting to PVE WebSocket:", err)
}
return
}
defer pveConn.Close()
conn, err := upgrader.Upgrade(ctx.Writer, ctx.Request, nil)
if err != nil {
log.Log.Info("Failed upgrading WebSocket:", err)
pveConn.Close()
return
}
defer conn.Close()
metrics.VncSessionsHandled.Inc()
metrics.CurrentActiveSessions.Inc()
metrics.Sessions.WithLabelValues(vncConfig.NodeName, types.ConvertToString(vncConfig.VmID)).Set(1)
// Channels to signal when forwarding is done
done1 := make(chan struct{})
done2 := make(chan struct{})
// Start bridging WebSocket 1 -> WebSocket 2
go bridgeConnections(pveConn, conn, done1)
// Start bridging WebSocket 2 -> WebSocket 1
go bridgeConnections(conn, pveConn, done2)
currentActiveConnectionList[vncConfig.NodeName] = append(currentActiveConnectionList[vncConfig.NodeName], types.ConvertToString(vncConfig.VmID))
select {
case <-done1:
log.Log.Info("Bridge from PVE to Client closed for ", vncConfig.VmID)
case <-done2:
log.Log.Info("Bridge from Client to PVE closed for ", vncConfig.VmID)
}
currentActiveConnectionList[vncConfig.NodeName] = removeElement(currentActiveConnectionList[vncConfig.NodeName], types.ConvertToString(vncConfig.VmID))
metrics.CurrentActiveSessions.Dec()
metrics.Sessions.WithLabelValues(vncConfig.NodeName, types.ConvertToString(vncConfig.VmID)).Set(0)
})
metrics.InitPrometheus(r)
development.RegisterDevSetup(r)
log.Log.Info("Start listening on port 8080")
if os.Getenv("TLS_CERT") == "" {
r.Run(":8080")
} else {
r.RunTLS(":8080", os.Getenv("TLS_CERT"), os.Getenv("TLS_KEY"))
}
}