Gerätevertrauen

Die Device Trust API sagt Ihnen, wie sehr Sie dem Gerät jedes Spielers vertrauen können, der Ihrem Spiel beitritt. Wenn ein Spieler beitritt, überprüft Roblox, ob sein Gerät vertrauenswürdig ist, und gibt Ihnen das Ergebnis als Gerätevertrauensniveau. Diese Überprüfung ist eine optionale Schutzschicht über dem integrierten Roblox-Anti-Cheat, das Exploits erkennt, nachdem ein Spieler beigetreten ist.

Roblox ergreift keine Maßnahmen basierend auf dem Gerätevertrauensniveau. Sie entscheiden, was es für Ihr Spiel bedeutet. Zum Beispiel können Sie Spieler mit ähnlichem Vertrauen zusammenbringen, sensible Funktionen wie den Handel auf vertrauenswürdige Geräte beschränken oder Spieler ablehnen, deren Geräte die Überprüfung nicht bestehen.

Die Device Trust API besteht aus dem IntegrityService.EvaluatePlayerDeviceTrust-Callback und der Player.DeviceTrustLevel-Eigenschaft. Um zu erfahren, wie Sie es in Ihren Skripten verwenden, siehe Vertrauensniveau lesen.

Gerätevertrauen ergänzt die Taktiken in Sicherheits- und Betrugsbekämpfungstaktiken, anstatt sie zu ersetzen.

Gerätevertrauensniveaus

Das Gerätevertrauensniveau eines Spielers ist einer der folgenden Enum.PlayerDeviceTrustLevel-Werte:

Unterstützte Plattformen

Roblox überprüft das Gerätevertrauen auf den folgenden Plattformen:

Bis Roblox eine Plattform unterstützt, melden Spieler darauf Unknown.

Auf einer unterstützten Plattform hängt das Vertrauensniveau, das ein Gerät erreichen kann, auch von seiner Hardware ab. Zum Beispiel unterstützen nicht alle Android-Geräte die Überprüfungen, die Roblox verwendet, sodass einige Geräte Standard oder Full nicht erreichen können, selbst wenn sie nicht manipuliert wurden. Für eine Liste bekannter unterstützter Geräte siehe das Hilfe-Center.

Wie es funktioniert

Wenn ein Spieler Ihrem Spiel beitritt, verwendet Roblox Hardwaresignale von seinem Gerät, um Folgendes zu bestätigen:

• Das Gerät ist ein physisches Gerät und kein Emulator.
• Das Betriebssystem wurde nicht manipuliert, zum Beispiel durch Rooten des Geräts.
• Die Roblox-App wurde nicht modifiziert.

Aus diesen Überprüfungen berechnet Roblox ein Gerätevertrauensniveau für den Spieler. Um die Effektivität des Systems zu bewahren, veröffentlicht Roblox nicht die spezifischen Signale, die es bewertet.

Die Überprüfung läuft im Hintergrund, während der Spieler beitritt, sodass es das Laden nicht verzögert. Spieler können mit dem Spielen beginnen, bevor ihr Vertrauensniveau verfügbar ist, daher behandeln Sie einen Spieler als untrusted, bis es verfügbar ist. Für Details siehe Vertrauensniveau lesen.

Das Gerätevertrauensniveau beschreibt das Gerät, nicht den Spieler oder sein Konto. Es sagt Ihnen nicht, ob ein Spieler betrügt. Es sagt Ihnen, wie schwierig Betrug auf ihrem Gerät ist. Um stattdessen das Konto zu überprüfen, verwenden Sie Player:IsVerified().

Auswirkungen auf legitime Spieler

Keine Geräteüberprüfung ist perfekt. Einige Spieler, die nicht betrügen wollen, erreichen dennoch ein niedriges Vertrauensniveau. Diese Spieler fallen in zwei Gruppen.

Spieler, die ihr Gerät reparieren können

