Das deutsche Python-Forum

Hallo Zusammen,

wie schon angemerkt bin ich noch blutiger Anfänger im Programieren.

Hier nun mein nächstes Problem:

Ich habe das folgende Lua-Script, das encryptete Texte innerhalb einer Datei entschlüsselt:

Code: Alles auswählen

function _aXqC1(str)
  local res = ""
  local dtable = "\r)=9\f\aK\",i{SrX#qLa0@Z8&:\014\030;d?\bA(\026G!\023b\000x\021jm 5\022$+s\025l\029<N^2\005WE\017M\vR]\003C\020_o1~keTvYH\002.\004zV\027\019Ptc\028\0063p\016IJ-O\n6\t\0157/\001h`uUByfDn[\018\031g>\024*|'4}w%QF\\"
  for i = 1, #str do
    local b = str:byte(i)
    if b > 0 and b <= 127 then
      res = res .. string.char(dtable:byte(b))
    else
      res = res .. string.char(b)
    end
  end
  return res
end

print (_aXqC1("\fVg\n2\028+*\nU+\021\018g2Ho"))

>>> Das Ergebnis: "Schild mit Zahlen"

Dieses versuche ich nun in Python zu übersetzen:

Code: Alles auswählen

def _aXqC1(string):
    res = ""
    dtable =r"\r)=9\f\aK\",i{SrX#qLa0@Z8&:\014\030;d?\bA(\026G!\023b\000x\021jm 5\022$+s\025l\029<N^2\005WE\017M\vR]\003C\020_o1~keTvYH\002.\004zV\027\019Ptc\028\0063p\016IJ-O\n6\t\0157/\001h`uUByfDn[\018\031g>\024*|'4}w%QF\\"
    for i in range(1,len(string)):
        b = ord(string[i])
        if b > 0 and b <= 127:
            res = res + chr(ord(dtable[b]))
        else:    
            res = res + chr(b)
    return res

text_decrypted = _aXqC1 (r"\fVg\n2\028+*\nU+\021\018g2Ho")

print (text_decrypted)

>>> Das Ergebnis: "\20E00E!00\<E0^\E!0\E!\000+"

Es wäre sehr nett, wenn mir jemand sagen könnte, was ich falsch gemacht habe und wie ich den Fehler beheben kann!

Gruss

archifox

@archifox: Als erstes würde ich mal das r vor der Zeichenkette wegnehmen. Die enthält ziemlich sicher Escapesequenzen die interpretiert werden sollten.

Und dann würde ich das nicht 1:1 übersetzen sondern die `translate()`-Methode auf Zeichenketten verwenden.

Also ohne r kommt auch nur Quatsch raus! Hmmm ...

@archifox: Ich sagte ja auch *als erstes*. Als nächstes müsste man mal die Bytewerte ermitteln die da drin stehen. In Lua.

Achso! Dann mach ich das mal ...

Hier sind die Bytewerte aus dem Lua-Script:

strbyte bei i=1: 12
dtablebyte bei i=1: 83
res bei i=1: S
strbyte bei i=2: 86
dtablebyte bei i=2: 99
res bei i=2: Sc
strbyte bei i=3: 103
dtablebyte bei i=3: 104
res bei i=3: Sch
strbyte bei i=4: 10
dtablebyte bei i=4: 105
res bei i=4: Schi
strbyte bei i=5: 50
dtablebyte bei i=5: 108
res bei i=5: Schil
strbyte bei i=6: 28
dtablebyte bei i=6: 100
res bei i=6: Schild
strbyte bei i=7: 43
dtablebyte bei i=7: 32
res bei i=7: Schild
strbyte bei i=8: 42
dtablebyte bei i=8: 109
res bei i=8: Schild m
strbyte bei i=9: 10
dtablebyte bei i=9: 105
res bei i=9: Schild mi
strbyte bei i=10: 85
dtablebyte bei i=10: 116
res bei i=10: Schild mit
strbyte bei i=11: 43
dtablebyte bei i=11: 32
res bei i=11: Schild mit
strbyte bei i=12: 21
dtablebyte bei i=12: 90
res bei i=12: Schild mit Z
strbyte bei i=13: 18
dtablebyte bei i=13: 97
res bei i=13: Schild mit Za
strbyte bei i=14: 103
dtablebyte bei i=14: 104
res bei i=14: Schild mit Zah
strbyte bei i=15: 50
dtablebyte bei i=15: 108
res bei i=15: Schild mit Zahl
strbyte bei i=16: 72
dtablebyte bei i=16: 101
res bei i=16: Schild mit Zahle
strbyte bei i=17: 111
dtablebyte bei i=17: 110
res bei i=17: Schild mit Zahlen
--------------------
Ergebnis: Schild mit Zahlen

