Strategie per sconfiggere gli editor di memoria per barare - Giochi desktop [chiuso]

Suppongo che stiamo parlando di giochi desktop, qualcosa che il giocatore scarica e gira sul proprio computer locale. Molti sono gli editor di memoria che ti consentono di rilevare e congelare i valori, come la salute del tuo giocatore.

Come si evita di imbrogliare tramite la modifica della memoria? Quali strategie sono efficaci per combattere questo tipo di imbrogli?

Per riferimento, so che i giocatori possono: - Cercare qualcosa per valore o intervallo - Cercare qualcosa che ha cambiato valore - Impostare i valori di memoria - Congelare i valori di memoria

Sto cercando alcuni buoni. Due che uso mediocri sono:

• Visualizzazione dei valori in percentuale anziché in numero (ad es. 46/50 = 92% di integrità)
• Una classe di basso livello che contiene valori in un array e li sposta ad ogni modifica. (Ad esempio, invece di un int, ho una classe che è un array di ints e ogni volta che il valore cambia, uso un oggetto array diverso, scelto casualmente per contenere il valore)

Il gioco è offline, gratuito e per giocatore singolo.

Modifica: per i posteri, ho risolto questo (in C #) e pubblicato la mia soluzione qui , sul mio blog.

Un'altra possibilità (per valori interi) è avere una seconda variabile membro che contiene un complemento bit a bit di una variabile esistente.

Quindi immagina di avere health, avresti anche healthComplement. L'implementazione potrebbe essere simile a questa:

// setter sets value and complement
void setHealth(int value){
    health = value;
    healthComplement = ~value;
}

// getter checks if value was changed outside of the setter
int getHealth(){
    if(value != ~healthComplement){
        // launch some cheat-counter-measure, like crashing the game?
        exit;
    }
    return health;
}

Qualcuno che vuole imbrogliare dovrebbe impostare correttamente Health and HealthComplement, altrimenti il ​​gioco andrebbe in crash.

Penso che sia un po 'inutile cercare di prevenire cose come questa. Le persone hanno creato con successo hack / cheat per cose molto più complesse e semplicemente offusca inutilmente il codice o peggiora le prestazioni del gioco.

Ecco uno schema che mi è venuto in mente quando qualcuno lo stava chiedendo da tempo su una tavola. L'uso delle percentuali o delle variabili raddoppiate non funziona davvero, poiché puoi cercare "qualsiasi" valori e congelarli.

Invece, crea un mostro di un tipo di dati.

In sostanza, memorizza i tuoi valori importanti come una struttura con:

• 32 puntatori a bit
• Per una lettura veloce, chiedi allo struct di includere anche il valore corrente come semplice int

Per la manipolazione, raccogliere il valore corrente dai bit allocati separatamente (che possono essere true / false ints), modificare il valore e quindi memorizzarli.

Ecco il brutto bit: ogni volta che manipoli il valore, libera e alloca nuovamente i bit. L'allocazione dovrebbe avvenire in ordine casuale , quindi i dati saltano in memoria e non possono essere facilmente congelati.

Ulteriori garanzie sarebbero di archiviare i checksum dei valori (così come i "semplici" int) e confrontarli anche durante le chiamate di manipolazione. Se si riscontra una discrepanza, fai qualcosa di sottile, come rimuovere una chiave casuale necessaria per sbloccare le porte per progredire nel gioco.

Modifica: per un ulteriore spostamento della memoria, assicurarsi di allocare i nuovi "bit" prima di liberare quelli vecchi.

Modifica: per i giochi multiplayer, è anche possibile serializzare la struttura dei dati, comprimerlo e inviarlo sulla rete. Non è l'uso più efficiente della rete, ma sicuramente più difficile da capire attraverso lo sniffing dei pacchetti.

Che ne dici di memorizzare la salute integrata con un valore casuale generato ogni volta che lo memorizzi. Questo almeno sconfiggerebbe il semplice meccanismo di ricerca di valori crescenti / decrescenti nella memoria per trovare la salute.

class Player
{
  int m_Health;
  int m_RandomHealth;
  Random m_Rnd = new Random();

  public int Health {
    get
    {
      return m_Health ^ m_RandomHealth;
    }

    set
    {
      m_RandomHealth = m_Rnd.Next();
      m_Health = value ^ m_RandomHealth;
    }
  }
}

Inoltre, potresti voler ripristinare il valore di ciascun fotogramma, anche se lo stato non cambia. Ciò impedirà alle persone di cercare indirizzi modificati quando la loro salute cambia e che rimangono invariati quando la loro salute rimane invariata.

Bonus: crea un nuovo oggetto ogni volta che cambia in modo da modificare l'aggiunta di memoria e imposta lo stato di salute per modificare il numero casuale, il valore xored e l'indirizzo in memoria ogni volta che lo leggi :

class Player
{
  int [] m_HealthArray; // [0] is random int, [1] is xored health
  Random m_Rnd = new Random();

  public Player() {
    this.Health = 100;
  }

  public int Health {
    get
    {
      int health = m_HealthArray[0] ^ m_HealthArray[1];
      Health = health; // reset to move in memory and change xor value
      return health;
    }

    set
    {
      m_HealthArray = new int[2];
      m_HealthArray[0] = m_Rnd.Next();
      m_HealthArray[1] = m_HealthArray[0] ^ value;
    }
  }
}

Anche se ho fatto il primo commento mettendo in discussione il punto di degradare l'esperienza di una parte del tuo pubblico senza alcun guadagno apparente, trovo comunque una domanda interessante da un punto di vista tecnico.

Ho appena avuto questa idea: ciò che fanno gli imbroglioni è trovare valori che cambiano e congelarli. La ricerca sarebbe quindi avvenuta solo tra morti o eventi che hanno cambiato la salute del giocatore. Inoltre, l'imbroglione potrebbe perfezionare la ricerca filtrando ciò che è cambiato quando "non stava morendo".

Cosa succede se il contatore "salute" sta cambiando tutto il tempo? Trasformalo in un puntatore e rialloca ogni frame o N frame se l'hit di performance è troppo grande. Oppure XOR con un valore casuale che cambia ogni fotogramma (XORing di nuovo rispetto allo stesso valore per la decrittografia prima della crittografia con un nuovo valore casuale).

Se hai altri dati di gioco che cambiano anche tutto il tempo (incluse le posizioni xey del personaggio del giocatore o il contatore del tempo), ciò potrebbe rendere più difficile scoprire quale di tutti i dati che cambiano è la salute. E congelare l'intero stato del gioco è un gioco da ragazzi.

Per ulteriori informazioni fuorvianti, puoi effettivamente archiviare la salute in una semplice variabile di sola scrittura intesa come un vaso di miele.

Modifica :

Tuttavia, l'imbroglione potrebbe provare a trovare quale delle variabili che sta cambiando continuamente è quella da congelare attraverso tentativi ed errori. Una possibile soluzione sarebbe quella di accoppiare le variabili.

Un esempio:

Invece di memorizzare salute (h) e posizione (x), li memorizzi in due variabili aeb, da cui puoi recuperare i valori in un secondo momento:

a = x+h; b = x-h
x = (a+b)/2; h = (a-b)/2

In questo modo, se l'imbroglione congela solo uno di essi e quindi sposta il personaggio, la posizione viene influenzata e, a seconda di quale è stato congelato, h diventa negativo (morte istantanea). Puoi passare tra le formule sopra e:

a = x-h; b = x+h
x = (a+b)/2; h = (b-a)/2

In fotogrammi consecutivi e garantisci che al massimo 2 fotogrammi dopo che una delle variabili è stata congelata, la salute girerà 0 nel momento in cui x cambia. Ricorda che stai memorizzando solo aeb. Combina questo con lo XOR continuo come menzionato sopra. Il risultato è una raccolta di variabili che stanno cambiando ogni fotogramma in valori apparentemente casuali e il congelamento di uno singolo o di un suo sottoinsieme produce solo effetti collaterali indesiderati nel gioco, la morte istantanea è uno di questi.

Una possibile opzione che penso possa funzionare (non ho troppa familiarità con questi strumenti per barare): non nasconderlo. Esegui le tue operazioni e attendi alcuni risultati. Dopo l'operazione (possibilmente il prossimo frame), controlla per assicurarti che i risultati siano come ti aspetti che siano. Se sottrai la salute e poi la verifichi, solo per scoprire che la salute non è mai cambiata, puoi essere abbastanza sicuro (purché tu non abbia qualche insetto oscuro) che sia stato bloccato.

Se rilevi degli imbrogli, ora sei libero di cambiare le regole del gioco come ritieni opportuno per il massimo dolore, se questo è il tuo intento. Se il tuo intento è quello di ignorare i trucchi e far funzionare il gioco, rialloca la salute altrove nella memoria e modifica i tuoi puntatori in modo che il nuovo valore venga utilizzato e il vecchio venga ignorato. Ripeti all'infinito.

Qualsiasi tentativo di semplice offuscamento è destinato a fallire in teoria, ma in pratica devi solo renderlo abbastanza difficile da rompere che la sfida diventa meno divertente che riuscire nel gioco. Non so quale sia il tuo gioco, quindi non rischierò di suggerire metodi di offuscamento dei dati, tanto meno perché credo che siano inutili.

Detto questo, e probabilmente non ti piacerà, credo che tu stia cercando la memoria , che è un concetto di Trusted Computing .

Una tecnica molto efficace utilizzata da alcuni roguelike (DoomRL, Brogue) è quella di mascherare le variabili effettive. Ciò significa che invece di mostrare la salute come "2/10", mostrala come "20%".

Ricorda, la maggior parte degli editor di memoria funziona bene con la ricerca / il filtro di valori specifici. Se non conosci il valore specifico, puoi comunque rintracciarlo (ad es. Cercare valori modificati / diminuiti dopo che la salute del giocatore scende), anche se ci vuole molto più tempo per farlo in quel modo.

Suggerisco anche un gioco anti-cheat. Ad esempio, se hai una partita in cui il giocatore subisce danni non positivi e la sua salute non diminuisce, puoi facilmente e accuratamente controllare questo e sapere che il giocatore imbroglia. Fai qualcosa di interessante, come generare dei super nemici intorno a lui :)