Einige Geräte sind in der Lage, die Überprüfungen zu bestehen, sind jedoch nicht entsprechend eingerichtet, wie ein Gerät mit einem veralteten Betriebssystem, ein gerootetes Gerät oder ein Gerät, das eine modifizierte Version der Roblox-App ausführt. Diese Spieler können ihr Vertrauensniveau normalerweise erhöhen, indem sie ihr Gerät aktualisieren, Roblox aus einem offiziellen App-Store neu installieren oder ihr Gerät in den ursprünglichen Zustand zurückversetzen. Sie können betroffenen Spielern die Fehlerbehebungsmaßnahmen im Hilfe-Center zeigen.

Spieler, die ihr Gerät nicht reparieren können

Andere Spieler verwenden ältere Geräte, die die Hardware, auf die sich diese Überprüfungen stützen, nicht unterstützen. Diese Spieler können ihr Vertrauensniveau auf diesem Gerät nicht erhöhen und können nur ein höheres Niveau erreichen, indem sie auf ein neueres, unterstütztes Gerät umsteigen. Für weitere Informationen siehe unterstützte Plattformen.

Was ein abgelehnter Spieler sieht

Wenn Ihr Spiel einen Spieler basierend auf seinem Vertrauensniveau ablehnt, wird der Spieler getrennt und sieht eine Nachricht. Sie können diese Nachricht selbst schreiben, um beispielsweise Spieler auf einen Modus hinzuweisen, den sie weiterhin spielen können. Wenn Sie dies nicht tun, zeigt Roblox eine Standardnachricht an, die erklärt, warum sie nicht beitreten konnten und wie sie ihr Gerät möglicherweise reparieren können.

Implementierung

Schätzen Sie die Auswirkungen

Bevor Sie auf das Gerätevertrauen reagieren, überprüfen Sie, wie viele Ihrer Spieler jedes Vertrauensniveau abdecken. Die Anti-Cheat-Seite im Creator Hub schätzt, wie sich Ihre täglich aktiven Benutzer, Spielzeit und Einnahmen auf unterstützten Plattformen nach Gerätevertrauensniveau aufteilen. Um es anzuzeigen, müssen Sie der Spielbesitzer sein oder die Analysen für Erlebnisse anzeigen Berechtigung haben.

1. Navigieren Sie zu Ihrer Creations Seite im Creator Hub und wählen Sie Ihr Spiel aus.
2. Wählen Sie im linken Menü Sicherheit und dann Anti-Cheat.

Wählen Sie eine Richtlinie

Ihre Richtlinie ist, wie Ihr Spiel auf jedes Gerätevertrauensniveau reagiert. Um eine auszuwählen:

1. Entscheiden Sie, was Unknown für Ihr Spiel bedeutet. Es liegt an Ihnen, ob Sie Spieler mit Unknown wie Spieler auf vertrauenswürdigen Geräten behandeln, wie Spieler mit None oder unterschiedlich in verschiedenen Teilen Ihres Spiels.
2. Überprüfen Sie die Auswirkungen. Überprüfen Sie die Anti-Cheat-Seite im Creator Hub, um zu sehen, wie sich Ihre Spieler nach Vertrauensniveau aufteilen. Für weitere Informationen siehe Schätzen Sie die Auswirkungen.
3. Wählen Sie, wie Sie auf jedes Niveau reagieren möchten. Die folgenden Antworten reichen von den wenigsten bis zu den störendsten, und Sie können sie kombinieren:

   • Leiten Sie Spieler nach Vertrauensniveau. Senden Sie Spieler zu Orten oder Servern, die ihrem Vertrauensniveau entsprechen, wie einen entspannten Ort für alle und einen Ranglistenort für vertrauenswürdige Geräte. Jeder Spieler kann weiterhin Ihr Spiel spielen. Für ein Beispiel siehe Spieler nach Vertrauensniveau leiten.
   • Einschränken sensibler Funktionen. Erfordern Sie ein höheres Vertrauensniveau für eine bestimmte Funktion, wie den Handel, und lassen Sie alle den Rest Ihres Spiels spielen. Für ein Beispiel siehe Funktionen nach Vertrauensniveau sperren.
   • Spieler ablehnen. Wenden Sie sich von Ihrem gesamten Spiel ab. Lehnen Sie nur Spieler mit None als letzten Ausweg ab. Für ein Beispiel siehe Spieler beim Beitritt ablehnen.

Empfohlene Richtlinien nach Genre

