Obfuskator Text zählen im file

[Mezis]

Hallo ich habe einen einfachen Obfuskator gebaut

def obfuscation(string):
obfuscated_string = ""
for c in string:
n = ord(c) + 54
b = chr(n)
obfuscated_string += b
return obfuscated_string

diesen hab ich dann Funktionen wie Kommentare erkennen, print Inhalte finden etc gegeben. Diese werden im Anschluss in einem Separaten py. File geöffnet.
Soweit so gut funktioniert alles.

Jetzt versuche ich es zu schaffen das alles von dem verschleierten Text in der Filedatei gezählt wird. Um die Anzahl der Verschleierungen heraus zu finden. Hätte jemand eine Idee wie man das anstellen könnte?
Die erste Idee war mit len() und split() zu arbeiten.
Hier hab ich einmal den Print Inhalte finden Code abschnitt, vlt könnte man den modifizieren das der alle aussagen nach dem Print welche dann auch Obfuskiert worden sind zählt. Jemand Ideen wie das Verwirklicht?
# Print-"Inhalte" finden
def print_argumente_erkennen(line):
if 'print("' in line: # sucht nach print
parts = line.split('print("')
for i in range(1, len(parts)):
argument, rest = parts.split('")', 1)
obfuscated_argument = obfuscation(argument)
parts = obfuscated_argument + '")' + rest
line = 'print("'.join(parts)
return line

[Mezis]

ich habe jetzt dies zusammengeschustert :

def print_argumente_erkennen(line):
num_args = 0 # initialisiere einen Zähler für die Anzahl der Argumente
# Suche nach "print(" in der Zeile
if 'print("' in line:
parts = line.split('print("')
for i in range(1, len(parts)):
argument, rest = parts.split('")', 1)
obfuscated_argument = obfuscation(argument)
parts = obfuscated_argument + '")' + rest
line = 'print("'.join(parts)
num_args += len(argument.split()) # Zähle die Anzahl der Wörter
# die Anzahl der Argumente zurückgeben
return num_args
else:
# wenn es keine Druckanweisungen in der Zeile gibt, gib 0 zurück
return 0

Das Problem ist das nur die #print(Hallo World) gezählt werden und nicht alle prints im Code jemand eine Lösung dazu?

[__blackjack__]

@Mezis: Anmerkungen zur ersten Funktion: Funktionsnamen beschreiben üblicherweise Tätigkeiten, die hiesse also besser `obfuscate()`.

Namen sollten keine kryptischen Abkürzungen enthalten, oder gar nur daraus bestehen. Bei `c` und `n` kann man ja noch raten wie die eigenltich heissen sollten, bei `b` fällt mir dann aber nichts offensichtliches mehr ein. Man muss auch nicht jedes kleine Zwischenergebnis überhaupt an einen Namen binden.

Wiederholtes ”aufaddieren” von Zeichenketten ist potentiell sehr ineffizient, da Zeichenketten unveränderbar sind, da also jedes mal die Zeichen aus den beiden summanden in eine neue Zeichenkette kopiert werden müssen. Der Aufwand dafür steigt exponentiell. Idiomatischer Code benutzt ``"".join()`` um die Teilzeichenketten zusammenzusetzen.

Die Funktion wäre im Grunde also kürzer und effizient das hier:

Code: Alles auswählen

def obfuscate(string):
    return "".join(chr(ord(character) + 54) for character in string)

Die hat allerdings ein Problem, dass man nicht einfach zu jedem Codepoint einfach eine konstante Zahl addieren kann und wieder einen gültigen Codepoint bekommt. Ausserdem kann man nicht jeden Codepoint so einfach speichern/serialisieren. Stichwort „surrogates“.

`print_argumente_erkennen()` wird so nicht funktionieren. `print()`-Argumente müssen nicht alle auf einer Zeile stehen. Literale Zeichenketten können nicht nur in " eingeschlossen sein. Es kann modifizierende Zeichen wie r oder f vor der literalen Zeichenkette geben. `print()` kann mehr als ein Argument zur Ausgabe bekommen. Und zusätzliche Schlüsselwortargumente. ``print("`` kann in Kommentaren vorkommen. Oder in Zeichenketten – wie in der `print_argumente_erkennen()`-Funktion selbst beispielsweise.

So wie die `obfuscate()`-Funktion angewendet wird, wirst Du mindestens Probleme mit "&" bekommen. Schau mal was dabei herauskommt und welche Bedeutung das in literalen Zeichenketten hat.

Wenn man literale Zeichenketten in `print()`-Aufrufen identifizieren will, wird man um einen Parser nicht herum kommen. Also beispielsweise das `ast`-Modul aus der Standardbibliothek. Eigentlich braucht man für solche aufgaben einen „concrete syntax tree“ (CST), aber bei so einfachen Sachen kommt man noch mit dem AST aus der immerhin die Fundstellen im Quelltext in den AST-Knoten speichert. Beim Ersetzen muss man dann darauf achten, dass man die Daten aus dem Original-Quelltext ohne Ersetzungen bezieht, weil die sich durch das ersetzen ja verschieben können, die Informationen im AST aber gleich bleiben.