Jetzt macht es natürlich Sinn, daß auch mit dem Python-Script zu machen ...

@archifox: Ich meinte jetzt weniger bei dem Beispieltext sondern Du brauchst ja die Werte von `dtable` in Python.

@archifox: Lua und Python haben eine Unterschiedliche Indizierung und auch andere String-Escapesequenzen. Außerdem ergibt eine wörtliche Übersetzung schrecklichen Pythoncode.

@archifox: Ich habe in Deinem Beitrag mit dem Lua-Quelltext das Syntaxhighlighting mal korrigiert und jetzt ist ziemlich deutlich wo das Problem liegt. Lua interpretiert '\0' als Anfang einer Escapesequenz bei der zwei Hexadezimalziffern folgen die den Bytewert ausmachen während Python '\0' als Nullbyte interpretiert und die beiden folgenden Hexadeziamlziffern einfach als Bytewerte für die ASCII-Zeichen für die sie stehen. Einen Hexwert gibt man in Python-Zeichenketten als '\x' gefolgt von zwei Hexadezimalziffern an.

@BlackJack: so verrückt ist selbst Lua nicht, '\ddd' ist eine Escapesequenz mit einer bis zu dreistelligen Dezimalzahl, nicht Hex.

@Sirius3: Grmpf, in einem anderen Thema habe ich gerade Dezimal als Hex ”erkannt” und nun das. Peinlich…

@archifox: Die Funktion in Python:

Code: Alles auswählen

from __future__ import absolute_import, division, print_function
from operator import methodcaller

DECODE_TABLE = (
    '\0\r)=9\x0c\x07K",i{SrX#qLa0@Z8&:\x0e\x1e;d?\x08A(\x1aG!\x17b\x00x\x15jm 5'
    '\x16$+s\x19l\x1d<N^2\x05WE\x11M\x0bR]\x03C\x14_o1~keTvYH\x02.\x04zV\x1b'
    "\x13Ptc\x1c\x063p\x10IJ-O\n6\t\x0f7/\x01h`uUByfDn[\x12\x1fg>\x18*|'4}w"
    '%QF\\' + ''.join(map(chr, xrange(128, 256)))
)


decode = methodcaller('translate', DECODE_TABLE)


def main():
    print(decode('\x0cVg\n2\x1c+*\nU+\x15\x12g2Ho'))


if __name__ == '__main__':
    main()

Wow! Vielen Dank erstmal an alle die sich meinem Problem angenommen haben!

@Sirius3
Nachdem ich vor dem range das x entfernt habe funktioniert es einwandfrei! Jetzt werde ich mich mal drangeben zu verstehen, was da in dem Script abläuft ...

Gelernt habe ich auf jedenfall schonmal, dass eine 1-zu-1-Übersetzung nicht wirklich zielführend ist!

Vielen Dank

Gruss

archifox

Doch sind sie. Nur wenn man nicht in beiden Sprachen tief genug drin steckt, sind solche Vorhaben zum scheitern verurteilt.

LUA: \f Vg\n2 \028 +*\nU+ \021 \018 g2Ho
PY: \x0c Vg\n2 \x1c +*\nU+ \x15 \x12 g2Ho

Also, ich habe verstanden, daß die Lua-Escapesequenz \0 + zwei Dezimalzahlen in Python dem \x + zwei Hexzeichen (UTF-8) entspricht. Das \f in Lua ist der Formfeed und wird in Hex somit \x0c.

LUA: \r)=9 \f \aK \",i{SrX#qLa0@Z8&: \014 \030 ;d? \b A(\026G!\023b\000x\021jm (Auszug)
PY: \0\r)=9 \x0c \x07 K",i{SrX#qLa0@Z8&: \x0e \x1e ;d? \x08 A(\x1aG!\x17b\x00x\x15jm (Auszug)

Wie aus z.B. \b im dtable \x08 im DECODE_TABLE wird habe ich beim Studium der HEX-Tabelle aber nicht gefunden. Gleiches gilt für den Anfang: \r)=9 -> \0\r)=9

Jetzt ist es so, dass ich in verschiedenen Dateien die Text-Vermurksung habe, d.h. ich habe jedesmal ein anderes dtable und andere zu entschlüsselnde Textzeilen. Das Verschlüsselungsprinzip bleibt zwar gleich, aber ich brauche somit einen Automatismus, der mir aus den dtables sozusagen DECODE_TABLES macht und mir die zu entschlüsselnden Textzeilen für den Ablauf des Scripts aufbereitet.