Die folgende Tabelle schlägt eine Ausgangspolitik für gängige Genres auf Roblox vor. Passen Sie sie an, wie Ihr Spiel funktioniert.

Vertrauensniveau lesen

Jede Verwendung der Device Trust API beginnt mit Player.DeviceTrustLevel, das das Vertrauensniveau eines Spielers enthält. Lesen Sie es auf dem Server, wenn Ihr Spiel eine Entscheidung treffen muss, z. B. wenn ein Spieler um Beitritt zu einem Ranglistenspiel oder zum Start eines Handels bittet.

Behalten Sie Folgendes im Hinterkopf, wenn Sie die Eigenschaft lesen:

• Jeder Spieler beginnt mit Pending, und die Eigenschaft ändert sich einmal, wenn das Vertrauensniveau verfügbar wird. Wenn Roblox die Überprüfung eines Geräts nicht abschließen kann, bleibt die Eigenschaft möglicherweise während der gesamten Sitzung auf Pending. Behandeln Sie Pending immer als nicht vertrauenswürdig genug für sensible Funktionen.
• Lesen Sie das Vertrauensniveau auf dem Server und lassen Sie den Server jedem Client mitteilen, welche Funktionen aktiviert oder deaktiviert werden sollen, z. B. indem Sie ein RemoteEvent an diesen Spieler auslösen. Vermeiden Sie es, die Eigenschaft auf dem Client zu lesen. Nur der eigene Client des Spielers kann sein Vertrauensniveau lesen, jeder andere Client sieht Pending, und Exploiter können ändern, was ihr Client damit macht.
• In Studio ist das Vertrauensniveau immer Pending. Für Details siehe Testen Sie Ihre Logik.

Warten auf das Vertrauensniveau

Einige Teile Ihres Spiels benötigen möglicherweise das Vertrauensniveau, bevor ein Spieler beginnt, z. B. ein Matchmaking, das Spieler basierend auf ihrem Vertrauensniveau in eine Lobby sendet. In diesem Fall können Sie einen Spieler in Players.PlayerAdded halten, bis der Callback ausgeführt wird, und dann mit ihrem Vertrauensniveau fortfahren.

Verwenden Sie dieses Muster nur, um Spieler zu akzeptieren und ihre Erfahrung anzupassen, z. B. indem Sie sie leiten oder Funktionen sperren. Um Spieler abzulehnen, geben Sie Reject aus dem IntegrityService.EvaluatePlayerDeviceTrust-Callback zurück und halten Sie diese Logik im Callback, wie in Spieler beim Beitritt ablehnen beschrieben.

Das folgende Skript speichert den Thread, in dem PlayerAdded ausgeführt wird, wartet mit coroutine.yield() und setzt ihn aus dem Callback mit task.defer() fort. Wenn der Spieler das Spiel verlässt oder das Vertrauensniveau nach MAX_WAIT_SECONDS nicht verfügbar ist, wird der Thread fortgesetzt, sodass kein Spieler ewig wartet:

local IntegrityService = game:GetService("IntegrityService")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

-- Wie lange ein Spieler gehalten werden soll, bevor Sie aufhören, auf sein Vertrauensniveau zu warten
local MAX_WAIT_SECONDS = 10

-- Der Thread, der auf das Vertrauensniveau jedes Spielers wartet
local waitingThreads: { [Player]: thread } = {}

-- Setzt den Thread fort, der auf den Spieler wartet, falls vorhanden
local function release(player: Player, trustLevel: Enum.PlayerDeviceTrustLevel?)
	local thread = waitingThreads[player]
	if thread then
		waitingThreads[player] = nil
		task.defer(thread, trustLevel)
	end
end

-- Wartet, bis das Vertrauensniveau des Spielers verfügbar ist. Gibt Pending zurück, wenn die
-- Wartezeit abläuft, und nil, wenn der Spieler zuerst das Spiel verlässt.
local function waitForTrustLevel(player: Player): Enum.PlayerDeviceTrustLevel?
	-- Roblox überprüft Geräte in Studio nicht, also halten Sie Spieler während der Playtests nicht auf
	if player.DeviceTrustLevel ~= Enum.PlayerDeviceTrustLevel.Pending or RunService:IsStudio() then
		return player.DeviceTrustLevel
	end

	waitingThreads[player] = coroutine.running()
	task.delay(MAX_WAIT_SECONDS, release, player, Enum.PlayerDeviceTrustLevel.Pending)
	return coroutine.yield()
