Fiducia del dispositivo

L'API di Fiducia del Dispositivo ti dice quanto puoi fidarti del dispositivo di ogni giocatore che si unisce al tuo gioco. Quando un giocatore si unisce, Roblox controlla se il loro dispositivo può essere considerato affidabile e ti fornisce il risultato come livello di fiducia del dispositivo. Questo controllo è un ulteriore strato di protezione oltre all'anti-cheat integrato di Roblox, che rileva gli exploit dopo che un giocatore si è unito.

Roblox non intraprende alcuna azione basata sul livello di fiducia del dispositivo. Sei tu a decidere cosa significa per il tuo gioco. Ad esempio, puoi abbinare i giocatori con livelli di fiducia simili, limitare funzionalità sensibili come il trading ai dispositivi fidati o rifiutare i giocatori i cui dispositivi non superano il controllo.

L'API di Fiducia del Dispositivo è composta dal callback IntegrityService.EvaluatePlayerDeviceTrust e dalla proprietà Player.DeviceTrustLevel. Per iniziare a usarla nei tuoi script, consulta leggi il livello di fiducia.

La fiducia del dispositivo completa le tattiche in tattiche di sicurezza e mitigazione degli exploit piuttosto che sostituirle.

Livelli di fiducia del dispositivo

Il livello di fiducia del dispositivo di un giocatore è uno dei seguenti valori di Enum.PlayerDeviceTrustLevel:

Piattaforme supportate

Roblox controlla la fiducia del dispositivo sulle seguenti piattaforme:

Fino a quando Roblox non supporta una piattaforma, i giocatori su di essa riportano Unknown.

Su una piattaforma supportata, il livello di fiducia che un dispositivo può raggiungere dipende anche dall'hardware. Ad esempio, non tutti i dispositivi Android supportano i controlli utilizzati da Roblox, quindi alcuni dispositivi non possono raggiungere Standard o Full anche se non sono stati manomessi. Per un elenco di dispositivi supportati noti, consulta il Centro Assistenza.

Come funziona

Quando un giocatore si unisce al tuo gioco, Roblox utilizza segnali hardware dal loro dispositivo per confermare quanto segue:

• Il dispositivo è un dispositivo fisico e non un emulatore.
• Il sistema operativo non è stato manomesso, ad esempio tramite il rooting del dispositivo.
• L'app di Roblox non è stata modificata.

Da questi controlli, Roblox calcola un livello di fiducia del dispositivo per il giocatore. Per preservare l'efficacia del sistema, Roblox non pubblica i segnali specifici che valuta.

Il controllo viene eseguito in background mentre il giocatore si unisce, quindi non ritarda il caricamento. I giocatori possono iniziare a giocare prima che il loro livello di fiducia sia disponibile, quindi tratta un giocatore come non fidato fino a quando non lo è. Per dettagli, consulta leggi il livello di fiducia.

Il livello di fiducia del dispositivo descrive il dispositivo, non il giocatore o il loro account. Non ti dice se un giocatore sta imbrogliano. Ti dice quanto è difficile imbrogliare sul loro dispositivo. Per controllare l'account, utilizza Player:IsVerified().

Impatto sui giocatori legittimi

Nessun controllo del dispositivo è perfetto. Alcuni giocatori che non hanno intenzione di imbrogliare raggiungono comunque un basso livello di fiducia. Questi giocatori rientrano in due gruppi.

Giocatori che possono sistemare il loro dispositivo

Alcuni dispositivi sono in grado di superare i controlli ma non sono configurati per farlo, come un dispositivo con un sistema operativo obsoleto, un dispositivo rootato o un dispositivo che esegue una versione modificata dell'app di Roblox. Questi giocatori possono solitamente aumentare il loro livello di fiducia aggiornando il dispositivo, reinstallando Roblox da un app store ufficiale o riportando il dispositivo al suo stato originale. Puoi indirizzare i giocatori interessati ai passaggi di risoluzione dei problemi nel Centro Assistenza.

Giocatori che non possono sistemare il loro dispositivo

Altri giocatori utilizzano dispositivi più vecchi che non supportano l'hardware su cui si basano questi controlli. Questi giocatori non possono aumentare il loro livello di fiducia su quel dispositivo e possono raggiungere un livello più alto solo passando a un dispositivo più recente e supportato. Per ulteriori informazioni, consulta piattaforme supportate.

