Bytes in Text umwandeln

[Kirby.exe]

Alsoo ich versuche gerade den folgenden Hexcode zu entschlüsseln:

6e0a9372ec49a3f6930ed8723f9df6f6720ed8d89dc4937222ec7214d89d1e0e352ce0aa6ec82bf622227bb70e7fb7352249b7d893c493d8539dec8fb7935d490e7f9d22ec89b7a322ec8fd80e7f8921

Hierzu habe ich das Zeug erstmal als Bytes umgewandelt mit bytes.fromhex(hex_string) das ergibt folgendes:

b'n\n\x93r\xecI\xa3\xf6\x93\x0e\xd8r?\x9d\xf6\xf6r\x0e\xd8\xd8\x9d\xc4\x93r"\xecr\x14\xd8\x9d\x1e\x0e5,\xe0\xaan\xc8+\xf6""{\xb7\x0e\x7f\xb75"I\xb7\xd8\x93\xc4\x93\xd8S\x9d\xec\x8f\xb7\x93]I\x0e\x7f\x9d"\xec\x89\xb7\xa3"\xec\x8f\xd8\x0e\x7f\x89!'

Jetzt habe ich das Problem das ich das Encoding nicht rausbekomme...Habe schon die Bibliothek chardet probiert aber des sagt, dass dies Thai wäre also Encoding TIS-620. Nur kommt da nur quatsch raus:

'n\n\x93r์Iฃ๖\x93\x0eุr?\x9d๖๖r\x0eุุ\x9dฤ\x93r"์r\x14ุ\x9d\x1e\x0e5,เชnศ+๖""{ท\x0e\x7fท5"Iทุ\x93ฤ\x93ุS\x9d์\x8fท\x93]I\x0e\x7f\x9d"์\x89ทฃ"์\x8fุ\x0e\x7f\x89!'

 

[LimDul]

So ganz ohne Anhaltspunkte schwer bis unmöglich.

Grundsätzlich würde ich schauen was bei UTF-8/UTF-16 rauskommt, weil das gängige Encodings sind.

Wichtig wäre: Wo kommt der Hex-String her? Was für weitere Informationen dazu gibt es? Ist das überhaupt ein String der dahintersteckt und der sich rein über das Encoding definiert? Oder kann da noch mehr eine Rolle spielen.

 

[Kirby.exe]

Oh ja stimmt also ich habe eine Python3 Datei welche das Encoding übernommen hat und versuche die Schritte rückwärts abzulaufen.
Hier ist der Quellcode:

import string
from secret import MSG

def encryption(msg):
    ct = []
    for char in msg:
        ct.append((123 * char + 18) % 256)
    return bytes(ct)

ct = encryption(MSG)
f = open('./msg.enc','w')
f.write(ct.hex())
f.close()

Den Shift kann man ja dann durch ((char-18)/123) % 256 reversen

 

[Kirby.exe]

Ich habe dazu mal eine "Decrypt" Datei geschrieben:

def decryption(msg):
    ct = bytes.fromhex(msg).decode('utf-16')
    for char in ct:
        ct.append(((char - 18)/123) % 256)
    return bytes(ct)


s = "6e0a9372ec49a3f6930ed8723f9df6f6720ed8d89dc4937222ec7214d89d1e0e352ce0aa6ec82bf622227bb70e7fb7352249b7d893c493d8539dec8fb7935d490e7f9d22ec89b7a322ec8fd80e7f8921"
print(decryption(s))

Bei UTF-16 bekomme ich diese Fehlermeldung:

Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print(decryption(s))
  File "test.py", line 2, in decryption
    ct = bytes.fromhex(msg).decode('utf-16')
UnicodeDecodeError: 'utf-16-le' codec can't decode bytes in position 18-19: illegal UTF-16 surrogate

und bei UTF-8 bekomme ich diese Fehlermeldung:

Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print(decryption(s))
  File "test.py", line 2, in decryption
    ct = bytes.fromhex(msg).decode('utf-16')
UnicodeDecodeError: 'utf-16-le' codec can't decode bytes in position 18-19: illegal UTF-16 surrogate

 

[LimDul]

An der Stelle ein Encoding anwenden ist doch kompletter Unfug. Ein Encoding wird überhaupt nicht gebraucht. Es sind schlicht Bytes, die da verarbeitet werden. Und am Ende kommt ein String raus, bestehend aus Ascii Werten. Der hat dann vielleicht ein Encoding, aber da ist nix mehr mit Enconding anwenden oder nicht.

Banal gesprochen: Das Encoding ist bei diesen Daten der Byte-Shift.

 

[Barista]

ct.append((123 * char + 18) % 256)