end

IntegrityService.EvaluatePlayerDeviceTrust = function(player, measures)
	release(player, player.DeviceTrustLevel)
	return { Action = Enum.PlayerDeviceTrustDecision.Accept }
end

Players.PlayerRemoving:Connect(function(player)
	release(player, nil)
end)

Players.PlayerAdded:Connect(function(player)
	local trustLevel = waitForTrustLevel(player)
	if trustLevel == nil then
		return
	end

	-- Starten Sie hier die Sitzung des Spielers, indem Sie ihn beispielsweise in eine Lobby senden
	-- die seinem Vertrauensniveau entspricht. Behandeln Sie Pending als nicht vertrauenswürdig.
	print(player.Name, "trat mit Vertrauensniveau", trustLevel.Name, "bei")
end)

Spieler nach Vertrauensniveau leiten

Anstatt Spieler abzulehnen, können Sie sie an einen Ort senden, der ihrem Vertrauensniveau entspricht. Zum Beispiel kann ein wettbewerbsfähiges Spiel jeden in einem entspannten Startort akzeptieren und nur Spieler, deren Vertrauensniveau Ihren Anforderungen entspricht, an einen separaten Ranglistenort senden.

Überprüfen Sie im entspannten Ort das Vertrauensniveau, bevor Sie einen Spieler mit TeleportService:TeleportAsync() in den Ranglistenort teleportieren. Dieses Skript geht davon aus, dass Ihre Client-UI ein RemoteEvent mit dem Namen JoinRanked in ReplicatedStorage auslöst, wenn ein Spieler um Ranglistenspiel bittet:

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TeleportService = game:GetService("TeleportService")

local RANKED_PLACE_ID = 12345678901234 -- Ersetzen Sie dies durch die ID Ihres Ranglistenorts

local RANKED_TRUST_LEVELS = {
	[Enum.PlayerDeviceTrustLevel.Standard] = true,
	[Enum.PlayerDeviceTrustLevel.Full] = true,
}

local joinRankedEvent = ReplicatedStorage:WaitForChild("JoinRanked")

joinRankedEvent.OnServerEvent:Connect(function(player)
	if not RANKED_TRUST_LEVELS[player.DeviceTrustLevel] then
		-- Lassen Sie den Spieler wissen, dass Ranglistenspiele auf ihrem Gerät nicht verfügbar sind
		return
	end

	local success, result = pcall(function()
		return TeleportService:TeleportAsync(RANKED_PLACE_ID, { player })
	end)
	if not success then
		warn("Teleport zum Ranglistenort fehlgeschlagen:", result)
	end
end)

Spieler können auf andere Weise in den Ranglistenort gelangen, z. B. indem sie einem Freund beitreten. Um dieselbe Richtlinie dort durchzusetzen, weisen Sie den IntegrityService.EvaluatePlayerDeviceTrust-Callback im Ranglistenort zu, wie in Spieler beim Beitritt ablehnen beschrieben, und lehnen Sie Spieler ab, die dies nicht erfüllen:

local IntegrityService = game:GetService("IntegrityService")

local RANKED_TRUST_LEVELS = {
	[Enum.PlayerDeviceTrustLevel.Standard] = true,
	[Enum.PlayerDeviceTrustLevel.Full] = true,
}

IntegrityService.EvaluatePlayerDeviceTrust = function(player, measures)
	if RANKED_TRUST_LEVELS[player.DeviceTrustLevel] then
		return { Action = Enum.PlayerDeviceTrustDecision.Accept }
	end

	return {
		Action = Enum.PlayerDeviceTrustDecision.Reject,
		Message = "Ranglistenspiele sind auf diesem Gerät nicht verfügbar. Sie können weiterhin den Casual-Modus spielen.",
	}
end

