167 lines
4.8 KiB
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"))
|
|
}
|
|
}
|