Cosa vede un giocatore rifiutato

Se il tuo gioco rifiuta un giocatore in base al loro livello di fiducia, il giocatore viene disconnesso e vede un messaggio. Puoi scrivere tu stesso questo messaggio, ad esempio per indirizzare i giocatori a una modalità che possono ancora giocare. Se non lo fai, Roblox mostra un messaggio predefinito che spiega perché non possono unirsi e come potrebbero sistemare il loro dispositivo.

Implementazione

Stima dell'impatto

Prima di agire sulla fiducia del dispositivo, controlla quanti dei tuoi giocatori copre ciascun livello di fiducia. La pagina Anti-cheat su Creator Hub stima come i tuoi utenti attivi giornalieri, il tempo di gioco e le entrate sulle piattaforme supportate si suddividono per livello di fiducia del dispositivo. Per visualizzarla, devi essere il proprietario del gioco o avere il permesso di visualizzare le analisi per le esperienze.

1. Naviga alla tua pagina Creazioni su Creator Hub e seleziona il tuo gioco.
2. Nel menu a sinistra, seleziona Sicurezza, quindi seleziona Anti-cheat.

Scegli una politica

La tua politica è come il tuo gioco risponde a ciascun livello di fiducia del dispositivo. Per sceglierne una:

1. Decidi cosa significa Unknown per il tuo gioco. Sta a te decidere se trattare i giocatori a Unknown come giocatori su dispositivi fidati, come giocatori a None, o in modo diverso in diverse parti del tuo gioco.
2. Controlla l'impatto. Rivedi la pagina Anti-cheat su Creator Hub per vedere come i tuoi giocatori si suddividono per livello di fiducia. Per ulteriori informazioni, consulta stima dell'impatto.
3. Scegli come rispondere a ciascun livello. Le seguenti risposte vanno dalla meno alla più dirompente, e puoi combinarle:

   • Instrada i giocatori in base al livello di fiducia. Invia i giocatori a luoghi o server che si adattano al loro livello di fiducia, come un luogo casual per tutti e un luogo classificato per dispositivi fidati. Ogni giocatore può comunque giocare al tuo gioco. Per un esempio, consulta instrada i giocatori in base al livello di fiducia.
   • Limita le funzionalità sensibili. Richiedi un livello di fiducia più elevato per una funzionalità specifica, come il trading, e consenti a tutti di giocare al resto del tuo gioco. Per un esempio, consulta limita le funzionalità in base al livello di fiducia.
   • Rifiuta i giocatori. Allontana i giocatori dal tuo intero gioco. Rifiuta solo i giocatori a None come ultima risorsa. Per un esempio, consulta rifiuta i giocatori all'unione.

Politiche raccomandate per genere

La seguente tabella suggerisce una politica iniziale per generi comuni su Roblox. Adattala a come funziona il tuo gioco.

Leggi il livello di fiducia

Ogni utilizzo dell'API di Fiducia del Dispositivo inizia con Player.DeviceTrustLevel, che contiene il livello di fiducia di un giocatore. Leggilo sul server quando il tuo gioco deve prendere una decisione, ad esempio quando un giocatore chiede di unirsi a una partita classificata o di avviare un trading.

Tieni presente quanto segue quando leggi la proprietà:

• Ogni giocatore inizia a Pending, e la proprietà cambia una sola volta, quando il livello di fiducia diventa disponibile. Se Roblox non riesce a completare il controllo di un dispositivo, la proprietà potrebbe rimanere a Pending per tutta la sessione. Tratta sempre Pending come non sufficientemente fidato per funzionalità sensibili.
• Leggi il livello di fiducia sul server e fai in modo che il server dica a ciascun client quali funzionalità abilitare o disabilitare, ad esempio attivando un RemoteEvent per quel giocatore. Evita di leggere la proprietà sul client. Solo il client del giocatore può leggere il proprio livello di fiducia, ogni altro client vede Pending, e gli exploitatori possono cambiare cosa fa il loro client con esso.
• In Studio, il livello di fiducia è sempre Pending. Per dettagli, consulta testa la tua logica.