Spieler können mit dem Spielen beginnen, bevor der Callback ausgeführt wird, also starten Sie kein Ranglistenspiel für einen Spieler, während sein Vertrauensniveau Pending ist. Um zu steuern, welche Orte Spieler direkt betreten können, siehe sichere Teleportation konfigurieren.

Diese Beispiele halten Spieler mit Pending, Unknown und None von Ranglistenspielen fern. Wenn Sie entscheiden, Spielern mit Unknown den Vorteil des Zweifels zu geben, fügen Sie Unknown beiden Tabellen hinzu.

Funktionen nach Vertrauensniveau sperren

Um allen das Spielen zu ermöglichen, aber sensible Funktionen wie den Handel einzuschränken, überprüfen Sie das Vertrauensniveau auf dem Server, wenn ein Spieler versucht, die Funktion zu nutzen. Das folgende Skript erlaubt einen Handel nur, wenn beide Spieler ein erlaubtes Vertrauensniveau haben. Das Auflisten der erlaubten Niveaus in einer Tabelle hält Ihre Richtlinie an einem Ort:

local TRADE_TRUST_LEVELS = {
	[Enum.PlayerDeviceTrustLevel.Unknown] = true,
	[Enum.PlayerDeviceTrustLevel.Standard] = true,
	[Enum.PlayerDeviceTrustLevel.Full] = true,
}

local function canTrade(player: Player): boolean
	return TRADE_TRUST_LEVELS[player.DeviceTrustLevel] == true
end

local function tradeItem(sender: Player, receiver: Player, itemId: string): boolean
	if not (canTrade(sender) and canTrade(receiver)) then
		return false
	end

	-- Validieren und übertragen Sie den Artikel hier auf dem Server
	return true
end

Dieses Beispiel blockiert den Handel für Spieler mit Pending und None und lässt Spieler mit Unknown handeln. Um auch den Handel für Spieler mit Unknown zu blockieren, entfernen Sie Unknown aus der Tabelle.

Um auch das Konto vor einer sensiblen Aktion zu überprüfen, kombinieren Sie das Vertrauensniveau mit Player:IsVerified().

Spieler beim Beitritt ablehnen

Wenn das Leiten von Spielern oder das Einschränken von Funktionen nicht ausreicht, können Sie Spieler aus Ihrem Spiel ablehnen. Weisen Sie einer Funktion den IntegrityService.EvaluatePlayerDeviceTrust-Callback in einem Script in ServerScriptService zu. Roblox ruft diese Funktion einmal für jeden Spieler auf, sobald ihr Gerätevertrauensniveau verfügbar ist.

Zum Beispiel lehnt das folgende Skript Spieler ab, deren Geräte die Überprüfung nicht bestehen, und akzeptiert alle anderen, einschließlich Spieler mit Unknown:

local IntegrityService = game:GetService("IntegrityService")

IntegrityService.EvaluatePlayerDeviceTrust = function(player, measures)
	if player.DeviceTrustLevel == Enum.PlayerDeviceTrustLevel.None then
		return {
			Action = Enum.PlayerDeviceTrustDecision.Reject,
			Message = "Dieses Spiel kann Ihr Gerät nicht verifizieren.",
		}
	end

	return { Action = Enum.PlayerDeviceTrustDecision.Accept }
end

Behalten Sie Folgendes im Hinterkopf, wenn Sie den Callback zuweisen:

• Der Callback wird nur auf dem Server ausgeführt. Sie können ihn nicht von einem LocalScript zuweisen.
• Jeder Ort hat einen Callback. Wenn Sie ihn mehr als einmal zuweisen, ersetzt die letzte Zuweisung die vorherigen, also weisen Sie ihn in einem einzigen Skript zu. Verschiedene Orte in Ihrem Spiel können unterschiedliche Callbacks zuweisen.
• Der Callback wird ausgeführt, nachdem Players.PlayerAdded ausgelöst wurde, da die Überprüfung des Geräts Zeit in Anspruch nimmt. Wenn der Callback ausgeführt wird, enthält Player.DeviceTrustLevel bereits das Vertrauensniveau des Spielers.
• Der Callback kann warten, um beispielsweise Daten zu laden, bevor er eine Entscheidung trifft. Der Spieler kann weiterhin spielen, während der Callback ausgeführt wird.
• Der Callback läuft nach etwa 10 Sekunden ab. Wenn es länger dauert, eine Entscheidung zurückzugeben, akzeptiert Roblox den Spieler.
• Wenn der Spieler das Spiel verlässt oder Ihre Skripte ihn entfernen, bevor sein Vertrauensniveau verfügbar ist, ruft Roblox den Callback für diesen Spieler nicht auf.