Scrivere un driver ring 0 che agganci SSDT e registri / blocchi quando ReadProcessMemory / WriteProcessMemory viene chiamato nell'applicazione. Sarebbe meglio semplicemente accedere in modo da poter cambiare lentamente il loro comportamento di gioco nel tempo piuttosto che semplicemente bloccarsi.

Perché dovresti impedire ai giocatori di imbrogliarsi (che equivale a imbrogliare in una partita a giocatore singolo)? In un ambiente multiplayer, è compito del server rilevare cambiamenti innaturali e contrastarli (in genere ignorando l'input o bloccando completamente il colpevole dal server), ma in un ambiente a giocatore singolo non sta succedendo nulla tranne che il cheater si sta facendo un disservizio.

IOW, a meno che tu non stia creando un gioco multiplayer sia uno spreco di denaro, e se stai pensando di indurire il posto sbagliato.

Ricerca gli strumenti di frode noti e controlla frequentemente se vengono rilevati alcuni dei più comuni in esecuzione (controlla i nomi dei processi?)

Se ne vengono rilevati alcuni, lascia che il giocatore imbroglia (se non in linea, è innocuo), ma assicurati che nessun punteggio / risultato venga pubblicato su qualsiasi sistema di classifica / successo online - fallo fallire silenziosamente?

Non fermerà gli hacker più determinati, ma ridurrà la possibilità che altri trucchi casuali rovinino le tue classifiche.

(Potrebbe infastidire i programmatori che hanno strumenti di sviluppo aperti e minimizzati per scopi legittimi e stanno prendendo una pausa di gioco, però ...)

Penso che la soluzione più semplice sia implementare un'opzione cheat. Disabilita il punteggio con l'opzione cheat.

Un'altra buona idea, che non ho idea di come implementeresti. È chiudere il gioco quando c'è una variabile di memoria congelata o qualcosa del genere :)

Buona fortuna)