🔐 Fair-Play-System: Multiplayer-Hash-Ketten-Generierung

Übersicht

Um Transparenz und nachweisbare Fairness sicherzustellen, haben wir für jedes Multiplayer-Spiel eine Kette aus 10 Millionen SHA256-Hashes generiert, beginnend mit einem Server-Geheimnis, dessen Ausgabe wiederholt 10 Millionen Mal in sich selbst durch SHA256 zurückgeführt wurde

Der SHA256-Wert des finalen Hash für Platform lautet: eeb4d340bfaed702601b9a08faba2f8088c4810c3e3a883293accaf25053b883

Der SHA256-Wert des finalen Hash für Crash lautet: c46f0705f6ba4df891ce44accda8f89f5a6fa8b987eb7c7b445280cf6cabfbc6

Der SHA256-Wert des finalen Hash für Battle lautet: 63cb1eb64ec4eb4de02f6bad85e42365d08f37497a1b7e907bd0b9183f27e1b3

Durch die Veröffentlichung hier verhindern wir jede Möglichkeit, eine alternative SHA256-Kette auszuwählen. Der Spielserver durchläuft diese Hash-Kette nun in umgekehrter Reihenfolge und verwendet diese Werte, um die Spielergebnisse nachweisbar fair zu berechnen.

So funktioniert es

1. Geheimer Ausgangs-Hash: Jeder Multiplayer-Spieltyp verfügt über seinen eigenen privaten Ausgangs-Hash (nur dem Server bekannt), der die Wurzel einer einzigartigen Hash-Kette bildet.

2. Hash-Ketten-Generierung: Ausgehend vom geheimen Ausgangs-Hash generieren wir durch wiederholte Anwendung von SHA256 eine Kette aus 10.000.000 Hashes.

  func HashSeed(seed string) string {
      hash := sha256.Sum256([]byte(seed))
      return hex.EncodeToString(hash[:])
  }

  func CalculateHashChain(firstHash string) []string {
    hashes := make([]string, 10_000_000)
    for i := int64(0); i <= 10_000_000; i++ {
      firstHash = HashSeed(firstHash)
      hashes[i] = firstHash
    }
    return hashes
  }

3. Umgekehrter Verbrauch: Wir veröffentlichen den letzten Hash der Kette. Jede Spielrunde verbraucht die Hashes in umgekehrter Reihenfolge: Runde 1 verwendet hash[10_000_000] Runde 2 verwendet hash[9_999_999] und so weiter…

4. Dieses Design macht es unmöglich, zukünftige Hashes zu fälschen, während es jedem ermöglicht, alle vorherigen Hashes zu überprüfen.

🔒 Vorteile für Sicherheit & Fairness

Unvorhersehbarkeit: Zukünftige Spielergebnisse können nicht bekannt sein oder beeinflusst werden, nicht einmal vom Server.

Überprüfbarkeit: Spieler können die Integrität jeder vorherigen Runde ausschließlich anhand des öffentlich veröffentlichten finalen Hash überprüfen.

Spielisolation: Jeder Spieltyp verfügt über seine eigene Kette, wodurch spielübergreifende Manipulation verhindert wird.

Fair Play für Einzelspieler-Spiele

Um nachweisbare Fairness bei Einzelspieler-Spielen sicherzustellen, verwendet unsere Plattform ein System, das auf drei Hauptkomponenten zur Generierung des Ergebnis-Seeds basiert:

1. Client-Seed: Dies ist ein vom Nutzer kontrollierter Seed. Er wird automatisch bei der Registrierung eines Nutzers generiert, kann aber vom Nutzer jederzeit geändert werden. Eine Änderung des Client-Seeds löst die Generierung eines neuen Server-Seeds aus.

2. Server-Seed: Dieser wird vom Server anhand interner Parameter generiert, die dem Nutzer nicht offengelegt werden. Er ist eindeutig an den aktuellen Client-Seed gebunden. Für jeden Client-Seed gibt es einen entsprechenden Server-Seed. Wenn der Nutzer den Client-Seed ändert, wird der vorherige Server-Seed zu Verifizierungszwecken offengelegt.

3. Nonce: Eine eindeutige Zahl, die auf dem Zeitstempel der Wette (in Millisekunden) basiert. Sie stellt sicher, dass selbst wiederholte Aktionen unterschiedliche Ergebnisse liefern.

Generierung des Spiel-Seeds

