feat: check steam ids when uploading demo (#148)

2 files changed, 128 insertions, 10 deletions

diff --git a/backend/handlers/record.go b/backend/handlers/record.go
index 79e9d3b..c620430 100644
--- a/backend/handlers/record.go
+++ b/backend/handlers/record.go
@@ -3,12 +3,14 @@ package handlers
 import (
         "context"
         "encoding/base64"
+        "fmt"
         "io"
         "log"
         "mime/multipart"
         "net/http"
         "os"
         "strconv"
+        "strings"
 
         "github.com/gin-gonic/gin"
         "github.com/google/uuid"
@@ -90,6 +92,7 @@ func CreateRecordWithDemo(c *gin.Context) {
         }
         var hostDemoUUID, hostDemoFileID, partnerDemoUUID, partnerDemoFileID string
         var hostDemoScoreCount, hostDemoScoreTime int
+        var hostSteamID, partnerSteamID string
         client := serviceAccount()
         srv, err := drive.New(client)
         if err != nil {
@@ -127,7 +130,7 @@ func CreateRecordWithDemo(c *gin.Context) {
                         c.JSON(http.StatusOK, models.ErrorResponse(err.Error()))
                         return
                 }
-                hostDemoScoreCount, hostDemoScoreTime, err = parser.ProcessDemo("backend/parser/" + uuid + ".dem")
+                hostDemoScoreCount, hostDemoScoreTime, hostSteamID, partnerSteamID, err = parser.ProcessDemo("backend/parser/" + uuid + ".dem")
                 if err != nil {
                         deleteFile(srv, file.Id)
                         CreateLog(user.(models.User).SteamID, LogTypeRecord, LogDescriptionCreateRecordProcessDemoFail, err.Error())
@@ -140,6 +143,25 @@ func CreateRecordWithDemo(c *gin.Context) {
                         c.JSON(http.StatusOK, models.ErrorResponse("Processing demo went wrong. Please contact a web admin and provide the demo in question."))
                         return
                 }
+                if !isCoop {
+                        hostSplit := strings.Split(hostSteamID, ":")
+                        if hostSplit[len(hostSplit)-1] != user.(models.User).SteamID {
+                                c.JSON(http.StatusOK, models.ErrorResponse(fmt.Sprintf("Host SteamID from demo and request does not match! Check your submission and try again.\nDemo Host SteamID: %s\nRequest Host SteamID: %s", hostSplit[len(hostSplit)-1], user.(models.User).SteamID)))
+                                return
+                        }
+                } else {
+                        partnerSplit := strings.Split(partnerSteamID, ":")
+                        if partnerSplit[len(partnerSplit)-1] != record.PartnerID {
+                                c.JSON(http.StatusOK, models.ErrorResponse(fmt.Sprintf("Partner SteamID from demo and request does not match! Check your submission and try again.\nDemo Partner SteamID: %s\nRequest Partner SteamID: %s", partnerSplit[len(partnerSplit)-1], record.PartnerID)))
+                                return
+                        }
+                        var verifyCoopSteamID string
+                        database.DB.QueryRow("SELECT steam_id FROM users WHERE steam_id = $1", record.PartnerID).Scan(&verifyCoopSteamID)
+                        if verifyCoopSteamID != record.PartnerID {
+                                c.JSON(http.StatusOK, models.ErrorResponse("Given partner SteamID does not match an account on LPHUB."))
+                                return
+                        }
+                }
                 if i == 0 {
                         hostDemoFileID = file.Id
                         hostDemoUUID = uuid
@@ -384,3 +406,23 @@ func createFile(service *drive.Service, name string, mimeType string, content io
 func deleteFile(service *drive.Service, fileId string) {
         service.Files.Delete(fileId)
 }
+
+// Convert from SteamID64 to Legacy SteamID bits
+func convertSteamID(steamID64 int64) int64 {
+        return (steamID64 >> 1) & 0x7FFFFFF
+}
+
+// Convert from Legacy SteamID bits to SteamID64
+func convertSteamID64(steamID string) int64 {
+        const baseSteam64ID = 76561197960265728 // Origin of this value remains unclear
+        parts := strings.Split(steamID, ":")
+        userId, err := strconv.Atoi(parts[2])
+        if err != nil {
+                return 0
+        }
+        steam64ID := baseSteam64ID + int64(userId*2) // Reason for multiplication by 2 is unknown
+        if parts[1] == "1" {
+                steam64ID++
+        }
+        return steam64ID
+}
diff --git a/backend/parser/parser.go b/backend/parser/parser.go
index db84256..1a80d4a 100644
--- a/backend/parser/parser.go
+++ b/backend/parser/parser.go
@@ -9,10 +9,10 @@ import (
 )
 
 // Don't try to understand it, feel it.
-func ProcessDemo(filePath string) (portalCount int, tickCount int, err error) {
+func ProcessDemo(filePath string) (portalCount int, tickCount int, hostSteamID string, partnerSteamID string, err error) {
         file, err := os.Open(filePath)
         if err != nil {
-                return 0, 0, err
+                return 0, 0, "", "", err
         }
         reader := bitreader.NewReader(file, true)
         demoFileStamp := reader.TryReadString()
@@ -20,13 +20,13 @@ func ProcessDemo(filePath string) (portalCount int, tickCount int, err error) {
         networkProtocol := reader.TryReadSInt32()
         reader.SkipBytes(1056)
         if demoFileStamp != "HL2DEMO" {
-                return 0, 0, errors.New("invalid demo file stamp")
+                return 0, 0, "", "", errors.New("invalid demo file stamp")
         }
         if demoProtocol != 4 {
-                return 0, 0, errors.New("this parser only supports demos from new engine")
+                return 0, 0, "", "", errors.New("this parser only supports demos from new engine")
         }
         if networkProtocol != 2001 {
-                return 0, 0, errors.New("this parser only supports demos from portal 2")
+                return 0, 0, "", "", errors.New("this parser only supports demos from portal 2")
         }
         for {
                 packetType := reader.TryReadUInt8()
@@ -217,21 +217,97 @@ func ProcessDemo(filePath string) (portalCount int, tickCount int, err error) {
                                 case 33:
                                         packetReader.SkipBits(packetReader.TryReadBits(32))
                                 default:
-                                        panic("unknown msg type")
+                                        return 0, 0, "", "", errors.New("unknown msg type")
                                 }
                         }
                 case 3, 7:
-                case 4, 6, 9:
+                case 4, 6:
                         reader.SkipBytes(uint64(reader.TryReadSInt32()))
                 case 5, 8:
                         reader.SkipBits(32)
                         reader.SkipBytes(uint64(reader.TryReadSInt32()))
+                case 9:
+                        type StringTableClass struct {
+                                Name string
+                                Data string
+                        }
+                        type StringTableEntry struct {
+                                Name      string
+                                EntryData any
+                        }
+                        type StringTable struct {
+                                Name         string
+                                TableEntries []StringTableEntry
+                                Classes      []StringTableClass
+                        }
+                        size := reader.TryReadSInt32()
+                        stringTableReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(size)), true)
+                        tableCount := stringTableReader.TryReadBits(8)
+                        guidCount := 0
+                        for i := 0; i < int(tableCount); i++ {
+                                tableName := stringTableReader.TryReadString()
+                                entryCount := stringTableReader.TryReadBits(16)
+                                for i := 0; i < int(entryCount); i++ {
+                                        stringTableReader.TryReadString()
+                                        if stringTableReader.TryReadBool() {
+                                                byteLen, err := stringTableReader.ReadBits(16)
+                                                if err != nil {
+                                                        return 0, 0, "", "", errors.New("error on reading entry length")
+                                                }
+                                                stringTableEntryReader := bitreader.NewReaderFromBytes(stringTableReader.TryReadBytesToSlice(byteLen), true)
+                                                if tableName == "userinfo" {
+                                                        const SignedGuidLen int32 = 32
+                                                        const MaxPlayerNameLength int32 = 32
+                                                        userInfo := struct {
+                                                                SteamID         uint64
+                                                                Name            string
+                                                                UserID          int32
+                                                                GUID            string
+                                                                FriendsID       uint32
+                                                                FriendsName     string
+                                                                FakePlayer      bool
+                                                                IsHltv          bool
+                                                                CustomFiles     []uint32
+                                                                FilesDownloaded uint8
+                                                        }{
+                                                                SteamID: stringTableEntryReader.TryReadUInt64(),
+                                                                Name:    stringTableEntryReader.TryReadStringLength(uint64(MaxPlayerNameLength)),
+                                                                UserID:  stringTableEntryReader.TryReadSInt32(),
+                                                                GUID:    stringTableEntryReader.TryReadStringLength(uint64(SignedGuidLen) + 1),
+                                                        }
+                                                        stringTableEntryReader.SkipBytes(3)
+                                                        userInfo.FriendsID = stringTableEntryReader.TryReadUInt32()
+                                                        userInfo.FriendsName = stringTableEntryReader.TryReadStringLength(uint64(MaxPlayerNameLength))
+                                                        userInfo.FakePlayer = stringTableEntryReader.TryReadUInt8() != 0
+                                                        userInfo.IsHltv = stringTableEntryReader.TryReadUInt8() != 0
+                                                        stringTableEntryReader.SkipBytes(2)
+                                                        userInfo.CustomFiles = []uint32{stringTableEntryReader.TryReadUInt32(), stringTableEntryReader.TryReadUInt32(), stringTableEntryReader.TryReadUInt32(), stringTableEntryReader.TryReadUInt32()}
+                                                        userInfo.FilesDownloaded = stringTableEntryReader.TryReadUInt8()
+                                                        stringTableEntryReader.SkipBytes(3)
+                                                        if guidCount == 0 {
+                                                                hostSteamID = userInfo.GUID
+                                                        } else if guidCount == 1 {
+                                                                partnerSteamID = userInfo.GUID
+                                                        }
+                                                }
+                                        }
+                                }
+                                if stringTableReader.TryReadBool() {
+                                        classCount := stringTableReader.TryReadBits(16)
+                                        for i := 0; i < int(classCount); i++ {
+                                                stringTableReader.TryReadString()
+                                                if stringTableReader.TryReadBool() {
+                                                        stringTableReader.TryReadStringLength(uint64(stringTableReader.TryReadUInt16()))
+                                                }
+                                        }
+                                }
+                        }
                 default:
-                        return 0, 0, errors.New("invalid packet type")
+                        return 0, 0, "", "", errors.New("invalid packet type")
                 }
                 if packetType == 7 {
                         break
                 }
         }
-        return portalCount, tickCount, nil
+        return portalCount, tickCount, hostSteamID, partnerSteamID, nil
 }