Aspetta il livello di fiducia

Alcune parti del tuo gioco potrebbero aver bisogno del livello di fiducia prima che un giocatore inizi, come il matchmaking che invia i giocatori a un lobby in base al loro livello di fiducia. In tal caso, puoi trattenere un giocatore in Players.PlayerAdded fino a quando il callback non viene eseguito, e poi continuare con il loro livello di fiducia.

Utilizza questo schema solo per accettare i giocatori e regolare la loro esperienza, ad esempio instradandoli o limitando le funzionalità. Per rifiutare i giocatori, restituisci Reject dal callback IntegrityService.EvaluatePlayerDeviceTrust e mantieni quella logica nel callback, come descritto in rifiuta i giocatori all'unione.

Il seguente script memorizza il thread in cui viene eseguito PlayerAdded, lo sospende con coroutine.yield(), e lo riprende dal callback con task.defer(). Se il giocatore esce, o il livello di fiducia non è disponibile dopo MAX_WAIT_SECONDS, lo script riprende il thread in modo che nessun giocatore aspetti per sempre:

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

-- Quanto tempo trattenere un giocatore prima di smettere di aspettare il loro livello di fiducia
local MAX_WAIT_SECONDS = 10

-- Il thread che sta aspettando il livello di fiducia di ciascun giocatore
local waitingThreads: { [Player]: thread } = {}

-- Riprende il thread che sta aspettando il giocatore, se ce n'è uno
local function release(player: Player, trustLevel: Enum.PlayerDeviceTrustLevel?)
	local thread = waitingThreads[player]
	if thread then
		waitingThreads[player] = nil
		task.defer(thread, trustLevel)
	end
end

-- Sospende fino a quando il livello di fiducia del giocatore non è disponibile. Restituisce Pending se il
-- tempo di attesa scade, e nil se il giocatore esce prima.
local function waitForTrustLevel(player: Player): Enum.PlayerDeviceTrustLevel?
	-- Roblox non controlla i dispositivi in Studio, quindi non trattenere i giocatori durante i test
	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

	-- Inizia la sessione del giocatore qui, ad esempio inviandoli a un lobby
	-- che si adatta al loro livello di fiducia. Tratta Pending come non fidato.
	print(player.Name, "è entrato con livello di fiducia", trustLevel.Name)
end)

Instrada i giocatori in base al livello di fiducia

Invece di rifiutare i giocatori, puoi inviarli a un luogo che si adatta al loro livello di fiducia. Ad esempio, un gioco competitivo può accettare tutti in un luogo di avvio casuale e inviare solo i giocatori il cui livello di fiducia soddisfa i tuoi requisiti a un luogo classificato separato.

Nel luogo casual, controlla il livello di fiducia prima di teletrasportare un giocatore al luogo classificato con TeleportService:TeleportAsync(). Questo script presume che la tua interfaccia utente client attivi un RemoteEvent chiamato JoinRanked in ReplicatedStorage quando un giocatore chiede di giocare in modalità classificata:

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

local RANKED_PLACE_ID = 12345678901234 -- Sostituisci con l'ID del tuo luogo classificato

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
		-- Fai sapere al giocatore che il gioco classificato non è disponibile sul loro dispositivo
		return
	end

	local success, result = pcall(function()
		return TeleportService:TeleportAsync(RANKED_PLACE_ID, { player })
	end)
	if not success then
		warn("Il teletrasporto al luogo classificato è fallito:", result)
	end
end)

I giocatori possono raggiungere il luogo classificato in altri modi, come unirsi a un amico. Per applicare la stessa politica lì, assegna il callback IntegrityService.EvaluatePlayerDeviceTrust nel luogo classificato, come descritto in rifiuta i giocatori all'unione, e rifiuta i giocatori che non soddisfano i requisiti:

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 = "Il gioco classificato non è disponibile su questo dispositivo. Puoi comunque giocare in modalità casual.",
	}
end

I giocatori possono iniziare a giocare prima che il callback venga eseguito, quindi non avviare una partita classificata per un giocatore mentre il loro livello di fiducia è Pending. Per controllare quali luoghi i giocatori possono unirsi direttamente, consulta configura il teletrasporto sicuro.