Diese drei Werte werden kombiniert und mittels HMAC-SHA256 gehasht, um den finalen Spiel-Seed zu generieren, der dann zur Bestimmung des Spielergebnisses verwendet wird.

  func GenerateUserGameSeed(userSeed string, userServerSeed string, nonce int64) (string, error) {
    data := fmt.Sprintf("%s:%s:%d", userServerSeed, userSeed, nonce)
    mac := hmac.New(sha256.New, []byte(data))
    gameSeed := hex.EncodeToString(mac.Sum(nil))
    return gameSeed, nil
  }

Verifizierung

Der Server stellt die gehashte Version des aktuellen Server-Seeds bereit, bevor eine Wette platziert wird.

Nachdem der Nutzer seinen Client-Seed geändert hat, wird der zuvor verwendete Server-Seed offengelegt.

Dies ermöglicht es Nutzern zu überprüfen, dass alle mit dem vorherigen Server-Seed generierten Ergebnisse konsistent und fair waren.

🎲 Dice-Spiel – Ergebnisberechnung

Beim Dice-Spiel wählt ein Nutzer zwischen 1 und 5 Zahlen (von 6 möglichen Seiten) aus. Ein einzelner Würfelwurf wird mithilfe des generierten Spiel-Seeds simuliert. Stimmt die gewürfelte Zahl mit einer der Auswahlen des Nutzers überein, gewinnt der Nutzer.

  func rollDice(seed string, selectedNumbers []int64) (int64, bool, error) {
    if len(selectedNumbers) < 1 || len(selectedNumbers) > 5 {
      return 0, false, fmt.Errorf("incorrect number of selected numbers: %d", len(selectedNumbers))
    }

    bigSeed, ok := new(big.Int).SetString(seed, 16)
    if !ok {
      return 0, false, fmt.Errorf("failed to convert seed to big.Int")
    }

    // Simulate dice roll: number from 1 to 6
    dice := new(big.Int).Mod(bigSeed, big.NewInt(6))
    diceFace := dice.Int64() + 1

    for _, num := range selectedNumbers {
      if num == diceFace {
        return diceFace, true, nil
      }
    }

    return diceFace, false, nil
  }

💣 Mines-Spiel – Logik der Minenplatzierung

Beim Mines-Spiel besteht das Ziel darin, so viele Felder wie möglich aufzudecken, ohne auf eine Mine zu treffen. Die Platzierung der Minen wird deterministisch anhand eines kryptografisch sicheren Spiel-Seeds abgeleitet. Dies gewährleistet Fairness und Transparenz und ermöglicht es dem Nutzer zu überprüfen, dass das Spielfeld nicht manipuliert wurde.

Eingaben:

seed: eine 64-stellige Hex-Zeichenfolge, abgeleitet aus der Kombination von ClientSeed, ServerSeed und Nonce mittels HMAC-SHA256.

numberOfMines: die Anzahl der auf dem Feld zu platzierenden Minen.

maxCells: Gesamtzahl der Felder auf dem Spielfeld (z. B. 25 für ein 5x5-Raster).

Go-Code

func generateMines(seedHex string, numberOfMines int) ([]int64, error) {
	if numberOfMines > 25 {
		return nil, fmt.Errorf("invalid number of mines: %d", numberOfMines)
	}

	var mines []int64
	used := make(map[int]bool)
	i := 0

	for len(mines) < numberOfMines {
		mac := hmac.New(sha256.New, []byte(seedHex))
		mac.Write([]byte(fmt.Sprintf("mine-%d", i)))
		sum := mac.Sum(nil)

		val := binary.BigEndian.Uint32(sum)
		pos := int(val%25) + 1

		if !used[pos] {
			used[pos] = true
			mines = append(mines, int64(pos))
		}
		i++
	}

	return mines, nil
}

Beispiel

Bei numberOfMines = 3 und maxCells = 25 gibt die Funktion deterministisch 3 eindeutige Feldindizes (von 1 bis 25) zurück, an denen Minen platziert werden.

🕹 Platforms — Spiellogik

Beim Platforms-Spiel wird das Ergebnis jeder Runde durch einen öffentlichen, überprüfbaren Hash bestimmt, der Teil einer zuvor veröffentlichten Hash-Kette ist.

📌 Logik des Plattformabwurfs

Jede Runde verwendet einen Hash aus der Kette, um die „letzte Plattform" zu bestimmen — die Plattform, die am Ende des Spiels verschwindet.

    func generateLastPlatform(hash string) (int64, error) {
      h, err := hex.DecodeString(hash)
      if err != nil {
        return 0, err
      }

      number := binary.BigEndian.Uint64(h[:8])

      rng := rand.New(rand.NewSource(int64(number)))
      randomNumber := rng.Intn(25) + 1 // Platforms are numbered 1 through 25

      return int64(randomNumber), nil
    }

