Ganzen Text in ASCII Code umwandeln

[mikyboy]

Ich habe den Auftrag bekommen, einen Text zu verschlüsseln, habe auch schon die Idee dazu, jedoch brach ich eine kleine Hilfe, die für viele vielleicht banal klingt:

Wie kann ich einen Text, den jemand eingibt, in den dezimal ASCII code umwandeln? Bei einzelnen Buchstaben klappts mit dem Befehl ord('A'), jedoch kann man so nur einzelne Buchstaben umwandeln. Wie kann ich es aber bewerkstelligen, den ganzen Text umwandeln zu lassen?

MfG Mike

[Rebecca]

Code: Alles auswählen

>>> text = "I don't like spam."
>>> map(ord, text)
[73, 32, 100, 111, 110, 39, 116, 32, 108, 105, 107, 101, 32, 115, 112, 97, 109, 46]

[mikyboy]

vielen Dank für die Antwort!
und was muss ich machen, wenn ich will, dass die Zahlen aneinander stehen? also statt
[73, 32, 100, 111, 110, 39, 116, 32, 108, 105, 107, 101, 32, 115, 112, 97, 109, 46]
einfach nur 733210011111039....

[schlangenbeschwörer]

Code: Alles auswählen

l = map(str(map(ord, text)))
n = ""
for x in l: n+=x

wobei ich bezweifle, dass du das willst, denn wer etwas verschlüsselt, will es auch irgendwann wieder entschlüsseln.

[mikyboy]

vielen dank, jedoch glaube ich dass ein Komma fehlt, sonst gibts immer eine Fehlermeldung.

l = map(str(map(ord, text))) zu
l = map(str,(map(ord, text))) gemacht


Ich muss einen Text mit der RSA verschlüsselung verschlüsseln, hab gedacht ich mach das so, dann verschlüssle ich die zahlen, dann mach ich wieder 2er gruppen daraus und diese können dann wieder entschlüsselt werden.

Oder hat jemand eine bessere Idee? bin für jeden Vorschlag wirklich sehr dankbar!

[schlangenbeschwörer]

vielen dank, jedoch glaube ich dass ein Komma fehlt, sonst gibts immer eine Fehlermeldung.

Oh, ja klar.
Aber wie willst du die Endloszahl wieder trennen. Du weißt ja nicht, wie viele Zahlen zusammengehören.

[mikyboy]

Achso stimmt. Wie kann ich es dann sonst machen?

[schlangenbeschwörer]

Überleg doch mal selbst!

[Leonidas]

Ich hätte es eher mit einer Generator-Expression gelöst:

Code: Alles auswählen

''.join(str(ord(char)) for char in text)

[birkenfeld]

Wenn es hinterher wieder aufteilbar sein soll, muss jede Zahl gleichlang sein:

Code: Alles auswählen

''.join("%02d" % ord(char) for char in text)

Schneller gehts mit

Code: Alles auswählen

text.encode("hex")

[keppla]

Achso stimmt. Wie kann ich es dann sonst machen?

Afaik arbeiten viele Algorithmen so, dass sie einen klartextstrom (beliebig viele Zeichen Text) in Stücke teilen, auf die sie dann den algorithmus anwenden, und die verschlüsselten Stücke zusammenkleben und als Chiffrestrom ausgeben.

Das ganze ist eine Art Mapping (deutsch Abbildung, afaik).

in python/pseude grob sowas:

Code: Alles auswählen

chunks = chunkify(text, length) # funktion, die text nimmt und ihn zerteilt
chunks = [ encrypt(chunk) for chunk in chuns ] # äquivalent mit chunks = map(encrypt, chunks)
cyphertext = ''.join(chunks)

Die Funktion "encrypt" repräsentiert den eigentlichen Algorithmus.

Rot13 teilt z.B. den Text in Stücke von 1 byte, "rotiert" das byte, und fügt es dem Chiffretext hinzu.
Base64 nimmt 3-byte-stücke, "verschlüsselt" sie zu 4-bytes, und fügt sie dem Chiffretext hinzu.

Beides keine kryptographisch sicheren Algorithmen, ich weis, sollte aber trotzdem als Beispiel reichen.

Ein fachwort zum suchen wäre Blockchiffre

[mikyboy]

zuerst mal danke für all die antworten und ansätze, hat mich scho sehr weit gebracht!
und noch ne frage, wenn ich jetzt einen Text mit "map(ord, text) " umwandle, wie kann ich das wieder rückgängig machen?

[BlackVivi]

zuerst mal danke für all die antworten und ansätze, hat mich scho sehr weit gebracht!
und noch ne frage, wenn ich jetzt einen Text mit "map(ord, text) " umwandle, wie kann ich das wieder rückgängig machen?

Code: Alles auswählen

In [1]: text = "Das ist ein Text"
In [2]: ascii = map(ord, text)
In [5]: "".join(map(chr, ascii))
Out[5]: 'Das ist ein Text'

oder

Code: Alles auswählen

In [1]: text = "Das ist ein Text"
In [2]: ascii = map(ord, text)
In [12]: string.join([chr(x) for x in ascii], "")
Out[12]: 'Das ist ein Text'

oder (ab hier beachtest du die am besten nicht mehr, ist nur dumme Spielerei von mir)...

Code: Alles auswählen

In [1]: def to_ascii(text):
   ...:     for i in text:
   ...:         yield ord(i)
   ...:         
   ...:         

In [2]: def ascii_to_string(ascii_list):
   ...:     temp = str()
   ...:     for i in ascii_list:
   ...:         temp += chr(i)
   ...:     return temp
   ...: 

In [3]: text = "DAS IST TEXT!!"

In [4]: ascii = to_ascii(text)

In [5]: ascii_to_string(ascii)
Out[5]: 'DAS IST TEXT!!'

oder

Code: Alles auswählen

import string

class AsciiTexter(object):

    def __init__(self, text):
        self.text = text

    def __str__(self):
        return "Text: " + self.text + \
               "\nAscii: " + string.join(str(x) for x in self.ascii) + \
               "\nHex: " + string.join(str(x) for x in self.hexa)
    @property
    def ascii(self):
        return map(ord, self.text)

    @property
    def hexa(self):
        return map(hex, self.ascii)

foo = AsciiTexter("Bla")
print foo.text
print foo.ascii
print foo.hexa
print foo

[jens]

Vielleicht auch interessant: http://www.python-forum.de/topic-8075.html

[BlackJack]

Ich würde noch gerne `array.array` in die Runde werfen.

[mikyboy]

Danke für all die Tips, hab bis jetzt (fast) alles eingebaut.

Noch eine Frage: Bei der RSA Verschlüsselung wird zum Verschlüsseln zuerst hoch eine Zahl und dann der mod davon genommen. Wenn ich das nun im Python mache, hängt es bei der Zahl noch ein "L" hintendran, was es problematisch macht, die Zahl wieder in Text zu verwandeln.
Meine Frage ist nun, wie ich das "L" wieder wegbeckomme.

Bsp: (7**23)%143 = 2L
ich brauche aber 2 statt 2L

vielen Dank, Mike

[BlackJack]

Da ist kein L wenn Du die Zahl in eine Zeichenkette umwandelst.

Code: Alles auswählen

In [11]: (7**23) % 143
Out[11]: 2L

Das ist keine Zeichenkette sondern eine literale 2 als "long". Wenn man die in eine Zeichenkette umwandelt…

Code: Alles auswählen

In [12]: str((7**23) % 143)
Out[12]: '2'

…ist da auch kein L mehr.