Eine Entscheidung zurückgeben

Geben Sie eine Tabelle mit den folgenden Feldern zurück:

Damit ein Fehler in Ihrem Code niemals Spieler aussperrt, akzeptiert Roblox den Spieler in jedem der folgenden Fälle:

• Kein Skript weist den Callback zu.
• Der Callback gibt nil, einen Wert, der kein Tabelle ist, oder eine Tabelle ohne gültige Action zurück.
• Der Callback wirft einen Fehler. Roblox meldet den Fehler wie jeden anderen Skripterror.

Auf individuelle Maßnahmen reagieren

Das zweite Argument des Callbacks, measures, ist eine Tabelle von Booleans, die das Vertrauensniveau des Spielers erklärt. Ein Wert von false bedeutet, dass das Gerät diese Maßnahme nicht bestanden hat.

Verwenden Sie die Maßnahmen, um Ihre Richtlinie zu verfeinern. Das folgende Skript lehnt Spieler mit None ab, lehnt auch Spieler mit Standard ab, deren Betriebssystem nicht in einem sicheren Zustand gestartet wurde, und akzeptiert alle anderen:

local IntegrityService = game:GetService("IntegrityService")

IntegrityService.EvaluatePlayerDeviceTrust = function(player, measures)
	local trustLevel = player.DeviceTrustLevel
	local isRejected = trustLevel == Enum.PlayerDeviceTrustLevel.None
		or (trustLevel == Enum.PlayerDeviceTrustLevel.Standard and not measures.IsPlatformBootSecure)

	if isRejected then
		return { Action = Enum.PlayerDeviceTrustDecision.Reject }
	end

	return { Action = Enum.PlayerDeviceTrustDecision.Accept }
end

Häufige Fehler

Vermeiden Sie die folgenden Muster, wenn Sie die Device Trust API verwenden:

• Vergleichen von Vertrauensniveaus als Zahlen. Jedes Vertrauensniveau hat einen Value, aber die Reihenfolge der Werte spiegelt nicht wider, wie sehr Sie einem Gerät vertrauen können. Unknown kommt vor None, sodass eine Überprüfung, dass das Niveau eines Spielers größer als None ist, auch jeden Spieler mit Unknown ausschließt. Listen Sie stattdessen die Niveaus auf, die Sie zulassen, wie die Beispiele auf dieser Seite es tun. Wenn Sie Spieler mit Unknown akzeptieren möchten, fügen Sie Unknown ausdrücklich hinzu.
• Ablehnen von Spielern aus Players.PlayerAdded. Wenn PlayerAdded ausgelöst wird, ist das Vertrauensniveau des Spielers normalerweise noch nicht verfügbar, sodass eine Überprüfung zu diesem Zeitpunkt Spieler ablehnen kann, deren Geräte vertrauenswürdig sind. Geben Sie stattdessen Reject aus dem IntegrityService.EvaluatePlayerDeviceTrust-Callback zurück, den Roblox aufruft, sobald das Vertrauensniveau verfügbar ist. Wenn Sie das Vertrauensniveau aus anderen Gründen in PlayerAdded benötigen, z. B. für das Matchmaking, siehe Warten auf das Vertrauensniveau.
• Langsame Operationen im Callback ausführen. Der Callback kann warten, aber er läuft nach etwa 10 Sekunden ab, und Roblox akzeptiert dann den Spieler. Mehrere Datenbanklesungen oder HTTP-Anfragen können lange genug dauern, um dieses Limit zu erreichen, also halten Sie wartende Operationen im Callback auf ein Minimum.
• Das Vertrauensniveau auf dem Client lesen. Der eigene Client eines Spielers kann sein Vertrauensniveau lesen, sodass Sie möglicherweise in einem LocalScript entscheiden, ob Sie eine Funktion anzeigen oder ein Remote-Event auslösen. Exploiter kontrollieren ihren Client und können diese Überprüfungen umgehen. Lesen Sie stattdessen das Vertrauensniveau auf dem Server und teilen Sie dem Client mit, welche Funktionen aktiviert werden sollen. Basieren Sie clientseitige Änderungen, wie das Ausblenden eines Handelsbuttons, auf dem, was der Server dem Client mitteilt, und überprüfen Sie das Vertrauensniveau immer erneut auf dem Server, bevor die Aktion erfolgt.
• Verwenden der Maßnahmen anstelle des Vertrauensniveaus. Eine Maßnahme ist auch true, wenn sie auf einem Gerät nicht verfügbar ist, sodass ein Gerät jede Maßnahme bestehen kann, ohne vollständig vertrauenswürdig zu sein. Behandeln Sie ein Gerät, das jede Maßnahme besteht, nicht als Full. Überprüfen Sie zuerst das Vertrauensniveau und verwenden Sie die Maßnahmen nur, um nach fehlgeschlagenen Überprüfungen zu suchen.