Wenn es entschlüsselbar ist, also eine eindeutige Zuordnung von Klartextzeichen zu verschlüsseltem Code gibt, kannst Du folgendes machen:

Du nimmst den Python-Code (eventuell auch in Java nachgebildet) und erzeugst für jedes Klartextzeichen das entsprechende verschlüsselte Code-Zeichen.

Diese Zuordnung (Map) speicherst Du (in einer Map, Array (Index zu Code) ) oder so.

Damit kannst Du den verschlüsselten String entschlüsseln.

Verwendet Python eigentlich 16-bit-chars?

Ich könnte mal nachsehen, ich habe auch Python-Bücher.

Findet man sicher auch im Netz.

 

[Barista]

Den Shift kann man ja dann durch ((char-18)/123) % 256 reversen

Ach so, Du hast bereits eine Umkehroperation.

Dann sollte es leicht sein, den Hexcode zu entschlüsseln.

 

[Kirby.exe]

Alsoo irgendwie gibt es zwar nicht für jedes Zeichen ein Ergebnis aber das habe ich jetzt raus für alle Klein und Großbuchstaben:

Character: a, Encryped: 
Character: b, Encryped: (
Character: c, Encryped: £
Character: d, Encryped:
Character: e, Encryped:
Character: f, Encryped:
Character: g, Encryped:
Character: h, Encryped:

Character: i, Encryped:

Character: j, Encryped:
Character: k, Encryped: {
Character: l, Encryped: ö
Character: m, Encryped: q
Character: n, Encryped: ì
Character: o, Encryped: g
Character: p, Encryped: â
Character: q, Encryped: ]
Character: r, Encryped: Ø
Character: s, Encryped: S
Character: t, Encryped: Î
Character: o, Encryped: g
Character: v, Encryped: Ä
Character: w, Encryped: ?
Character: x, Encryped: º
Character: y, Encryped: 5
Character: z, Encryped: °
Character: A, Encryped: M
Character: B, Encryped: È
Character: C, Encryped: C
Character: D, Encryped: ¾
Character: E, Encryped: 9
Character: F, Encryped: ´
Character: G, Encryped: /
Character: H, Encryped: ª
Character: I, Encryped: %
Character: J, Encryped: 
Character: K, Encryped:
haracter: L, Encryped:
Character: M, Encryped:
Character: N, Encryped:
Character: O, Encryped:
Character: P, Encryped:
Character: Q, Encryped: ý
Character: R, Encryped: x
Character: S, Encryped: ó
Character: T, Encryped: n
Character: O, Encryped:
Character: V, Encryped: d
Character: W, Encryped: ß
Character: X, Encryped: Z
Character: Y, Encryped: Õ
Character: Z, Encryped: P

 

[Kirby.exe]

Ach so, Du hast bereits eine Umkehroperation.

Dann sollte es leicht sein, den Hexcode zu entschlüsseln.

Ehm ok XD Erleuchte mich

 

[Barista]

Python:

def decryption(msg):
    ct = bytes.fromhex(msg).decode('utf-16')
    for char in ct:
        ct.append(((char - 18)/123) % 256)
    return bytes(ct)


s = "6e0a9372ec49a3f6930ed8723f9df6f6720ed8d89dc4937222ec7214d89d1e0e352ce0aa6ec82bf622227bb70e7fb7352249b7d893c493d8539dec8fb7935d490e7f9d22ec89b7a322ec8fd80e7f8921"
print(decryption(s))

Ich würde sagen, Du darfst den verschlüsselten Text nicht encoden, also lass das decode nach bytes.fromhex weg.
Erst auf die entschlüsselten chars ist ein Encoding sinnvoll anwendbar.

 

[Kirby.exe]

Mhh also irgendwie kommt da trotzdem nur quatsch...Kann es sein, dass meine Shift Funktion falsch ist?

 

[LimDul]

Mhh also irgendwie kommt da trotzdem nur quatsch...Kann es sein, dass meine Shift Funktion falsch ist?

Ja. bei einer Integer-Division durch 123 kommt maximal der Wert 2 raus..

Ich bekomme es gerade auch nicht auf die Schnelle zusammen, wie man das zurückrechnet, aber so auf jeden Fall nicht

 

[Barista]

[CODE lang="java" title="Decrypt"]public class Decrypt
{

public static void main(String[] args)
{
for ( int i = 0 ; i <= Short.MAX_VALUE ; i++ )
{
System.out.println( i + ": " + encrypt( i ) );
}
}

private static int encrypt(
final int valueToEncrypt )
{
return (123 * valueToEncrypt + 18) % 256;
}

}
[/CODE]

 

[Kirby.exe]

[CODE lang="java" title="Decrypt"]public class Decrypt
{

public static void main(String[] args)
{
for ( int i = 0 ; i <= Short.MAX_VALUE ; i++ )
{
System.out.println( i + ": " + encrypt( i ) );
}
}

private static int encrypt(
final int valueToEncrypt )
{
return (123 * valueToEncrypt + 18) % 256;
}

}
[/CODE]

Now i'm kinda confused xD Was soll ich dann mit den gemappten werten machen? Denn es kommt hier auch zu Kollisionen

 

[Kirby.exe]

Ich habe jetzt sowas gemacht xD

class MapValue:

    def __init__(self, value, encrypt):
        self.value = value
        self.encrypt = encrypt
    
    def getValue(self):
        return self.value
    
    def getEncrypt(self):
        return self.encrypt

def encrypted(value):
    return (123 * value - 18) % 256

mapping_table = []
for x in range(0,32767):
    mapping_table.append(MapValue(x, encrypted(x)))

cryptic = b'n\n\x93r\xecI\xa3\xf6\x93\x0e\xd8r?\x9d\xf6\xf6r\x0e\xd8\xd8\x9d\xc4\x93r"\xecr\x14\xd8\x9d\x1e\x0e5,\xe0\xaan\xc8+\xf6""{\xb7\x0e\x7f\xb75"I\xb7\xd8\x93\xc4\x93\xd8S\x9d\xec\x8f\xb7\x93]I\x0e\x7f\x9d"\xec\x89\xb7\xa3"\xec\x8f\xd8\x0e\x7f\x89!'

res = ''

for item in cryptic:
    for x in mapping_table:
        if x.getEncrypt() == item:
            print('Item: {}, Decrypted: {}'.format(item , x.getValue()))
    #res += '{}'.format()

 

[Barista]

Was soll ich dann mit den gemappten werten machen? Denn es kommt hier auch zu Kollisionen

Dann handelt es sich wahrscheinlich nicht um eine Verrschlüsselung, sondern um eine Art Hashing, eben ohne Verkleinerung der Datenmenge.

 

[fhoffmann]

Denn es kommt hier auch zu Kollisionen

Du kannst natürlich nur die Werte von 0 bis 255 in die Tabelle schreiben. Dabei würde ich die Tabelle (Map) umgekehrt anordnen, also

        for (int i = 0; i < 256; ++i) {
            codes.put((i * 123 + 18) % 256, i);
        }

 

[Kirby.exe]

Mhh also wenn ich das nur von 0-256 mache und dann die Verschlüsselten Werte mit den normalen Werten linke, dann kommt irgendwie immernoch keine Richtigen Wörter heraus...Das bekomme ich raus: _L¡]_L\Ln§`c¥\¡__a\

Das ist der Code der den ganzen Kram berechnet:

class MapValue:

    def __init__(self, value, encrypt):
        self.value = value
        self.encrypt = encrypt
    
    def getValue(self):
        return self.value
    
    def getEncrypt(self):
        return self.encrypt

def encrypted(value):
    return (123 * value - 18) % 256

mapping_table = []
for x in range(0,256):
    mapping_table.append(MapValue(x, encrypted(x)))

cryptic = b'n\n\x93r\xecI\xa3\xf6\x93\x0e\xd8r?\x9d\xf6\xf6r\x0e\xd8\xd8\x9d\xc4\x93r"\xecr\x14\xd8\x9d\x1e\x0e5,\xe0\xaan\xc8+\xf6""{\xb7\x0e\x7f\xb75"I\xb7\xd8\x93\xc4\x93\xd8S\x9d\xec\x8f\xb7\x93]I\x0e\x7f\x9d"\xec\x89\xb7\xa3"\xec\x8f\xd8\x0e\x7f\x89!'

res = ''

for item in cryptic:
    for x in mapping_table:
        if x.getEncrypt() == item:
            res += '{}'.format(chr(x.getValue()))
            print('Item: {}, Decrypted: {}'.format(item , x.getValue()))

print(res)

 

[fhoffmann]

return (123 * value - 18) % 256

Warum rechnest du hier "- 18" und nicht "+ 18"?

Und warum erzeugst du die Map nicht "umgekehrt", also

mapping_table.append(MapValue(encrypted(x), x))

EDIT: Dann kannst du dir dir for-Schleife sparen!

 

[Kirby.exe]

Warum rechnest du hier "- 18" und nicht "+ 18"?

Gott das war der Fehler xD Jetzt kommt richtiger Text heraus Danke für eure Hilfe

 

[fhoffmann]

Gott das war der Fehler

Aber den anderen "Fehler", dass du die Map falschherum aufbaust, solltest du auch noch korrigieren.
Bisher speicherst du den key im value und den value im key; deshalb musst du durch die Map iterieren, um zu einem value den passenden key zu finden.