Score verschlüsseln in Textdatei

[timm4444]

Hi Leute,
ich möchte von meinem Spiel die Punkteanzeige verschlüsselt in einer Textdatei abspeichern, weiß aber nicht wie ich Zahlen verschlüsseln soll, so dass es auch einigermaßen manipulationssicher ist.

Danke im vorraus

[Sirius3]

Das könnte man z.B. so machen:

Code: Alles auswählen

SCOREFILE = "score.txt"

def write_score(score):
    with open(SCOREFILE, 'w') as file:
        file.write(f"{53452 - score}")

def read_score(score):
    with open(SCOREFILE, 'r') as file:
        return 53452 - int(file.read())

Das Gute an der Verschlüsselung ist, dass falls jemand die Zahl manipulieren will und eine größere Zahl einträgt, bekommt er einen kleineren Score.

[timm4444]

Ok, danke

[imonbln]

Eine Integer-Subtraktion ist nicht, einigermaßen manipulationssicher, das ist simple Mathematik!

Die Idee mit der Subtraktion ist nett, aber damit es einigermaßen manipulationssicher, ist solltest du die Zahl selbst noch irgendwie manipulieren, zum Beispiel in dem du den Score in zwei Zahlen speicherst, eine Zufall zahl und als zweite Zahl speicherst du das Produkt Zufallszahl xor Score.

Beim Laden berechnest du dann wieder (Produkt Zufallszahl xor Score) xor Zufallszahl und hast den Score.
Ungefähr so:

Code: Alles auswählen

import sys
import random

SCOREFILE = "score.txt"

def write_score(score: int) -> None:
    mask = random.randint(0, sys.maxsize)
    store_value = mask ^ score
    with open(SCOREFILE, 'w') as file:
        file.write(f'{mask}:{store_value}\n')


def read_score() -> int:
    with open(SCOREFILE, 'r') as file:
        smask, svalue = file.readline().split(':', 1)
        return int(smask) ^ int(svalue)

die Datei score.txt würde dann so aussehen

Code: Alles auswählen

8990959533802933526:8990959533802933737

Theoretisch könntest du beide Ansätze auch Kombinieren.

[imonbln]

Jetzt noch die werte mit einer crc32 Checksumme sichern und dann ist der score so gesichert, dass man wenigstens etwas rechnen muss um zu manipulieren.
Ungefähr so:

Code: Alles auswählen

import random
import sys
import zlib

SCOREFILE = "score.txt"

def write_score(score: int) -> None:
    mask = random.randint(0, sys.maxsize)
    store_value = mask ^ score
    string = f'{mask}:{store_value}'
    crc32 = zlib.crc32(string.encode())
    with open(SCOREFILE, 'w') as file:
        file.write(f'{string}:{crc32}\n')


def read_score() -> int:
    with open(SCOREFILE, 'r') as file:
        string, crc32 = file.readline().rsplit(':', 1)
        check = zlib.crc32(string.encode())
        if int(crc32) != check:
            raise ValueError('Wrong Checksum')
        smask, svalue = string.split(':', 1)
        score = int(smask) ^ int(svalue)
        return score

[Sirius3]

@imonbln: ich muß gar nichts rechnen, sondern nur Deine komplizierten Funktionen direkt benutzen. Damit ist meine Variante genauso manipulationssicher wie Deine, oder jede andere.

[__blackjack__]

Klassisches „security by obscurity“.

[imonbln]

Lets face it, denn Highscore irgendwo zu speichern ist immer "security by obscurity", das liegt in der Natur der Sache, selbst wenn du irgendwas mit Krypto machen würdest.

Wie Sirus3 schon gesagt hat, ein Angreifer kann immer einfach den Code ausführen, und bekommt eine valide Repräsentation des Scores.
Wenn die Anforderung aber ist, einfach zu verhindern, dass jemand einen Editor öffnet, um die Zahlen direkt zu manipulieren, dann ist das Xor mit CRC32 die passende Mitigation im Gegensatz zur Subtraktion. Es kommt halt immer auf das Threatmodel an.

[DeaD_EyE]