🎯 Plattformabwurf in Echtzeit

Während des Spiels stehen die Spieler auf unterschiedlichen Plattformen. Die abfallende Plattform wird zufällig aus den verfügbaren Plattformen ausgewählt, wobei sichergestellt wird, dass sie nie mit der zuvor abgefallenen identisch ist.

🚀 Rocket — Spiellogik

Bei Rocket wird das Ergebnis jeder Runde (Crash-Multiplikator) mithilfe eines öffentlichen Hash aus der vorgenerierten Hash-Kette (einzigartig pro Spiel) bestimmt. Das Ergebnis wird mithilfe einer deterministischen Funktion berechnet, die den Hash in einen Multiplikator umwandelt.

  func generateMultiplier(hash string) (float64, error) {
    const N = 40

    bigH, ok := new(big.Int).SetString(hash, 16)
    if !ok {
      return 0, fmt.Errorf("failed to convert seed to big.Int")
    }

    mod := new(big.Int).Mod(bigH, big.NewInt(N))
    if mod.Cmp(big.NewInt(0)) == 0 {
      return 1, nil
    }

    if len(hash) < 13 {
      return 0, fmt.Errorf("hash too short")
    }
    h13Str := hash[:13]
    bigH13, ok := new(big.Int).SetString(h13Str, 16)
    if !ok {
      return 0, fmt.Errorf("failed to convert first 13 hex digits to big.Int")
    }

    // Compute 100 * (2^52 - h) / (2^52 - h)
    e := new(big.Int).Lsh(big.NewInt(1), 52) // 2^52
    hundred := big.NewInt(100)
    hundredE := new(big.Int).Mul(hundred, e)
    numerator := new(big.Int).Sub(hundredE, bigH13)
    denom := new(big.Int).Sub(e, bigH13)

    numFloat := new(big.Float).SetInt(numerator)
    denomFloat := new(big.Float).SetInt(denom)
    ratio, _ := new(big.Float).Quo(numFloat, denomFloat).Float64()

    floored := math.Floor(ratio)
    result := floored / 100.0

    return result, nil
  }

Jeder Spieler erhält den Hash vor der Runde und kann unabhängig überprüfen, dass das Ergebnis der veröffentlichten Formel entspricht, was volle Transparenz und nachweisbare Fairness gewährleistet.

🎲 Battle — Fairness des gewichteten Roulettes

Bei Battle wird ein Spieler basierend auf dem proportionalen Anteil seines Einsatzes am Gesamtpool als Gewinner ausgewählt. Das bedeutet, größere Einsätze führen zu höheren Gewinnchancen.

Wir verwenden einen deterministischen und nachweisbar fairen Auswahlmechanismus:

1. Ein öffentlicher Spiel-Hash wird verwendet, um eine pseudozufällige Zahl im Bereich [0.0, 1.0) zu generieren.

2. Jedem Spieler wird ein Segment des Bereichs proportional zu seinem Einsatz zugewiesen (z. B. deckt ein 20 %-Einsatz 20 % des Bereichs ab).

3. Die Zufallszahl bestimmt das Gewinnersegment und damit den Gewinner.

  func pickWinner(hash string, chances []float64) (int, error) {
    if len(chances) == 0 {
      return -1, fmt.Errorf("zero participants")
    }

    total := 0.0
    for _, chance := range chances {
      if chance < 0 {
        return -1, fmt.Errorf("chance cannot be negative")
      }
      total += chance
    }

    if total < 99.99 || total > 100.01 {
      return -1, fmt.Errorf("sum of chances must be 100%%, got: %.2f%%", total)
    }

    randomValue, err := deterministicFloatFromHash(hash)
    if err != nil {
      return -1, fmt.Errorf("random generation failed: %w", err)
    }

    cumulative := 0.0
    for i, chance := range chances {
      cumulative += chance / 100.0
      if randomValue < cumulative {
        return i, nil
      }
    }

    return -1, fmt.Errorf("failed to pick winner")
  }

  func deterministicFloatFromHash(hash string) (float64, error) {
    bytes, err := hex.DecodeString(hash)
    if err != nil {
      return 0, err
    }
    if len(bytes) < 8 {
      return 0, fmt.Errorf("hash too short")
    }
    num := binary.BigEndian.Uint64(bytes[:8])
    return float64(num) / float64(math.MaxUint64), nil
  }