Questi esempi tengono i giocatori a Pending, Unknown e None fuori dal gioco classificato. Se decidi di dare ai giocatori a Unknown il beneficio del dubbio, aggiungi Unknown a entrambe le tabelle.

Limita le funzionalità in base al livello di fiducia

Per consentire a tutti di giocare ma limitare funzionalità sensibili, come il trading, controlla il livello di fiducia sul server quando un giocatore prova a utilizzare la funzionalità. Il seguente script consente solo un trading quando entrambi i giocatori hanno un livello di fiducia consentito. Elencare i livelli consentiti in una tabella mantiene la tua politica in un unico posto:

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

	-- Valida e trasferisci l'oggetto sul server qui
	return true
end

Questo esempio blocca il trading per i giocatori a Pending e None, e consente ai giocatori a Unknown di scambiare. Per bloccare anche il trading per i giocatori a Unknown, rimuovi Unknown dalla tabella.

Per controllare anche l'account prima di un'azione sensibile, combina il livello di fiducia con Player:IsVerified().

Rifiuta i giocatori all'unione

Se instradare i giocatori o limitare le funzionalità non è sufficiente, puoi rifiutare i giocatori dal tuo gioco. Assegna una funzione al callback IntegrityService.EvaluatePlayerDeviceTrust in un Script in ServerScriptService. Roblox chiama questa funzione una volta per ogni giocatore, non appena il loro livello di fiducia del dispositivo è disponibile.

Ad esempio, il seguente script rifiuta i giocatori i cui dispositivi non superano il controllo e accetta tutti gli altri, compresi i giocatori a Unknown:

local IntegrityService = game:GetService("IntegrityService")

IntegrityService.EvaluatePlayerDeviceTrust = function(player, measures)
	if player.DeviceTrustLevel == Enum.PlayerDeviceTrustLevel.None then
		return {
			Action = Enum.PlayerDeviceTrustDecision.Reject,
			Message = "Questo gioco non può verificare il tuo dispositivo.",
		}
	end

	return { Action = Enum.PlayerDeviceTrustDecision.Accept }
end

Tieni presente quanto segue quando assegni il callback:

• Il callback viene eseguito solo sul server. Non puoi assegnarlo da un LocalScript.
• Ogni luogo ha un callback. Se lo assegni più di una volta, l'ultima assegnazione sostituisce le precedenti, quindi assegnalo in un singolo script. Luoghi diversi nel tuo gioco possono assegnare callback diversi.
• Il callback viene eseguito dopo che Players.PlayerAdded è stato attivato, perché il controllo del dispositivo richiede tempo. Quando il callback viene eseguito, Player.DeviceTrustLevel contiene già il livello di fiducia del giocatore.
• Il callback può sospendersi, ad esempio per caricare dati prima di prendere una decisione. Il giocatore continua a giocare mentre il callback viene eseguito.
• Il callback scade dopo circa 10 secondi. Se impiega più tempo a restituire una decisione, Roblox accetta il giocatore.
• Se il giocatore esce, o i tuoi script lo rimuovono, prima che il loro livello di fiducia sia disponibile, Roblox non chiama il callback per quel giocatore.

Restituisci una decisione

Restituisci una tabella con i seguenti campi:

In modo che un errore nel tuo codice non blocchi mai i giocatori, Roblox accetta il giocatore in ciascuno dei seguenti casi:

• Nessuno script assegna il callback.
• Il callback restituisce nil, un valore che non è una tabella, o una tabella senza un Action valido.
• Il callback genera un errore. Roblox riporta l'errore come qualsiasi altro errore di script.

Rispondi a misure individuali

Il secondo argomento del callback, measures, è una tabella di booleani che spiega il livello di fiducia del giocatore. Un valore di false significa che il dispositivo non ha superato quella misura.

Utilizza le misure per affinare la tua politica. Il seguente script rifiuta i giocatori a None, rifiuta anche i giocatori a Standard il cui sistema operativo non è stato avviato in uno stato sicuro e accetta tutti gli altri:

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

Errori comuni

Evita i seguenti schemi quando utilizzi l'API di Fiducia del Dispositivo:

• Confrontare i livelli di fiducia come numeri. Ogni livello di fiducia ha un Value, ma l'ordine dei valori non riflette quanto puoi fidarti di un dispositivo. Unknown viene prima di None, quindi un controllo che verifica se il livello di un giocatore è maggiore di None esclude anche ogni giocatore a Unknown. Invece, elenca i livelli che consenti, come fanno gli esempi in questa pagina. Se vuoi accettare i giocatori a Unknown, includi esplicitamente Unknown.
• Rifiutare i giocatori da Players.PlayerAdded. Quando PlayerAdded viene attivato, il livello di fiducia del giocatore di solito non è ancora disponibile, quindi un controllo a quel punto può rifiutare i giocatori i cui dispositivi sono fidati. Invece, restituisci Reject dal callback IntegrityService.EvaluatePlayerDeviceTrust, che Roblox chiama non appena il livello di fiducia è disponibile. Se hai bisogno del livello di fiducia in PlayerAdded per altri motivi, come il matchmaking, consulta aspetta il livello di fiducia.
• Eseguire operazioni lente nel callback. Il callback può sospendersi, ma scade dopo circa 10 secondi, e Roblox accetta quindi il giocatore. Diverse letture di datastore o richieste HTTP possono richiedere abbastanza tempo per raggiungere questo limite, quindi mantieni al minimo le operazioni di sospensione nel callback.
• Leggere il livello di fiducia sul client. Il client di un giocatore può leggere il proprio livello di fiducia, quindi potresti decidere in un LocalScript se mostrare una funzionalità o attivare un evento remoto. Gli exploitatori controllano il loro client e possono bypassare questi controlli. Invece, leggi il livello di fiducia sul server e dì al client quali funzionalità abilitare. Basare le modifiche lato client, come nascondere un pulsante di trading, su ciò che il server dice al client, e controlla sempre di nuovo il livello di fiducia sul server prima che l'azione avvenga.
• Utilizzare le misure invece del livello di fiducia. Una misura è anche true quando non è disponibile su un dispositivo, quindi un dispositivo può superare ogni misura senza essere completamente fidato. Non trattare un dispositivo che supera ogni misura come Full. Controlla prima il livello di fiducia e utilizza le misure solo per cercare controlli che non sono riusciti.

Testa la tua logica

Roblox non controlla i dispositivi in Studio, quindi durante i test il livello di fiducia del dispositivo rimane a Pending e il callback non viene eseguito. Poiché i tuoi script trattano Pending come non fidato, le funzionalità che limiti in base al livello di fiducia non sono disponibili durante i test.

Per testare queste funzionalità e comunque testare la tua politica, mantieni la tua politica in una funzione che accetta il livello di fiducia. Quando RunService:IsStudio() restituisce true, salta il controllo di fiducia e chiama la tua politica con ciascun livello di fiducia invece. Il seguente script fa questo per l'esempio del trading in limita le funzionalità in base al livello di fiducia:

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

-- Controlla questo sul server prima di ogni trading
local function canTrade(player: Player): boolean
	-- Roblox non controlla i dispositivi in Studio, quindi consenti il trading durante i test
	if IS_STUDIO then
		return true
	end

	return isTradeAllowed(player.DeviceTrustLevel)
end

-- In Studio, stampa come la tua politica gestisce ciascun livello di fiducia
if IS_STUDIO then
	for _, trustLevel in Enum.PlayerDeviceTrustLevel:GetEnumItems() do
		print(trustLevel.Name, isTradeAllowed(trustLevel))
	end
end

Limitazioni

La fiducia del dispositivo aumenta il costo dell'imbroglio, ma non è una soluzione completa:

• Non sostituisce un design di gioco sicuro. Gli exploit che si basano su una validazione lato server debole, come fidarsi delle posizioni, dei punteggi o della valuta riportati dal client, funzionano ancora su dispositivi fidati. Valida le azioni importanti sul server, come descritto in mettere in sicurezza il confine client-server.
• Riduce l'imbroglio, ma non lo elimina. Gli sviluppatori di cheat si adattano nel tempo, quindi tratta la fiducia del dispositivo come uno strato delle tue difese insieme a rilevamento lato server.
• Non tutte le piattaforme sono supportate. Per dettagli, consulta piattaforme supportate.