Testen Sie Ihre Logik

Roblox überprüft Geräte in Studio nicht, sodass das Gerätevertrauensniveau während der Playtests auf Pending bleibt und der Callback nicht ausgeführt wird. Da Ihre Skripte Pending als nicht vertrauenswürdig behandeln, sind Funktionen, die Sie nach Vertrauensniveau sperren, während der Playtests ebenfalls nicht verfügbar.

Um diese Funktionen zu testen und dennoch Ihre Richtlinie zu testen, halten Sie Ihre Richtlinie in einer Funktion, die das Vertrauensniveau annimmt. Wenn RunService:IsStudio() true zurückgibt, überspringen Sie die Vertrauensüberprüfung und rufen Sie Ihre Richtlinie stattdessen mit jedem Vertrauensniveau auf. Das folgende Skript tut dies für das Handelsbeispiel in Funktionen nach Vertrauensniveau sperren:

local RunService = game:GetService("RunService")

local IS_STUDIO = RunService:IsStudio()

local TRADE_TRUST_LEVELS = {
	[Enum.PlayerDeviceTrustLevel.Unknown] = true,
	[Enum.PlayerDeviceTrustLevel.Standard] = true,
	[Enum.PlayerDeviceTrustLevel.Full] = true,
}

local function isTradeAllowed(trustLevel: Enum.PlayerDeviceTrustLevel): boolean
	return TRADE_TRUST_LEVELS[trustLevel] == true
end

-- Überprüfen Sie dies auf dem Server vor jedem Handel
local function canTrade(player: Player): boolean
	-- Roblox überprüft Geräte in Studio nicht, also erlauben Sie den Handel während der Playtests
	if IS_STUDIO then
		return true
	end

	return isTradeAllowed(player.DeviceTrustLevel)
end

-- In Studio drucken Sie, wie Ihre Richtlinie mit jedem Vertrauensniveau umgeht
if IS_STUDIO then
	for _, trustLevel in Enum.PlayerDeviceTrustLevel:GetEnumItems() do
		print(trustLevel.Name, isTradeAllowed(trustLevel))
	end
end

Einschränkungen

Gerätevertrauen erhöht die Kosten für Betrug, ist jedoch keine vollständige Lösung:

• Es ersetzt kein sicheres Spieldesign. Exploits, die sich auf schwache serverseitige Validierung verlassen, wie das Vertrauen in Positionen, Punktzahlen oder Währungen, die vom Client gemeldet werden, funktionieren weiterhin auf vertrauenswürdigen Geräten. Validieren Sie wichtige Aktionen auf dem Server, wie in Sichern der Client-Server-Grenze beschrieben.
• Es reduziert Betrug, beseitigt ihn jedoch nicht. Betrugsentwickler passen sich im Laufe der Zeit an, daher behandeln Sie Gerätevertrauen als eine Schicht Ihrer Verteidigung neben serverseitiger Erkennung.
• Nicht jede Plattform wird unterstützt. Für Details siehe unterstützte Plattformen.