Ich versuche gerade den Zusammenhang zwischen Security und einem Punktestand im Spiel zu finden. Es gibt keinen.

Code: Alles auswählen

from uuid import getnode
# uuid kann nicht verwendet werden, da sich die Zahl immer ändert
# getnode wird aus der mac-adresse erstellt
from binascii import crc32


def encode_decode(zahl):
    return getnode() ^ zahl


def crc(zahl):
    size = zahl.bit_length() // 8 + 1
    return crc32(zahl.to_bytes(size, "little"))


def check_crc(zahl, crc_wert):
    return crc(zahl) == crc_wert


enc = encode_decode(1337)
enc_crc = crc(enc)

print(enc)
dec = encode_decode(enc)
if check_crc(enc, enc_crc):
    print("CRC32 passt. Die Zahl ist", dec)
else:
    print("CRC32 stimmt nicht überein")

Wieso man das kryptografisch sicher machen sollte, entzieht sich meiner Fantasie.

[imonbln]

Ich versuche gerade den Zusammenhang zwischen Security und einem Punktestand im Spiel zu finden. Es gibt keinen.

Der TO : "ich möchte von meinem Spiel die Punkteanzeige verschlüsselt in einer Textdatei abspeichern“, verschlüsselt ist erstmal Security! Bei nähere Betrachtung kommt man zu dem Schluss, eigentlich würde es reichen die Punkteanzeige zu signieren, denn der Wert soll ja nur gegen Manipulation gesichert sein, er ist nicht geheim!

Dann nach kommt die Frage, womit Signieren und die Antwort gar nicht, denn der Schlüssel zum Signieren muss auf dem System sein, bildlich gesprochen neben den Daten die er Signieren soll. Ergo macht eine Signatur auch keinen Sinn. Wie @__backjack__, festgestellt hat, es ist security by obscurity und eigentlich kann man hier aufhören.

Wenn man jedoch fragt, was will der TO erreichen und die Aussage "einigermaßen manipulationssicher", als Antwort nimmt, dann kann man jetzt so deuten, Manipulation ist nicht ausgeschlossen, sondern nur etwas aufwändiger ist.

Um die Manipulation, aufwändig zu machen sollten:
a.) die Punktestände nicht in Klartext gespeichert werden.
b.) die Manipulation der Punkte durch eine Checksumme erschwert werden.

Das Kriterium a kann man durch ein Xor mit einer zweiten Zahl erreichen, deine Variante mit der MAC Adresse gefällt mir ganz gut, hat aber den Nachteil das die Punktestände nicht Portable sind und das sie sich relativ zueinander nicht ändern. Ob das ein Problem ist, muss der TO selbst entscheiden. Das Kriterium b kann man durch eine Checksumme über a erreichen (welche spielt erstmal keine Rolle) nun muss jemand der Manipulation will, zwei Zahlen aufeinander abstimmen.

Letzten Endes hat @Sirus3, jedenfalls recht mit der Behauptung, ein Cheater kann einfach denn Code aus dem Python extrahieren und jeden wert erzeugen. Dennoch wenn das Programm jetzt zum Beispiel, in einer anderen Sprache geschrieben wäre (C++, Rust, Golang) irgendwas das Kompiliert wird, könnte man Argumentieren, Ziel erreicht! Ein Entwickler mit Debugg Fähigkeiten kann immer noch Manipulieren, jemand der einfach nur eine Datei mit einem Editor ändern will, ist aber raus.

Alles in allen finde ich, dass man an dem Wunsch "ich möchte von meinem Spiel die Punkteanzeige verschlüsselt in einer Textdatei abspeichern" schön üben kann, eine Security Betrachtung zu machen.

[snafu]

Oder man schreibt eine Web-Anwendung und liest den Punktestand vom Server aus (sofern man denn Zugriff auf einen hat und die entsprechenden Programmierfähigkeiten beherrscht).

[kbr]

Oder man stellt die Anforderung "Textdatei" infrage.

[__blackjack__]

Oder die Anforderung die Punkte zu verschlüsseln. Soll der Benutzer die doch ändern wenn's ihm Spass macht.