Also muss ich im dtable bzw. in den zu entschlüsselnden Textzeilen die entsprechenden Stringteile suchen und ersetzen. Puuh ... Eine Herausforderung für mich!

@darktrym: Da wirst Du wohl Recht haben ...

@archifox: '\b': Bell kannst Du so auch mit Python als Escape-Sequenz verwenden, genauso '\f', '\n', '\r'. Die '\0' am Anfang kommt daher, dass Lua Indizes von 1 ab zählt, Python von 0., bzw. in der Übersetzungstabelle ein Zeichen 0 braucht. Ich habe die Umrechnung mit einem einfachen regulären Ausdruck: re.sub(r'\\(\d{1,3})', lambda x: '\\x%02x' % int(x.group(1)), dtable) gemacht.

@darktrym: Am Anfang des Übersetzens steht immer das Verstehen. Und wenn man den Algorithmus erst verstanden hat, dann kann man ihn auch gleich ordentlich schreiben.

@archifox: Wie Sirius3 schon angemerkt hat sind das bei Lua drei Dezimalziffern, und im Quelltext sind die alle unter 100 weshalb alle mit einer 0 anfangen. Was das UTF-8 in Klammern in Deinem Text verloren hat verstehe ich nicht so ganz.

'\f' und '\b' kann man in Python auch verwenden:

Code: Alles auswählen

In [1]: '\f'
Out[1]: '\x0c'

In [2]: '\b'
Out[2]: '\x08'

Am Anfang ist keine Umwandlung eines Zeichenliterals von Lua nach Python sondern ein zusätzlicher Wert weil Lua bei 1 anfängt die Zeichen in einer Zeichenkette zu zählen, Python aber bei 0. Ich habe dort das Nullbyte ('\0' oder '\x00') gewählt damit ein Nullbyte unverändert durch das dekodieren kommt.

Ich habe die Zeichenketten auch nicht manuell angepasst sondern die in Lua einfach als Base64 ausgeben lassen und das in Python dann geparst. Ist weniger fehleranfällig als da die Werte einzeln per Hand zu übersetzen:

Code: Alles auswählen

> mime = require("mime")      
> print((mime.b64("\r)=9\f\aK\",i{SrX#qLa0@Z8&:\014\030;d?\bA(\026G!\023b\000x\021jm 5\022$+s\025l\029<N^2\005WE\017M\vR]\003C\020_o1~keTvYH\002.\004zV\027\019Ptc\028\0063p\016IJ-O\n6\t\0157/\001h`uUByfDn[\018\031g>\024*|'4}w%QF\\")))
DSk9OQwHSyIsaXtTclgjcUxhMEBaOCY6Dh47ZD8IQSgaRyEXYgB4FWptIDUWJCtzGWwdPE5eMgVXRRFNC1JdA0MUX28xfmtlVHZZSAIuBHpWGxNQdGMcBjNwEElKLU8KNgkPNy8BaGB1VUJ5ZkRuWxIfZz4YKnwnNH13JVFGXA==

Code: Alles auswählen

In [4]: 'DSk9OQwHSyIsaXtTclgjcUxhMEBaOCY6Dh47ZD8IQSgaRyEXYgB4FWptIDUWJCtzGWwdPE5eMgVXRRFNC1JdA0MUX28xfmtlVHZZSAIuBHpWGxNQdGMcBjNwEElKLU8KNgkPNy8BaGB1VUJ5ZkRuWxIfZz4YKnwnNH13JVFGXA=='.decode('base64')
Out[4]: '\r)=9\x0c\x07K",i{SrX#qLa0@Z8&:\x0e\x1e;d?\x08A(\x1aG!\x17b\x00x\x15jm 5\x16$+s\x19l\x1d<N^2\x05WE\x11M\x0bR]\x03C\x14_o1~keTvYH\x02.\x04zV\x1b\x13Ptc\x1c\x063p\x10IJ-O\n6\t\x0f7/\x01h`uUByfDn[\x12\x1fg>\x18*|\'4}w%QF\\'

Sirius3 hat geschrieben: @darktrym: Am Anfang des Übersetzens steht immer das Verstehen. Und wenn man den Algorithmus erst verstanden hat, dann kann man ihn auch gleich ordentlich schreiben.

Nun, bei diesem Code ist die Logik überschaubar und die Eigenheiten der Sprache waren das Problem. Ich würde mir das nicht zutrauen, krypt. Dinge umzuschreiben nur weil ich die Theorie dahinter verstanden habe.

Das deutsche Python-Forum

Lua-Script 2 Python-Script

Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script

Re: Lua-Script 2 Python-Script